public void Visit(CaseWhenElseBlockTag caseWhenElseBlockTag) { var valueToMatchResult = LiquidExpressionEvaluator.Eval(caseWhenElseBlockTag.LiquidExpressionTree, _templateContext); //Console.WriteLine("Value to Match: "+valueToMatch); if (valueToMatchResult.IsError) { RegisterRenderingError(valueToMatchResult.ErrorResult); //RenderError(valueToMatchResult.ErrorResult); return; } var match = caseWhenElseBlockTag.WhenClauses.FirstOrDefault( expr => // Take the valueToMatch "Case" expression result value // and check if it's equal to the expr.GroupNameExpressionTree expression. // THe "EasyValueComparer" is supposed to match stuff fairly liberally, // though it doesn't cast values---probably it should. expr.LiquidExpressionTree.Any(val => new EasyOptionComparer().Equals(valueToMatchResult.SuccessResult, LiquidExpressionEvaluator.Eval(val, _templateContext).SuccessResult))); if (match != null) // found match { StartWalking(match.LiquidBlock); // so eval + render the HTML } else if (caseWhenElseBlockTag.HasElseClause) { StartWalking(caseWhenElseBlockTag.ElseClause.LiquidBlock); } }
/// <summary> /// Side effect: state is managed in the _counters dictionary. /// </summary> /// <returns></returns> private String GetNextCycleText(String groupName, CycleTag cycleTag) { int currentIndex; // Create a like dictionary key entry to keep track of this declaration. THis takes the variable // names (not the eval-ed variables) or literals and concatenates them together. var key = "cycle_" + groupName + "_" + String.Join("|", cycleTag.CycleList.Select(x => x.Data.Expression.ToString())); while (true) { currentIndex = _counters.GetOrAdd(key, 0); var newindex = (currentIndex + 1) % cycleTag.Length; // fails if updated concurrently by someone else. if (_counters.TryUpdate(key, newindex, currentIndex)) { break; } } String result = ""; var currentElement = cycleTag.ElementAt(currentIndex); LiquidExpressionEvaluator.Eval(currentElement, _templateContext) .WhenSuccess(x => result = ValueCaster.RenderAsString(LiquidExpressionEvaluator.Eval(currentElement, _templateContext).SuccessResult.Value)) .WhenError(err => result = FormatErrors(new List <LiquidError> { err })); return(result); }
public void Visit(AssignTag assignTag) { LiquidExpressionEvaluator.Eval(assignTag.LiquidExpressionTree, _templateContext) .WhenSuccess(x => _templateContext.SymbolTableStack.DefineGlobal(assignTag.VarName, x)) .WhenError(err => { RegisterRenderingError(err); //RenderError(err); }); }
public void Visit(LiquidExpressionTree liquidExpressionTree) { var result = LiquidExpressionEvaluator.Eval(liquidExpressionTree, _templateContext); result.WhenSuccess(success => success.WhenSome(x => AppendTextToCurrentAccumulator(Render(x)))) .WhenError(error => { RegisterRenderingError(error); //RenderingErrors.Add(error); //RenderError(error); }); }
public void Visit(IfThenElseBlockTag ifThenElseBlockTag) { // find the first place where the expression tree evaluates to true (i.e. which of the if/elsif/else clauses) // This ignores "eval" errors in clauses. var match = ifThenElseBlockTag.IfElseClauses.FirstOrDefault( expr => LiquidExpressionResultIsTrue(LiquidExpressionEvaluator.Eval(expr.LiquidExpressionTree, _templateContext))); if (match != null) { StartWalking(match.LiquidBlock); // then render the contents } }
public void Visit(CustomTag customTag) { //Console.WriteLine("Looking up Custom Tag " + customTag.TagName); var tagType = _templateContext.SymbolTableStack.LookupCustomTagRendererType(customTag.TagName); if (tagType != null) { AppendTextToCurrentAccumulator(RenderCustomTag(customTag, tagType)); return; } //Console.WriteLine("Looking up Macro "+ customTag.TagName); var macroDescription = _templateContext.SymbolTableStack.LookupMacro(customTag.TagName); if (macroDescription != null) { //Console.WriteLine("..."); var evalResults = customTag.LiquidExpressionTrees.Select(x => LiquidExpressionEvaluator.Eval(x, _templateContext)).ToList(); if (evalResults.Any(x => x.IsError)) { var errors = evalResults.Where(x => x.IsError).Select(x => x.ErrorResult).ToList(); foreach (LiquidError error in errors) { RegisterRenderingError(error); } //RenderErrors(errors); return; } AppendTextToCurrentAccumulator(RenderMacro(macroDescription, evalResults.Select(x => x.SuccessResult))); return; } var err = new LiquidError { Message = "Liquid syntax error: Unknown tag '" + customTag.TagName + "'" }; //RenderError(err); RegisterRenderingError(err); }
public void EvalExpressions( IEnumerable <TreeNode <LiquidExpression> > expressionTrees, Action <IEnumerable <Option <ILiquidValue> > > successAction = null, Action <IEnumerable <LiquidError> > failureAction = null) { var evaledArgs = expressionTrees.Select(x => LiquidExpressionEvaluator.Eval(x, _templateContext)).ToList(); if (evaledArgs.Any(x => x.IsError)) { if (failureAction != null) { failureAction(evaledArgs.Where(x => x.IsError).Select(x => x.ErrorResult)); } } else { if (successAction != null) { successAction(evaledArgs.Select(x => x.SuccessResult)); } } }
public void Visit(CycleTag cycleTag) { if (cycleTag.GroupNameExpressionTree == null) { AppendTextToCurrentAccumulator(GetNextCycleText(groupName: null, cycleTag: cycleTag)); } else { // figure out the group name if any, otherwise use null. LiquidExpressionEvaluator.Eval(cycleTag.GroupNameExpressionTree, _templateContext) .WhenSuccess( x => AppendTextToCurrentAccumulator( GetNextCycleText( groupName: x.HasValue ? ValueCaster.RenderAsString(x.Value) : null, cycleTag: cycleTag))) .WhenError(err => { RegisterRenderingError(err); //RenderError(err); }); } }