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();
}