/// <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 It_Renders_Null_As_Empty()
{
// Arrange
var result = ValueCaster.RenderAsString((ILiquidValue)null);
Assert.That(result, Is.EqualTo(""));
}
public void It_Should_Convert_Num()
{
var result = ValueCaster.Cast <LiquidNumeric, LiquidString>(LiquidNumeric.Create(1));
Assert.That(result.IsSuccess, Is.True);
Assert.That(result.SuccessResult.HasValue, Is.True);
}
public void It_Should_Cast_Null_To_None()
{
var result = ValueCaster.Cast <LiquidString, LiquidNumeric>(null);
Assert.True(result.IsSuccess);
Assert.False(result.SuccessResult.HasValue);
}
public void It_Should_ConvertFromNull()
{
var result = ValueCaster.ConvertFromNull <LiquidCollection>();
Assert.True(result.IsSuccess);
Assert.False(result.SuccessResult.HasValue);
}
public void Render(IncludeTag includeTag,
ITemplateContext templateContext)
{
if (templateContext.FileSystem == null)
{
AddRenderingErrorToResult(new LiquidError {
Message = " ERROR: FileSystem is not defined"
});
return;
}
String virtualFileName = null;
LiquidExpressionEvaluator.Eval(includeTag.VirtualFileExpression, templateContext)
.WhenError(AddRenderingErrorToResult)
.WhenSuccess(result => { virtualFileName = ValueCaster.RenderAsString(result); });
if (virtualFileName == null)
{
return;
}
//virtualFileName = ValueCaster.RenderAsString(virtualFilenameVar.SuccessResult.Value);
String snippet = templateContext.FileSystem.Include(templateContext, virtualFileName);
templateContext.SymbolTableStack.DefineLocalRegistry(LOCALREGISTRY_FILE_KEY, virtualFileName);
RenderSnippet(includeTag, templateContext, snippet, virtualFileName);
}
public void It_Renders_Null_As_Empty()
{
// Arrange
var result = ValueCaster.RenderAsString((ILiquidValue)null);
Assert.Equal("", result);
}
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 void It_Should_Cast_Numeric_To_Numeric()
{
var result = ValueCaster.Cast <LiquidNumeric, LiquidNumeric>(LiquidNumeric.Create(1));
Assert.True(result.IsSuccess);
Assert.True(result.SuccessResult.HasValue);
}
private string RenderMacro(MacroBlockTag macroBlockTag, IEnumerable <Option <ILiquidValue> > args)
{
var macroRenderer = new MacroRenderer();
var expressionConstant = (ILiquidValue)macroRenderer.Render(this, macroBlockTag, _templateContext, args.ToList());
return(ValueCaster.RenderAsString(expressionConstant));
}
public void It_Should_Convert_To_A_Long_Using_Away_From_Zero(decimal input, long expected)
{
// Act
var result = ValueCaster.ConvertToLong(input);
// Assert
Assert.Equal(expected, result);
}
public void It_Should_Convert_To_An_Int_Using_Away_From_Zero(decimal input, int expected)
{
// Act
var result = ValueCaster.ConvertToInt(input);
// Assert
Assert.That(result, Is.EqualTo(expected));
}
public void It_Should_Not_Cast_Array_To_Numeric()
{
// Arrange
var result = ValueCaster.Cast <LiquidCollection, LiquidNumeric>(new LiquidCollection {
LiquidString.Create("test")
});
Assert.False(result.IsSuccess);
}
public void It_Should_Convert_Null_To_EmptyString()
{
// Act
var result = ValueCaster.ConvertFromNull <LiquidString>();
var stringResult = result.SuccessValue <LiquidString>();
// Assert
Assert.Equal("", stringResult.StringVal);
}
public void It_Should_Convert_A_Null_Date_To_0L()
{
var result = ValueCaster.Cast <LiquidDate, LiquidNumeric>(new LiquidDate(null));
Assert.True(result.IsSuccess);
Assert.True(result.SuccessResult.HasValue);
// ReSharper disable once PossibleInvalidOperationException
Assert.Equal(0L, result.SuccessValue <LiquidNumeric>().LongValue);
}
public void It_Should_Convert_A_Numeric_To_A_Date()
{
var date = new DateTime(2015, 10, 29, 10, 11, 12);
var result = ValueCaster.Cast <LiquidNumeric, LiquidDate>(LiquidNumeric.Create(date.Ticks));
Assert.True(result.IsSuccess);
Assert.True(result.SuccessResult.HasValue);
// ReSharper disable once PossibleInvalidOperationException
Assert.Equal(date, result.SuccessValue <LiquidDate>().DateTimeValue.Value);
}
public void It_Should_Convert_An_Array()
{
var result = ValueCaster.Cast <LiquidCollection, LiquidString>(new LiquidCollection {
LiquidString.Create("test")
});
Assert.True(result.IsSuccess);
Assert.True(result.SuccessResult.HasValue);
Assert.Equal("test", result.SuccessValue <LiquidString>().StringVal);
}
public void It_Should_Convert_A_Date_To_A_Numeric()
{
var date = new DateTime(2015, 10, 29, 10, 11, 12);
var result = ValueCaster.Cast <LiquidDate, LiquidNumeric>(new LiquidDate(date));
Assert.That(result.IsSuccess, Is.True);
Assert.That(result.SuccessResult.HasValue, Is.True);
// ReSharper disable once PossibleInvalidOperationException
Assert.That(result.SuccessValue <LiquidNumeric>().LongValue, Is.EqualTo(date.Ticks));
}
public void It_Should_Convert_Null_To_Numeric_Zero()
{
// Act
var result = ValueCaster.ConvertFromNull <LiquidNumeric>();
var numericResult = result.SuccessValue <LiquidNumeric>();
// Assert
Assert.True(numericResult.IsInt);
Assert.Equal(0, numericResult.IntValue);
}
public static LiquidString Eval(ILiquidValue liquidExpression, Func <String, String> f)
{
String before = ValueCaster.RenderAsString(liquidExpression);
if (String.IsNullOrWhiteSpace(before))
{
return(LiquidString.Create(""));
}
return(LiquidString.Create(f(before)));
}
public void It_Should_Return_The_Same_Object_If_Src_And_Dest_Are_Strings()
{
// Arrange
var original = LiquidString.Create("Test");
// Act
var result = ValueCaster.Cast <LiquidString, LiquidString>(original).SuccessValue <LiquidString>();
// Assert
Assert.Equal(original, result);
}
public void It_Should_Return_The_Same_Object_If_Dest_Is_An_ExpressionConstant()
{
// Arrange
var original = new LiquidCollection {
LiquidNumeric.Create(123.4m), LiquidNumeric.Create(5)
};
// Act
var result = ValueCaster.Cast <LiquidCollection, LiquidValue>(original).SuccessValue <LiquidCollection>();
// Assert
Assert.That(result, Is.EqualTo(original));
}
public void It_Can_Cast_With_Generics()
{
// Arrange
var num = LiquidNumeric.Create(123.45m);
// Act
var stringliteral = ValueCaster.Cast <LiquidNumeric, LiquidString>(num)
.SuccessValue <LiquidString>()
.StringVal;
// Assert
Assert.Equal("123.45", stringliteral);
}
public override LiquidExpressionResult ApplyTo(ITemplateContext ctx, ILiquidValue liquidExpression)
{
String before = ValueCaster.RenderAsString(liquidExpression);
if (String.IsNullOrWhiteSpace(before))
{
return(LiquidExpressionResult.Success(LiquidString.Create("")));
}
var nospaces = before.TrimStart();
String trimmed = before.Substring(0, before.Length - nospaces.Length);
return(LiquidExpressionResult.Success(LiquidString.Create(trimmed + char.ToUpper(nospaces[0]) + nospaces.Substring(1))));
}
public void It_Should_Cast_A_Number_To_A_String()
{
// Arrange
var num = LiquidNumeric.Create(123.45m);
// Act
var stringliteral = ValueCaster.Cast <LiquidNumeric, LiquidString>(num)
.SuccessValue <LiquidString>()
.StringVal;
// Assert
Assert.Equal("123.45", stringliteral);
}
public void It_Should_Return_The_Same_Object_If_Src_And_Dest_Are_Arrays()
{
// Arrange
var original = new LiquidCollection {
LiquidNumeric.Create(123.4m), LiquidNumeric.Create(5)
};
// Act
var result = ValueCaster.Cast <LiquidCollection, LiquidCollection>(original).SuccessValue <LiquidCollection>();
// Assert
Assert.Equal(original, result);
}
private void RenderFromLiquidExpression(IncludeTag includeTag, ITemplateContext templateContext, String virtualFileName,
Option <ILiquidValue> forExpressionOption, LiquidAST snippetAst)
{
ValueCaster.Cast <ILiquidValue, LiquidCollection>(forExpressionOption.Value)
.WhenError(AddRenderingErrorToResult)
.WhenSuccess(result =>
{
foreach (Option <ILiquidValue> val in (LiquidCollection)result.Value)
{
var val1 = val;
RenderBlock(includeTag, templateContext, snippetAst, localBlockScope => localBlockScope.DefineLocalVariable(virtualFileName, val1));
}
});
}
public void It_Should_Handle_Casting_A_Null_Value()
{
// Arrange
var original = LiquidString.Create(null);
// Act
var result = ValueCaster.Cast <LiquidString, LiquidNumeric>(original);
Assert.True(result.IsSuccess);
// Assert
//Assert.Equal(0, result.SuccessValue<LiquidNumeric>().IntValue);
Assert.True(result.IsSuccess);
Assert.False(result.SuccessOption <ILiquidValue>().HasValue);
}
public void It_Should_Format_An_Array_By_Concatenating_Each_Elements_STring_Value()
{
// Arrange
var num = new LiquidCollection {
LiquidString.Create("a"), LiquidString.Create("b"), LiquidString.Create("c")
};
// Act
var result1 = ValueCaster.Cast <LiquidCollection, LiquidString>(num);
var stringliteral = result1.SuccessValue <LiquidString>()
.StringVal;
// Assert
Assert.Equal("abc", stringliteral);
}
private String AsString(ITemplateContext ctx, Option <ILiquidValue> x, string field)
{
if (!x.HasValue)
{
return("");
}
var liquidExpressionResult = FieldAccessor.TryField(ctx, x.Value, field);
if (liquidExpressionResult.IsError || !liquidExpressionResult.SuccessResult.HasValue)
{
return("");
}
return(ValueCaster.RenderAsString(liquidExpressionResult.SuccessResult.Value));
}
