public override void GenerateStartBlockCode (Block target, CodeGeneratorContext context)
{
if (context.Host.DesignTimeMode)
return;
context.FlushBufferedStatement();
var sb = new StringBuilder ();
if (!string.IsNullOrEmpty (context.TargetWriterName)) {
sb.AppendFormat (
"{0} ({1}, ",
context.Host.GeneratedClassContext.WriteAttributeToMethodName,
context.TargetWriterName
);
} else {
sb.AppendFormat (
"{0} (",
context.Host.GeneratedClassContext.WriteAttributeMethodName
);
}
sb.WriteCStyleStringLiteral (Name);
sb.Append (", ");
sb.WriteCStyleStringLiteral (Prefix);
sb.Append (", ");
sb.WriteCStyleStringLiteral (Suffix);
context.AddStatement (sb.ToString ());
}
public BlockBuilder(Block original)
{
Type = original.Type;
Children = new List<SyntaxTreeNode>(original.Children);
Name = original.Name;
CodeGenerator = original.CodeGenerator;
}
public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
{
_writer = context.CreateCodeWriter();
string prefix = context.BuildCodeString(
cw => cw.WriteHelperHeaderPrefix(context.Host.GeneratedClassContext.TemplateTypeName, context.Host.StaticHelpers));
_writer.WriteLinePragma(
context.GenerateLinePragma(Signature.Location, prefix.Length, Signature.Value.Length));
_writer.WriteSnippet(prefix);
_writer.WriteSnippet(Signature);
if (HeaderComplete)
{
_writer.WriteHelperHeaderSuffix(context.Host.GeneratedClassContext.TemplateTypeName);
}
_writer.WriteLinePragma(null);
if (HeaderComplete)
{
_writer.WriteReturn();
_writer.WriteStartConstructor(context.Host.GeneratedClassContext.TemplateTypeName);
_writer.WriteStartLambdaDelegate(HelperWriterName);
}
_statementCollectorToken = context.ChangeStatementCollector(AddStatementToHelper);
_oldWriter = context.TargetWriterName;
context.TargetWriterName = HelperWriterName;
}
public GeneratorResults(Block document,
IList<RazorError> parserErrors,
CodeCompileUnit generatedCode,
IDictionary<int, GeneratedCodeMapping> designTimeLineMappings)
: this(parserErrors.Count == 0, document, parserErrors, generatedCode, designTimeLineMappings)
{
}
public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
{
if (context.Host.DesignTimeMode)
{
return; // Don't generate anything!
}
context.FlushBufferedStatement();
context.AddStatement(context.BuildCodeString(cw =>
{
if (!String.IsNullOrEmpty(context.TargetWriterName))
{
cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.WriteAttributeToMethodName);
cw.WriteSnippet(context.TargetWriterName);
cw.WriteParameterSeparator();
}
else
{
cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.WriteAttributeMethodName);
}
cw.WriteStringLiteral(Name);
cw.WriteParameterSeparator();
cw.WriteLocationTaggedString(Prefix);
cw.WriteParameterSeparator();
cw.WriteLocationTaggedString(Suffix);
// In VB, we need a line continuation
cw.WriteLineContinuation();
}));
}
public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
{
string endBlock = context.BuildCodeString(cw =>
{
if (context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput)
{
if (!context.Host.DesignTimeMode)
{
cw.WriteEndMethodInvoke();
}
cw.WriteEndStatement();
}
else
{
cw.WriteLineContinuation();
}
});
context.MarkEndOfGeneratedCode();
context.BufferStatementFragment(endBlock);
context.FlushBufferedStatement();
if (context.Host.EnableInstrumentation && context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput)
{
Span contentSpan = target.Children
.OfType<Span>()
.Where(s => s.Kind == SpanKind.Code || s.Kind == SpanKind.Markup)
.FirstOrDefault();
if (contentSpan != null)
{
context.AddContextCall(contentSpan, context.Host.GeneratedClassContext.EndContextMethodName, false);
}
}
}
public virtual void RenderClientTemplate(Block document, TextWriter output)
{
output.Write("function (Model) { ");
output.Write("var _buf = []; ");
ParseSyntaxTreeNode(document, output);
output.Write(" return _buf.join(''); };");
}
internal static void WriteDebugTree(string sourceFile, Block document, PartialParseResult result, TextChange change, RazorEditorParser parser, bool treeStructureChanged)
{
if (!OutputDebuggingEnabled)
{
return;
}
RunTask(() =>
{
string outputFileName = Normalize(sourceFile) + "_tree";
string outputPath = Path.Combine(Path.GetDirectoryName(sourceFile), outputFileName);
var treeBuilder = new StringBuilder();
WriteTree(document, treeBuilder);
treeBuilder.AppendLine();
treeBuilder.AppendFormat(CultureInfo.CurrentCulture, "Last Change: {0}", change);
treeBuilder.AppendLine();
treeBuilder.AppendFormat(CultureInfo.CurrentCulture, "Normalized To: {0}", change.Normalize());
treeBuilder.AppendLine();
treeBuilder.AppendFormat(CultureInfo.CurrentCulture, "Partial Parse Result: {0}", result);
treeBuilder.AppendLine();
if (result.HasFlag(PartialParseResult.Rejected))
{
treeBuilder.AppendFormat(CultureInfo.CurrentCulture, "Tree Structure Changed: {0}", treeStructureChanged);
treeBuilder.AppendLine();
}
if (result.HasFlag(PartialParseResult.AutoCompleteBlock))
{
treeBuilder.AppendFormat(CultureInfo.CurrentCulture, "Auto Complete Insert String: \"{0}\"", parser.GetAutoCompleteString());
treeBuilder.AppendLine();
}
File.WriteAllText(outputPath, treeBuilder.ToString());
});
}
internal virtual void RunParseTest(string document, Func<ParserBase, Action> parserActionSelector, Block expectedRoot, IList<RazorError> expectedErrors, bool designTimeParser) {
// Create the source
using (StringTextBuffer reader = new StringTextBuffer(document)) {
ParserResults results = null;
try {
ParserBase codeParser = CreateCodeParser();
MarkupParser markupParser = CreateMarkupParser();
SyntaxTreeBuilderVisitor listener = new SyntaxTreeBuilderVisitor();
ParserContext context = CreateParserRun(new TextBufferReader(reader), codeParser, markupParser, listener);
context.DesignTimeMode = designTimeParser;
codeParser.Context = context;
markupParser.Context = context;
// Run the parser
parserActionSelector(context.ActiveParser)();
context.OnComplete();
// Collect the results
results = listener.Results;
EvaluateResults(TestContext, results, expectedRoot, expectedErrors);
}
finally {
if (TestContext != null && results != null && results.Document != null) {
TestContext.WriteLine(String.Empty);
TestContext.WriteLine("Actual Parse Tree:");
WriteNode(0, TestContext, results.Document);
}
}
}
}
public override void GenerateStartBlockCode (Block target, CodeGeneratorContext context)
{
if (context.Host.DesignTimeMode)
return;
Block child = target.Children.Where (n => n.IsBlock).Cast<Block> ().FirstOrDefault ();
isExpression = child != null && child.Type == BlockType.Expression;
var sb = new StringBuilder ();
sb.Append (", Tuple.Create<string,object,bool> (");
sb.WriteCStyleStringLiteral (Prefix.Value);
sb.Append (", ");
if (isExpression) {
oldRenderingMode = context.GetExpressionRenderingMode ();
context.SetExpressionRenderingMode (ExpressionRenderingMode.InjectCode);
} else {
sb.AppendFormat (
"new {0} ({1} => {{",
context.Host.GeneratedClassContext.TemplateTypeName,
ValueWriterName);
}
context.MarkEndOfGeneratedCode ();
context.BufferStatementFragment (sb.ToString ());
oldTargetWriter = context.TargetWriterName;
context.TargetWriterName = ValueWriterName;
}
public override void VisitBlock(Block block)
{
if (CanRewrite(block))
{
SyntaxTreeNode newNode = RewriteBlock(_blocks.Peek(), block);
if (newNode != null)
{
_blocks.Peek().Children.Add(newNode);
}
}
else
{
// Not rewritable.
BlockBuilder builder = new BlockBuilder(block);
builder.Children.Clear();
_blocks.Push(builder);
base.VisitBlock(block);
Debug.Assert(ReferenceEquals(builder, _blocks.Peek()));
if (_blocks.Count > 1)
{
_blocks.Pop();
_blocks.Peek().Children.Add(builder.Build());
}
}
}
public static string GetBlockName(Block block)
{
const string defaultName = "...";
switch (block.Type)
{
case BlockType.Statement:
return "{...}";
case BlockType.Directive:
break;
case BlockType.Functions:
return "@funtions";
case BlockType.Expression:
break;
case BlockType.Helper:
return GetHelperBlockName(block);
case BlockType.Markup:
break;
case BlockType.Section:
return GetSectionBlockName(block);
case BlockType.Template:
break;
case BlockType.Comment:
return GetCommentBlockName(block);
default:
return defaultName;
}
return defaultName;
}
public override void GenerateEndBlockCode (Block target, CodeGeneratorContext context)
{
if (context.Host.DesignTimeMode)
return;
context.FlushBufferedStatement ();
context.AddStatement (");");
}
protected GeneratorResults(bool success,
Block document,
IList<RazorError> parserErrors,
CodeCompileUnit generatedCode,
IDictionary<int, GeneratedCodeMapping> designTimeLineMappings)
: base(success, document, parserErrors) {
GeneratedCode = generatedCode;
DesignTimeLineMappings = designTimeLineMappings;
}
public virtual void VisitBlock(Block block)
{
VisitStartBlock(block);
foreach (SyntaxTreeNode node in block.Children)
{
node.Accept(this);
}
VisitEndBlock(block);
}
public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
{
// Flush the buffered statement since we're interrupting it with a comment.
if (!String.IsNullOrEmpty(context.CurrentBufferedStatement))
{
context.MarkEndOfGeneratedCode();
context.BufferStatementFragment(context.BuildCodeString(cw => cw.WriteLineContinuation()));
}
context.FlushBufferedStatement();
}
public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
{
string startBlock = context.BuildCodeString(cw =>
{
cw.WriteEndLambdaDelegate();
cw.WriteEndMethodInvoke();
cw.WriteEndStatement();
});
context.AddStatement(startBlock);
}
protected override SyntaxTreeNode RewriteBlock(BlockBuilder parent, Block block)
{
// Collect the content of this node
string content = String.Concat(block.Children.Cast<Span>().Select(s => s.Content));
// Create a new span containing this content
SpanBuilder span = new SpanBuilder();
FillSpan(span, block.Children.Cast<Span>().First().Start, content);
return span.Build();
}
internal void WriteTemplateFunction(Block document, TextWriter output)
{
output.WriteLine(@"function (Model) {");
output.WriteLine(" var buffer = [];");
ParseSyntaxTreeNode(document, output);
output.WriteLine(" return buffer.join('');");
output.Write("}");
}
private static string GetSectionBlockName(Block block)
{
var sectionName = "";
if (block.Children != null)
{
var sectionHeader =
block.Children.FirstOrDefault(c => c.GetType() == typeof (SectionHeaderSpan)) as SectionHeaderSpan;
sectionName = sectionHeader != null ? sectionHeader.SectionName : "";
}
return string.Format("section {0}", sectionName);
}
protected virtual bool VisitBlock(Block block, TextWriter output)
{
if(block == null) return false;
foreach (var child in block.Children)
{
ParseSyntaxTreeNode(child, output);
}
return true;
}
public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
{
string startBlock = context.BuildCodeString(cw =>
{
cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.DefineSectionMethodName);
cw.WriteStringLiteral(SectionName);
cw.WriteParameterSeparator();
cw.WriteStartLambdaDelegate();
});
context.AddStatement(startBlock);
}
private static string GetHelperBlockName(Block block)
{
var headerName = "";
var helperHeader = block.Children.FirstOrDefault(c => c.GetType() == typeof (HelperHeaderSpan)) as HelperHeaderSpan;
if (helperHeader != null)
{
headerName =
helperHeader.Content.Substring(0, helperHeader.Content.IndexOf("(", StringComparison.Ordinal)).Trim();
}
return string.Format("helper {0}", headerName);
}
public void ConstructorSetsPropertyValue() {
// Arrange
IEnumerable<SyntaxTreeNode> contents = new SyntaxTreeNode[0];
// Act
Block block = new Block(BlockType.Expression, contents);
// Assert
Assert.AreEqual(BlockType.Expression, block.Type);
Assert.AreSame(contents, block.Children);
}
protected override SyntaxTreeNode RewriteBlock (BlockBuilder parent, Block block)
{
var b = new BlockBuilder (block);
var abGen = block.CodeGenerator as AttributeBlockCodeGenerator;
if (abGen != null) {
b.CodeGenerator = new PreprocessedAttributeBlockCodeGenerator (abGen);
} else {
b.CodeGenerator = new PreprocessedDynamicAttributeBlockCodeGenerator ((DynamicAttributeBlockCodeGenerator)b.CodeGenerator);
}
return b.Build ();
}
public override void VisitEndBlock(BlockType type) {
base.VisitEndBlock(type);
List<SyntaxTreeNode> elems = _blockStack.Pop();
Block block = new Block(type, elems);
if (_blockStack.Count == 0) {
_rootBlock = block;
}
else {
CurrentBlock.Add(block);
}
}
public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
{
string generatedCode = context.BuildCodeString(cw =>
{
cw.WriteEndLambdaDelegate();
cw.WriteEndConstructor();
cw.WriteEndLambdaExpression();
});
context.BufferStatementFragment(generatedCode);
context.TargetWriterName = _oldTargetWriter;
}
public IEnumerable<Node> Parse(Block block)
{
Node[] nodes = SyntaxTreeParser.Traverse(block).ToArray();
if (nodes.Length == 0)
{
return SyntaxTreeParser.EmptyNodeCollection;
}
return nodes.All(node => node.Type == NodeType.Markup || node.Type == NodeType.Expression)
? nodes
: new[] { new BlockNode(nodes) };
}
public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
{
if (context.Host.DesignTimeMode)
{
return; // Don't generate anything!
}
context.FlushBufferedStatement();
context.AddStatement(context.BuildCodeString(cw =>
{
cw.WriteEndMethodInvoke();
cw.WriteEndStatement();
}));
}
public void ConstructorSetsParentPointerOnChildren() {
// Arrange
SyntaxTreeNode[] contents = new SyntaxTreeNode[2] {
new Block(BlockType.Comment, new SyntaxTreeNode[0]),
new CodeSpan(String.Empty)
};
// Act
Block block = new Block(BlockType.Expression, contents);
// Assert
Assert.AreSame(block, contents[0].Parent);
Assert.AreSame(block, contents[1].Parent);
}
