public static IList <Chunk> ParseElementChunks(string content, int position)
{
var node = ParseNode(content, position);
var contentToParse = node is ElementNode?GetElementNodeAsString((ElementNode)node) : content;
var grammar = new MarkupGrammar();
var visitorContext = new VisitorContext {
SyntaxProvider = new DefaultSyntaxProvider(new ParserSettings())
};
var result = grammar.Nodes(Source(contentToParse));
var nodes = result.Value;
foreach (var visitor in BuildChunkVisitors(visitorContext))
{
visitor.Accept(nodes);
nodes = visitor.Nodes;
}
var chunkBuilder = new ChunkBuilderVisitor(visitorContext);
chunkBuilder.Accept(nodes);
var chunks = chunkBuilder.Chunks;
return(chunks);
}
public void GetTokens_OverlappingTags_ReturnsSequenceAsIs()
{
var input = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("odd")),
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("auto-closed")),
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("even")),
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenArrayEnd,
};
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("odd")),
MarkupGrammar.TokenElementBegin(new DataName("auto-closed")),
MarkupGrammar.TokenElementBegin(new DataName("even")),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void ChainConditionalAttribute()
{
var grammar = new MarkupGrammar();
string input = "<div if=\"false\">hello</div><div elseif=\"true\">world</div><else>that's all</else>";
var nodes = grammar.Nodes(new Position(new SourceContext(input))).Value;
var visitor0 = new SpecialNodeVisitor(new VisitorContext());
visitor0.Accept(nodes);
var visitor = new ConditionalAttributeVisitor(new VisitorContext());
visitor.Accept(visitor0.Nodes);
Assert.AreEqual(3, visitor.Nodes.Count);
Assert.IsAssignableFrom(typeof(SpecialNode), visitor.Nodes[0]);
Assert.IsAssignableFrom(typeof(SpecialNode), visitor.Nodes[1]);
Assert.IsAssignableFrom(typeof(SpecialNode), visitor.Nodes[2]);
var ifNode = (SpecialNode)visitor.Nodes[0];
Assert.AreEqual("if", ifNode.Element.Name);
var elseifNode = (SpecialNode)visitor.Nodes[1];
Assert.AreEqual("elseif", elseifNode.Element.Name);
var elseNode = (SpecialNode)visitor.Nodes[2];
Assert.AreEqual("else", elseNode.Element.Name);
}
public void GetTokens_UnclosedTags_AutoCloses()
{
var input = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("odd", "a", "http://example.com/odd/a")),
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("auto-closed", "b", "http://example.com/auto-closed/b")),
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("even", "c", "http://example.com/even/c")),
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenArrayEnd,
};
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("odd", "a", "http://example.com/odd/a")),
MarkupGrammar.TokenElementBegin(new DataName("auto-closed", "b", "http://example.com/auto-closed/b")),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementBegin(new DataName("even", "c", "http://example.com/even/c")),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_ParentAndChildShareDefaultNamespace_ReturnsSequence()
{
var input = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("foo", String.Empty, "http://example.org")),
MarkupGrammar.TokenElementBegin(new DataName("child", String.Empty, "http://example.org")),
MarkupGrammar.TokenPrimitive("value"),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
};
var expected = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive("foo"),
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("xmlns"),
ModelGrammar.TokenPrimitive("http://example.org"),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive("child"),
ModelGrammar.TokenPrimitive("value"),
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenArrayEnd
};
var converter = new JsonMLReader.JsonMLInTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void Format_NamespacedObjectOneProperty_CorrectlyEmitsNamespace()
{
var input = new[]
{
ModelGrammar.TokenObjectBegin("foo"),
ModelGrammar.TokenProperty(new DataName("key", String.Empty, "http://json.org")),
ModelGrammar.TokenPrimitive("value"),
ModelGrammar.TokenObjectEnd
};
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("div")),
MarkupGrammar.TokenElementBegin(new DataName("dl")),
MarkupGrammar.TokenAttribute(new DataName("title")),
MarkupGrammar.TokenPrimitive(new DataName("foo")),
MarkupGrammar.TokenElementBegin(new DataName("dt")),
MarkupGrammar.TokenPrimitive(new DataName("key", String.Empty, "http://json.org")),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementBegin(new DataName("dd")),
MarkupGrammar.TokenPrimitive("value"),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd
};
var transformer = new HtmlOutTransformer();
var actual = transformer.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_CodeCommentAroundMarkup_ReturnsSingleUnparsedBlock()
{
var input = new[]
{
ModelGrammar.TokenPrimitive(new UnparsedBlock("%--", "--%",
@"
<html>
<body style=""color:lime"">
<!-- not much to say here -->
</body>
</html>
"))
};
var expected = new[]
{
MarkupGrammar.TokenUnparsed("%--", "--%",
@"
<html>
<body style=""color:lime"">
<!-- not much to say here -->
</body>
</html>
")
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void Format_HtmlContent_ReturnsMarkup()
{
var input = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("div")),
MarkupGrammar.TokenAttribute(new DataName("class")),
MarkupGrammar.TokenPrimitive("content"),
MarkupGrammar.TokenElementBegin(new DataName("p")),
MarkupGrammar.TokenAttribute(new DataName("style")),
MarkupGrammar.TokenPrimitive("color:red"),
MarkupGrammar.TokenElementBegin(new DataName("strong")),
MarkupGrammar.TokenPrimitive("Lorem ipsum"),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenPrimitive(" dolor sit amet, "),
MarkupGrammar.TokenElementBegin(new DataName("i")),
MarkupGrammar.TokenPrimitive("consectetur"),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenPrimitive(" adipiscing elit."),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
};
const string expected = @"<div class=""content""><p style=""color:red""><strong>Lorem ipsum</strong> dolor sit amet, <i>consectetur</i> adipiscing elit.</p></div>";
var formatter = new HtmlFormatter(new DataWriterSettings());
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public void Format_CodeCommentAroundMarkup_ReturnsSingleUnparsedBlock()
{
var input = new[]
{
MarkupGrammar.TokenUnparsed("%--", "--%",
@"
<html>
<body style=""color:lime"">
<!-- not much to say here -->
</body>
</html>
")
};
const string expected =
@"<%--
<html>
<body style=""color:lime"">
<!-- not much to say here -->
</body>
</html>
--%>";
var formatter = new HtmlFormatter(new DataWriterSettings());
var actual = formatter.Format(input);
Assert.Equal(expected, actual);
}
public SourceSupervisor(ISparkSource source)
{
_source = source;
IVsHierarchy hierarchy;
uint itemid;
IVsTextLines buffer;
_source.GetDocument(out hierarchy, out itemid, out buffer);
_path = GetDocumentPath(hierarchy, itemid);
//Spark.Web.Mvc.SparkView
//MyBaseView
var settings = new VsProjectSparkSettings(hierarchy)
{
PageBaseType = source.GetDefaultPageBaseType()
};
var viewFolder = new VsProjectViewFolder(_source, hierarchy);
_engine = new SparkViewEngine(settings)
{
ViewFolder = viewFolder
};
_grammar = new MarkupGrammar(settings);
}
public IList <Node> ParseNodes(string content)
{
var grammar = new MarkupGrammar();
var result = grammar.Nodes(Source(content));
return(result.Value);
}
public SourceSupervisor(ISparkSource source)
{
_source = source;
IVsHierarchy hierarchy;
uint itemid;
IVsTextLines buffer;
_source.GetDocument(out hierarchy, out itemid, out buffer);
_path = GetDocumentPath(hierarchy, itemid);
//Spark.Web.Mvc.SparkView
//MyBaseView
var settings = new VsProjectSparkSettings(hierarchy)
{
PageBaseType = source.GetDefaultPageBaseType()
};
var viewFolder = new VsProjectViewFolder(_source, hierarchy);
_engine = new SparkViewEngine(settings)
{
ViewFolder = viewFolder
};
_grammar = new MarkupGrammar(settings);
}
public void GetTokens_DifferentPrefixSameNamespace_ReturnsSequence()
{
var input = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("foo", String.Empty, "http://example.org")),
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty(new DataName("key", "blah", "http://example.org")),
ModelGrammar.TokenPrimitive("value"),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenArrayEnd
};
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("foo", String.Empty, "http://example.org")),
MarkupGrammar.TokenAttribute(new DataName("key", "blah", "http://example.org")),
MarkupGrammar.TokenPrimitive("value"),
MarkupGrammar.TokenElementEnd
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_NamespacedChildTag_ReturnsSequence()
{
var input = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("foo")),
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("child", String.Empty, "http://example.com/schema")),
ModelGrammar.TokenPrimitive("value"),
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenArrayEnd
};
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("foo")),
MarkupGrammar.TokenElementBegin(new DataName("child", String.Empty, "http://example.com/schema")),
MarkupGrammar.TokenPrimitive("value"),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_HtmlContentPrettyPrinted_ReturnsSequence()
{
var input = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("div")),
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty(new DataName("class")),
ModelGrammar.TokenPrimitive("content"),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenPrimitive("\r\n\t"),
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("p")),
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty(new DataName("style")),
ModelGrammar.TokenPrimitive("color:red"),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenPrimitive("\r\n\t\t"),
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("strong")),
ModelGrammar.TokenPrimitive("Lorem ipsum"),
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenPrimitive(" dolor sit amet, "),
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("i")),
ModelGrammar.TokenPrimitive("consectetur"),
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenPrimitive(" adipiscing elit.\r\n\t"),
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenPrimitive("\r\n"),
ModelGrammar.TokenArrayEnd
};
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("div")),
MarkupGrammar.TokenAttribute(new DataName("class")),
MarkupGrammar.TokenPrimitive("content"),
MarkupGrammar.TokenPrimitive("\r\n\t"),
MarkupGrammar.TokenElementBegin(new DataName("p")),
MarkupGrammar.TokenAttribute(new DataName("style")),
MarkupGrammar.TokenPrimitive("color:red"),
MarkupGrammar.TokenPrimitive("\r\n\t\t"),
MarkupGrammar.TokenElementBegin(new DataName("strong")),
MarkupGrammar.TokenPrimitive("Lorem ipsum"),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenPrimitive(" dolor sit amet, "),
MarkupGrammar.TokenElementBegin(new DataName("i")),
MarkupGrammar.TokenPrimitive("consectetur"),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenPrimitive(" adipiscing elit.\r\n\t"),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenPrimitive("\r\n"),
MarkupGrammar.TokenElementEnd,
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_UndeclaredPrefixes_ReturnsDefault()
{
var input = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("one")),
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("two")),
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("three")),
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenArrayEnd
};
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("one")),
MarkupGrammar.TokenElementBegin(new DataName("two")),
MarkupGrammar.TokenElementBegin(new DataName("three")),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_ParentAndChildSharePrefixedNamespace_ReturnsSequence()
{
var input = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("foo", "bar", "http://example.org")),
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("child", "bar", "http://example.org")),
ModelGrammar.TokenPrimitive("value"),
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenArrayEnd
};
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("foo", "bar", "http://example.org")),
MarkupGrammar.TokenElementBegin(new DataName("child", "bar", "http://example.org")),
MarkupGrammar.TokenPrimitive("value"),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_AttributeWhitespaceQuotDelims_ReturnsSequence()
{
var input = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("root")),
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty(new DataName("white")),
ModelGrammar.TokenPrimitive(" extra whitespace around quote delims "),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenArrayEnd
};
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("root")),
MarkupGrammar.TokenAttribute(new DataName("white")),
MarkupGrammar.TokenPrimitive(" extra whitespace around quote delims "),
MarkupGrammar.TokenElementEnd
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_HtmlContent_ReturnsSequence()
{
const string input = @"<div class=""content""><p style=""color:red""><strong>Lorem ipsum</strong> dolor sit amet, <i>consectetur</i> adipiscing elit.</p></div>";
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("div")),
MarkupGrammar.TokenAttribute(new DataName("class")),
MarkupGrammar.TokenPrimitive("content"),
MarkupGrammar.TokenElementBegin(new DataName("p")),
MarkupGrammar.TokenAttribute(new DataName("style")),
MarkupGrammar.TokenPrimitive("color:red"),
MarkupGrammar.TokenElementBegin(new DataName("strong")),
MarkupGrammar.TokenPrimitive("Lorem ipsum"),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenPrimitive(" dolor sit amet, "),
MarkupGrammar.TokenElementBegin(new DataName("i")),
MarkupGrammar.TokenPrimitive("consectetur"),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenPrimitive(" adipiscing elit."),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
};
var tokenizer = new XmlReader.XmlTokenizer();
var actual = tokenizer.GetTokens(input).ToArray();
Assert.Equal(expected, actual);
}
public void Format_NestedObjectsAlternatingNamespaces_CorrectlyEmitsNamespaces()
{
var input = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("foo1", String.Empty, "http://json.org")),
MarkupGrammar.TokenElementBegin(new DataName("key1", String.Empty, "http://jsonfx.net")),
MarkupGrammar.TokenElementBegin(new DataName("key2", String.Empty, "http://json.org")),
MarkupGrammar.TokenPrimitive("value"),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
};
var expected = new[]
{
ModelGrammar.TokenObjectBegin(new DataName("foo1", String.Empty, "http://json.org")),
ModelGrammar.TokenProperty(new DataName("key1", String.Empty, "http://jsonfx.net")),
ModelGrammar.TokenObjectBegin(new DataName("key2", String.Empty, "http://json.org")),
ModelGrammar.TokenProperty(new DataName("key2", String.Empty, "http://json.org")),
ModelGrammar.TokenPrimitive("value"),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenObjectEnd
};
var transformer = new XmlReader.XmlInTransformer(new DataReaderSettings());
var actual = transformer.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
private List<Completion> CheckForSpecialNodes()
{
var tag = ApplicableTo;// _textExplorer.GetTagAtPosition(_textExplorer.GetStartPosition());
var startingPoint = 1;// ApplicableTo.GetStartPoint(_textBuffer.CurrentSnapshot);
//var line = startingPoint.GetContainingLine();
//var extent = line.Extent;
var grammar = new MarkupGrammar();
SpecialNode node = null;//grammar.AnyNode(Source(extent.GetText())).Value;
var attributesForSpecialNode = new List<Completion>();
if (node is SpecialNode)
{
var knownAttributesForNode = GetKnownAttributesForSpecialNode((SpecialNode)node);
knownAttributesForNode.ForEach(attribute => attributesForSpecialNode.Add(
new Completion(
attribute,
String.Format("{0}=\"\"", attribute),
String.Format("'{0}' attribute for '{1}' element", attribute, ((SpecialNode)node).Element.Name),
SparkAttributeIcon, null)));
}
return attributesForSpecialNode;
}
public void Format_ArrayOneItem_ReturnsExpectedArray()
{
var input = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenNull,
ModelGrammar.TokenArrayEnd
};
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("div")),
MarkupGrammar.TokenElementBegin(new DataName("ol")),
MarkupGrammar.TokenElementBegin(new DataName("li")),
MarkupGrammar.TokenPrimitive(null),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd
};
var transformer = new HtmlOutTransformer();
var actual = transformer.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void Format_NamedObjectOneProperty_RendersSimpleObject()
{
var input = new[]
{
ModelGrammar.TokenObjectBegin("Yada"),
ModelGrammar.TokenProperty("key"),
ModelGrammar.TokenPrimitive("value"),
ModelGrammar.TokenObjectEnd
};
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("div")),
MarkupGrammar.TokenElementBegin(new DataName("dl")),
MarkupGrammar.TokenAttribute(new DataName("title")),
MarkupGrammar.TokenPrimitive(new DataName("Yada")),
MarkupGrammar.TokenElementBegin(new DataName("dt")),
MarkupGrammar.TokenPrimitive(new DataName("key")),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementBegin(new DataName("dd")),
MarkupGrammar.TokenPrimitive("value"),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd
};
var transformer = new HtmlOutTransformer();
var actual = transformer.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void ChainConditionalAttribute()
{
var grammar = new MarkupGrammar();
string input = "<div if=\"false\">hello</div><div elseif=\"true\">world</div><else>that's all</else>";
var nodes = grammar.Nodes(new Position(new SourceContext(input))).Value;
var visitor0 = new SpecialNodeVisitor(new VisitorContext());
visitor0.Accept(nodes);
var visitor = new ConditionalAttributeVisitor(new VisitorContext());
visitor.Accept(visitor0.Nodes);
Assert.AreEqual(3, visitor.Nodes.Count);
Assert.IsAssignableFrom(typeof(SpecialNode), visitor.Nodes[0]);
Assert.IsAssignableFrom(typeof(SpecialNode), visitor.Nodes[1]);
Assert.IsAssignableFrom(typeof(SpecialNode), visitor.Nodes[2]);
var ifNode = (SpecialNode)visitor.Nodes[0];
Assert.AreEqual("if", ifNode.Element.Name);
var elseifNode = (SpecialNode)visitor.Nodes[1];
Assert.AreEqual("elseif", elseifNode.Element.Name);
var elseNode = (SpecialNode)visitor.Nodes[2];
Assert.AreEqual("else", elseNode.Element.Name);
}
private List <Completion> CheckForSpecialNodes()
{
var tag = ApplicableTo; // _textExplorer.GetTagAtPosition(_textExplorer.GetStartPosition());
var startingPoint = 1; // ApplicableTo.GetStartPoint(_textBuffer.CurrentSnapshot);
//var line = startingPoint.GetContainingLine();
//var extent = line.Extent;
var grammar = new MarkupGrammar();
SpecialNode node = null;//grammar.AnyNode(Source(extent.GetText())).Value;
var attributesForSpecialNode = new List <Completion>();
if (node is SpecialNode)
{
var knownAttributesForNode = GetKnownAttributesForSpecialNode((SpecialNode)node);
knownAttributesForNode.ForEach(attribute => attributesForSpecialNode.Add(
new Completion(
attribute,
String.Format("{0}=\"\"", attribute),
String.Format("'{0}' attribute for '{1}' element", attribute, ((SpecialNode)node).Element.Name),
SparkAttributeIcon, null)));
}
return(attributesForSpecialNode);
}
public void Format_ArrayMultiItem_ReturnsExpectedArray()
{
var input = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("array")),
MarkupGrammar.TokenElementBegin(new DataName("item")),
MarkupGrammar.TokenPrimitive(0),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementVoid(new DataName("item")),
MarkupGrammar.TokenElementBegin(new DataName("item")),
MarkupGrammar.TokenPrimitive(false),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementBegin(new DataName("item")),
MarkupGrammar.TokenPrimitive(true),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
};
var expected = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(0),
ModelGrammar.TokenNull,
ModelGrammar.TokenFalse,
ModelGrammar.TokenTrue,
ModelGrammar.TokenArrayEnd
};
var transformer = new XmlReader.XmlInTransformer(new DataReaderSettings());
var actual = transformer.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
private void EmitNewLine(List <Token <MarkupTokenType> > output)
{
bool tabIsEmpty = String.IsNullOrEmpty(this.Settings.Tab);
if (tabIsEmpty &&
String.IsNullOrEmpty(this.Settings.NewLine))
{
return;
}
// emit CRLF
StringBuilder buffer = new StringBuilder(this.Settings.NewLine);
if (!tabIsEmpty)
{
if (this.Settings.Tab.Length == 1)
{
buffer.Append(this.Settings.Tab[0], this.depth);
}
else
{
for (int i = 0; i < this.depth; i++)
{
// indent next line accordingly
buffer.Append(this.Settings.Tab);
}
}
}
output.Add(MarkupGrammar.TokenPrimitive(buffer.ToString()));
}
public void Format_ObjectNested_RendersNestedObject()
{
// input from pass3.json in test suite at http://www.json.org/JSON_checker/
var input = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("object")),
MarkupGrammar.TokenElementBegin(new DataName("JSON_x0020_Test_x0020_Pattern_x0020_pass3")),
MarkupGrammar.TokenElementBegin(new DataName("The_x0020_outermost_x0020_value")),
MarkupGrammar.TokenPrimitive("must be an object or array."),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementBegin(new DataName("In_x0020_this_x0020_test")),
MarkupGrammar.TokenPrimitive("It is an object."),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd,
};
var expected = new[]
{
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("JSON Test Pattern pass3"),
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty("The outermost value"),
ModelGrammar.TokenPrimitive("must be an object or array."),
ModelGrammar.TokenProperty("In this test"),
ModelGrammar.TokenPrimitive("It is an object."),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenObjectEnd
};
var transformer = new XmlReader.XmlInTransformer(new DataReaderSettings());
var actual = transformer.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_MultipleAttributes_ReturnsSequence()
{
var input = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("root")),
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty(new DataName("no-value")),
ModelGrammar.TokenPrimitive(String.Empty),
ModelGrammar.TokenProperty(new DataName("whitespace")),
ModelGrammar.TokenPrimitive(" this contains whitespace "),
ModelGrammar.TokenProperty(new DataName("anyQuotedText")),
ModelGrammar.TokenPrimitive("/\\\uCAFE\uBABE\uAB98\uFCDE\ubcda\uef4A\b\f\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?"),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenArrayEnd
};
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("root")),
MarkupGrammar.TokenAttribute(new DataName("no-value")),
MarkupGrammar.TokenPrimitive(String.Empty),
MarkupGrammar.TokenAttribute(new DataName("whitespace")),
MarkupGrammar.TokenPrimitive(" this contains whitespace "),
MarkupGrammar.TokenAttribute(new DataName("anyQuotedText")),
MarkupGrammar.TokenPrimitive("/\\\uCAFE\uBABE\uAB98\uFCDE\ubcda\uef4A\b\f\n\r\t`1~!@#$%^&*()_+-=[]{}|;:',./<>?"),
MarkupGrammar.TokenElementEnd
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_ParentAndChildDifferentDefaultNamespaces_ReturnsSequence()
{
var input = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("foo", String.Empty, "http://json.org")),
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("child", String.Empty, "http://jsonfx.net")),
ModelGrammar.TokenPrimitive("text value"),
ModelGrammar.TokenArrayEnd,
ModelGrammar.TokenArrayEnd
};
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("foo", String.Empty, "http://json.org")),
MarkupGrammar.TokenElementBegin(new DataName("child", String.Empty, "http://jsonfx.net")),
MarkupGrammar.TokenPrimitive("text value"),
MarkupGrammar.TokenElementEnd,
MarkupGrammar.TokenElementEnd
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void GetTokens_SingleAttributeEmptyValue_ReturnsSequence()
{
var input = new[]
{
ModelGrammar.TokenArrayBeginUnnamed,
ModelGrammar.TokenPrimitive(new DataName("root")),
ModelGrammar.TokenObjectBeginUnnamed,
ModelGrammar.TokenProperty(new DataName("emptyValue")),
ModelGrammar.TokenPrimitive(String.Empty),
ModelGrammar.TokenObjectEnd,
ModelGrammar.TokenArrayEnd
};
var expected = new[]
{
MarkupGrammar.TokenElementBegin(new DataName("root")),
MarkupGrammar.TokenAttribute(new DataName("emptyValue")),
MarkupGrammar.TokenPrimitive(String.Empty),
MarkupGrammar.TokenElementEnd
};
var converter = new JsonMLWriter.JsonMLOutTransformer();
var actual = converter.Transform(input).ToArray();
Assert.Equal(expected, actual);
}
public void PaintingNodes()
{
var input = "<div><p class='subtle'>Hello World</p> ${Tada} </div>";
var grammar = new MarkupGrammar();
var result = grammar.Nodes(new Position(new SourceContext(input)));
Assert.AreEqual(8, result.Value.Count);
Assert.AreEqual(10, result.Rest.GetPaint().OfType <Paint <Node> >().Count());
}
public void BangSyntaxHasRawContentWhenDisabled()
{
var settings = new ParserSettings { AutomaticEncoding = false };
var grammar = new MarkupGrammar(settings);
var result = grammar.Nodes(Source("!{'hello world'}"));
Assert.AreEqual(1, result.Value.Count);
Assert.AreEqual("\"hello world\"", (string)((ExpressionNode)result.Value[0]).Code);
Assert.IsFalse(((ExpressionNode)result.Value[0]).AutomaticEncoding);
}
private void EmitTag(List <Token <MarkupTokenType> > output, DataName elementName, IDictionary <DataName, Token <ModelTokenType> > attributes, MarkupTokenType tagType)
{
if (this.pendingNewLine)
{
if (this.Settings.PrettyPrint)
{
this.depth++;
this.EmitNewLine(output);
}
this.pendingNewLine = false;
}
PrefixScopeChain.Scope scope = new PrefixScopeChain.Scope();
scope.TagName = elementName;
if (!this.ScopeChain.ContainsNamespace(elementName.NamespaceUri))
{
scope[elementName.Prefix] = elementName.NamespaceUri;
}
this.ScopeChain.Push(scope);
switch (tagType)
{
case MarkupTokenType.ElementVoid:
{
output.Add(MarkupGrammar.TokenElementVoid(elementName));
break;
}
case MarkupTokenType.ElementEnd:
{
output.Add(MarkupGrammar.TokenElementEnd);
break;
}
default:
case MarkupTokenType.ElementBegin:
{
output.Add(MarkupGrammar.TokenElementBegin(elementName));
break;
}
}
if (attributes != null)
{
foreach (var attr in attributes)
{
output.Add(MarkupGrammar.TokenAttribute(attr.Key));
output.Add(attr.Value.ChangeType(MarkupTokenType.Primitive));
}
attributes.Clear();
}
}
public void CorrectSectionsCreated()
{
var grammar = new MarkupGrammar();
var nodes = grammar.Nodes(new Position(new SourceContext(
"<foo>1<tr>2<td>3</foo> <bar>4</td>5</tr>6</bar> stuff <baaz>yadda<baaz></baaz><quux><quux/></baaz>")));
var visitor = new ViewComponentSectionChunkBuilderVisitor();
visitor.Accept(nodes.Value);
Assert.AreEqual(3, visitor.Sections.Count);
Assert.AreEqual(1, visitor.Sections["foo"].Count);
Assert.AreEqual("1<tr>2<td>3", ((SendLiteralChunk)visitor.Sections["foo"][0]).Text);
}
public void CorrectSectionsCreated()
{
var grammar = new MarkupGrammar(ParserSettings.DefaultBehavior);
var nodes = grammar.Nodes(new Position(new SourceContext(
"<foo>1<tr>2<td>3</foo> <bar>4</td>5</tr>6</bar> stuff <baaz>yadda<baaz></baaz><quux><quux/></baaz>")));
var details = new ViewComponentDetailsAttribute("Testing") { Sections = "foo,baaz,bar,quux" };
var visitor = new ViewComponentVisitor(new ChunkBuilderVisitor(new VisitorContext{Paint=nodes.Rest.GetPaint()}), new ViewComponentInfo { Details = details });
visitor.Accept(nodes.Value);
Assert.AreEqual(3, visitor.Sections.Count);
Assert.AreEqual(1, visitor.Sections["foo"].Count);
Assert.AreEqual("1<tr>2<td>3", ((SendLiteralChunk)visitor.Sections["foo"][0]).Text);
}
public void DetectIfAttribute()
{
var grammar = new MarkupGrammar();
string input = "<div if=\"true\">hello</div>";
var nodes = grammar.Nodes(new Position(new SourceContext(input))).Value;
var visitor = new ConditionalAttributeVisitor(new VisitorContext());
visitor.Accept(nodes);
Assert.AreEqual(1, visitor.Nodes.Count);
Assert.IsAssignableFrom(typeof(SpecialNode), visitor.Nodes[0]);
var ifNode = visitor.Nodes[0] as SpecialNode;
Assert.IsNotNull(ifNode);
Assert.AreEqual("if", ifNode.Element.Name);
}
public void RemoveLinesBeforeSpecialNodes()
{
var grammar = new MarkupGrammar();
var nodes = grammar.Nodes(Source("<p>\r\n <test if='true'>\r\n <span>was true</span>\r\n </test>\r\n</p>"));
var specialNodeVisitor = new SpecialNodeVisitor(new VisitorContext());
specialNodeVisitor.Accept(nodes.Value);
omit.Accept(specialNodeVisitor.Nodes);
Assert.AreEqual(5, omit.Nodes.Count);
Assert.IsAssignableFrom(typeof(ElementNode), omit.Nodes[0]);
Assert.IsAssignableFrom(typeof(TextNode), omit.Nodes[1]);
Assert.AreEqual("", ((TextNode)omit.Nodes[1]).Text);
Assert.IsAssignableFrom(typeof(SpecialNode), omit.Nodes[2]);
var childNodes = ((SpecialNode) omit.Nodes[2]).Body;
Assert.AreEqual(5, childNodes.Count);
Assert.IsAssignableFrom(typeof(TextNode), childNodes[0]);
Assert.AreEqual("\r\n ", ((TextNode)childNodes[0]).Text);
Assert.IsAssignableFrom(typeof(TextNode), childNodes[4]);
Assert.AreEqual("", ((TextNode)childNodes[4]).Text);
}
public void PaintingAttributes()
{
var input = "<div id='rea' class='foo'/>";
var grammar = new MarkupGrammar();
var result = grammar.Nodes(new Position(new SourceContext(input)));
Assert.AreEqual(1, result.Value.Count);
var paints = result.Rest.GetPaint();
Assert.AreEqual(1, paints.Select(p => p.Value).OfType<ElementNode>().Count());
Assert.AreEqual(2, paints.Select(p => p.Value).OfType<AttributeNode>().Count());
Assert.AreEqual(2, paints.Select(p => p.Value).OfType<TextNode>().Count());
Assert.AreEqual(5, paints.OfType<Paint<Node>>().Count());
var attrId = paints.Single(p => (p.Value is AttributeNode) && ((AttributeNode)p.Value).Name == "id");
var attrClass = paints.Single(p => (p.Value is AttributeNode) && ((AttributeNode)p.Value).Name == "class");
Assert.AreEqual(5, attrId.Begin.Offset);
Assert.AreEqual(13, attrId.End.Offset);
Assert.AreEqual(14, attrClass.Begin.Offset);
Assert.AreEqual(25, attrClass.End.Offset);
}
public void HashSyntaxIgnoredWhenCustomMarkerProvided()
{
var settings = new ParserSettings { AutomaticEncoding = true, StatementMarker = "hi" };
var grammar = new MarkupGrammar(settings);
var result = grammar.Nodes(Source(" #foo \r\n"));
Assert.AreEqual(1, result.Value.Count);
var statement = result.Value.OfType<StatementNode>().Any();
Assert.That(statement, Is.False);
}
public DefaultSyntaxProvider(IParserSettings settings)
{
_grammar = new MarkupGrammar(settings);
}
public void CustomMarkerForStatements()
{
var settings = new ParserSettings { AutomaticEncoding = true, StatementMarker="hi" };
var grammar = new MarkupGrammar(settings);
var result = grammar.Nodes(Source(" hibernate \r\n"));
Assert.AreEqual(2, result.Value.Count);
var statement = result.Value.OfType<StatementNode>().Single();
Assert.That(statement.Code.ToString(), Is.EqualTo("bernate "));
}
public CustomSyntaxProvider(ISparkSettings settings)
: base(settings)
{
_grammar = new MarkupGrammar(settings);
_releaseMode = !settings.Debug;
}
public void HashSyntaxForStatementsByDefault()
{
var settings = new ParserSettings { AutomaticEncoding = true };
var grammar = new MarkupGrammar(settings);
var result = grammar.Nodes(Source(" #foo \r\n"));
Assert.AreEqual(2, result.Value.Count);
var statement = result.Value.OfType<StatementNode>().Single();
Assert.That(statement.Code.ToString(), Is.EqualTo("foo "));
}
public void DollarHasEncodedContentWhenEnabled()
{
var settings = new ParserSettings { AutomaticEncoding = true };
var grammar = new MarkupGrammar(settings);
var result = grammar.Nodes(Source("${'hello world'}"));
Assert.AreEqual(1, result.Value.Count);
Assert.AreEqual("\"hello world\"", (string)((ExpressionNode)result.Value[0]).Code);
Assert.IsTrue(((ExpressionNode)result.Value[0]).AutomaticEncoding);
}
public void PaintingNodes()
{
var input = "<div><p class='subtle'>Hello World</p> ${Tada} </div>";
var grammar = new MarkupGrammar();
var result = grammar.Nodes(new Position(new SourceContext(input)));
Assert.AreEqual(8, result.Value.Count);
Assert.AreEqual(10, result.Rest.GetPaint().OfType<Paint<Node>>().Count());
}
public static IList<Chunk> ParseElementChunks(string content, int position)
{
var node = ParseNode(content, position);
var contentToParse = node is ElementNode ? GetElementNodeAsString((ElementNode)node) : content;
var grammar = new MarkupGrammar();
var visitorContext = new VisitorContext { SyntaxProvider = new DefaultSyntaxProvider(new ParserSettings()) };
var result = grammar.Nodes(Source(contentToParse));
var nodes = result.Value;
foreach (var visitor in BuildChunkVisitors(visitorContext))
{
visitor.Accept(nodes);
nodes = visitor.Nodes;
}
var chunkBuilder = new ChunkBuilderVisitor(visitorContext);
chunkBuilder.Accept(nodes);
var chunks = chunkBuilder.Chunks;
return chunks;
}
public static IList<Node> ParseNodes(string content)
{
var grammar = new MarkupGrammar();
var result = grammar.Nodes(Source(content));
return result.Value;
}
private static Position GetStartPosition(string content, int position)
{
var parser = new MarkupGrammar();
Position startPosition = null;
var endPosition = Source(content);
ParseResult<Node> currentNode = null;
while (endPosition.Offset < position)
{
startPosition = endPosition;
currentNode = parser.AnyNode(startPosition);
endPosition = currentNode.Rest;
}
return startPosition;
}
public void Init()
{
grammar = new MarkupGrammar();
}
