public void DothtmlTokenizer_DirectiveParsing_Invalid_OnlyAtSymbol()
{
var input = @"@";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.DirectiveStart, tokenizer.Tokens[i++].Type);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.AreEqual(DothtmlTokenType.DirectiveName, tokenizer.Tokens[i++].Type);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.AreEqual(DothtmlTokenType.DirectiveValue, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_ElementParsing_Invalid_AttributeName_MissingTagName()
{
var input = @"<a prefix:=''/>";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(input);
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Colon, tokenizer.Tokens[i++].Type);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Equals, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.SingleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.SingleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Slash, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_DirectiveParsing_Valid_TwoDirectives()
{
var input = @"
@viewmodel DotVVM.Samples.Sample1.IndexViewModel
@masterpage ~/Site.dothtml
this is a test content";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
// first line
var i = 0;
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DirectiveStart, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DirectiveName, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DirectiveValue, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DirectiveStart, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DirectiveName, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DirectiveValue, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_DirectiveParsing_Invalid_AtSymbol_Space_NewLine_Content()
{
var input = @"@
test";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.DirectiveStart, tokenizer.Tokens[i++].Type);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.AreEqual(DothtmlTokenType.DirectiveName, tokenizer.Tokens[i++].Type);
Assert.AreEqual(2, tokenizer.Tokens[i].Length);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.AreEqual(DothtmlTokenType.DirectiveValue, tokenizer.Tokens[i++].Type);
Assert.AreEqual("\r\n", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual("test", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_BindingParsing_Valid_SelfClosing_BindingAttribute()
{
var input = @" tr <input value=""{binding: FirstName}"" />";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(input);
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Equals, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DoubleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenBinding, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Colon, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseBinding, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DoubleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Slash, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_BindingParsing_Valid_Tag_CurlyBraceInStringInBinding_EscapedQuotes()
{
var input = @"<a href=""{binding: ""\""{"" + FirstName + '\'""{'}"">";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(input);
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Equals, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DoubleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenBinding, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Colon, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(@"""\""{"" + FirstName + '\'""{'", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseBinding, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DoubleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_ServerCommentParsing_Valid()
{
var input = @"test <%-- this is a text < > "" ' --%> test2";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(input);
CheckForErrors(tokenizer, input.Length);
// first line
var i = 0;
Assert.AreEqual("test ", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual("<%--", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.OpenServerComment, tokenizer.Tokens[i++].Type);
Assert.AreEqual(@" this is a text < > "" ' ", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.CommentBody, tokenizer.Tokens[i++].Type);
Assert.AreEqual("--%>", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.CloseComment, tokenizer.Tokens[i++].Type);
Assert.AreEqual(" test2", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_ElementParsing_Valid_AttributeWithoutValue()
{
var input = @" tr <input type=""checkbox"" checked />";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(input);
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Equals, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DoubleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DoubleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Slash, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_DoctypeParsing_Valid()
{
var input = @"test <!DOCTYPE html> test2";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
// first line
var i = 0;
Assert.AreEqual("test ", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual("<!DOCTYPE", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.OpenDoctype, tokenizer.Tokens[i++].Type);
Assert.AreEqual(" html", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.DoctypeBody, tokenizer.Tokens[i++].Type);
Assert.AreEqual(">", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.CloseDoctype, tokenizer.Tokens[i++].Type);
Assert.AreEqual(" test2", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_DoctypeParsing_Valid_End()
{
var input = @"test <!DOCTYPE html>";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(input);
CheckForErrors(tokenizer, input.Length);
// first line
var i = 0;
Assert.AreEqual("test ", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual("<!DOCTYPE", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.OpenDoctype, tokenizer.Tokens[i++].Type);
Assert.AreEqual(" html", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.DoctypeBody, tokenizer.Tokens[i++].Type);
Assert.AreEqual(">", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.CloseDoctype, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_BindingParsing_Valid_SelfClosing_BindingAttribute()
{
var input = @" tr <input value=""{binding: FirstName}"" />";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Equals, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DoubleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenBinding, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Colon, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseBinding, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DoubleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Slash, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_ElementParsing_Incomplete_OpenTag_WhiteSpace_AnotherTag()
{
var input = @"<html <a/>";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Slash, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
}
/// <summary>
/// Extracts the place holder ids.
/// </summary>
public List <string> ExtractPlaceHolderIds(string fileName)
{
try
{
var sourceText = File.ReadAllText(fileName);
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(sourceText);
var parser = new DothtmlParser();
var tree = parser.Parse(tokenizer.Tokens);
var results = new List <string>();
foreach (var node in tree.EnumerateNodes().OfType <DothtmlElementNode>())
{
if (node.FullTagName == "dot:ContentPlaceHolder" || node.FullTagName == "dot:SpaContentPlaceHolder")
{
var id = node.Attributes.FirstOrDefault(a => a.AttributeName == "ID");
if (id != null && id.ValueNode is DothtmlValueTextNode)
{
results.Add((id.ValueNode as DothtmlValueTextNode).Text);
}
}
}
return(results);
}
catch (Exception ex)
{
throw new Exception($"Cannot extract ContentPlaceHolderIds from a file '{fileName}'!", ex);
}
}
public void DothtmlTokenizer_ElementParsing_Incomplete_OpenTag_AttributeName_Equals_Quote_Quote_AnotherTag()
{
var input = @"<html attr=''<a/>";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(input);
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Equals, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.SingleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.SingleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Slash, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_CDataParsing_Valid()
{
var input = @"test <![CDATA[ this is a text < > "" ' ]]> test2";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(input);
CheckForErrors(tokenizer, input.Length);
// first line
var i = 0;
Assert.AreEqual("test ", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual("<![CDATA[", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.OpenCData, tokenizer.Tokens[i++].Type);
Assert.AreEqual(@" this is a text < > "" ' ", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.CDataBody, tokenizer.Tokens[i++].Type);
Assert.AreEqual("]]>", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.CloseCData, tokenizer.Tokens[i++].Type);
Assert.AreEqual(" test2", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
}
protected void CheckForErrors(DothtmlTokenizer tokenizer, int inputLength)
{
// check for parsing errors
if (tokenizer.Tokens.Any(t => t.Length != t.Text.Length))
{
throw new Exception("The length of the token does not match with its text content length!");
}
// check that the token sequence is complete
var position = 0;
foreach (var token in tokenizer.Tokens)
{
if (token.StartPosition != position)
{
throw new Exception("The token sequence is not complete!");
}
position += token.Length;
}
if (position != inputLength)
{
throw new Exception("The parser did not finished the file!");
}
}
public void DothtmlTokenizer_XmlProcessingInstructionParsing_Valid()
{
var input = @"test <?xml version=""1.0"" encoding=""utf-8"" ?> test2";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(input);
CheckForErrors(tokenizer, input.Length);
// first line
var i = 0;
Assert.AreEqual("test ", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual("<?", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.OpenXmlProcessingInstruction, tokenizer.Tokens[i++].Type);
Assert.AreEqual(@"xml version=""1.0"" encoding=""utf-8"" ", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.XmlProcessingInstructionBody, tokenizer.Tokens[i++].Type);
Assert.AreEqual("?>", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.CloseXmlProcessingInstruction, tokenizer.Tokens[i++].Type);
Assert.AreEqual(" test2", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_ElementParsing_Valid_SelfClosing_EmptyAttribute()
{
var input = @" tr <html xmlns="""" />";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(input);
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Equals, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DoubleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DoubleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Slash, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
}
/// <summary>
/// Initializes a new instance of the <see cref="DothtmlClassifier"/> class.
/// </summary>
public DothtmlClassifier(IClassificationTypeRegistryService registry, ITextBuffer buffer)
{
tokenizer = new DothtmlTokenizer();
this.buffer = buffer;
bindingBrace = registry.GetClassificationType(DothtmlClassificationTypes.BindingBrace);
bindingContent = registry.GetClassificationType(DothtmlClassificationTypes.BindingContent);
}
public void DothtmlTokenizer_BindingParsing_Invalid_BindingInPlainText_ClosedWithOneBrace()
{
var input = @"tr {{binding: FirstName}test"" />";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(input);
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenBinding, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Colon, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual("FirstName", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(1, tokenizer.Tokens[i].Length);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(DothtmlTokenType.CloseBinding, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
}
/// <summary>
/// Extracts the place holder ids.
/// </summary>
public List <string> ExtractPlaceHolderIds(string fileName)
{
try
{
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new FileReader(fileName));
var parser = new DothtmlParser();
var tree = parser.Parse(tokenizer.Tokens);
var results = new List <string>();
foreach (var node in tree.EnumerateNodes().OfType <DothtmlElementNode>())
{
if (node.FullTagName == "dot:ContentPlaceHolder" || node.FullTagName == "dot:SpaContentPlaceHolder")
{
var id = node.Attributes.FirstOrDefault(a => a.AttributeName == "ID");
if (id != null && id.Literal.GetType() == typeof(DothtmlLiteralNode))
{
results.Add(id.Literal.Value);
}
}
}
return(results);
}
catch (Exception ex)
{
LogService.LogError(new Exception($"Cannot extract ContentPlaceHolderIds from a file '{fileName}'!", ex));
return(null);
}
}
public static List <DothtmlToken> Tokenize(string dothtml)
{
var t = new DothtmlTokenizer();
t.Tokenize(dothtml);
return(t.Tokens);
}
protected override IEnumerable <string> GetValidationErrors()
{
try
{
ResolvedTreeRoot root;
try
{
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(Code);
var parser = new DothtmlParser();
var node = parser.Parse(tokenizer.Tokens);
var resolver = new DefaultControlTreeResolver(DotvvmConfiguration.CreateDefault());
root = (ResolvedTreeRoot)resolver.ResolveTree(node, Guid.NewGuid() + ".dothtml");
}
catch (Exception ex)
{
throw new CodeValidationException("Syntax error in the DOTHTML code.", ex);
}
Validator.Validate(root);
return(Enumerable.Empty <string>());
}
catch (CodeValidationException ex)
{
return(new[] { ex.Message });
}
}
public void DothtmlTokenizer_DirectiveParsing_Valid_TwoDirectives()
{
var input = @"
@viewmodel DotVVM.Samples.Sample1.IndexViewModel
@masterpage ~/Site.dothtml
this is a test content";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
// first line
var i = 0;
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DirectiveStart, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DirectiveName, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DirectiveValue, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DirectiveStart, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DirectiveName, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DirectiveValue, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
}
public void MutableTokens()
{
// for incremental updates of the tree, the Text and Position must be accessible
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize("some not very interesting text <!-- Comment -->");
var parser = new DothtmlParser();
var tree = parser.Parse(tokenizer.Tokens);
var textNode = tree.EnumerateNodes().OfType <DothtmlLiteralNode>().Single();
Assert.AreEqual("some not very interesting text ", textNode.Value);
var text = tokenizer.Tokens[0];
var comment = tokenizer.Tokens[2];
Assert.AreEqual(text.Type, DothtmlTokenType.Text);
Assert.AreEqual(tokenizer.Tokens[1].Type, DothtmlTokenType.OpenComment);
Assert.AreEqual(comment.Type, DothtmlTokenType.CommentBody);
Assert.AreEqual(tokenizer.Tokens[3].Type, DothtmlTokenType.CloseComment);
Assert.AreEqual(4, tokenizer.Tokens.Count);
text.Text = "some little bit more interesting text";
text.Length = text.Text.Length;
comment.StartPosition = "some little bit more interesting text".Length;
Assert.AreEqual("some little bit more interesting text", textNode.Value);
}
public void TokenizeAndParse()
{
var t = new DothtmlTokenizer();
t.Tokenize(new StringReader(data));
var p = new DothtmlParser();
var node = p.Parse(t.Tokens);
}
protected IList <DothtmlToken> Tokenize(string markup)
{
var t = new DothtmlTokenizer();
t.Tokenize(new StringReader(markup));
return(t.Tokens);
}
public void TokenizeAndParse()
{
var t = new DothtmlTokenizer();
t.Tokenize(data);
var p = new DothtmlParser();
var node = p.Parse(t.Tokens);
}
/// <summary>
/// Compiles the view and returns a function that can be invoked repeatedly. The function builds full control tree and activates the page.
/// </summary>
public virtual CSharpCompilation CompileView(string sourceCode, string fileName, CSharpCompilation compilation, string namespaceName, string className)
{
// parse the document
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(sourceCode);
var parser = new DothtmlParser();
var node = parser.Parse(tokenizer.Tokens);
var resolvedView = (ResolvedTreeRoot)controlTreeResolver.ResolveTree(node, fileName);
var errorCheckingVisitor = new ErrorCheckingVisitor();
resolvedView.Accept(errorCheckingVisitor);
foreach (var token in tokenizer.Tokens)
{
if (token.HasError && token.Error.IsCritical)
{
throw new DotvvmCompilationException(token.Error.ErrorMessage, new[] { (token.Error as BeginWithLastTokenOfTypeTokenError <DothtmlToken, DothtmlTokenType>)?.LastToken ?? token });
}
}
foreach (var n in node.EnumerateNodes())
{
if (n.HasNodeErrors)
{
throw new DotvvmCompilationException(string.Join(", ", n.NodeErrors), n.Tokens);
}
}
var styleVisitor = new StylingVisitor(configuration.Styles);
resolvedView.Accept(styleVisitor);
var validationVisitor = new Validation.ControlUsageValidationVisitor(configuration);
resolvedView.Accept(validationVisitor);
if (validationVisitor.Errors.Any())
{
var controlUsageError = validationVisitor.Errors.First();
throw new DotvvmCompilationException(controlUsageError.ErrorMessage, controlUsageError.Nodes.SelectMany(n => n.Tokens));
}
if (configuration.Debug && configuration.ApplicationPhysicalPath != null)
{
var addExpressionDebugvisitor = new ExpressionDebugInfoAddingVisitor(Path.Combine(configuration.ApplicationPhysicalPath, fileName));
addExpressionDebugvisitor.VisitView(resolvedView);
}
var emitter = new DefaultViewCompilerCodeEmitter();
var compilingVisitor = new ViewCompilingVisitor(emitter, configuration.ServiceLocator.GetService <IBindingCompiler>(), className,
b => configuration.ServiceLocator.GetService <IBindingIdGenerator>().GetId(b, fileName));
resolvedView.Accept(compilingVisitor);
return(AddToCompilation(compilation, emitter, fileName, namespaceName, className));
}
public static DothtmlRootNode TokenizeAndParse(string dothtml)
{
var t = new DothtmlTokenizer();
t.Tokenize(dothtml);
var p = new DothtmlParser();
return(p.Parse(t.Tokens));
}
/// <summary>
/// Parses text from ITextBuffer and returns root node of syntax tree.
/// </summary>
/// <param name="buffer"></param>
/// <returns></returns>
public static DothtmlRootNode GetDothtmlRootNode(this ITextBuffer buffer)
{
DothtmlTokenizer t = new DothtmlTokenizer();
t.Tokenize(new StringReader(buffer.CurrentSnapshot.GetText()));
var parser = new DothtmlParser();
return(parser.Parse(t.Tokens));
}
/// <summary>
/// Compiles the view and returns a function that can be invoked repeatedly. The function builds full control tree and activates the page.
/// </summary>
public virtual (ControlBuilderDescriptor, Func <CSharpCompilation>) CompileView(string sourceCode, string fileName, CSharpCompilation compilation, string namespaceName, string className)
{
// parse the document
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(sourceCode);
var parser = new DothtmlParser();
var node = parser.Parse(tokenizer.Tokens);
var resolvedView = (ResolvedTreeRoot)controlTreeResolver.ResolveTree(node, fileName);
return(new ControlBuilderDescriptor(resolvedView.DataContextTypeStack.DataContextType, resolvedView.Metadata.Type), () => {
var errorCheckingVisitor = new ErrorCheckingVisitor();
resolvedView.Accept(errorCheckingVisitor);
foreach (var token in tokenizer.Tokens)
{
if (token.HasError && token.Error.IsCritical)
{
throw new DotvvmCompilationException(token.Error.ErrorMessage, new[] { (token.Error as BeginWithLastTokenOfTypeTokenError <DothtmlToken, DothtmlTokenType>)?.LastToken ?? token });
}
}
foreach (var n in node.EnumerateNodes())
{
if (n.HasNodeErrors)
{
throw new DotvvmCompilationException(string.Join(", ", n.NodeErrors), n.Tokens);
}
}
var bindingResourceRegisteringVisitor = this.bindingResourceRegisteringVisitor();
resolvedView.Accept(bindingResourceRegisteringVisitor);
var styleVisitor = new StylingVisitor(configuration);
resolvedView.Accept(styleVisitor);
var contextSpaceVisitor = new DataContextPropertyAssigningVisitor();
resolvedView.Accept(contextSpaceVisitor);
var validationVisitor = new Validation.ControlUsageValidationVisitor(configuration);
resolvedView.Accept(validationVisitor);
if (validationVisitor.Errors.Any())
{
var controlUsageError = validationVisitor.Errors.First();
throw new DotvvmCompilationException(controlUsageError.ErrorMessage, controlUsageError.Nodes.SelectMany(n => n.Tokens));
}
var emitter = new DefaultViewCompilerCodeEmitter();
var compilingVisitor = new ViewCompilingVisitor(emitter, configuration.ServiceLocator.GetService <IBindingCompiler>(), className);
resolvedView.Accept(compilingVisitor);
return AddToCompilation(compilation, emitter, fileName, namespaceName, className);
}
);
}
public void DothtmlTokenizer_TokenizeBinding_Invalid_Unclosed()
{
var input = @"{binding: FirstName";
// parse
var tokenizer = new DothtmlTokenizer();
var result = tokenizer.TokenizeBinding(input, false);
Assert.IsFalse(result);
}
public static DothtmlRootNode ParseMarkup(string markup)
{
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(markup);
var parser = new DothtmlParser();
var node = parser.Parse(tokenizer.Tokens);
return(node);
}
public void DothtmlTokenizer_Invalid_OpenBraceInText()
{
var input = "inline < script";
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(input);
Assert.IsTrue(tokenizer.Tokens.All(t => t.Type == DothtmlTokenType.Text));
Assert.AreEqual(string.Concat(tokenizer.Tokens.Select(t => t.Text)), input);
}
/// <summary>
/// Compiles the view and returns a function that can be invoked repeatedly. The function builds full control tree and activates the page.
/// </summary>
public virtual CSharpCompilation CompileView(IReader reader, string fileName, CSharpCompilation compilation, string namespaceName, string className)
{
// parse the document
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(reader);
var parser = new DothtmlParser();
var node = parser.Parse(tokenizer.Tokens);
var resolvedView = (ResolvedTreeRoot)controlTreeResolver.ResolveTree(node, fileName);
var errorCheckingVisitor = new ErrorCheckingVisitor();
resolvedView.Accept(errorCheckingVisitor);
foreach (var token in tokenizer.Tokens)
{
if (token.HasError && token.Error.IsCritical)
{
throw new DotvvmCompilationException(token.Error.ErrorMessage, new[] { (token.Error as BeginWithLastTokenOfTypeTokenError<DothtmlToken, DothtmlTokenType>)?.LastToken ?? token });
}
}
foreach (var n in node.EnumerateNodes())
{
if (n.HasNodeErrors)
{
throw new DotvvmCompilationException(string.Join(", ", n.NodeErrors), n.Tokens);
}
}
var styleVisitor = new StylingVisitor(configuration.Styles);
resolvedView.Accept(styleVisitor);
var validationVisitor = new Validation.ControlUsageValidationVisitor(configuration);
resolvedView.Accept(validationVisitor);
if (validationVisitor.Errors.Any())
{
var controlUsageError = validationVisitor.Errors.First();
throw new DotvvmCompilationException(controlUsageError.ErrorMessage, controlUsageError.Nodes.SelectMany(n => n.Tokens));
}
if (configuration.Debug && configuration.ApplicationPhysicalPath != null)
{
var addExpressionDebugvisitor = new ExpressionDebugInfoAddingVisitor(Path.Combine(configuration.ApplicationPhysicalPath, fileName));
addExpressionDebugvisitor.VisitView(resolvedView);
}
var emitter = new DefaultViewCompilerCodeEmitter();
var compilingVisitor = new ViewCompilingVisitor(emitter, configuration.ServiceLocator.GetService<IBindingCompiler>(), className,
b => configuration.ServiceLocator.GetService<IBindingIdGenerator>().GetId(b, fileName));
resolvedView.Accept(compilingVisitor);
return AddToCompilation(compilation, emitter, fileName, namespaceName, className);
}
public void DothtmlTokenizer_ElementParsing_Valid_NestedTags_MultipleAttributes()
{
var input = @"<html><body lang=cs><h1 class=alert size=big>Test</h1> </body></html>";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Equals, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Equals, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Equals, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Slash, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Slash, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Slash, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_DirectiveParsing_Valid_NoDirectives_NoWhiteSpaceOnStart()
{
var input = @"this is a test content";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
// first line
var i = 0;
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_ElementParsing_Valid_SelfClosing_NoAttributes_TextOnEnd()
{
var input = @"<html/>aaa";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Slash, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_BindingParsing_Valid_BindingInPlainText()
{
var input = @"tr {{binding: FirstName}}"" />";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenBinding, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Colon, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseBinding, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_BindingParsing_Incomplete_OpenBinding()
{
var input = @"<input value=""{";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Equals, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DoubleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenBinding, tokenizer.Tokens[i++].Type);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(DothtmlTokenType.Colon, tokenizer.Tokens[i++].Type);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(DothtmlTokenType.CloseBinding, tokenizer.Tokens[i++].Type);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(DothtmlTokenType.DoubleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_ElementParsing_Valid_SelfClosing_NonQuotedAttribute_TextOnBegin()
{
var input = @" tr <html xmlns=hello />";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Equals, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Slash, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
}
protected override bool Execute(uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut, IOleCommandTarget nextCommandTarget)
{
var groupId = CommandGroupId;
if (nextCommandTarget.Exec(ref groupId, nCmdID, nCmdexecopt, pvaIn, pvaOut) == VSConstants.S_OK)
{
// parse the content
var tokenizer = new DothtmlTokenizer();
var text = TextView.TextSnapshot.GetText();
tokenizer.Tokenize(new StringReader(text));
var parser = new DothtmlParser();
var node = parser.Parse(tokenizer.Tokens);
// prepare the metadata control resolver
var completionSource = TextView.TextBuffer.Properties.GetProperty<DothtmlCompletionSource>(typeof(DothtmlCompletionSource));
var metadataControlResolver = completionSource.MetadataControlResolver;
metadataControlResolver.ReloadAllControls(completionSource.GetCompletionContext());
try
{
CompletionHelper.DTE.UndoContext.Open("Format Dothtml document");
var edit = TextView.TextBuffer.CreateEdit(EditOptions.None, null, null);
// fix the casing of all elements
var editText = new StringBuilder(text);
foreach (var element in node.EnumerateNodes().OfType<DothtmlElementNode>())
{
FixElement(editText, metadataControlResolver, TextView.TextBuffer, element);
}
edit.Replace(0, editText.Length, editText.ToString());
edit.Apply();
}
finally
{
CompletionHelper.DTE.UndoContext.Close();
}
}
return true;
}
/// <summary>
/// Compiles the view and returns a function that can be invoked repeatedly. The function builds full control tree and activates the page.
/// </summary>
public IControlBuilder CompileView(IReader reader, string fileName, string assemblyName, string namespaceName, string className)
{
// parse the document
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(reader);
var parser = new DothtmlParser();
var node = parser.Parse(tokenizer.Tokens);
var resolvedView = controlTreeResolver.ResolveTree(node, fileName);
var styleVisitor = new StylingVisitor(configuration.Styles);
resolvedView.Accept(styleVisitor);
var emitter = new DefaultViewCompilerCodeEmitter();
var compilingVisitor = new ViewCompilingVisitor(emitter, configuration.ServiceLocator.GetService<IBindingCompiler>(), className);
resolvedView.Accept(compilingVisitor);
// create the assembly
var assembly = BuildAssembly(emitter, assemblyName, namespaceName, className);
var controlBuilder = (IControlBuilder)assembly.CreateInstance(namespaceName + "." + className);
resolvedView.Metadata.ControlBuilderType = controlBuilder.GetType();
return controlBuilder;
}
protected void CheckForErrors(DothtmlTokenizer tokenizer, int inputLength)
{
// check for parsing errors
if (tokenizer.Tokens.Any(t => t.Length != t.Text.Length))
{
throw new Exception("The length of the token does not match with its text content length!");
}
// check that the token sequence is complete
var position = 0;
foreach (var token in tokenizer.Tokens)
{
if (token.StartPosition != position)
{
throw new Exception("The token sequence is not complete!");
}
position += token.Length;
}
if (position != inputLength)
{
throw new Exception("The parser didn't finished the file!");
}
}
public void DothtmlTokenizer_XmlProcessingInstructionParsing_Valid()
{
var input = @"test <?xml version=""1.0"" encoding=""utf-8"" ?> test2";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
// first line
var i = 0;
Assert.AreEqual("test ", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual("<?", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.OpenXmlProcessingInstruction, tokenizer.Tokens[i++].Type);
Assert.AreEqual(@"xml version=""1.0"" encoding=""utf-8"" ", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.XmlProcessingInstructionBody, tokenizer.Tokens[i++].Type);
Assert.AreEqual("?>", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.CloseXmlProcessingInstruction, tokenizer.Tokens[i++].Type);
Assert.AreEqual(" test2", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_ElementParsing_Invalid_AttributeName_MissingTagName()
{
var input = @"<a prefix:=''/>";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Colon, tokenizer.Tokens[i++].Type);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Equals, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.SingleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.SingleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Slash, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_DoctypeParsing_Invalid_Incomplete_NoValue()
{
var input = @"<!DOCTYPE";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
// first line
var i = 0;
Assert.AreEqual("<!DOCTYPE", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.OpenDoctype, tokenizer.Tokens[i++].Type);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.AreEqual(DothtmlTokenType.DoctypeBody, tokenizer.Tokens[i++].Type);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.AreEqual(DothtmlTokenType.CloseDoctype, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_ElementParsing_Invalid_ElementName_MissingTagPrefix()
{
var input = @"<:name/>";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Colon, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Slash, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
}
public void Tokenize()
{
var t = new DothtmlTokenizer();
t.Tokenize(new StringReader(data));
}
public void DothtmlTokenizer_ElementParsing_Incomplete_OpenTag_AttributeName_Equals_Quote_Quote_AnotherTag()
{
var input = @"<html attr=''<a/>";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Equals, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.SingleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.SingleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Slash, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
}
public static DothtmlRootNode ParseMarkup(string markup)
{
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(markup));
var parser = new DothtmlParser();
var node = parser.Parse(tokenizer.Tokens);
return node;
}
public void DothtmlTokenizer_ElementParsing_Valid_AttributeWithoutValue()
{
var input = @" tr <input type=""checkbox"" checked />";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Equals, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DoubleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.DoubleQuote, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Slash, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
}
protected ViewCompilationResult CompileView(string fileName)
{
var file = fileLoader.GetMarkup(configuration, fileName);
// parse the document
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(file.ContentsReaderFactory());
var parser = new DothtmlParser();
var node = parser.Parse(tokenizer.Tokens);
var resolvedView = (ResolvedTreeRoot)controlTreeResolver.ResolveTree(node, fileName);
var errorCheckingVisitor = new ErrorCheckingVisitor();
resolvedView.Accept(errorCheckingVisitor);
foreach (var n in node.EnumerateNodes())
{
if (n.HasNodeErrors)
{
throw new DotvvmCompilationException(string.Join(", ", n.NodeErrors), n.Tokens);
}
}
var styleVisitor = new StylingVisitor(configuration.Styles);
resolvedView.Accept(styleVisitor);
var validationVisitor = new ControlUsageValidationVisitor(configuration);
resolvedView.Accept(validationVisitor);
if (validationVisitor.Errors.Any())
{
var controlUsageError = validationVisitor.Errors.First();
throw new DotvvmCompilationException(controlUsageError.ErrorMessage, controlUsageError.Nodes.SelectMany(n => n.Tokens));
}
DefaultViewCompilerCodeEmitter emitter = null;
string fullClassName = null;
if (Options.FullCompile)
{
var namespaceName = DefaultControlBuilderFactory.GetNamespaceFromFileName(file.FileName, file.LastWriteDateTimeUtc);
var className = DefaultControlBuilderFactory.GetClassFromFileName(file.FileName) + "ControlBuilder";
fullClassName = namespaceName + "." + className;
emitter = new DefaultViewCompilerCodeEmitter();
var compilingVisitor = new ViewCompilingVisitor(emitter, configuration.ServiceLocator.GetService<IBindingCompiler>(), className, b => configuration.ServiceLocator.GetService<IBindingIdGenerator>().GetId(b, fileName));
resolvedView.Accept(compilingVisitor);
// compile master pages
if (resolvedView.Directives.ContainsKey("masterPage"))
CompileFile(resolvedView.Directives["masterPage"].Single());
compilation = compilation
.AddSyntaxTrees(emitter.BuildTree(namespaceName, className, fileName)/*.Select(t => SyntaxFactory.ParseSyntaxTree(t.GetRoot().NormalizeWhitespace().ToString()))*/)
.AddReferences(emitter.UsedAssemblies
.Select(a => CompiledAssemblyCache.Instance.GetAssemblyMetadata(a)));
}
Program.WriteInfo($"view { fileName } compiled");
var res = new ViewCompilationResult
{
BuilderClassName = fullClassName,
ControlType = resolvedView.Metadata.Type,
DataContextType = emitter?.BuilderDataContextType,
ResolvedTree = Options.OutputResolvedDothtmlMap ? resolvedView : null
};
BuildFileResult(fileName, res);
return res;
}
public void DothtmlTokenizer_DirectiveParsing_Invalid_AtSymbol_Space_NewLine_Content()
{
var input = @"@
test";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.DirectiveStart, tokenizer.Tokens[i++].Type);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.AreEqual(DothtmlTokenType.DirectiveName, tokenizer.Tokens[i++].Type);
Assert.AreEqual(2, tokenizer.Tokens[i].Length);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.AreEqual(DothtmlTokenType.DirectiveValue, tokenizer.Tokens[i++].Type);
Assert.AreEqual("\r\n", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.AreEqual("test", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_CommentParsing_Valid()
{
var input = @"test <!-- this is a text < > "" ' --> test2";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
// first line
var i = 0;
Assert.AreEqual("test ", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual("<!--", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.OpenComment, tokenizer.Tokens[i++].Type);
Assert.AreEqual(@" this is a text < > "" ' ", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.CommentBody, tokenizer.Tokens[i++].Type);
Assert.AreEqual("-->", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.CloseComment, tokenizer.Tokens[i++].Type);
Assert.AreEqual(" test2", tokenizer.Tokens[i].Text);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
}
private ResolvedTreeRoot ParseSource(string markup, string fileName = "default.dothtml")
{
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(markup));
var parser = new DothtmlParser();
var tree = parser.Parse(tokenizer.Tokens);
return (ResolvedTreeRoot)controlTreeResolver.ResolveTree(tree, fileName);
}
public void DothtmlTokenizer_DirectiveParsing_Invalid_OnlyAtSymbol()
{
var input = @"@";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.DirectiveStart, tokenizer.Tokens[i++].Type);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.AreEqual(DothtmlTokenType.DirectiveName, tokenizer.Tokens[i++].Type);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.AreEqual(DothtmlTokenType.WhiteSpace, tokenizer.Tokens[i++].Type);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.AreEqual(DothtmlTokenType.DirectiveValue, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_ElementParsing_Invalid_CloseTag_TreatedAsText()
{
var input = @">";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
}
public void DothtmlTokenizer_ElementParsing_Invalid_OpenTag_Quotes()
{
var input = @"<'";
// parse
var tokenizer = new DothtmlTokenizer();
tokenizer.Tokenize(new StringReader(input));
CheckForErrors(tokenizer, input.Length);
var i = 0;
Assert.AreEqual(DothtmlTokenType.OpenTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
Assert.AreEqual(0, tokenizer.Tokens[i].Length);
Assert.IsTrue(tokenizer.Tokens[i].HasError);
Assert.AreEqual(DothtmlTokenType.CloseTag, tokenizer.Tokens[i++].Type);
Assert.AreEqual(DothtmlTokenType.Text, tokenizer.Tokens[i++].Type);
}
