示例#1
0
        public static LiquidExpressionResult Eval(
            LiquidExpression expression,
            IEnumerable <Option <ILiquidValue> > leaves,
            ITemplateContext templateContext)
        {
            // calculate the first part of the expression
            var objResult = expression.Expression == null?
                            LiquidExpressionResult.Success(new None <ILiquidValue>()) :
                                expression.Expression.Eval(templateContext, leaves);

            if (objResult.IsError)
            {
                return(objResult);
            }

            // Compose a chain of filters, making sure type-casting
            // is done between them.
            //IEnumerable<Tuple<FilterSymbol, IFilterExpression>> filterExpressionTuples;
//            try
//            {
            var filterExpressionTuples = expression.FilterSymbols.Select(symbol =>
                                                                         new Tuple <FilterSymbol, Try <IFilterExpression> >(symbol, InstantiateFilter(templateContext, symbol)))
                                         .ToList();

            //}
            //catch (Exception ex)
            //{
            //   return LiquidExpressionResult.Error(ex.Message);
            //}
            if (filterExpressionTuples.Any(x => x.Item2.IsFailure))
            {
                // just return the first error.
                return(LiquidExpressionResult.Error(filterExpressionTuples.First().Item2.Exception.Message));
            }

            var erroringFilternames = filterExpressionTuples.Where(x => x.Item2 == null).Select(x => x.Item1).ToList();

            if (erroringFilternames.Any())
            {
                //throw new Exception("Missing filters...");
                //return ConstantFactory.CreateError<LiquidString>();
                return(LiquidExpressionResult.Error("Missing filters: " + String.Join(", ", erroringFilternames.Select(x => x.Name))));
            }

            var filterChain = FilterChain.CreateChain(
                objResult.GetType(),
                templateContext,
                filterExpressionTuples.Select(x => x.Item2.Value));

            // apply the composed function to the object

            var result = filterChain(objResult.SuccessResult);

            return(result);
        }
示例#2
0
        public void StartLiquidExpression(IExpressionDescription expressionDescription)
        {
            //Console.WriteLine("LiquidExpressionBuilder >>> PUSH");
            LiquidExpression liquidExpression = new LiquidExpression {
                Expression = expressionDescription
            };
            var child = new TreeNode <LiquidExpression>(liquidExpression);

            if (_liquidExpressionStack.Any())
            {
                //Console.WriteLine(" to " + _liquidExpressionStack.Peek());
                _liquidExpressionStack.Peek().AddChild(child);
            }
//            else
//            {
//                //Console.WriteLine(" to ROOT ");
//                _liquidExpressionTree = child;
//            }
            _liquidExpressionStack.Push(child);
        }
示例#3
0
 public void Visit(LiquidExpression liquidExpression)
 {
     _result += liquidExpression.ToString();
 }