private CompiledTemplate(JinjaEnvironment environment, ExpressionData templateNode, string?templateName, string?templatePath)
{
TemplateNode = templateNode;
Environment = environment;
TemplateName = templateName;
TemplatePath = templatePath;
}
internal static bool TryParseRaw(JinjaEnvironment environment, Lexer lexer, ILookaroundEnumerator <ParsingNode> enumerator, [NotNullWhen(true)] out ASTNode?parsedNode)
{
parsedNode = default;
if (RawParser.StartBlock.TryParse(enumerator.Current) == false)
{
return(false);
}
var startParsingNode = enumerator.Current;
var children = new List <ParsingNode>();
while (true)
{
if (enumerator.MoveNext() == false)
{
throw new NotImplementedException();
}
if (RawParser.EndBlock.TryParse(enumerator.Current))
{
break;
}
children.Add(enumerator.Current);
}
var endParsingNode = enumerator.Current;
parsedNode = new RawNode(startParsingNode, children, endParsingNode);
return(true);
}
private ExpressionNode(JinjaEnvironment environment, string expression) : base(new ParsingNode(ParsingNodeType.Expression, new[] { new Token(TokenType.Unknown, expression) }))
{
Expression = expression;
Output = false;
ExpressionParserNode = environment.Evaluation.Parse(expression);
WhiteSpaceControl = new WhiteSpaceControlSet();
}
internal static bool TryParseMacro(JinjaEnvironment environment, Lexer lexer, ILookaroundEnumerator <ParsingNode> enumerator, [NotNullWhen(true)] out ASTNode?parsedNode)
{
parsedNode = default;
if (MacroParser.StartBlock.TryParse(enumerator.Current, out var outsideStart, out var insideStart) == false)
{
return(false);
}
if (MacroParser.StartBlock.TryGetAccumulation(MacroParser.MacroState.MacroDefinition, 0, out var macroText) == false)
{
throw new NotImplementedException();
}
var startParsingNode = enumerator.Current;
enumerator.MoveNext();
var contents = ASTGenerator.ParseUntilFailure(environment, lexer, enumerator).ToArray();
if (MacroParser.EndBlock.TryParse(enumerator.Current, out var insideEnd, out var outsideEnd) == false)
{
throw new NotImplementedException();
}
var endParsingNode = enumerator.Current;
var contentsNode = new ContainerNode(null, contents, null,
new WhiteSpaceControlSet(insideStart, insideEnd)
);
parsedNode = new MacroNode(environment, startParsingNode, macroText, contentsNode, endParsingNode,
new WhiteSpaceControlSet(outsideStart, outsideEnd)
);
return(true);
}
internal static bool TryParse(JinjaEnvironment environment, ILookaroundEnumerator <ParsingNode> enumerator, [NotNullWhen(true)] out ASTNode?parsedNode)
{
parsedNode = default;
string?ifClause = null;
string?elseClause = null;
if (ExpressionNodeParser.Parser.TryParse(enumerator.Current, out var startWhiteSpace, out var endWhiteSpace) == false)
{
return(false);
}
if (ExpressionNodeParser.Parser.TryGetAccumulation(ExpressionNodeParser.ExpressionState.Expression, 0, out var expression) == false)
{
throw new NotImplementedException();
}
if (ExpressionNodeParser.Parser.TryGetAccumulation(ExpressionNodeParser.ExpressionState.IfClause, 0, out var ifClauseString))
{
ifClause = ifClauseString;
}
if (ExpressionNodeParser.Parser.TryGetAccumulation(ExpressionNodeParser.ExpressionState.ElseClause, 0, out var elseClauseString))
{
elseClause = elseClauseString;
}
if (string.IsNullOrEmpty(expression))
{
throw new NotImplementedException();
}
parsedNode = new ExpressionNode(environment, enumerator.Current, startWhiteSpace, endWhiteSpace, expression, ifClause, elseClause);
return(true);
}
internal Lexer(JinjaEnvironment environment)
{
Environment = environment;
_Delegates = new TryDelegate[]
{
TryNewLine,
TryWhiteSpace,
TryKeyword,
TrySingleChar,
};
_KeywordLookups.Add(environment.Settings.BlockStartString.ToCharArray(), TokenType.StatementStart);
_KeywordLookups.Add(environment.Settings.BlockEndString.ToCharArray(), TokenType.StatementEnd);
_KeywordLookups.Add(environment.Settings.VariableStartString.ToCharArray(), TokenType.ExpressionStart);
_KeywordLookups.Add(environment.Settings.VariableEndString.ToCharArray(), TokenType.ExpressionEnd);
_KeywordLookups.Add(environment.Settings.CommentStartString.ToCharArray(), TokenType.CommentStart);
_KeywordLookups.Add(environment.Settings.CommentEndString.ToCharArray(), TokenType.CommentEnd);
if (environment.Settings.LineCommentPrefix != null)
{
_KeywordLookups.Add(environment.Settings.LineCommentPrefix.ToCharArray(), TokenType.LineComment);
}
if (environment.Settings.LineStatementPrefix != null)
{
_KeywordLookups.Add(environment.Settings.LineStatementPrefix.ToCharArray(), TokenType.LineStatement);
}
}
private DynamicTemplate(JinjaEnvironment environment, TemplateNode templateNode, string?templateName, string?templatePath)
{
TemplateNode = templateNode;
Environment = environment;
TemplateName = templateName;
TemplatePath = templatePath;
}
public void CreateEnvironment()
{
_Environment = new JinjaEnvironment(settings: new EnvironmentSettings
{
TrimBlocks = true
});
}
public void ValidateValidTemplate()
{
var environment = new JinjaEnvironment();
var result = environment.ValidateTemplateFromString("{% if a is divisibleby 3 %}{% endif %}");
Assert.AreEqual(true, result);
}
public void ValidateInvalidTemplate()
{
var environment = new JinjaEnvironment();
var result = environment.ValidateTemplateFromString("{% if a is asdf %}{% endif %}");
Assert.AreEqual(false, result);
}
internal static bool TryParseFilter(JinjaEnvironment environment, Lexer lexer, ILookaroundEnumerator <ParsingNode> enumerator, [NotNullWhen(true)] out ASTNode?parsedNode)
{
parsedNode = default;
if (FilterParser.StartBlock.TryParse(enumerator.Current) == false)
{
return(false);
}
var startParsingNode = enumerator.Current;
if (FilterParser.StartBlock.TryGetAccumulation(FilterParser.FilterState.FilterName, 0, out var filterName) == false)
{
throw new NotImplementedException();
}
if (string.IsNullOrEmpty(filterName))
{
throw new NotImplementedException();
}
enumerator.MoveNext();
var contents = ASTGenerator.ParseUntilFailure(environment, lexer, enumerator).ToArray();
if (FilterParser.EndBlock.TryParse(enumerator.Current) == false)
{
throw new NotImplementedException();
}
var contentsNode = new ContainerNode(null, contents, null);
parsedNode = new FilterNode(startParsingNode, filterName, contentsNode, enumerator.Current);
return(true);
}
internal static CompiledTemplate LoadTemplate(JinjaEnvironment environment, string templateText, IDictionary <string, object?> variableTemplate, string templateName, string?templatePath)
{
var rootScope = CompiledScope.CreateRootScope("GLOBALS", variableTemplate);
var expr = ToExpression(templateName, environment, templateText, rootScope);
return(new CompiledTemplate(environment, ExpressionData.CreateCompiled(expr, rootScope), templateName, templatePath));
}
internal override bool TryGetSource(JinjaEnvironment environment, string templateName, [NotNullWhen(true)] out TemplateInfo?templateInfo)
{
templateInfo = default;
if (_Templates.TryGetValue(templateName, out var templateText) == false)
{
return(false);
}
templateInfo = new TemplateInfo(templateText, templateName, true);
return(true);
}
internal static CompiledTemplate FromBlockNode(string templateName, JinjaEnvironment environment, BlockNode blockNode, IDictionary <string, object?> variableTemplate)
{
var rootScope = CompiledScope.CreateRootScope("GLOBALS", variableTemplate);
#if DEBUG
var expr = NewASTCompiler.ToExpression(templateName, environment, blockNode, out var newcompiler, rootScope);
return(new CompiledTemplate(environment, ExpressionData.CreateCompiled(expr, rootScope), blockNode.Name, null));
#else
throw new NotImplementedException();
#endif
}
//internal static Expression ToExpression(JinjaEnvironment environment, string templateText, IDictionary<string, object?> variableTemplate, out ASTCompiler compiler)
//{
// var lexer = new Lexer(environment);
// var tokens = lexer.Tokenize(templateText).ToArray();
// var parsed = Parser.Parse(tokens).ToArray();
// var environmentTrimmed = EnvironmentTrimming.EnvironmentTrim(parsed, environment.Settings).ToArray();
// var templateNode = ASTGenerator.ParseTemplate(environmentTrimmed);
// var commentsRemoved = templateNode.Transform(CommentRemoverTransformer.Instance);
// var controlledWhiteSpace = WhiteSpaceController.ControlWhiteSpace(commentsRemoved);
// var containerAssembled = controlledWhiteSpace.Transform(TemplateContainerAssembler.Instance);
// var finished = NewASTCompiler.ToExpression(environment, containerAssembled, variableTemplate, out var newcompiler);
// throw new NotImplementedException();
//}
internal static Expression ToExpression(string templateName, JinjaEnvironment environment, string templateText, CompiledScope rootScope)
{
var containerAssembled = ASTNode.GetTemplateNode(environment, templateText);
#if DEBUG
var finished = NewASTCompiler.ToExpression(templateName, environment, containerAssembled, out var newcompiler, rootScope);
return(finished);
#else
throw new NotImplementedException();
#endif
}
internal MacroNode(JinjaEnvironment environment, ParsingNode?startParsingNode, string macroText, ContainerNode contents, ParsingNode?endParsingNode, WhiteSpaceControlSet?whiteSpace = null)
: base(startParsingNode, contents.ParsingNodes, endParsingNode)
{
Contents = contents;
WhiteSpaceControl = whiteSpace ?? new WhiteSpaceControlSet();
//MacroText = macroText;
if (environment.Evaluation.TryParseFunctionDeclaration(macroText, out var functionDeclaration) == false || functionDeclaration == null)
{
throw new NotImplementedException();
}
FunctionDeclaration = functionDeclaration;
}
public void TestInclude()
{
var environment = new JinjaEnvironment(new DictLoader(new Dictionary <string, string>
{
{ "include", "{% macro test(foo) %}[{{ foo }}]{% endmacro %}" }
}));
dynamic template = new DynamicTemplateRenderer(
environment.FromString("{% from \"include\" import test %}{{ test(\"foo\") }}")
);
MyAssert.AreEqual("[foo]", template.Render());
}
internal static string CheckOriginalText(JinjaEnvironment environment, string templateText)
{
var lexer = new Lexer(environment);
var tokens = lexer.Tokenize(templateText).ToArray();
var parsed = Parser.Parse(tokens).ToArray();
var outputCombined = OutputCombiner.CombineOutput(parsed);
ASTNode templateNode = ASTGenerator.ParseTemplate(environment, lexer, outputCombined);
var stringBuilder = new StringBuilder();
templateNode.ToOriginalText(stringBuilder);
return(stringBuilder.ToString());
}
internal static ASTNode GetTemplateNode(JinjaEnvironment environment, string templateText)
{
var lexer = new Lexer(environment);
var tokens = lexer.Tokenize(templateText).ToArray();
var parsed = Parser.Parse(tokens).ToArray();
var outputCombined = OutputCombiner.CombineOutput(parsed);
ASTNode templateNode = ASTGenerator.ParseTemplate(environment, lexer, outputCombined);
//templateNode = templateNode.Transform(CommentRemoverTransformer.Instance);
templateNode = WhiteSpaceController.ControlWhiteSpace(environment, templateNode);
return(templateNode);
}
internal static ASTNode ControlWhiteSpace(JinjaEnvironment environment, ASTNode templateNode)
{
if (environment.Settings.TrimBlocks)
{
templateNode.Transform(TrimBlocksVisitor.Instance);
}
if (environment.Settings.LStripBlocks)
{
templateNode.Transform(LStripBlocksVisitor.Instance);
}
templateNode.Transform(ManualWhiteSpaceVisitor.Instance);
return(templateNode);
}
internal static bool TryParse(JinjaEnvironment environment, Lexer lexer, ILookaroundEnumerator <ParsingNode> enumerator, [NotNullWhen(true)] out ASTNode?parsedNode)
{
parsedNode = _Delegates.Select(del =>
{
var Result = del(environment, lexer, enumerator, out var ParsedNode);
return(new
{
Result,
ParsedNode,
});
}).FirstOrDefault(res => res.Result)?.ParsedNode;
return(parsedNode != default);
}
internal static bool TryParseFor(JinjaEnvironment environment, Lexer lexer, ILookaroundEnumerator <ParsingNode> enumerator, [NotNullWhen(true)] out ASTNode?parsedNode)
{
ContainerNode? elseBlock = null;
ExpressionNode?filterNode = null;
parsedNode = default;
if (ForParser.StartBlock.TryParse(enumerator.Current, out var outsideStart, out var primaryInsideStart) == false)
{
return(false);
}
var primaryStartParsingNode = enumerator.Current;
if (ForParser.StartBlock.TryGetAccumulations(ForParser.ForState.VariableNames, out var variableNames) == false || variableNames.Length == 0)
{
throw new NotImplementedException();
}
if (ForParser.StartBlock.TryGetAccumulation(ForParser.ForState.Expression, 0, out var expression) == false)
{
throw new NotImplementedException();
}
if (ForParser.StartBlock.TryGetAccumulation(ForParser.ForState.Filter, 0, out string?filter))
{
filterNode = ExpressionNode.FromString(environment, filter);
}
ForParser.StartBlock.TryGetVariable <bool>("recursive", out var recursive);
enumerator.MoveNext();
var primaryBlockChildren = ASTGenerator.ParseUntilFailure(environment, lexer, enumerator).ToArray();
ContainerNode primaryBlock;
if (ForParser.ElseBlock.TryParse(enumerator.Current, out var primaryInsideEnd, out var elseInsideStart))
{
var elseStartParsingNode = enumerator.Current;
enumerator.MoveNext();
var elseBlockChildren = ASTGenerator.ParseUntilFailure(environment, lexer, enumerator).ToArray();
if (ForParser.EndBlock.TryParse(enumerator.Current, out var elseInsideEnd, out var outsideEnd) == false)
{
throw new NotImplementedException();
}
primaryBlock = new ContainerNode(primaryStartParsingNode, primaryBlockChildren, null,
new WhiteSpaceControlSet(primaryInsideStart, primaryInsideEnd));
elseBlock = new ContainerNode(elseStartParsingNode, elseBlockChildren, null,
new WhiteSpaceControlSet(elseInsideStart, elseInsideEnd));
parsedNode = new ForNode(primaryBlock, elseBlock, variableNames, ExpressionNode.FromString(environment, expression),
filterNode, recursive, enumerator.Current, new WhiteSpaceControlSet(outsideStart, outsideEnd));
return(true);
}
public void ValidateValidVariables()
{
var templateString = "{{ a.ToString(\"O\") }}";
var vars = new Dictionary <string, object?>
{
{ "a", DateTime.Now }
};
var environment = new JinjaEnvironment();
//var result = environment.ValidateTemplateFromString(templateString);
//Assert.AreEqual(true, result);
var template = environment.FromString(templateString);
var result = template.Validate(vars);
Assert.AreEqual(true, result);
}
internal ExpressionNode(JinjaEnvironment environment, ParsingNode parsingNode,
WhiteSpaceMode startWhiteSpace, WhiteSpaceMode endWhiteSpace, string expression, string?ifClause, string?elseClause) : base(parsingNode)
{
Expression = expression;
ExpressionParserNode = environment.Evaluation.Parse(expression);
if (ifClause != null)
{
IfClause = environment.Evaluation.Parse(ifClause);
}
if (elseClause != null)
{
ElseClause = new ExpressionNode(environment, elseClause);
}
WhiteSpaceControl = new WhiteSpaceControlSet(startWhiteSpace, endWhiteSpace);
}
internal static TemplateNode ParseTemplate(JinjaEnvironment environment, Lexer lexer, IEnumerable <ParsingNode> source)
{
using var enumerator = LookaroundEnumeratorFactory.CreateLookaroundEnumerator(source, 10);
while (enumerator.MoveNext())
{
var nodes = ParseUntilFailure(environment, lexer, enumerator).ToArray();
if (enumerator.TryGetNext(out var nextNode))
{
throw new NotImplementedException();
}
return(new TemplateNode(nodes));
}
throw new NotImplementedException();
}
internal static bool TryParseInclude(JinjaEnvironment environment, Lexer lexer, ILookaroundEnumerator <ParsingNode> enumerator, [NotNullWhen(true)] out ASTNode?parsedNode)
{
parsedNode = default;
if (IncludeParser.Parser.TryParse(enumerator.Current) == false)
{
return(false);
}
if (IncludeParser.Parser.TryGetAccumulation(IncludeParser.IncludeState.TemplateNames, 0, out var templateNames) == false)
{
throw new NotImplementedException();
}
var templateNamesExpression = ExpressionNode.FromString(environment, templateNames);
var ignoreMissing = IncludeParser.Parser.GetVariable <bool>("ignoreMissing", false);
var context = IncludeParser.Parser.GetVariable <bool?>("context", null);
parsedNode = new IncludeNode(enumerator.Current, templateNamesExpression, ignoreMissing, context);
return(true);
}
internal static bool TryParseImport(JinjaEnvironment environment, Lexer lexer, ILookaroundEnumerator <ParsingNode> enumerator, [NotNullWhen(true)] out ASTNode?parsedNode)
{
parsedNode = default;
if (ImportParser.ParserImport.TryParse(enumerator.Current) == false)
{
return(false);
}
if (ImportParser.ParserImport.TryGetAccumulation(ImportParser.ImportState.Template, 0, out var template) == false)
{
throw new NotImplementedException();
}
if (ImportParser.ParserImport.TryGetAccumulation(ImportParser.ImportState.As, 0, out var asText) == false)
{
throw new NotImplementedException();
}
var templateNode = environment.Evaluation.Parse(template);
parsedNode = new ImportNode(enumerator.Current, templateNode, asText);
return(true);
}
internal static IEnumerable <ASTNode> ParseUntilFailure(JinjaEnvironment environment, Lexer lexer, ILookaroundEnumerator <ParsingNode> enumerator)
{
do
{
ASTNode?astNode = default;
switch (enumerator.Current.NodeType)
{
case ParsingNodeType.Statement:
StatementNode.TryParse(environment, lexer, enumerator, out astNode);
break;
case ParsingNodeType.NewLine:
astNode = new NewLineNode(enumerator.Current);
break;
case ParsingNodeType.Comment:
astNode = new CommentNode(enumerator.Current);
break;
case ParsingNodeType.WhiteSpace:
astNode = WhiteSpaceNode.Parse(enumerator);
break;
case ParsingNodeType.Expression:
if (ExpressionNode.TryParse(environment, enumerator, out astNode) == false)
{
throw new NotImplementedException();
}
break;
case ParsingNodeType.Output:
astNode = new OutputNode(enumerator.Current);
break;
}
if (astNode == default)
{
yield break;
}
yield return(astNode);
} while (enumerator.MoveNext());
}
internal static bool TryParseSet(JinjaEnvironment environment, Lexer lexer, ILookaroundEnumerator <ParsingNode> enumerator, [NotNullWhen(true)] out ASTNode?parsedNode)
{
parsedNode = default;
if (SetParser.StartBlock.TryParse(enumerator.Current) == false)
{
return(false);
}
var startParsingNode = enumerator.Current;
if (SetParser.StartBlock.TryGetAccumulations(SetParser.SetState.VariableName, out var variableNames) == false)
{
throw new NotImplementedException();
}
if (variableNames == null || variableNames.Length == 0)
{
throw new NotImplementedException();
}
if (variableNames.Length != 1)
{
throw new NotImplementedException(); // Not supported yet
}
if (SetParser.StartBlock.TryGetAccumulation(SetParser.SetState.AssignmentExpression, 0, out var assignmentExpression))
{
parsedNode = new SetNode(startParsingNode, variableNames, assignmentExpression, null);
return(true);
}
enumerator.MoveNext();
var contents = ASTGenerator.ParseUntilFailure(environment, lexer, enumerator).ToArray();
if (SetParser.EndBlock.TryParse(enumerator.Current) == false)
{
throw new NotImplementedException();
}
var contentsNode = new ContainerNode(null, contents, null);
parsedNode = new SetNode(startParsingNode, variableNames, contentsNode, enumerator.Current);
return(true);
}
internal static bool TryParseCall(JinjaEnvironment environment, Lexer lexer, ILookaroundEnumerator <ParsingNode> enumerator, [NotNullWhen(true)] out ASTNode?parsedNode)
{
parsedNode = default;
if (CallParser.StartBlock.TryParse(enumerator.Current, out var outsideStart, out var insideStart) == false)
{
return(false);
}
if (CallParser.StartBlock.TryGetAccumulation(CallParser.CallState.CallDefinition, 0, out var callDefinition) == false)
{
throw new NotImplementedException();
}
var startParsingNode = enumerator.Current;
enumerator.MoveNext();
var contents = ASTGenerator.ParseUntilFailure(environment, lexer, enumerator).ToArray();
if (CallParser.EndBlock.TryParse(enumerator.Current, out var insideEnd, out var outsideEnd) == false)
{
return(false);
}
var endParsingNode = enumerator.Current;
var contentsNode = new ContainerNode(null, contents, null,
new WhiteSpaceControlSet(insideStart, insideEnd)
);
if (TryParseCallDefinition(lexer, callDefinition, out var callArgumentList, out var macroCall) == false)
{
throw new NotImplementedException();
}
parsedNode = new CallNode(startParsingNode,
ExpressionNode.FromString(environment, callArgumentList),
ExpressionNode.FromString(environment, macroCall), contentsNode, endParsingNode,
new WhiteSpaceControlSet(outsideStart, outsideEnd)
);
return(true);
}
