public void XElementWorkOnTextNodes1() { XElement elem = new XElement("A", "text2"); XNode n = elem.FirstNode; using (UndoManager undo = new UndoManager(elem)) { undo.Group(); using (EventsHelper eHelper = new EventsHelper(elem)) { n.AddBeforeSelf("text0"); Assert.Equal("text0text2", elem.Value); n.AddBeforeSelf("text1"); Assert.Equal("text0text1text2", elem.Value); eHelper.Verify(new XObjectChange[] { XObjectChange.Add, XObjectChange.Value }); } undo.Undo(); Assert.Equal("text2", elem.Value); } }
/// <summary> /// Ensures the whitespace separation between two nodes. Appropriate whitespace is added before the given node /// </summary> /// <param name="first"></param> private XText EnsureWhitespaceBeforeNode(XNode node) { Debug.Assert( node.Parent != null && node.Parent.Elements().Count() > 0, "Call EnsureFirstNodeWhitespaceSeparation when the added element is the first node"); var newLine = new XText(Environment.NewLine + new string(' ', GetIndentLevel() * 2)); node.AddBeforeSelf(newLine); return(newLine); }
//[Variation(Priority = 1, Desc = "Working on the text nodes 1.")] public void WorkOnTextNodes1() { runWithEvents = (bool)Params[0]; var elem = new XElement("A", new XElement("B"), "text2", new XElement("C")); XNode n = elem.FirstNode.NextNode; if (runWithEvents) { eHelper = new EventsHelper(elem); } n.AddBeforeSelf("text0"); n.AddBeforeSelf("text1"); if (runWithEvents) { eHelper.Verify(new[] { XObjectChange.Add, XObjectChange.Value }); } TestLog.Compare(elem.Nodes().Count(), 4, "elem.Nodes().Count(), 4"); TestLog.Compare((n as XText).Value, "text2", "(n as XText).Value, text2"); TestLog.Compare((n.PreviousNode as XText).Value, "text0text1", "(n as XText).Value, text0text1"); }
public bool Visit(XNode node) { if (node is XElement asElement) { if (asElement.HasElements) { asElement.Add(_newlineText); } if (!"Project".Equals(asElement.Name.LocalName, StringComparison.OrdinalIgnoreCase)) { node.AddBeforeSelf(_newlineText); } } else if (node.NodeType == XmlNodeType.Comment) { node.AddBeforeSelf(_newlineText); } return(true); }
public void AddOrUpdateElement(string name, string value) { var child = Element.Elements().FirstOrDefault(x => x.Name.LocalName == name); if (child != null) { child.Value = value; } else { if (_closingElementSpace == null) { _closingElementSpace = new XText("\r\n" + new string(' ', (Depth) * 2)); Element.Add(_closingElementSpace); } child = new XElement(XName.Get(name)); child.Add(value); _closingElementSpace.AddBeforeSelf(child); child.AddBeforeSelf(new XText("\r\n" + new string(' ', (Depth + 1) * 2))); } }
/// <summary> /// Returns an XDocument where the XElement instances are /// positioned at the exact same line number as the original xml source. /// </summary> /// <param name="input"></param> /// <returns></returns> private static XDocument AdjustLineNumbers(XDocument input) { XDocument result; // save input to stream and re-read using (var stream = new MemoryStream()) { input.Save(stream, SaveOptions.DisableFormatting); stream.Seek(0, SeekOrigin.Begin); // read serialized xml result = XDocument.Load(stream, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo); } // find line info on each element and insert whitespace where needed var offset = 0; foreach (var element in result.Descendants()) { var lineInfo = (IXmlLineInfo)element; var originalLineAttr = element.Attribute(LineNumberName); if (originalLineAttr == null) { continue; } int originalLineNumber; if (int.TryParse((string)originalLineAttr, NumberStyles.Integer, CultureInfo.InvariantCulture, out originalLineNumber)) { if (originalLineNumber > lineInfo.LineNumber + offset) { var count = originalLineNumber - lineInfo.LineNumber - offset; var whitespace = new XText(string.Join(Environment.NewLine, new string[count + 1])); offset += count; // insert newlines before whitespace of element XNode node = element; while (node.PreviousNode != null && IsWhitespace(node.PreviousNode)) { node = node.PreviousNode; } node.AddBeforeSelf(whitespace); } } // and remove line number attribute originalLineAttr.Remove(); } return(result); }
public bool Visit(XNode node) { if (node.NodeType == XmlNodeType.Element) { node.AddBeforeSelf(new XText("\n")); if (node.NodesAfterSelf().All(x => x.NodeType == XmlNodeType.Text)) { node.AddAfterSelf(new XText("\n")); } } return(false); }
/// <summary> /// Moves the element up. /// </summary> /// <param name="element">The element.</param> /// <exception cref="System.ArgumentException">Nowhere to move element to!</exception> public static void MoveElementUp(this XElement element) { // Walk backwards until we find an element - ignore text nodes XNode previousNode = element.PreviousNode; while (previousNode != null && !(previousNode is XElement)) { previousNode = previousNode.PreviousNode; } if (previousNode == null) { throw new ArgumentException("Nowhere to move element to!"); } element.Remove(); previousNode.AddBeforeSelf(element); }
//[Variation(Priority = 1, Desc = "XElement - Working on the text nodes 2.")] public void WorkOnTextNodes2() { XElement elem = new XElement("A", "text2"); XNode n = elem.FirstNode; using (UndoManager undo = new UndoManager(elem)) { undo.Group(); using (EventsHelper eHelper = new EventsHelper(elem)) { n.AddBeforeSelf("text0", "text1"); TestLog.Compare(elem.Value, "text0text1text2", "Did not concat text nodes correctly"); eHelper.Verify(XObjectChange.Add); } undo.Undo(); TestLog.Compare(elem.Value, "text2", "Undo did not work"); } }
/// <summary> /// Ensures the whitespace separation for the first child element added to a node. /// </summary> /// <param name="element"></param> private void EnsureFirstNodeWhitespaceSeparation(XNode element) { #if DEBUG if (element.Parent != null) { Debug.Assert(element.Parent.Elements().Count() == 1, "Unexpected count of elements!"); } else { // if first.Parent is null, then this is the root element in a document Debug.Assert(element.Document.Root == element, "element had null parent, but is not the root element of the document"); } #endif var precedingNewLine = new XText(Environment.NewLine + new string(' ', GetIndentLevel() * 2)); var trailingNewLine = new XText(Environment.NewLine + new string(' ', Parent.GetIndentLevel() * 2)); element.AddBeforeSelf(precedingNewLine); element.AddAfterSelf(trailingNewLine); }
public static XElement MoveBefore(this XElement element, XNode target) { if (element == null) { throw new ArgumentNullException("element"); } if (element != target) { if (element.Parent != null) { element.Remove(); } if (target.Parent != null) { target.AddBeforeSelf(element); } } return(element); }
public void ExecuteXDocumentVariation(XNode[] toAdd, XNode contextNode) { IEnumerable <XNode> toAddList = toAdd.OfType <XNode>(); XDocument xDoc = new XDocument(contextNode); XDocument xDocOriginal = new XDocument(xDoc); using (UndoManager undo = new UndoManager(xDoc)) { undo.Group(); using (EventsHelper docHelper = new EventsHelper(xDoc)) { using (EventsHelper nodeHelper = new EventsHelper(contextNode)) { contextNode.AddBeforeSelf(toAdd); Assert.True(toAddList.SequenceEqual(contextNode.NodesBeforeSelf(), XNode.EqualityComparer), "Nodes not added correctly!"); nodeHelper.Verify(0); } docHelper.Verify(XObjectChange.Add, toAdd); } undo.Undo(); Assert.True(XNode.DeepEquals(xDoc, xDocOriginal), "Undo did not work!"); } }
public void ExecuteXElementVariation(XNode[] toAdd, XNode contextNode) { IEnumerable <XNode> toAddList = toAdd.OfType <XNode>(); XElement xElem = new XElement("root", contextNode); XElement xElemOriginal = new XElement(xElem); using (UndoManager undo = new UndoManager(xElem)) { undo.Group(); using (EventsHelper elemHelper = new EventsHelper(xElem)) { using (EventsHelper nodeHelper = new EventsHelper(contextNode)) { contextNode.AddBeforeSelf(toAdd); Assert.True(toAddList.SequenceEqual(contextNode.NodesBeforeSelf(), XNode.EqualityComparer), "Nodes not added correctly!"); nodeHelper.Verify(0); } elemHelper.Verify(XObjectChange.Add, toAdd); } undo.Undo(); Assert.True(xElem.Nodes().SequenceEqual(xElemOriginal.Nodes(), XNode.EqualityComparer), "Undo did not work!"); Assert.True(xElem.Attributes().EqualsAllAttributes(xElemOriginal.Attributes(), Helpers.MyAttributeComparer), "Undo did not work!"); } }
//[Variation(Desc = "Tuple - New Dev10 Types", Param = 1)] //[Variation(Desc = "DynamicObject - New Dev10 Types", Param = 2)] //[Variation(Desc = "Guid - old type", Param = 3)] //[Variation(Desc = "Dictionary - old type", Param = 4)] public void CreatingXElementsFromNewDev10Types() { object t = null; Type type = typeof(object); int param = (int)this.Variation.Param; switch (param) { case 1: t = Tuple.Create(1, "Melitta", 7.5); type = typeof(Tuple); break; case 3: t = new Guid(); type = typeof(Guid); break; case 4: t = new Dictionary <int, string>(); ((Dictionary <int, string>)t).Add(7, "a"); type = typeof(Dictionary <int, string>); break; } XElement e = new XElement("e1", new XElement("e2"), "text1", new XElement("e3"), t); e.Add(t); e.FirstNode.ReplaceWith(t); XNode n = e.FirstNode.NextNode; n.AddBeforeSelf(t); n.AddAnnotation(t); n.ReplaceWith(t); e.FirstNode.AddAfterSelf(t); e.AddFirst(t); e.Annotation(type); e.Annotations(type); e.RemoveAnnotations(type); e.ReplaceAll(t); e.ReplaceAttributes(t); e.ReplaceNodes(t); e.SetAttributeValue("a", t); e.SetElementValue("e2", t); e.SetValue(t); XAttribute a = new XAttribute("a", t); XStreamingElement se = new XStreamingElement("se", t); se.Add(t); try { new XDocument(t); } catch (ArgumentException) { try { new XDocument(t); } catch (ArgumentException) { return; } } TestLog.Compare(false, "Failed"); }