public void String_ToNumber_ParsesNumber()
{
var value = StringValue.Create("0.1357") as IValue;
var result = value.ImplicitConversionToNumberValue();
Assert.AreEqual(0.1357M, result.Value);
}
public void StringEmpty_ToBool_IsFalse()
{
var value = StringValue.Create("") as IValue;
var result = value.ImplicitConversionToBoolValue();
Assert.AreEqual(false, result.Value);
}
public void StringNonEmpty_ToBool_IsTrue()
{
var value = StringValue.Create("x") as IValue;
var result = value.ImplicitConversionToBoolValue();
Assert.AreEqual(true, result.Value);
}
public ValueTask <FluidValue> ProcessAsync(FluidValue input, FilterArguments arguments, TemplateContext context)
{
switch (input.Type)
{
case FluidValues.Array:
return(new ValueTask <FluidValue>(new StringValue(JsonConvert.SerializeObject(input.Enumerate().Select(o => o.ToObjectValue())))));
case FluidValues.Boolean:
return(new ValueTask <FluidValue>(new StringValue(JsonConvert.SerializeObject(input.ToBooleanValue()))));
case FluidValues.Nil:
return(new ValueTask <FluidValue>(StringValue.Create("null")));
case FluidValues.Number:
return(new ValueTask <FluidValue>(new StringValue(JsonConvert.SerializeObject(input.ToNumberValue()))));
case FluidValues.DateTime:
case FluidValues.Dictionary:
case FluidValues.Object:
return(new ValueTask <FluidValue>(new StringValue(JsonConvert.SerializeObject(input.ToObjectValue()))));
case FluidValues.String:
var stringValue = input.ToStringValue();
if (string.IsNullOrWhiteSpace(stringValue))
{
return(new ValueTask <FluidValue>(input));
}
return(new ValueTask <FluidValue>(new StringValue(JsonConvert.SerializeObject(stringValue))));
}
throw new NotSupportedException("Unrecognized FluidValue");
}
public void String_ToString_IsSameValue()
{
var value = StringValue.Create("V?") as IValue;
var result = value.ImplicitConversionToStringValue();
Assert.AreEqual("V?", result.Value);
}
public static FluidValue Json(FluidValue input, FilterArguments arguments, TemplateContext context)
{
var options = new JsonSerializerOptions
{
WriteIndented = arguments.At(0).ToBooleanValue()
};
switch (input.Type)
{
case FluidValues.Array:
return(new StringValue(JsonSerializer.Serialize(input.Enumerate().Select(o => o.ToObjectValue()), options)));
case FluidValues.Boolean:
return(new StringValue(JsonSerializer.Serialize(input.ToBooleanValue(), options)));
case FluidValues.Nil:
return(StringValue.Create("null"));
case FluidValues.Number:
return(new StringValue(JsonSerializer.Serialize(input.ToNumberValue(), options)));
case FluidValues.DateTime:
case FluidValues.Dictionary:
case FluidValues.Object:
return(new StringValue(JsonSerializer.Serialize(input.ToObjectValue(), options)));
case FluidValues.String:
return(new StringValue(JsonSerializer.Serialize(input.ToStringValue(), options)));
}
throw new NotSupportedException("Unrecognized FluidValue");
}
/// <summary>
/// Redefines the True/False keywords to be case-insensitive.
/// </summary>
private void DefineLavaTrueFalseAsCaseInsensitive()
{
// To redefine the True and False parsers, we need to rebuild the Fluid Primary expression parser.
// Fluid defines a Primary expression as: primary => NUMBER | STRING | BOOLEAN | MEMBER
// Reproduce the standard Fluid parsers that are internally defined by the default parser.
var indexer = Between(LBracket, Primary, RBracket).Then <MemberSegment>(x => new IndexerSegment(x));
var member = Identifier.Then <MemberSegment>(x => new IdentifierSegment(x)).And(
ZeroOrMany(
Dot.SkipAnd(Identifier.Then <MemberSegment>(x => new IdentifierSegment(x)))
.Or(indexer)))
.Then(x =>
{
x.Item2.Insert(0, x.Item1);
return(new MemberExpression(x.Item2));
});
// Redefine the Fluid keywords "true" and "false" as case-insensitive.
var trueParser = Terms.Text("true", caseInsensitive: true);
var falseParser = Terms.Text("false", caseInsensitive: true);
// Replace the default definition of the Fluid Primary parser.
Primary.Parser = Number.Then <Expression>(x => new LiteralExpression(NumberValue.Create(x)))
.Or(String.Then <Expression>(x => new LiteralExpression(StringValue.Create(x.ToString()))))
.Or(trueParser.Then <Expression>(x => new LiteralExpression(BooleanValue.True)))
.Or(falseParser.Then <Expression>(x => new LiteralExpression(BooleanValue.False)))
.Or(member.Then <Expression>(x => x));
}
public static ValueTask <FluidValue> Split(FluidValue input, FilterArguments arguments, TemplateContext context)
{
string[] strings;
var stringInput = input.ToStringValue();
var separator = arguments.At(0).ToStringValue();
if (separator == "")
{
strings = new string[stringInput.Length];
for (var i = 0; i < stringInput.Length; i++)
{
strings[i] = stringInput[i].ToString();
}
}
else
{
strings = stringInput.Split(separator, StringSplitOptions.RemoveEmptyEntries);
}
var values = new FluidValue[strings.Length];
for (var i = 0; i < strings.Length; i++)
{
values[i] = StringValue.Create(strings[i]);
}
return(new ArrayValue(values));
}
public void StringNonNumber_ToNumber_IsZero()
{
var value = StringValue.Create("Bob") as IValue;
var result = value.ImplicitConversionToNumberValue();
Assert.AreEqual(0, result.Value);
}
public override Value GetValue(UserItem item)
{
if (item.Item is Movie)
{
return(StringValue.Create(item.Item.Name));
}
return(Value.None);
}
public override Value GetValue(UserItem item)
{
if (item.Item is Audio audio)
{
return(StringValue.Create(audio.Album));
}
return(Value.None);
}
public override Value GetValue(UserItem item)
{
if (item.Item is Episode episode)
{
return(StringValue.Create(episode.SeriesName));
}
return(Value.None);
}
public Task <BaseValue> GetFiles(string directoryPath) => this.Execute(
Bridge.File.GetFiles(directoryPath),
files =>
{
int i = 1;
return(new ArrayValue(files.ToDictionary(
value => (i++).ToString(CultureInfo.CurrentCulture),
value => StringValue.Create(value))));
});
public void MinusWithDecimalPointFromObject(string input, string argument, decimal expectedResult)
{
var inputA = NumberValue.Create(input);
var inputB = new FilterArguments(StringValue.Create(argument));
var context = new TemplateContext();
var result = NumberFilters.Minus(inputA, inputB, context);
Assert.Equal(expectedResult, result.Result.ToNumberValue());
}
/// <summary>
/// Redefines the True/False keywords to be case-insensitive.
/// </summary>
private void DefineLavaTrueFalseAsCaseInsensitive()
{
// To redefine the True and False parsers, we need to rebuild the Fluid Primary expression parser.
// Fluid defines a Primary expression as: primary => STRING | BOOLEAN | EMPTY | MEMBER | NUMBER.
// Reproduce the standard Fluid parsers that are internally defined by the default parser.
var integer = Terms.Integer().Then <Expression>(x => new LiteralExpression(NumberValue.Create(x)));
var indexer = Between(LBracket, Primary, RBracket).Then <MemberSegment>(x => new IndexerSegment(x));
var member = Identifier.Then <MemberSegment>(x => new IdentifierSegment(x)).And(
ZeroOrMany(
Dot.SkipAnd(Identifier.Then <MemberSegment>(x => new IdentifierSegment(x)))
.Or(indexer)))
.Then(x =>
{
x.Item2.Insert(0, x.Item1);
return(new MemberExpression(x.Item2));
});
var range = LParen
.SkipAnd(OneOf(integer, member.Then <Expression>(x => x)))
.AndSkip(Terms.Text(".."))
.And(OneOf(integer, member.Then <Expression>(x => x)))
.AndSkip(RParen)
.Then <Expression>(x => new RangeExpression(x.Item1, x.Item2));
Primary.Parser =
String.Then <Expression>(x => new LiteralExpression(StringValue.Create(x.ToString())))
.Or(member.Then <Expression>(x => {
if (x.Segments.Count == 1)
{
// Redefine these Liquid keywords as case-insensitive for compatibility with Lava.
switch ((x.Segments[0] as IdentifierSegment).Identifier.ToLower())
{
case "empty":
return(EmptyKeyword);
case "blank":
return(BlankKeyword);
case "true":
return(TrueKeyword);
case "false":
return(FalseKeyword);
}
}
return(x);
}))
.Or(Number.Then <Expression>(x => new LiteralExpression(NumberValue.Create(x))))
.Or(range);
}
public BaseValue GetValue(string arrayName, string index)
{
if (this.arrays.TryGetValue(arrayName, out ArrayValue array) && array.TryGetValue(index, out BaseValue value))
{
return(value);
}
else
{
return(StringValue.Create(string.Empty));
}
}
public void Plus()
{
var input = NumberValue.Create(6);
var arguments = new FilterArguments(StringValue.Create("3"));
var context = new TemplateContext();
var result = NumberFilters.Plus(input, arguments, context);
Assert.Equal(9, result.Result.ToNumberValue());
}
public async Task NoTimeZoneIsParsedAsLocal()
{
var input = StringValue.Create("1970-01-01 00:00:00");
var format = new FilterArguments(new StringValue("%a %b %e %H:%M:%S %Y %z"));
var context = new TemplateContext {
TimeZone = Pacific
};
var result = await MiscFilters.Date(input, format, context);
Assert.Equal("Thu Jan 1 00:00:00 1970 -0800", result.ToStringValue());
}
public override bool TryParse(string value, out Value val)
{
val = null;
var match = ParseRegEx.Match(value);
if (match.Success)
{
val = StringValue.Create(match.Groups[1].Value);
return(true);
}
return(false);
}
public async Task DefaultTimeZoneIsSetWhenNotParsed()
{
// This test ensures that when a TZ is specified it uses it instead of the settings one
var input = StringValue.Create("1970-01-01 00:00:00");
var format = new FilterArguments(new StringValue("%s"));
var context = new TemplateContext {
TimeZone = Eastern
};
var result = await MiscFilters.Date(input, format, context);
Assert.Equal("18000", result.ToStringValue());
}
private async Task <BaseValue> Execute <T>(Task <FileBridgeModels.Result <T> > action, Func <T, BaseValue> converter)
{
var result = await action.ConfigureAwait(false);
if (result.Success)
{
this.lastError = string.Empty;
return(converter(result.Value));
}
else
{
this.lastError = result.Error;
return(StringValue.Create(FailedResponse));
}
}
public IValue Evaluate()
{
if (Operator == "+")
{
return(NumberValue.Create(Left.Evaluate().ImplicitConversionToNumberValue().Value + Right.Evaluate().ImplicitConversionToNumberValue().Value));
}
if (Operator == "-")
{
return(NumberValue.Create(Left.Evaluate().ImplicitConversionToNumberValue().Value - Right.Evaluate().ImplicitConversionToNumberValue().Value));
}
if (Operator == "*")
{
return(NumberValue.Create(Left.Evaluate().ImplicitConversionToNumberValue().Value *Right.Evaluate().ImplicitConversionToNumberValue().Value));
}
if (Operator == "/")
{
return(NumberValue.Create(Left.Evaluate().ImplicitConversionToNumberValue().Value / Right.Evaluate().ImplicitConversionToNumberValue().Value));
}
if (Operator == "%")
{
return(NumberValue.Create(Left.Evaluate().ImplicitConversionToNumberValue().Value % Right.Evaluate().ImplicitConversionToNumberValue().Value));
}
if (Operator == "@&")
{
return(NumberValue.Create(Left.Evaluate().ImplicitConversionToNumberValue().BitwiseValue & Right.Evaluate().ImplicitConversionToNumberValue().BitwiseValue));
}
if (Operator == "@|")
{
return(NumberValue.Create(Left.Evaluate().ImplicitConversionToNumberValue().BitwiseValue | Right.Evaluate().ImplicitConversionToNumberValue().BitwiseValue));
}
if (Operator == "@^")
{
return(NumberValue.Create(Left.Evaluate().ImplicitConversionToNumberValue().BitwiseValue ^ Right.Evaluate().ImplicitConversionToNumberValue().BitwiseValue));
}
if (Operator == "&")
{
return(StringValue.Create(Left.Evaluate().ImplicitConversionToStringValue().Value + Right.Evaluate().ImplicitConversionToStringValue().Value));
}
if (Operator == "&&")
{
return(BoolValue.Create(Left.Evaluate().ImplicitConversionToBoolValue().Value&& Right.Evaluate().ImplicitConversionToBoolValue().Value));
}
if (Operator == "||")
{
return(BoolValue.Create(Left.Evaluate().ImplicitConversionToBoolValue().Value || Right.Evaluate().ImplicitConversionToBoolValue().Value));
}
throw new Exception("Internal error: no implementation for operator '" + Operator + "'"); // TODO: different exception type?
}
public async Task DefaultTimeZoneAppliesDaylightSaving()
{
// This test ensures that the DST is respected when TZ is rendered
var input = StringValue.Create("2021-01-01 00:00:00");
var format = new FilterArguments(new StringValue("%z"));
var context = new TemplateContext {
TimeZone = Pacific
};
var result = await MiscFilters.Date(input, format, context);
Assert.Equal("-0800", result.ToStringValue());
input = StringValue.Create("2021-06-01 00:00:00");
result = await MiscFilters.Date(input, format, context);
Assert.Equal("-0700", result.ToStringValue());
}
public BaseValue GetValue(string arrayName, string index)
{
this.log.AppendLine($"Array.GetValue(arrayName: '{arrayName}', index: '{index}')");
return(StringValue.Create(string.Empty));
}
public static IValue Create(string value)
{
return(StringValue.Create(value));
}
public Task <BaseValue> ReadContents(string filePath)
{
this.log.AppendLine($"File.ReadContents(filePath: '{filePath}')");
return(Task.FromResult(StringValue.Create(string.Empty)));
}
public Task <BaseValue> ReadLine(string filePath, decimal lineNumber)
{
this.log.AppendLine($"File.ReadLine(filePath: '{filePath}', lineNumber: '{lineNumber}')");
return(Task.FromResult(StringValue.Create(string.Empty)));
}
public static Account Create(int customerId)
=> new Account(
customerId,
StringValue.Create(Guid.NewGuid().ToString()).Value,
PositiveDecimal.Create(0).Value);
public StringValue ImplicitConversionToStringValue()
{
return(StringValue.Create(Value ? "true" : "false"));
}
public override Value GetValue(UserItem item)
{
return(StringValue.Create(item.Item.Name));
}