public static void AssertSyntaxTreeIsEmpty(this HandlebarsParserState state, string errorMessage)
{
if (state.BlockStack.Count > 1 || !state.BlockStack.GetCurrentBlockNode().IsEmpty())
{
throw new VeilParserException(errorMessage, state.CurrentLocation);
}
}
private static void HandleIterationElse(HandlebarsParserState state)
{
var elseBlock = state.BlockStack.GetCurrentBlockContainer <IterateNode>().EmptyBody;
state.BlockStack.PopBlock();
state.BlockStack.PushModelInheritingBlock(elseBlock);
}
public static void AssertStackOnRootNode(this HandlebarsParserState state)
{
if (state.BlockStack.Count != 1)
{
throw new VeilParserException(String.Format("Mismatched block found. Expected to find the end of the template but found '{0}' open blocks.", state.BlockStack.Count - 1), state.CurrentLocation);
}
}
private static void HandlePartial(HandlebarsParserState state)
{
var partialTemplateName = state.CurrentToken.Content.Substring(1).Trim();
var self = SyntaxTreeExpression.Self(state.BlockStack.GetCurrentModelType());
state.AddNodeToCurrentBlock(SyntaxTree.Include(partialTemplateName, self));
}
public SyntaxTreeNode Parse(TextReader templateReader, Type modelType)
{
var state = new HandlebarsParserState();
var tokens = HandlebarsTokenizer.Tokenize(templateReader);
state.BlockStack.PushNewBlockWithModel(modelType);
foreach (var token in tokens)
{
state.SetCurrentToken(token);
foreach (var handler in SyntaxHandlers)
{
if (handler.Key(token))
{
handler.Value.Invoke(state);
if (state.ContinueProcessingToken)
{
state.ContinueProcessingToken = false;
continue;
}
break;
}
}
}
state.AssertStackOnRootNode();
return state.RootNode;
}
public static ExpressionNode Parse(HandlebarsParserState state, HandlebarsBlockStack blockStack, SourceLocation location, string expression, IMemberLocator memberLocator = null)
{
int recursionLevel = 0;
memberLocator = memberLocator ?? MemberLocator.Default;
expression = expression.Trim();
if (expression == "this")
{
return SyntaxTreeExpression.Self(blockStack.GetCurrentModelType(), location);
}
if (expression.StartsWith("../"))
{
var blockNode = blockStack.FirstNode();
while (expression.StartsWith("../"))
{
var parentBlockNode = blockStack.GetParentNode(blockNode);
if (parentBlockNode != null)
{
blockNode = parentBlockNode;
expression = expression.Substring(3);
location = location.MoveIndex(3);
}
recursionLevel++;
}
return ParseAgainstModel(blockStack.GetCurrentModelType(blockNode), expression, ExpressionScope.ModelOfParentScope, recursionLevel, memberLocator, location);
}
return ParseAgainstModel(blockStack.GetCurrentModelType(), expression, ExpressionScope.CurrentModelOnStack, recursionLevel, memberLocator, location);
}
public SyntaxTreeNode Parse(TextReader templateReader, Type modelType)
{
var state = new HandlebarsParserState();
var tokens = HandlebarsTokenizer.Tokenize(templateReader);
state.BlockStack.PushNewBlockWithModel(modelType);
foreach (var token in tokens)
{
state.SetCurrentToken(token);
foreach (var handler in SyntaxHandlers)
{
if (handler.Key(token))
{
handler.Value.Invoke(state);
if (state.ContinueProcessingToken)
{
state.ContinueProcessingToken = false;
continue;
}
break;
}
}
}
state.AssertStackOnRootNode();
return(state.RootNode);
}
private static void HandleConditionalElse(HandlebarsParserState state)
{
var block = SyntaxTree.Block();
state.BlockStack.GetCurrentBlockContainer<ConditionalNode>().FalseBlock = block;
state.BlockStack.PopBlock();
state.BlockStack.PushModelInheritingBlock(block);
}
public static ExpressionNode Parse(HandlebarsParserState state, HandlebarsBlockStack blockStack, SourceLocation location, string expression, IMemberLocator memberLocator = null)
{
int recursionLevel = 0;
memberLocator = memberLocator ?? MemberLocator.Default;
expression = expression.Trim();
if (expression == "this")
{
return(SyntaxTreeExpression.Self(blockStack.GetCurrentModelType(), location));
}
if (expression.StartsWith("../"))
{
var blockNode = blockStack.FirstNode();
while (expression.StartsWith("../"))
{
var parentBlockNode = blockStack.GetParentNode(blockNode);
if (parentBlockNode != null)
{
blockNode = parentBlockNode;
expression = expression.Substring(3);
location = location.MoveIndex(3);
}
recursionLevel++;
}
return(ParseAgainstModel(blockStack.GetCurrentModelType(blockNode), expression, ExpressionScope.ModelOfParentScope, recursionLevel, memberLocator, location));
}
return(ParseAgainstModel(blockStack.GetCurrentModelType(), expression, ExpressionScope.CurrentModelOnStack, recursionLevel, memberLocator, location));
}
public SyntaxTreeNode Parse(string templateId, TextReader templateReader, Type modelType, IMemberLocator memberLocator, IHelperHandler[] helperHandlers)
{
if (memberLocator == null)
memberLocator = MemberLocator.Default;
var state = new HandlebarsParserState(templateId, memberLocator);
var tokens = HandlebarsTokenizer.Tokenize(templateReader);
state.BlockStack.PushNewBlockWithModel(modelType, new SourceLocation(templateId, 0, 0));
var helpers = SyntaxHandlers.Union(GetHelperHandlers(helperHandlers ?? Enumerable.Empty<IHelperHandler>())).Union(SyntaxHandlersAfter).ToList();
foreach (var token in tokens)
{
state.SetCurrentToken(token);
foreach (var handler in helpers)
{
if (handler.Key(token))
{
handler.Value.Invoke(state);
if (state.ContinueProcessingToken)
{
state.ContinueProcessingToken = false;
continue;
}
break;
}
}
}
state.AssertStackOnRootNode();
return state.RootNode;
}
private static void HandleConditionalElse(HandlebarsParserState state)
{
var block = SyntaxTree.Block();
state.BlockStack.GetCurrentBlockContainer <ConditionalNode>().FalseBlock = block;
state.BlockStack.PopBlock();
state.BlockStack.PushModelInheritingBlock(block);
}
private static void HandleUnless(HandlebarsParserState state)
{
var block = SyntaxTree.Block(state.CurrentLocation);
var conditional = SyntaxTree.Conditional(state.ParseExpression(state.CurrentToken.Content.Substring(8), state.CurrentLocation.MoveIndex(8)), state.CurrentLocation, SyntaxTree.Block(state.CurrentLocation), block);
state.AddNodeToCurrentBlock(conditional);
state.BlockStack.PushModelInheritingBlock(block);
}
private static void HandleHelperStart(HandlebarsParserState state, IBlockHelperHandler helper)
{
var block = SyntaxTree.Block(state.CurrentLocation);
var helperBlock = SyntaxTree.Helper(SyntaxTreeExpression.Helper(state.CurrentToken.Content.Substring(1), helper, state.CurrentLocation), block, state.CurrentLocation);
state.AddNodeToCurrentBlock(helperBlock);
state.BlockStack.PushModelInheritingBlock(block);
}
private static void HandleIf(HandlebarsParserState state)
{
var block = SyntaxTree.Block();
var conditional = SyntaxTree.Conditional(state.ParseExpression(state.CurrentToken.Content.Substring(4)), block);
state.AddNodeToCurrentBlock(conditional);
state.BlockStack.PushModelInheritingBlock(block);
}
public static bool IsInEachBlock(this HandlebarsParserState state)
{
if (state.BlockStack.Count < 2)
{
return(false);
}
return(state.BlockStack.IsCurrentBlockContainerOfType <IterateNode>());
}
private static void HandleMaster(HandlebarsParserState state)
{
state.AssertSyntaxTreeIsEmpty("There can be no content before a {{< }} expression.");
var masterTemplateName = state.CurrentToken.Content.Substring(1).Trim();
state.ExtendNode = SyntaxTree.Extend(masterTemplateName, new Dictionary <string, SyntaxTreeNode>
{
{ OverrideSectionName, state.BlockStack.GetCurrentBlockNode() }
});
}
private static void HandleTrimLastLiteral(HandlebarsParserState state)
{
var literal = state.LastNode() as WriteLiteralNode;
if (literal != null)
{
literal.LiteralContent = literal.LiteralContent.TrimEnd();
}
state.ContinueProcessingToken = true;
}
public static void AssertInsideWith(this HandlebarsParserState state, string foundToken)
{
var faulted = state.BlockStack.Count < 2;
faulted = faulted || !state.BlockStack.IsCurrentBlockContainerOfType <ScopedNode>();
if (faulted)
{
throw new VeilParserException(String.Format("Found token '{0}' outside of a with block.", foundToken), state.CurrentLocation);
}
}
public static void AssertInsideConditionalOrIteration(this HandlebarsParserState state, string foundToken)
{
var faulted = state.BlockStack.Count < 2;
faulted = faulted || !(state.BlockStack.IsCurrentBlockContainerOfType <ConditionalNode>() || state.BlockStack.IsCurrentBlockContainerOfType <IterateNode>());
if (faulted)
{
throw new VeilParserException(String.Format("Found token '{0}' outside of a conditional or iteration block.", foundToken), state.CurrentLocation);
}
}
private static void HandleEach(HandlebarsParserState state)
{
var iteration = SyntaxTree.Iterate(
state.ParseExpression(state.CurrentToken.Content.Substring(6)),
SyntaxTree.Block()
);
state.AddNodeToCurrentBlock(iteration);
state.BlockStack.PushBlock(new HandlebarsParserBlock {
Block = iteration.Body, ModelInScope = iteration.ItemType
});
}
private static void HandleWith(HandlebarsParserState state)
{
var withBlock = SyntaxTree.Block();
var modelExpression = state.ParseExpression(state.CurrentToken.Content.Substring(6).Trim());
state.AddNodeToCurrentBlock(SyntaxTree.ScopeNode(modelExpression, withBlock));
state.BlockStack.PushBlock(new HandlebarsParserBlock
{
Block = withBlock,
ModelInScope = modelExpression.ResultType
});
}
private static void HandleElse(HandlebarsParserState state)
{
state.AssertInsideConditionalOrIteration("{{else}}");
if (state.IsInEachBlock())
{
HandleIterationElse(state);
}
else
{
HandleConditionalElse(state);
}
}
public static ExpressionNode Parse(HandlebarsParserState state, HandlebarsBlockStack blockStack, SourceLocation location, string expression, IMemberLocator memberLocator = null)
{
memberLocator = memberLocator ?? MemberLocator.Default;
expression = expression.Trim();
if (expression == "this")
{
return SyntaxTreeExpression.Self(blockStack.GetCurrentModelType(), location, ExpressionScope.CurrentModelOnStack);
}
if (expression.StartsWith("../"))
{
return ParseAgainstModel(blockStack.GetParentModelType(), expression.Substring(3), ExpressionScope.ModelOfParentScope, memberLocator, location.MoveIndex(3));
}
return ParseAgainstModel(blockStack.GetCurrentModelType(), expression, ExpressionScope.CurrentModelOnStack, memberLocator, location);
}
public SyntaxTreeNode Parse(string templateId, TextReader templateReader, Type modelType, IMemberLocator memberLocator, IHelperHandler[] helperHandlers)
{
if (memberLocator == null)
{
memberLocator = MemberLocator.Default;
}
var state = new HandlebarsParserState(templateId, memberLocator);
var tokens = HandlebarsTokenizer.Tokenize(templateReader);
state.BlockStack.PushNewBlockWithModel(modelType, new SourceLocation(templateId, 0, 0));
var helpers = SyntaxHandlers.Union(GetHelperHandlers(helperHandlers ?? Enumerable.Empty <IHelperHandler>())).Union(SyntaxHandlersAfter).ToList();
foreach (var token in tokens)
{
state.SetCurrentToken(token);
foreach (var handler in helpers)
{
if (handler.Key(token))
{
handler.Value.Invoke(state);
if (state.ContinueProcessingToken)
{
state.ContinueProcessingToken = false;
continue;
}
break;
}
}
}
state.AssertStackOnRootNode();
return(state.RootNode);
}
private static void HandleStringLiteral(HandlebarsParserState state)
{
state.WriteLiteral(state.CurrentToken.Content, state.CurrentLocation);
}
private static void HandleFlush(HandlebarsParserState state)
{
state.AddNodeToCurrentBlock(SyntaxTree.Flush());
}
private static void HandleEndWith(HandlebarsParserState state)
{
state.AssertInsideWith("{{/with}}");
state.BlockStack.PopBlock();
}
private static void HandleFlush(HandlebarsParserState state)
{
state.AddNodeToCurrentBlock(SyntaxTree.Flush(state.CurrentLocation));
}
private static void HandleEach(HandlebarsParserState state)
{
var iteration = SyntaxTree.Iterate(
state.ParseExpression(state.CurrentToken.Content.Substring(6), state.CurrentLocation.MoveIndex(6)),
state.CurrentLocation,
SyntaxTree.Block(state.CurrentLocation)
);
state.AddNodeToCurrentBlock(iteration);
state.BlockStack.PushBlock(new HandlebarsParserBlock { Block = iteration.Body, ModelInScope = iteration.ItemType });
}
private static void HandleUnless(HandlebarsParserState state)
{
var block = SyntaxTree.Block(state.CurrentLocation);
var conditional = SyntaxTree.Conditional(state.ParseExpression(state.CurrentToken.Content.Substring(8), state.CurrentLocation.MoveIndex(8)), state.CurrentLocation, SyntaxTree.Block(state.CurrentLocation), block);
state.AddNodeToCurrentBlock(conditional);
state.BlockStack.PushModelInheritingBlock(block);
}
private static void HandleElse(HandlebarsParserState state)
{
state.AssertInsideConditionalOrIteration("{{else}}");
if (state.IsInEachBlock())
{
HandleIterationElse(state);
}
else
{
HandleConditionalElse(state);
}
}
private static void HandleEndEach(HandlebarsParserState state)
{
state.AssertInsideIteration("{{/each}}");
state.BlockStack.PopBlock();
}
private static void HandleStringLiteral(HandlebarsParserState state)
{
state.WriteLiteral(state.CurrentToken.Content);
}
private static void HandleHelper(HandlebarsParserState state, IHelperHandler helper)
{
string expression = state.CurrentToken.Content;
state.AddNodeToCurrentBlock(SyntaxTreeExpression.Helper(expression, helper, state.CurrentLocation));
}
private static void HandleExpression(HandlebarsParserState state)
{
var expression = state.ParseExpression(state.CurrentToken.Content, state.CurrentLocation);
state.AddNodeToCurrentBlock(SyntaxTree.WriteExpression(expression, state.CurrentLocation, state.CurrentToken.IsHtmlEscape));
}
private static void HandleMaster(HandlebarsParserState state)
{
state.AssertSyntaxTreeIsEmpty("There can be no content before a {{< }} expression.");
var masterTemplateName = state.CurrentToken.Content.Substring(1).Trim();
state.ExtendNode = SyntaxTree.Extend(masterTemplateName, state.CurrentLocation, new Dictionary<string, SyntaxTreeNode>
{
{ OverrideSectionName, state.BlockStack.GetCurrentBlockNode() }
});
}
private static void HandleTrimLastLiteral(HandlebarsParserState state)
{
var literal = state.LastNode() as WriteLiteralNode;
if (literal != null)
{
literal.LiteralContent = literal.LiteralContent.TrimEnd();
}
state.ContinueProcessingToken = true;
}
private static void HandleTrimNextLiteral(HandlebarsParserState state)
{
state.TrimNextLiteral = true;
state.ContinueProcessingToken = true;
}
private static void HandleTrimNextLiteral(HandlebarsParserState state)
{
state.TrimNextLiteral = true;
state.ContinueProcessingToken = true;
}
private static void HandleHelperEnd(HandlebarsParserState state, IBlockHelperHandler helper)
{
// TODO: Stack validation
state.BlockStack.PopBlock();
}
private static void HandleIterationElse(HandlebarsParserState state)
{
var elseBlock = state.BlockStack.GetCurrentBlockContainer<IterateNode>().EmptyBody;
state.BlockStack.PopBlock();
state.BlockStack.PushModelInheritingBlock(elseBlock);
}
private static void HandleEndUnless(HandlebarsParserState state)
{
state.AssertInsideConditional("{{/unless}}");
state.BlockStack.PopBlock();
}
private static void HandleEndUnless(HandlebarsParserState state)
{
state.AssertInsideConditional("{{/unless}}");
state.BlockStack.PopBlock();
}
private static void HandleHelperEnd(HandlebarsParserState state, IBlockHelperHandler helper)
{
// TODO: Stack validation
state.BlockStack.PopBlock();
}
private static void HandleEndEach(HandlebarsParserState state)
{
state.AssertInsideIteration("{{/each}}");
state.BlockStack.PopBlock();
}
private static void HandleHelperStart(HandlebarsParserState state, IBlockHelperHandler helper)
{
var block = SyntaxTree.Block(state.CurrentLocation);
var helperBlock = SyntaxTree.Helper(SyntaxTreeExpression.Helper(state.CurrentToken.Content.Substring(1), helper, state.CurrentLocation), block, state.CurrentLocation);
state.AddNodeToCurrentBlock(helperBlock);
state.BlockStack.PushModelInheritingBlock(block);
}
private static void HandleWith(HandlebarsParserState state)
{
var withBlock = SyntaxTree.Block(state.CurrentLocation);
var modelExpression = state.ParseExpression(state.CurrentToken.Content.Substring(6), state.CurrentLocation.MoveIndex(6));
state.AddNodeToCurrentBlock(SyntaxTree.ScopeNode(modelExpression, withBlock, state.CurrentLocation));
state.BlockStack.PushBlock(new HandlebarsParserBlock
{
Block = withBlock,
ModelInScope = modelExpression.ResultType
});
}
private static void HandleHelper(HandlebarsParserState state, IHelperHandler helper)
{
string expression = state.CurrentToken.Content;
state.AddNodeToCurrentBlock(SyntaxTreeExpression.Helper(expression, helper, state.CurrentLocation));
}
private static void HandlePartial(HandlebarsParserState state)
{
var partialTemplateName = state.CurrentToken.Content.Substring(1).Trim();
var self = SyntaxTreeExpression.Self(state.BlockStack.GetCurrentModelType(), state.CurrentLocation);
state.AddNodeToCurrentBlock(SyntaxTree.Include(partialTemplateName, self, state.CurrentLocation));
}
private static void HandleEndWith(HandlebarsParserState state)
{
state.AssertInsideWith("{{/with}}");
state.BlockStack.PopBlock();
}
private static void HandleBody(HandlebarsParserState state)
{
state.AddNodeToCurrentBlock(SyntaxTree.Override(OverrideSectionName, state.CurrentLocation));
}
private static void HandleBody(HandlebarsParserState state)
{
state.AddNodeToCurrentBlock(SyntaxTree.Override(OverrideSectionName));
}
private static void HandleExpression(HandlebarsParserState state)
{
var expression = state.ParseExpression(state.CurrentToken.Content);
state.AddNodeToCurrentBlock(SyntaxTree.WriteExpression(expression, state.CurrentToken.IsHtmlEscape));
}
private static void HandleIf(HandlebarsParserState state)
{
var block = SyntaxTree.Block();
var conditional = SyntaxTree.Conditional(state.ParseExpression(state.CurrentToken.Content.Substring(4)), block);
state.AddNodeToCurrentBlock(conditional);
state.BlockStack.PushModelInheritingBlock(block);
}
