public override LiquidExpressionResult Eval(ITemplateContext templateContext, IEnumerable <Option <ILiquidValue> > expressions)
{
IList <Option <ILiquidValue> > exprList = expressions.ToList();
if (exprList.Count != 2)
{
// This shouldn't happen if the parser is correct.
return(LiquidExpressionResult.Error("Equals is a binary expression but received " + exprList.Count + "."));
}
if (!exprList[0].HasValue && !exprList[1].HasValue)
{
return(LiquidExpressionResult.Success(new LiquidBoolean(true)));
}
if (!exprList[0].HasValue || !exprList[1].HasValue)
{
return(LiquidExpressionResult.Success(new LiquidBoolean(false)));
}
if (exprList[0].GetType() == exprList[1].GetType())
{
var isEqual = exprList[0].Value.Equals(exprList[1].Value);
return(LiquidExpressionResult.Success(new LiquidBoolean(isEqual)));
}
return(LiquidExpressionResult.Error("\"Equals\" implementation can't cast that yet"));
}
public override LiquidExpressionResult ApplyTo(ITemplateContext ctx, ILiquidValue liquidExpression)
{
var strArray = ValueCaster.RenderAsString(liquidExpression).Split();
// TODO: add ability to toggle lower-case on/off
return(LiquidExpressionResult.Success(StringUtils.Eval(liquidExpression, x => Slug.Create(true, strArray))));
}
public override LiquidExpressionResult Eval(ITemplateContext templateContext, IEnumerable <Option <ILiquidValue> > expressions)
{
IList <Option <ILiquidValue> > exprList = expressions.ToList();
if (exprList.Count != 2)
{
return(LiquidExpressionResult.Error("Contains is a binary expression but received " + exprList.Count + "."));
}
if (!exprList[0].HasValue || !exprList[1].HasValue)
{
return(LiquidExpressionResult.Success(new LiquidBoolean(false)));
}
//return Contains((dynamic) exprList[0].Value, exprList[1].Value);
var arr = exprList[0].Value as LiquidCollection;
if (arr != null)
{
return(Contains(arr, exprList[1].Value));
}
var dict = exprList[0].Value as LiquidHash;
if (dict != null)
{
return(Contains(dict, exprList[1].Value));
}
var str = exprList[0].Value as LiquidString;
if (str != null)
{
return(Contains(str, exprList[1].Value));
}
return(Contains(exprList[0].Value, exprList[1].Value));
}
public override LiquidExpressionResult Apply(ITemplateContext ctx, LiquidString liquidLiquidStringExpression)
{
return(LiquidExpressionResult.Success(LiquidString.Create(
(liquidLiquidStringExpression == null ? "NULL" : liquidLiquidStringExpression.StringVal) + " " +
(LiquidStringArg1 == null ? "NULL" : LiquidStringArg1.StringVal) + " " +
(LiquidStringArg2 == null ? "NULL" : LiquidStringArg2.StringVal))));
}
public override LiquidExpressionResult ApplyTo(ITemplateContext ctx, LiquidRange liquidGeneratorExpression)
{
//return GetSize(liquidGeneratorExpression, () => LiquidNumeric.Create(liquidGeneratorExpression.Length));
return(liquidGeneratorExpression == null
? SizeOfNil()
: LiquidExpressionResult.Success(LiquidNumeric.Create(liquidGeneratorExpression.Length)));
}
/// <summary>
/// Look up the index in the value. This works for dictionaries, arrays and strings.
/// </summary>
/// <param name="ctx"></param>
/// <param name="value"></param>
/// <param name="indexProperty"></param>
/// <returns></returns>
public LiquidExpressionResult Lookup(
ITemplateContext ctx,
ILiquidValue value,
ILiquidValue indexProperty)
{
var arr = value as LiquidCollection;
if (arr != null)
{
return(DoLookup(ctx, arr, indexProperty));
}
var dict = value as LiquidHash;
if (dict != null)
{
return(DoLookup(ctx, dict, indexProperty));
}
var str = value as LiquidString;
if (str != null)
{
return(DoLookup(ctx, str, indexProperty));
}
return(LiquidExpressionResult.Error("ERROR : cannot apply an index to a " + value.LiquidTypeName + "."));
}
// public override void Accept(IExpressionDescriptionVisitor expressionDescriptionVisitor)
// {
// expressionDescriptionVisitor.Visit(this);
// }
//public ILiquidValue Eval(SymbolTableStack symbolTableStack, IEnumerable<ILiquidValue> expressions)
public override LiquidExpressionResult Eval(ITemplateContext templateContext, IEnumerable <Option <ILiquidValue> > expressions)
{
//IList<ILiquidValue> exprList = expressions.ToList();
IList <Option <ILiquidValue> > exprList = expressions.ToList();
//Console.WriteLine("EqualsExpression is Eval-ing expressions ");
if (exprList.Count != 2)
{
//return LiquidExpressionResult.Error("Equals is a binary expression but received " + exprList.Count() + ".");
return(LiquidExpressionResult.Error("Equals is a binary expression but received " + exprList.Count + "."));
}
if (exprList.All(x => !x.HasValue)) // both null
{
return(LiquidExpressionResult.Success(new LiquidBoolean(false)));
}
if (exprList.Any(x => !x.HasValue)) // one null
{
return(LiquidExpressionResult.Success(new LiquidBoolean(true)));
}
if (exprList[0].GetType() == exprList[1].GetType())
{
return(LiquidExpressionResult.Success(new LiquidBoolean(!exprList[0].Value.Equals(exprList[1].Value))));
}
return(LiquidExpressionResult.Error("\"Not Equals\" implementation can't cast yet"));
}
public override LiquidExpressionResult ApplyTo(ITemplateContext ctx, ILiquidValue liquidExpression)
{
return(LiquidExpressionResult.Success(StringUtils.Eval(liquidExpression, before =>
{
return String.Concat(before.Split(new[] { ' ', '-', '_' }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => char.ToUpper(x[0]) + x.Substring(1).ToLower()));
})));
}
public override LiquidExpressionResult Eval(ITemplateContext templateContext, IEnumerable <Option <ILiquidValue> > expressions)
{
var childExpressions = expressions.ToList();
return(childExpressions.Count != 1 ?
LiquidExpressionResult.Error("Unable to parse expression in parentheses") :
LiquidExpressionResult.Success(childExpressions.First()));
}
private LiquidExpressionResult ApplyValueOrNil(ITemplateContext ctx, LiquidExpressionResult current)
{
var result = current.SuccessResult.HasValue
? Apply(ctx, current.SuccessResult.Value)
: ApplyToNil(ctx); // pass through nil, because maybe there's e.g. a "default" filter somewhere in the chain.
return(result);
}
public override LiquidExpressionResult ApplyTo(ITemplateContext ctx, LiquidCollection liquidArrayExpression)
{
String separator = _separator == null ? "" : _separator.StringVal;
var vals = liquidArrayExpression.Select(ValueCaster.RenderAsString);
return(LiquidExpressionResult.Success(LiquidString.Create(String.Join(separator, vals))));
}
public static LiquidExpressionResult Cast <TSource, TDest>(TSource src)
where TDest : ILiquidValue
where TSource : ILiquidValue
{
if (src == null)
{
return(LiquidExpressionResult.Success(new None <ILiquidValue>()));
}
if (src is TDest)
{
//var result = (TDest) ((dynamic) src);
//ILiquidValue success = (TDest)((dynamic)src);
ILiquidValue success = (TDest)(object)src;
return(LiquidExpressionResult.Success(new Some <ILiquidValue>(success)));
}
if (typeof(TDest) == typeof(LiquidString))
{
return(LiquidExpressionResult.Success(LiquidString.Create(src.ToString())));
}
var str = src as LiquidString;
if (str != null)
{
return(Convert <TDest>(str));
}
var num = src as LiquidNumeric;
if (num != null)
{
return(Convert <TDest>(num));
}
var boo = src as LiquidBoolean;
if (boo != null)
{
return(Convert <TDest>(boo));
}
var dict = src as LiquidHash;
if (dict != null)
{
return(Convert <TDest>(dict));
}
var arr = src as LiquidCollection;
if (arr != null)
{
return(Convert <TDest>(arr));
}
var date = src as LiquidDate;
if (date != null)
{
return(Convert <TDest>(date));
}
//return Convert<TDest>(src);
throw new Exception("Unknown type: " + src.GetType());
}
private static LiquidExpressionResult Convert <TDest>(LiquidString str)
where TDest : ILiquidValue
{
var destType = typeof(TDest);
// if (destType == typeof (LiquidString))
// {
// return LiquidExpressionResult.Success(str);
// }
if (destType == typeof(LiquidNumeric))
{
try
{
var stringVal = str.StringVal;
if (stringVal == null)
{
return(LiquidExpressionResult.Success(LiquidNumeric.Create(0))); // liquid to_numeric seems to convert these to 0.
}
if (stringVal.Contains("."))
{
var val = ToDecimalCultureInvariant(stringVal);
return(LiquidExpressionResult.Success(LiquidNumeric.Create(val)));
}
else
{
try
{
var val = int.Parse(stringVal);
return(LiquidExpressionResult.Success(LiquidNumeric.Create(val)));
}
catch (OverflowException)
{
var val = ToDecimalCultureInvariant(stringVal);
return(LiquidExpressionResult.Success(LiquidNumeric.Create(val)));
}
}
}
catch
{
// https://github.com/Shopify/liquid/blob/master/lib/liquid/standardfilters.rb
return(LiquidExpressionResult.Success(LiquidNumeric.Create(0))); // liquid to_numeric seems to convert these to 0.
}
}
if (destType == typeof(LiquidCollection))
{
var expressionConstants = new Some <ILiquidValue>(str);
// IN liquid, it doesn't seem to cast a string to an array of chars---it casts to an array of one element.
//var expressionConstants = str.StringVal.Select(x => (Option<ILiquidValue>) new Some<ILiquidValue>(LiquidString.Create(x.ToString())));
return(LiquidExpressionResult.Success(new LiquidCollection {
expressionConstants
}));
}
return(LiquidExpressionResult.Error("Can't convert from string to " + destType));
}
public override LiquidExpressionResult ApplyTo(ITemplateContext ctx, LiquidCollection liquidArrayExpression)
{
if (_start == null)
{
return(LiquidExpressionResult.Error("Please pass a start parameter."));
}
return(LiquidExpressionResult.Success(new LiquidCollection(SliceList(liquidArrayExpression))));
}
// ReSharper disable once UnusedParameter.Local
private static LiquidExpressionResult Convert <TDest>(LiquidCollection liquidCollection)
where TDest : ILiquidValue
{
//Console.WriteLine("Rendering array");
var destType = typeof(TDest);
// TODO: Should this return the default value for whatever TDest is requested?
return(LiquidExpressionResult.Error("Can't convert from an LiquidCollection to " + destType));
}
public override LiquidExpressionResult ApplyTo(ITemplateContext ctx, LiquidString liquidLiquidStringExpression)
{
if (liquidLiquidStringExpression == null || String.IsNullOrEmpty(liquidLiquidStringExpression.StringVal))
{
return(LiquidExpressionResult.Error("String is nil"));
}
var positionFilter = new PositionFilter(LiquidNumeric.Create(liquidLiquidStringExpression.StringVal.Length - 1));
return(positionFilter.ApplyTo(ctx, liquidLiquidStringExpression));
}
// public override void Accept(IExpressionDescriptionVisitor expressionDescriptionVisitor)
// {
// expressionDescriptionVisitor.Visit(this);
// }
public override LiquidExpressionResult Eval(ITemplateContext templateContext, IEnumerable <Option <ILiquidValue> > expressions)
{
IList <Option <ILiquidValue> > exprList = expressions.ToList();
if (exprList.Count != 1)
{
return(LiquidExpressionResult.Error("\"Not\" is a unary expression but received " + exprList.Count + " arguments."));
}
return(LiquidExpressionResult.Success(new LiquidBoolean(!exprList[0].HasValue || !exprList[0].Value.IsTrue)));
}
public override LiquidExpressionResult ApplyTo(ITemplateContext ctx, LiquidString liquidLiquidStringExpression)
{
if (String.IsNullOrEmpty(liquidLiquidStringExpression.StringVal))
{
return(LiquidExpressionResult.Success(Option <ILiquidValue> .None()));
}
return(LiquidExpressionResult.Success(LiquidString.Create(String.Join(_separator.StringVal,
liquidLiquidStringExpression.StringVal.ToCharArray().Select(c => c.ToString())))));
}
public override LiquidExpressionResult ApplyTo(ITemplateContext ctx, LiquidString liquidLiquidStringExpression)
{
if (_delimiter == null)
{
return(LiquidExpressionResult.Error("Split filter must have a delimiter"));
}
var strings = liquidLiquidStringExpression.StringVal.Split(new[] { _delimiter.StringVal }, StringSplitOptions.RemoveEmptyEntries);
return(LiquidExpressionResult.Success(new LiquidCollection(strings.Select(s => LiquidString.Create(s).ToOption()).ToList())));
}
public override LiquidExpressionResult Apply(ITemplateContext ctx, LiquidNumeric liquidNumeric)
{
if (_operand == null)
{
return(LiquidExpressionResult.Error("The argument to \"" + Name + "\" is missing."));
}
var val = liquidNumeric.DecimalValue + _operand.DecimalValue;
return(MathHelper.GetReturnValue(val, liquidNumeric, _operand));
}
public override LiquidExpressionResult Apply(ITemplateContext ctx, LiquidNumeric liquidExpression)
{
if (_operand == null)
{
return(LiquidExpressionResult.Error("The operand to \"" + Name + "\" is missing."));
}
var result = liquidExpression.DecimalValue - _operand.DecimalValue;
return(MathHelper.GetReturnValue(result, liquidExpression, _operand));
}
public override LiquidExpressionResult Eval(ITemplateContext templateContext, IEnumerable <Option <ILiquidValue> > expressions)
{
var exprList = expressions.ToList();
if (exprList.Count != 2)
{
throw new Exception("An AND expression must have two values"); // TODO: when the Eval is separated this will be redundant.
}
return(LiquidExpressionResult.Success(new LiquidBoolean(exprList.All(x => x.HasValue) && exprList.All(x => x.Value.IsTrue))));
}
public override LiquidExpressionResult ApplyTo(ITemplateContext ctx, LiquidCollection liquidArrayExpression)
{
if (liquidArrayExpression == null || liquidArrayExpression.Value == null)
{
return(LiquidExpressionResult.Error("Array is nil"));
}
var positionFilter = new PositionFilter(LiquidNumeric.Create(liquidArrayExpression.Count - 1));
return(positionFilter.ApplyTo(ctx, liquidArrayExpression));
}
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);
}
private LiquidExpressionResult ErrorOrNone(ITemplateContext templateContext, LiquidExpressionResult failureResult)
{
if (templateContext.Options.ErrorWhenValueMissing)
{
return(failureResult);
}
else
{
return(LiquidExpressionResult.Success(new None <ILiquidValue>()));
}
}
public override LiquidExpressionResult ApplyTo(ITemplateContext ctx, LiquidString liquidString)
{
var list = liquidString.StringVal.ToCharArray().ToList();
if (_start == null)
{
return(LiquidExpressionResult.Error("Please pass a start parameter."));
}
return(LiquidExpressionResult.Success(LiquidString.Create(String.Concat(SliceList(list)))));
}
public Object ReferenceLocalRegistryVariable(String reference, int skiplevels = 0)
{
for (int i = _symbolTables.Count - 1 - skiplevels; i >= 0; i--)
{
if (_symbolTables[i].HasLocalRegistryVariableReference(reference))
{
return(_symbolTables[i].ReferenceLocalRegistryVariable(reference));
}
}
return(LiquidExpressionResult.Success(new None <ILiquidValue>()));
}
// TODO: use StringUtils.Eval?
public override LiquidExpressionResult Apply(ITemplateContext ctx, LiquidString liquidLiquidStringExpression)
{
// TODO: Return errors
//Console.WriteLine("APPLYING REMOVE " + _replacement.Value + "TO " + liquidLiquidStringExpression.Value);
if (_replacement == null || _replacement.Value == null)
{
return(LiquidExpressionResult.Error("Please specify a replacement string."));
}
return(LiquidExpressionResult.Success(Remove((String)liquidLiquidStringExpression.Value, _replacement)));
}
public override LiquidExpressionResult Eval(ITemplateContext templateContext,
IEnumerable <Option <ILiquidValue> > expressions)
{
var expressionList = expressions.ToList();
if (expressionList.Any(x => !x.HasValue))
{
return(LiquidExpressionResult.Success(new LiquidBoolean(false)));
}
return(LiquidExpressionResult.Success(ComparisonExpressions.Compare(expressionList[0].Value, expressionList[1].Value, (x, y) => x >= y)));
}
private LiquidExpressionResult SortByProperty(ITemplateContext ctx, LiquidCollection val, string sortfield)
{
if (ctx.Options.ErrorWhenValueMissing &&
val.Any(x => FieldAccessor.TryField(ctx, x.Value, sortfield).IsError))
{
return(LiquidExpressionResult.Error("an array element is missing the field '" + sortfield + "'"));
}
var ordered = val.OrderBy(x => AsString(ctx, x, sortfield));
return(LiquidExpressionResult.Success(new LiquidCollection(ordered.ToList())));
}
