/// <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)); }