|
public static GetOptionalAttributeValue ( |
||
| node | The XmlNode to look in. | |
| attrName | string | The attribute to find. |
| return | string | |
private string GetTxtAtributeValue(XmlNode node)
{
return(XmlUtils.GetOptionalAttributeValue(
node,
"txt",
XmlUtils.GetManditoryAttributeValue(node, "id"))); // 'id' is default, if no 'txt' attribute is present.
}
public void IndentedOverride()
{
// simulate a path to the Antonymns
XmlNode rootLayout = root.SelectSingleNode("layout[@name=\"Test1\"]");
XmlNode sensesPartRef = rootLayout.SelectSingleNode("part[@ref=\"Senses\"]");
XmlNode antonymnPartRef = sensesPartRef.SelectSingleNode("indent/part[@ref=\"Antonymns\"]");
object[] path = { rootLayout, 1, sensesPartRef, 2, antonymnPartRef };
XmlNode finalPartref;
XmlNode result = Inventory.MakeOverride(path, "visibility", "ifdata", 1, out finalPartref);
Assert.AreEqual(rootLayout.ChildNodes.Count, result.ChildNodes.Count);
XmlNode antonymNewPartRef = result.SelectSingleNode("//part[@ref=\"Antonymns\"]");
Assert.AreEqual("ifdata", XmlUtils.GetOptionalAttributeValue(antonymNewPartRef, "visibility"));
XmlNode indentNewPartRef = antonymNewPartRef.ParentNode;
Assert.AreEqual("indent", indentNewPartRef.Name);
XmlNode sensesNewPartRef = indentNewPartRef.ParentNode;
Assert.AreEqual("part", sensesNewPartRef.Name);
Assert.AreEqual("Senses", XmlUtils.GetOptionalAttributeValue(sensesNewPartRef, "ref"));
XmlNode rootNewLayout = sensesNewPartRef.ParentNode;
Assert.AreEqual("layout", rootNewLayout.Name);
Assert.AreEqual(result, rootNewLayout);
}
public void LevelThreeOverride()
{
// simulate a path to the gloss of a synonym. Include some non-part-ref XML nodes.
XmlNode rootLayout = root.SelectSingleNode("layout[@name=\"Test1\"]");
XmlNode sensesPartRef = rootLayout.SelectSingleNode("part[@ref=\"Senses\"]");
XmlNode glossPartRef = root.SelectSingleNode("part[@ref=\"Gloss\"]");
XmlNode synPartRef = root.SelectSingleNode("part[@ref=\"Synonyms\"]");
XmlNode blahPart = root.SelectSingleNode("part[@id=\"blah\"]");
XmlNode nonsenceLayout = root.SelectSingleNode("layout[@id=\"nonsence\"]");
object[] path = { rootLayout, 1, sensesPartRef, blahPart, nonsenceLayout, synPartRef, 2, glossPartRef };
XmlNode finalPartref;
XmlNode result = Inventory.MakeOverride(path, "visibility", "ifdata", 1, out finalPartref);
Assert.AreEqual(rootLayout.ChildNodes.Count, result.ChildNodes.Count);
XmlNode glossNewPartRef = result.SelectSingleNode("//part[@ref=\"Gloss\"]");
Assert.AreEqual("ifdata", XmlUtils.GetOptionalAttributeValue(glossNewPartRef, "visibility"));
XmlNode synNewPartRef = glossNewPartRef.ParentNode;
Assert.AreEqual("part", synNewPartRef.Name);
Assert.AreEqual("Synonyms", XmlUtils.GetOptionalAttributeValue(synNewPartRef, "ref"));
// Should have kept unmodified attributes of this element.
Assert.AreEqual("TestingParam", XmlUtils.GetOptionalAttributeValue(synNewPartRef, "param"));
XmlNode sensesNewPartRef = synNewPartRef.ParentNode;
Assert.AreEqual("part", sensesNewPartRef.Name);
Assert.AreEqual("Senses", XmlUtils.GetOptionalAttributeValue(sensesNewPartRef, "ref"));
XmlNode rootNewLayout = sensesNewPartRef.ParentNode;
Assert.AreEqual("layout", rootNewLayout.Name);
Assert.AreEqual(result, rootNewLayout);
}
/// <summary>
/// Get an obligatory attribute value.
/// </summary>
/// <param name="node">The XmlNode to look in.</param>
/// <param name="attrName">The required attribute to find.</param>
/// <returns>The value of the attribute.</returns>
/// <exception cref="ApplicationException">
/// Thrown when the value is not found in the node.
/// </exception>
public static string GetManditoryAttributeValue(XmlNode node, string attrName)
{
string retval = XmlUtils.GetOptionalAttributeValue(node, attrName, null);
if (retval == null)
{
throw new ApplicationException("The attribute'"
+ attrName
+ "' is mandatory, but was missing. "
+ node.OuterXml);
}
return(retval);
}
/// <summary>
/// This is similar to GetStringWithXPath, but the path argument identifies a
/// single root node, which contains string elemenents (and optionally others,
/// which are ignored), each containing id and optionally txt elements.
/// This is much more efficient than GetStringWithXPath when multiple items
/// are wanted from the same root node, but only reliable when the path
/// identifies a single root.
/// </summary>
/// <param name="id"></param>
/// <param name="rootXPathFragment"></param>
/// <param name="fTrim"></param>
/// <returns></returns>
private string GetStringWithRootXPath(string id, string rootXPathFragment, bool fTrim)
{
if (fTrim)
{
id = id.Trim();
}
Dictionary <string, string> items = null;
if (m_pathsToStrings.ContainsKey(rootXPathFragment))
{
items = m_pathsToStrings[rootXPathFragment];
}
else
{
string path = "strings/" + rootXPathFragment;
if (path[path.Length - 1] == '/')
{
path = path.Substring(0, path.Length - 1); // strip closing slash.
}
XmlNode parent = m_document.SelectSingleNode(path);
items = new Dictionary <string, string>();
m_pathsToStrings[rootXPathFragment] = items;
if (parent != null)
{
foreach (XmlNode child in parent.ChildNodes)
{
string idChild = XmlUtils.GetOptionalAttributeValue(child, "id");
//if the txt attribute is missing, use the id attr,
//as this is unacceptable shorthand to use for English entries.
//e.g.: <string id="Anywhere"/> is equivalent to <string id="Anywhere" txt="Anywhere"/>
string txt = XmlUtils.GetOptionalAttributeValue(child, "txt", idChild);
if (child.Name == "string" && idChild != null)
{
items[idChild] = txt;
}
}
}
}
if (items.ContainsKey(id))
{
return(items[id]);
}
if (m_parent != null)
{
return(m_parent.GetStringWithXPath(id, rootXPathFragment));
}
return("*" + id + "*");
}
private void MergeCustomGroups(XmlNode parentNode, XmlNodeList customGroupNodeList)
{
if (customGroupNodeList == null || customGroupNodeList.Count == 0)
{
return; // Stop recursing in this method.
}
foreach (XmlNode customGroupNode in customGroupNodeList)
{
string customGroupId = XmlUtils.GetManditoryAttributeValue(customGroupNode, "id");
XmlNode srcMatchingGroupNode = parentNode.SelectSingleNode("group[@id='" + customGroupId + "']");
if (srcMatchingGroupNode == null)
{
// Import the entire custom node.
m_document.DocumentElement.AppendChild(m_document.ImportNode(customGroupNode, true));
}
else
{
// 1. Import new strings, or override extant strings with custom strings.
foreach (XmlNode customStringNode in customGroupNode.SelectNodes("string"))
{
string customId = XmlUtils.GetManditoryAttributeValue(customStringNode, "id");
string customTxt = GetTxtAtributeValue(customStringNode);
XmlNode srcMatchingStringNode = srcMatchingGroupNode.SelectSingleNode("string[@id='" + customId + "']");
if (srcMatchingStringNode == null)
{
// Import the new string into the extant group.
srcMatchingGroupNode.AppendChild(m_document.ImportNode(customStringNode, true));
}
else
{
// Replace the original value with the new value.
// The 'txt' attribute is optional, but it will be added as a cpoy of the 'id' here, if needed.
string srcTxt = XmlUtils.GetOptionalAttributeValue(srcMatchingStringNode, "txt");
if (srcTxt == null)
{
XmlUtils.AppendAttribute(srcMatchingStringNode, "txt", customTxt);
}
else
{
srcMatchingStringNode.Attributes["txt"].Value = customTxt;
}
}
}
// 2. Group elements can be nested, so merge them, too.
MergeCustomGroups(srcMatchingGroupNode, customGroupNode.SelectNodes("group"));
}
}
}
public void SimpleOverride()
{
// simulate a path to the citation form
XmlNode rootLayout = root.SelectSingleNode("layout[@name=\"Test1\"]");
XmlNode cfPartRef = rootLayout.SelectSingleNode("part[@ref=\"CitationForm\"]");
object[] path = { rootLayout, cfPartRef };
XmlNode finalPartref;
XmlNode result = Inventory.MakeOverride(path, "visibility", "ifdata", 7, out finalPartref);
Assert.AreEqual(rootLayout.ChildNodes.Count, result.ChildNodes.Count);
XmlNode cfNewPartRef = result.SelectSingleNode("part[@ref=\"CitationForm\"]");
Assert.AreEqual("ifdata", XmlUtils.GetOptionalAttributeValue(cfNewPartRef, "visibility"));
Assert.AreEqual("7", XmlUtils.GetOptionalAttributeValue(result, "version"));
}
public void OverrideDerived()
{
// Check that we can find a base node for a layout derived from an override.
CheckBaseNode("layout", new string[] { "LexEntry", "jtview", null, "DerivedForOverride" }, "DO2");
CheckAlterationNode("layout", new string[] { "LexEntry", "jtview", null, "DerivedForOverride" }, "DO3");
XmlNode unified = CheckNode("layout", new string[] { "LexEntry", "jtview", null, "DerivedForOverride" }, "DO3");
XmlNode groupSecond = unified.ChildNodes[1];
Assert.AreEqual("group", groupSecond.Name, "first child of unified should be a group");
Assert.AreEqual(2, groupSecond.ChildNodes.Count, "main group should have two chidren");
Assert.AreEqual("second", XmlUtils.GetOptionalAttributeValue(groupSecond, "label"),
"second child should be group 'second'");
VerifyAttr(groupSecond, "ws", "vernacular"); // inherited from derived element.
VerifyAttr(groupSecond, "rubbish", "nonsense"); // from override.
}
public void Overrides()
{
// Check that we can find a base node for a layout derived from an override.
CheckBaseNode("layout", new string[] { "LexSense", "jtview", null, "Test8D" }, "test7D");
CheckAlterationNode("layout", new string[] { "LexSense", "jtview", null, "Test8D" }, "test8D");
XmlNode unified = CheckNode("layout", new string[] { "LexSense", "jtview", null, "Test8D" }, "test8D");
XmlNode groupMain = unified.ChildNodes[0];
Assert.AreEqual("group", groupMain.Name, "first child of unified should be a group");
Assert.AreEqual(0, groupMain.ChildNodes.Count, "main group should have no chidren");
Assert.AreEqual("main", XmlUtils.GetOptionalAttributeValue(groupMain, "label"),
"first child should be group 'main'");
VerifyAttr(groupMain, "ws", "analysis"); // inherited from override.
VerifyAttr(groupMain, "rubbish", "goodstuff"); // overridden.
VerifyAttr(groupMain, "dummy", "base"); // inherited from original base.
}
protected void FindParent(string baseDirectory)
{
XmlNode node = m_document.SelectSingleNode("strings");
if (node == null)
{
throw new ApplicationException("Could not find the root node, <strings> in " + baseDirectory);
}
string inheritPath = XmlUtils.GetOptionalAttributeValue(node, "inheritPath");
if (inheritPath != null && inheritPath.Length > 0)
{
string path = Path.Combine(baseDirectory, inheritPath);
m_parent = new StringTable(path);
}
}
/// <summary>
/// look up a list of string IDs and return an array of strings
/// </summary>
/// <example>
/// here, the strings will be looked up at the root level
/// <stringList ids="anywhere, somewhere to left, somewhere to right, adjacent to left, adjacent to right"/>
/// </example>
/// <example>
/// here, the strings will be looked up under a nested group
/// <stringList group="MoMorphAdhocProhib/adjacency" ids="anywhere, somewhere to left, somewhere to right, adjacent to left, adjacent to right"/>
/// </example>
/// <param name="node">the name of the node is ignored, only the attributes are read</param>
/// <returns></returns>
public string[] GetStringsFromStringListNode(XmlNode node)
{
string ids = XmlUtils.GetManditoryAttributeValue(node, "ids");
string[] idList = ids.Split(new char[] { ',' });
string[] strings = new string[idList.Length];
string groupPath = "";
string simplePath = XmlUtils.GetOptionalAttributeValue(node, "group");
if (simplePath != null)
{
groupPath = GetXPathFragmentFromSimpleNotation(simplePath);
}
int i = 0;
foreach (string id in idList)
{
strings[i++] = GetStringWithXPath(id, groupPath);
}
return(strings);
}
/// <summary>
/// Get an optional attribute value from an XmlNode.
/// </summary>
/// <param name="node">The XmlNode to look in.</param>
/// <param name="attrName">The attribute to find.</param>
/// <returns>The value of the attribute, or null, if not found.</returns>
public static string GetAttributeValue(XmlNode node, string attrName)
{
return(XmlUtils.GetOptionalAttributeValue(node, attrName));
}
public void DerivedElements()
{
// Check that we can get a base node for this view BEFORE we have retrieved anything about the layout
// (a derived one) on which it is based.
CheckBaseNode("layout", new string[] { "LexEntry", "jtview", null, "Test5D" }, "test1D");
// Load a file involving derived elements.
// Check that we can retrieve the base, derived, and unified versions of the elements.
XmlNode unified = CheckNode("layout", new string[] { "LexEntry", "jtview", null, "Test1D" }, "test1D");
XmlNode baseNode = CheckBaseNode("layout", new string[] { "LexEntry", "jtview", null, "Test1D" }, "test3");
XmlNode derived = CheckAlterationNode("layout", new string[] { "LexEntry", "jtview", null, "Test1D" }, "test1D");
Assert.IsNull(m_inventory.GetAlteration("layout", new string[] { "LexEntry", "jtview", null, "Test1" }),
"GetAlteration should be null for non-derived node.");
// Check correct working of unification:
// - first main child is present as expected
XmlNode groupMain = unified.ChildNodes[0];
Assert.AreEqual("group", groupMain.Name, "first child of unified should be a group");
Assert.AreEqual(3, groupMain.ChildNodes.Count, "main group should have three chidren");
Assert.AreEqual("main", XmlUtils.GetOptionalAttributeValue(groupMain, "label"),
"first child should be group 'main'");
// - added elements are added. (Also checks default order: original plus extras.)
// - unmatched original elements are left alone.
XmlNode part0M = VerifyChild(groupMain, 0, "ref", "LexEntry-Jt-Citationform");
XmlNode part1M = VerifyChild(groupMain, 1, "ref", "LexEntry-Jt-Senses");
XmlNode part2M = VerifyChild(groupMain, 2, "ref", "LexEntry-Jt-Forms");
// - child elements are correctly ordered when 'reorder' is true.
XmlNode groupSecond = unified.ChildNodes[1];
Assert.AreEqual("group", groupSecond.Name, "second child of unified should be a group");
Assert.AreEqual(3, groupSecond.ChildNodes.Count, "main group should have three chidren");
Assert.AreEqual("second", XmlUtils.GetOptionalAttributeValue(groupSecond, "label"),
"second child should be group 'second'");
XmlNode part0S = VerifyChild(groupSecond, 0, "ref", "LexEntry-Jt-Forms");
XmlNode part1S = VerifyChild(groupSecond, 1, "ref", "LexEntry-Jt-Citationform");
XmlNode part2S = VerifyChild(groupSecond, 2, "ref", "LexEntry-Jt-Senses");
// - check no reordering when no element added, and reorder is false
XmlNode groupThird = unified.ChildNodes[2];
Assert.AreEqual("group", groupThird.Name, "Third child of unified should be a group");
Assert.AreEqual(3, groupThird.ChildNodes.Count, "main group should have three chidren");
Assert.AreEqual("third", XmlUtils.GetOptionalAttributeValue(groupThird, "label"),
"third child should be group 'Third'");
VerifyChild(groupThird, 0, "ref", "LexEntry-Jt-Citationform");
VerifyChild(groupThird, 1, "ref", "LexEntry-Jt-Senses");
VerifyChild(groupThird, 2, "ref", "LexEntry-Jt-Forms");
// - added attributes are added.
VerifyAttr(part0M, "part", "default");
VerifyAttr(part1S, "part", "default");
VerifyAttr(unified, "dummy", "true");
// - overridden attributes are replaced.
VerifyAttr(part0M, "ws", "technical");
VerifyAttr(part1S, "ws", "technical");
VerifyAttr(unified, "visible", "never");
// - attributes not mentioned in override are unchanged.
VerifyAttr(part0M, "visible", "always");
VerifyAttr(part1S, "visible", "always");
VerifyAttr(unified, "ws", "vernacular");
}
void VerifyAttr(XmlNode node, string attr, string val)
{
Assert.AreEqual(val, XmlUtils.GetOptionalAttributeValue(node, attr));
}
/// <summary>
/// replace the node with the node or nodes that it refers to
/// </summary>
/// <example>
/// <include path='IncludeXmlTestSource.xml' query='food/fruit/name'/>
/// </example>
/// <param name="includeNode"></param>
protected void ReplaceNode(Dictionary <string, XmlDocument> cachedDoms, string parentPath, XmlNode includeNode, string defaultPath)
{
string path = null;
if (defaultPath != null && defaultPath.Length > 0)
{
path = XmlUtils.GetOptionalAttributeValue(includeNode, "path", defaultPath);
}
else
{
path = XmlUtils.GetOptionalAttributeValue(includeNode, "path");
if (path == null || path.Trim().Length == 0)
{
throw new ApplicationException(
"The path attribute was missing and no default path was specified. \r\n"
+ includeNode.OuterXml);
}
}
XmlNode parentNode = includeNode.ParentNode;
try
{
/* To support extensions, we need to see if 'path' starts with 'Extensions/* /'. (without the extra space following the '*'.)
* If it does, then we will have to get any folders (the '*' wildcard)
* and see if any of them have the specified file (at end of 'path'.
*/
StringCollection paths = new StringCollection();
// The extension XML files should be stored in the data area, not in the code area.
// This reduces the need for users to have administrative privileges.
bool fExtension = false;
string extensionBaseDir = null;
if (path.StartsWith("Extensions") || path.StartsWith("extensions"))
{
// Extension <include> element,
// which may have zero or more actual extensions.
string extensionFileName = path.Substring(path.LastIndexOf("/") + 1);
string pluginBaseDir = (parentPath == null) ? m_resolver.BaseDirectory : parentPath;
extensionBaseDir = pluginBaseDir;
string sBaseCode = DirectoryFinder.FWCodeDirectory;
string sBaseData = DirectoryFinder.FWDataDirectory;
if (extensionBaseDir.StartsWith(sBaseCode) && sBaseCode != sBaseData)
{
extensionBaseDir = extensionBaseDir.Replace(sBaseCode, sBaseData);
}
// JohnT: allow the Extensions directory not even to exist. Just means no extentions, as if empty.
if (!Directory.Exists(extensionBaseDir + "/Extensions"))
{
return;
}
foreach (string extensionDir in Directory.GetDirectories(extensionBaseDir + "/Extensions"))
{
string extensionPathname = Path.Combine(extensionDir, extensionFileName);
// Add to 'paths' collection, but only from 'Extensions' on.
if (File.Exists(extensionPathname))
{
paths.Add(extensionPathname.Substring(extensionPathname.IndexOf("Extensions")));
}
}
// Check for newer versions of the extension files in the
// "Available Plugins" directory. See LT-8051.
UpdateExtensionFilesIfNeeded(paths, pluginBaseDir, extensionBaseDir);
if (paths.Count == 0)
{
return;
}
fExtension = true;
}
else
{
// Standard, non-extension, <include> element.
paths.Add(path);
}
/* Any fragments (extensions or standard) will be added before the <include>
* element. Aftwerwards, the <include> element will be removed.
*/
string query = XmlUtils.GetManditoryAttributeValue(includeNode, "query");
foreach (string innerPath in paths)
{
XmlDocumentFragment fragment;
if (innerPath == "$this")
{
fragment = CreateFragmentWithTargetNodes(query, includeNode.OwnerDocument);
}
else
{
fragment = GetTargetNodes(cachedDoms,
fExtension ? extensionBaseDir : parentPath, innerPath, query);
}
if (fragment != null)
{
XmlNode node = includeNode.OwnerDocument.ImportNode(fragment, true);
// Since we can't tell the index of includeNode,
// always add the fluffed-up node before the include node to keep it/them in the original order.
parentNode.InsertBefore(node, includeNode);
}
}
// Handle any overrides.
HandleIncludeOverrides(includeNode);
}
finally
{
// Don't want the original <include> element any more, no matter what.
parentNode.RemoveChild(includeNode);
}
}
