private void MakeDocument() { if (IsClosed) { throw new InvalidOperationException("message has already been closed"); } if (_doc == null) { try { MakeStream(); _doc = XDocFactory.From(_stream, ContentType); if ((_doc == null) || _doc.IsEmpty) { throw new InvalidDataException(string.Format("message body with content type '{0}' is not well-formed xml", ContentType)); } } finally { if (_stream != null) { _stream.Close(); _stream = null; _streamOpen = false; } } } }
public static XDoc WebXml( [DekiScriptParam("XML source text or source uri")] string source, [DekiScriptParam("xpath to value (default: none)", true)] string xpath, [DekiScriptParam("namespaces (default: none)", true)] Hashtable namespaces, [DekiScriptParam("caching duration in seconds (range: 60 - 86400; default: 300)", true)] double?ttl, [DekiScriptParam("return nil if source could not be loaded (default: text with error message)", true)] bool?nilIfMissing ) { string text = WebText(source, xpath, namespaces, true, ttl, nilIfMissing); if (text == null) { return(null); } XDoc result = XDocFactory.From(text, MimeType.XML); if (result.IsEmpty) { // try again assuming the input is HTML if (text.TrimStart().StartsWith("<")) { result = XDocFactory.From(text, MimeType.HTML); } else { // wrap response into a valid HTML document result = new XDoc("html").Elem("body", text); } } if (result.HasName("html")) { result = CleanseHtmlDocument(result); } return(result); }
public void DiffUnambiguosAddRemoveReplace() { // NOTE (steveb): test unamibiguous addition, deletion, and replacement XDoc a = XDocFactory.From("<p>the quick brown fox jumped over the lazy dog</p>", MimeType.XML); XDoc b = XDocFactory.From("<p>the slow black fox jumped far over the dog</p>", MimeType.XML); var diff = XDocDiff.Diff(a, b, 10000); Match(diff[0], ArrayDiffKind.Same, XmlNodeType.Element, "p"); Match(diff[1], ArrayDiffKind.Same, XmlNodeType.EndElement, string.Empty); Match(diff[2], ArrayDiffKind.Same, XmlNodeType.Text, "the"); Match(diff[3], ArrayDiffKind.Same, XmlNodeType.Text, " "); Match(diff[4], ArrayDiffKind.Removed, XmlNodeType.Text, "quick"); Match(diff[5], ArrayDiffKind.Added, XmlNodeType.Text, "slow"); Match(diff[6], ArrayDiffKind.Same, XmlNodeType.Text, " "); Match(diff[7], ArrayDiffKind.Removed, XmlNodeType.Text, "brown"); Match(diff[8], ArrayDiffKind.Added, XmlNodeType.Text, "black"); Match(diff[9], ArrayDiffKind.Same, XmlNodeType.Text, " "); Match(diff[10], ArrayDiffKind.Same, XmlNodeType.Text, "fox"); Match(diff[11], ArrayDiffKind.Same, XmlNodeType.Text, " "); Match(diff[12], ArrayDiffKind.Same, XmlNodeType.Text, "jumped"); Match(diff[13], ArrayDiffKind.Same, XmlNodeType.Text, " "); Match(diff[14], ArrayDiffKind.Added, XmlNodeType.Text, "far"); Match(diff[15], ArrayDiffKind.Added, XmlNodeType.Text, " "); Match(diff[16], ArrayDiffKind.Same, XmlNodeType.Text, "over"); Match(diff[17], ArrayDiffKind.Same, XmlNodeType.Text, " "); Match(diff[18], ArrayDiffKind.Same, XmlNodeType.Text, "the"); Match(diff[19], ArrayDiffKind.Removed, XmlNodeType.Text, " "); Match(diff[20], ArrayDiffKind.Removed, XmlNodeType.Text, "lazy"); Match(diff[21], ArrayDiffKind.Same, XmlNodeType.Text, " "); Match(diff[22], ArrayDiffKind.Same, XmlNodeType.Text, "dog"); Match(diff[23], ArrayDiffKind.Same, XmlNodeType.None, "p"); }
public void PostContentWithH2() { // Log in as ADMIN Plug p = Utils.BuildPlugForAdmin(); string titlecontent = "TITLE"; string content = string.Format("<h2>{0}</h2><p>this is content</p>", titlecontent); // Create a page with above contents string id = null; string path = null; DreamMessage msg = PageUtils.SavePage(p, string.Empty, PageUtils.GenerateUniquePageName(), content, out id, out path); // Retrieve page contents msg = p.At("pages", id, "contents").Get(); Assert.AreEqual(DreamStatus.Ok, msg.Status, "Page content retrieval failed"); // Retrieve contents HTML document, isolate <h2> tag (title), and assert it matches the above content XDoc html = XDocFactory.From("<html>" + System.Web.HttpUtility.HtmlDecode(msg.ToDocument().Contents) + "</html>", MimeType.HTML); Assert.IsTrue(html["//h2"].AsText == titlecontent, "Saved and retrieved H2 content do not match!"); // Delete the page PageUtils.DeletePageByID(p, id, true); }
private XDoc FetchSchema(Plug adoNetPlug) { XDoc ret = null; string key = adoNetPlug.At(METADATA_PATH).ToString(); lock (_cache) { _cache.TryGetValue(key, out ret); } if (ret == null) { string temp = adoNetPlug.At(METADATA_PATH).Get().AsTextReader().ReadToEnd(); //HACKHACKHACK to workaround ns issue temp = temp.Replace("xmlns=\"http://schemas.microsoft.com/ado/2006/04/edm\"", ""); ret = XDocFactory.From(temp, MimeType.XML); // add result to cache and start a clean-up timer lock (_cache) { _cache[key] = ret; } TaskTimer.New(TimeSpan.FromSeconds(CACHE_TTL), RemoveCachedEntry, key, TaskEnv.None); } //TODO: throw exception if schema is invalid somehow (or if the schema changed) return(ret); }
public ITestScriptService AddFunctionAsXml(string function) { var functionDocument = XDocFactory.From(function, MimeType.TEXT_XML); Assert.IsFalse(functionDocument.IsEmpty, string.Format("unable to parse function: {0}", function)); return(AddFunctionAsXml(functionDocument)); }
/// <summary> /// Query the collection based on an indexed key in the document. /// </summary> /// <param name="keyName">Name of the index key.</param> /// <param name="keyValue">Value of the key.</param> /// <param name="offset">Offset into collection.</param> /// <param name="limit">Maximum number of documents to retrieve.</param> /// <returns>Enumerable of matching documents.</returns> public IEnumerable <XDoc> Get(string keyName, string keyValue, int offset, int limit) { var info = _indexer.GetIndexInfo(keyName); if (info == null) { throw new ArgumentException(string.Format("No key '{0}' defined", keyName), "keyName"); } var docs = new List <XDoc>(); _catalog.NewQuery(string.Format("SELECT id, revision, doc FROM {0} LEFT JOIN {1} ON {0}.id = {1}.ref_id WHERE {1}.idx_value = ?KEY ORDER BY {0}.id{2}", _name, info.Table, GetLimitAndOffsetClause(limit, offset))) .With("KEY", keyValue) .Execute(delegate(IDataReader reader) { while (reader.Read()) { XDoc doc = XDocFactory.From(reader.GetString(2), MimeType.TEXT_XML); Map(doc); foreach (XDoc match in doc[info.XPath]) { if (StringUtil.EqualsInvariant(match.AsText, keyValue)) { int id = reader.GetInt32(0); int revision = reader.GetInt32(1); doc.Attr("docstore:revision", revision); doc.Attr("docstore:id", id); docs.Add(doc); break; } } } }); return(docs); }
private IEnumerable <XDoc> YieldAll(int limit, int offset) { var docResults = new List <QueryItem>(); _catalog.NewQuery(string.Format("SELECT id, revision, doc FROM {0} ORDER BY {0}.id{1}", _name, GetLimitAndOffsetClause(limit, offset))) .Execute(delegate(IDataReader dr) { while (dr.Read()) { var docResult = new QueryItem { Id = dr.GetInt32(0), Revision = dr.GetInt32(1), Doc = dr.GetString(2) }; docResults.Add(docResult); } }); foreach (var docResult in docResults) { XDoc doc = XDocFactory.From(docResult.Doc, MimeType.TEXT_XML); Map(doc); doc.Attr("docstore:revision", docResult.Revision); doc.Attr("docstore:id", docResult.Id); yield return(doc); } }
public void UnSafeXhtml_cleanses_Audio_element() { XDoc doc = XDocFactory.From("<doc><audio src=\"\" poster=\"\" onloadstart=\"\" onprogress=\"\" unsafe=\"\"></audio></doc>", MimeType.TEXT_XML); DekiScriptLibrary.ValidateXHtml(doc, false, true); Assert.AreEqual("<doc><audio src=\"\" onloadstart=\"\" onprogress=\"\"></audio></doc>", doc.ToString()); }
public void XDocFactory_parse_non_XML() { string xml = "hello"; XDoc doc = XDocFactory.From(xml, MimeType.XML); Assert.IsTrue(doc.IsEmpty); }
public void UnSafeXhtml_cleanses_Video_with_sources() { XDoc doc = XDocFactory.From("<doc><video poster=\"\" onloadstart=\"\" onprogress=\"\"><source src=\"\" unsafe=\"\"/></video></doc>", MimeType.TEXT_XML); DekiScriptLibrary.ValidateXHtml(doc, false, true); Assert.AreEqual("<doc><video poster=\"\" onloadstart=\"\" onprogress=\"\"><source src=\"\" /></video></doc>", doc.ToString()); }
public void SafeXhtml_cleanses_Audio_src_attribute() { XDoc doc = XDocFactory.From("<doc><audio src=\"javascript://\" poster=\"javascript://\" autoplay=\"\" loop=\"\" controls=\"\"></audio></doc>", MimeType.TEXT_XML); DekiScriptLibrary.ValidateXHtml(doc, true, true); Assert.AreEqual("<doc><audio autoplay=\"\" loop=\"\" controls=\"\"></audio></doc>", doc.ToString()); }
public void SafeXhtml_cleanses_Video_element() { XDoc doc = XDocFactory.From("<doc><video src=\"\" poster=\"\" autoplay=\"\" loop=\"\" controls=\"\" width=\"\" height=\"\" onloadstart=\"\" onprogress=\"\"></video></doc>", MimeType.TEXT_XML); DekiScriptLibrary.ValidateXHtml(doc, true, true); Assert.AreEqual("<doc><video src=\"\" poster=\"\" autoplay=\"\" loop=\"\" controls=\"\" width=\"\" height=\"\"></video></doc>", doc.ToString()); }
public void ParseCDataToXhtml() { string text = @"<html><body><script type=""text/javascript"">/*<![CDATA[*/var test = '<div>""test""</div>';/*]]>*/</script><p>test</p></body></html>"; XDoc doc = XDocFactory.From(text, MimeType.HTML); Assert.AreEqual(@"<html><body><script type=""text/javascript"">/*<![CDATA[*/var test = '<div>""test""</div>';/*]]>*/</script><p>test</p></body></html>", doc.ToXHtml()); }
public XDoc GadgetScript( [DekiExtParam("Google gadget script")] string script ) { // validate xml XDoc xml = XDocFactory.From("<html><body>" + script + "</body></html>", MimeType.HTML)["//script"]; if ((xml == null) || !xml.HasName("script")) { throw new ArgumentException("Google gadget must contained in a <script> tag"); } // validate uri XUri uri = xml["@src"].AsUri ?? XUri.Localhost; if (!uri.Host.EqualsInvariantIgnoreCase("gmodules.com") && !uri.Host.EqualsInvariantIgnoreCase("www.gmodules.com")) { throw new ArgumentException("Google gadget must be originating from gmodules.com"); } // remove .js output option uri = uri.WithoutParams("output"); // create <iframe> in which we'll load the gadget return(NewIFrame(uri, SysUtil.ChangeType <float?>(uri.GetParam("w")), SysUtil.ChangeType <float>(uri.GetParam("h")))); }
public void PageWithMailToLink() { // Log in as ADMIN Plug p = Utils.BuildPlugForAdmin(); // Create a page with contents containing and email address string content = "<p>[email protected]</p>"; string id = null; string path = null; DreamMessage msg = PageUtils.SavePage(p, string.Empty, PageUtils.GenerateUniquePageName(), content, out id, out path); // Retrieve page contents msg = p.At("pages", "=" + XUri.DoubleEncode(path), "contents").With("mode", "view").Get(); Assert.AreEqual(DreamStatus.Ok, msg.Status, "Page content retrieval failed"); // Assert email link is rendered correctly XDoc html = XDocFactory.From("<html>" + System.Web.HttpUtility.HtmlDecode(msg.ToDocument()["body"].AsText) + "</html>", MimeType.HTML); Assert.IsTrue("mailto:[email protected]" == html["//a/@href"].AsText, "Link did not render correctly"); // Delete the page PageUtils.DeletePageByID(p, id, true); }
public void PageWithLineBreakInLink() { // Login as ADMIN Plug p = Utils.BuildPlugForAdmin(); // Creates a page with contents containing a link with a line break string content = "<p>[[http://www.mindtouch.com/|\n<strong>Link Text</strong>\n]] </p>"; string id = null; string path = null; DreamMessage msg = PageUtils.SavePage(p, string.Empty, PageUtils.GenerateUniquePageName(), content, out id, out path); // Retrieve page content msg = p.At("pages", "=" + XUri.DoubleEncode(path), "contents").With("mode", "view").Get(); Assert.AreEqual(DreamStatus.Ok, msg.Status, "Page contents retrieval failed"); content = msg.ToDocument()["body"].AsText; // Assert link is rendered correctly XDoc html = XDocFactory.From("<html>" + System.Web.HttpUtility.HtmlDecode(content) + "</html>", MimeType.HTML); Assert.IsTrue(1 == html["//a"].ListLength && "Link Text" == html["//a/strong"].Contents && "http://www.mindtouch.com/" == html["//a/@href"].Contents, "Link did not render correctly"); // Delete the page PageUtils.DeletePageByID(p, id, true); }
private object ProcessGraph(string graph, string app, string format) { if (string.IsNullOrEmpty(graph)) { throw new DreamBadRequestException("invalid graph"); } if (string.IsNullOrEmpty(app) || !File.Exists(app)) { throw new DreamBadRequestException("application misconfigured or missing"); } if (format == null) { throw new ArgumentNullException("format"); } // determined the output format switch (format.ToLowerInvariant()) { case "png": return(GetResoucePlug(graph, app, format, MimeType.PNG).Uri); case "png+map": { string id = StringUtil.CreateAlphaNumericKey(8); // TODO (steveb): dot -Tcmapx -oTEMPFILE.map -Tgif -oTEMPFILE.png < source // generate map file and replace attributes XDoc map = XDocFactory.From(GetResoucePlug(graph, app, "cmapx", MimeType.XML).Get().AsText(), MimeType.XML); map["@id"].ReplaceValue(id); map["@name"].ReplaceValue(id); // create composite result return(new XDoc("html") .Start("body") .Start("img") .Attr("src", GetResoucePlug(graph, app, "png", MimeType.PNG).Uri) .Attr("usemap", "#" + id) .End() .Add(map) .End()); } case "svg": return(new XDoc("html") .Start("body") .Start("embed") .Attr("src", GetResoucePlug(graph, app, format, MimeType.SVG)) .Attr("type", MimeType.SVG.FullType) .Attr("pluginspage", "http://www.adobe.com/svg/viewer/install/") .End() .End()); case "xdot": return(GetResoucePlug(graph, app, format, MimeType.TEXT).Get().AsText()); default: throw new DreamBadRequestException(string.Format("unknown format: {0}", format)); } }
public void XDocFactory_parse_valid_XML() { string xml = "<root>mixed<inner>text</inner></root>"; XDoc doc = XDocFactory.From(xml, MimeType.XML); Assert.IsFalse(doc.IsEmpty); Assert.AreEqual(xml, doc.ToString()); }
public void Bug_MT8962_PostPageContentsWithFile() { Plug adminPlug = Utils.BuildPlugForAdmin(); // Create random contributor string username = null; string userid = null; DreamMessage msg = UserUtils.CreateRandomUser(adminPlug, "Contributor", "password", out userid, out username); // Login as user Plug userPlug = Utils.BuildPlugForUser(username); // Create a page string page_id; string page_path; msg = PageUtils.CreateRandomPage(userPlug, out page_id, out page_path); // Create a file string fileName = FileUtils.CreateRamdomFile(null); msg = DreamMessage.FromFile(fileName); fileName = "foo.jpg"; // Upload file to page msg = userPlug.At("pages", page_id, "files", "=" + fileName).Put(msg); Assert.AreEqual(DreamStatus.Ok, msg.Status, "PUT request failed"); // update the page XDoc pageContents = new XDoc("content"); pageContents.Attr("type", "application/x.deki-text"); pageContents.Attr("unsafe", "false"); pageContents.Start("body"); pageContents.Start("img"); pageContents.Attr("class", "internal default"); pageContents.Attr("src.path", "//"); pageContents.Attr("src.filename", fileName); pageContents.End(); //img pageContents.End(); //body msg = userPlug.At("pages", page_id, "contents") .With("edittime", "now") .With("redirects", 0) .With("reltopath", page_path) .Post(pageContents); Assert.AreEqual(DreamStatus.Ok, msg.Status, "page creation failed!"); msg = userPlug.At("pages", page_id, "contents") .With("mode", "view") .Get(); string contents = msg.AsDocument()["/content/body"].Contents; XDoc imgDoc = XDocFactory.From(contents, MimeType.XML); XUri imgSrcUri = XUri.TryParse(imgDoc["@src"].AsText); Assert.IsNotNull(imgSrcUri, "img src uri is invalid!"); }
public void Can_create_BE_from_XDoc() { var doc = new XDoc("test").Elem("foo", StringUtil.CreateAlphaNumericKey(6)); var be = new ResourceContentBE(doc); var doc2 = XDocFactory.From(be.ToStream(), be.MimeType); Assert.AreEqual(doc, doc2); }
public void Pack_and_unpack_manifest() { // Arrange string directory = Path.Combine(Path.GetTempPath(), StringUtil.CreateAlphaNumericKey(6)); Directory.CreateDirectory(directory); List <XDoc> docs = new List <XDoc>(); docs.Add(new XDoc("doc1").Attr("dataid", "a")); docs.Add(new XDoc("doc2").Attr("dataid", "b")); docs.Add(new XDoc("doc3").Attr("dataid", "c")); List <Tuplet <string, MemoryStream> > data = new List <Tuplet <string, MemoryStream> >(); foreach (XDoc doc in docs) { string id = doc["@dataid"].AsText; data.Add(new Tuplet <string, MemoryStream>(id, new MemoryStream(doc.ToBytes()))); } XDoc manifest = new XDoc("manifest") .Start("page").Attr("dataid", "a").End() .Start("page").Attr("dataid", "b").End() .Start("page").Attr("dataid", "c").End(); // Act using (FilePackageWriter packageWriter = new FilePackageWriter(directory)) { foreach (Tuplet <string, MemoryStream> tuple in data) { var item = new ExportItem(tuple.Item1, tuple.Item2, tuple.Item2.Length, new XDoc("item").Elem("path", "abc")); packageWriter.WriteDataAsync(item, new Result()).Wait(); } packageWriter.WriteManifest(manifest, new Result()).Wait(); } XDoc manifest2; List <XDoc> docs2 = new List <XDoc>(); using (FilePackageReader packageReader = new FilePackageReader(directory)) { manifest2 = packageReader.ReadManifest(new Result <XDoc>()).Wait(); foreach (XDoc id in manifest2["*/@dataid"]) { using (ImportItem item = packageReader.ReadData(new ImportItem(id.AsText, null, null), new Result <ImportItem>()).Wait()) { using (StreamReader reader = new StreamReader(item.Data)) { docs2.Add(XDocFactory.From(reader, MimeType.TEXT_XML)); } } } } // Assert Assert.IsTrue(File.Exists(Path.Combine(directory, "package.xml"))); Assert.AreEqual(ToCanonical(manifest), ToCanonical(manifest2)); Assert.AreEqual(docs.Count, docs2.Count); foreach (var doc in docs) { Assert.IsTrue(docs2.Select(x => x == doc).Any()); } }
public void XDocFactory_parse_HTML_with_entity_codes_and_render_as_XHTML_without_entities() { string xhtml = "<html><body>Ω ℵ Ÿ € © ø </body></html>"; XDoc doc = XDocFactory.From(xhtml, MimeType.HTML); // check if entities were converted string text = doc["body"].ToXHtml(false); Assert.AreEqual("<body>Ω ℵ Ÿ € © ø  </body>", text); }
public void Dom_partial_evaluation_for_foreach2() { const string source = "<html xmlns:eval='http://mindtouch.com/2007/dekiscript'><body init='var x = 2'><div foreach='var y in num.series(1, 5)' where='y != x'><eval:expr>y</eval:expr></div></body></html>"; XDoc doc = XDocFactory.From(source, MimeType.XML); DekiScriptExpression node = DekiScriptParser.Parse(doc); node = _dekiScriptTester.Runtime.Optimize(node, DekiScriptEvalMode.Evaluate, _dekiScriptTester.Runtime.CreateEnv()); Assert.AreEqual("<html><body><div>1; </div><div>3; </div><div>4; </div><div>5; </div></body></html>", node.ToString()); }
public void MergeConflicting() { XDoc org = XDocFactory.From("<p>the <span>brown</span> box</p>", MimeType.XML); XDoc left = XDocFactory.From("<p>the <em>brown</em> box</p>", MimeType.XML); XDoc right = XDocFactory.From("<p>the <b>brown</b> fox</p>", MimeType.XML); var conflict = false; var result = XDocDiff.Merge(org, left, right, 10000, ArrayMergeDiffPriority.Left, out conflict); Assert.AreEqual("<p>the <em>brown</em> fox</p>", result.ToString()); }
public void Write_XDoc() { var doc = new XDoc("test").Start("content").Value("this is content").End(); var stream = new ChunkedMemoryStream(); doc.WriteTo(stream); stream.Position = 0; var newdoc = XDocFactory.From(stream, MimeType.XML); Assert.AreEqual(doc, newdoc, "xdoc changed during serialization"); }
public object Fetch( [DekiExtParam("document id")] string id ) { // fetch response from cache CacheEntry result; lock (_cacheLookup) { _cacheLookup.TryGetValue(id, out result); } // check if we have a cached entry XDoc document = null; if (result != null) { _log.DebugFormat("cache hit for '{0}'", result.Id); result.ResetMemoryExpiration(); if (result.Cache != null) { _log.DebugFormat("cache data in memory '{0}'", result.Id); document = XDocFactory.From(result.Cache, MimeType.XML); } else { // we have the result on disk, so let's fetch it DreamMessage msg = Storage.At(CACHE_DATA, result.Guid + ".bin").GetAsync().Wait(); if (msg.IsSuccessful) { _log.DebugFormat("cache data pulled from disk"); result.Cache = Encoding.UTF8.GetString(msg.AsBytes()); document = XDocFactory.From(result.Cache, MimeType.XML); } else { _log.DebugFormat("unable to fetch cache data from disk: {0}", msg.Status); } } } // check if we have a document to convert if (document != null) { try { DekiScriptList list = (DekiScriptList)DekiScriptLiteral.FromXml(document); return(list[0]); } catch { // the cached entry is corrupted, remove it Clear(id); } } return(null); }
public static ArrayList WebList( [DekiScriptParam("XML source text or source uri")] string source, [DekiScriptParam("xpath to list of values")] string xpath, [DekiScriptParam("namespaces (default: none)", true)] Hashtable namespaces, [DekiScriptParam("capture enclosing XML element (default: false)", true)] bool?xml, [DekiScriptParam("caching duration in seconds (range: 60 - 86400; default: 300)", true)] double?ttl, [DekiScriptParam("return nil if source could not be loaded (default: text with error message)", true)] bool?nilIfMissing ) { XUri uri = XUri.TryParse(source); ArrayList result; if (uri == null) { // source is a string -> convert sourcwe to an XML document and apply xpath XDoc doc = XDocFactory.From(source, MimeType.XML); if ((doc == null) || doc.IsEmpty) { result = nilIfMissing.GetValueOrDefault() ? null : new ArrayList(); } else { result = AtXPathList(doc, xpath, namespaces, xml ?? false); } } else { // we need to fetch an online document string response = CachedWebGet(uri, ttl, nilIfMissing); if (response == null) { return(null); } XDoc doc = XDocFactory.From(response, MimeType.XML); if (doc.IsEmpty) { doc = XDocFactory.From(response, MimeType.HTML); } if (doc.IsEmpty) { // * source is a uri pointing to text document -> fetch source and convert to string (ignore xpath) result = nilIfMissing.GetValueOrDefault() ? null : new ArrayList { response }; } else { // * source is a uri pointing to xml document -> fetch source, convert to XML document, and apply xpath result = AtXPathList(doc, xpath, namespaces, xml ?? false); } } return(result); }
private void BuildIndex(IndexInfo info) { _catalog.NewQuery(string.Format("SELECT id, revision, doc FROM {0}", _name)).Execute(delegate(IDataReader reader) { while (reader.Read()) { int id = reader.GetInt32(0); int revision = reader.GetInt32(1); XDoc doc = XDocFactory.From(reader.GetString(2), MimeType.TEXT_XML); QueueSingleIndexUpdate(info, id, revision, doc); } }); }
private Yield ReadPackage_Helper(Result result) { ZipEntry manifestEntry = _zipFile.GetEntry("package.xml"); Result <MemoryStream> readResult; yield return(readResult = ReadZipStream(manifestEntry, new Result <MemoryStream>())); using (TextReader reader = new StreamReader(readResult.Value)) { _package = XDocFactory.From(reader, MimeType.TEXT_XML); } result.Return(); }