public void Test_Introductory_Example_With_Syntactic_Sugar() { // create a place to accumulate parsing and rendering errors. var errors = new List <LiquidError>(); // Note that you will still get a best-guess LiquidTemplate, even if you encounter errors. var liquidTemplate = LiquidTemplate.Create("<div>{{myvariable}}</div>") .OnParsingError(errors.Add) .LiquidTemplate; // [add code here to handle the parsing errors, return] Assert.That(errors.Any(), Is.False); var ctx = new TemplateContext() .WithAllFilters() .DefineLocalVariable("myvariable", LiquidString.Create("Hello World")); // The final String output will still be available in .Result, // even when parsing or rendering errors are encountered. var result = liquidTemplate.Render(ctx) .OnAnyError(errors.Add) // also available: .OnParsingError, .OnRenderingError .Result; // [add code here to handle the parsing and rendering errors] Assert.That(errors.Any(), Is.False); Console.WriteLine(result); Assert.That(result, Is.EqualTo("<div>Hello World</div>")); }
public void It_Should_Set_A_Value() { var dict = new LiquidHash(); dict["key"] = new Some <ILiquidValue>(LiquidString.Create("test")); Assert.Equal(LiquidString.Create("test"), dict["key"].Value); }
public void It_Should_Add_A_Value() { var dict = new LiquidHash(); dict.Add("key", LiquidString.Create("test")); Assert.Equal(LiquidString.Create("test"), dict["key"].Value); }
public void Test_Introductory_Example() { // create a template context that knows about the standard filters, // and define a string variable "myvariable" ITemplateContext ctx = new TemplateContext() .WithAllFilters() .DefineLocalVariable("myvariable", LiquidString.Create("Hello World")); // parse the template and check for errors var parsingResult = LiquidTemplate.Create("<div>{{myvariable}}</div>"); if (parsingResult.HasParsingErrors) { HandleErrors(parsingResult.ParsingErrors); return; } // merge the variables from the context into the template and check for errors var renderingResult = parsingResult.LiquidTemplate.Render(ctx); if (renderingResult.HasParsingErrors) { HandleErrors(renderingResult.ParsingErrors); return; } if (renderingResult.HasRenderingErrors) { HandleErrors(renderingResult.RenderingErrors); return; } Assert.That(renderingResult.Result, Is.EqualTo("<div>Hello World</div>")); }
public static Option <ILiquidValue> Transform(JValue obj) { if (obj.Type.Equals(JTokenType.Integer)) { return(LiquidNumeric.Create(obj.ToObject <int>())); } else if (obj.Type.Equals(JTokenType.Float)) { return(LiquidNumeric.Create(obj.ToObject <decimal>())); } else if (obj.Type.Equals(JTokenType.String)) { return(LiquidString.Create(obj.ToObject <String>())); } else if (obj.Type.Equals(JTokenType.Boolean)) { return(new LiquidBoolean(obj.ToObject <bool>())); } else if (obj.Type.Equals(JTokenType.Null)) { //throw new ApplicationException("NULL Not implemented yet"); //return null; // TODO: Change this to an option return(Option <ILiquidValue> .None()); } else { throw new Exception("Don't know how to transform a " + obj.GetType() + "."); } }
public LiquidString Render( RenderingVisitor renderingVisitor, MacroBlockTag macroBlocktag, ITemplateContext templateContext, IList <Option <ILiquidValue> > args) { var macroScope = new SymbolTable(); var i = 0; foreach (var varName in macroBlocktag.Args.Take(args.Count)) { macroScope.DefineLocalVariable(varName, args[i]); i++; } templateContext.SymbolTableStack.Push(macroScope); String hiddenText = ""; renderingVisitor.PushTextAccumulator(str => hiddenText += str); renderingVisitor.StartWalking(macroBlocktag.LiquidBlock); renderingVisitor.PopTextAccumulator(); templateContext.SymbolTableStack.Pop(); return(LiquidString.Create(hiddenText)); }
public LiquidString Render( RenderingVisitor renderingVisitor, ITemplateContext templateContext, TreeNode <IASTNode> liquidBlock, IList <Option <ILiquidValue> > args) { var localBlockScope = new SymbolTable(); templateContext.SymbolTableStack.Push(localBlockScope); LiquidString result; try { // normally you would need to verify that arg0 and arg1 exists and are the correct value types. String varname = args[0].Value.ToString(); var iterableFactory = new ArrayValueCreator( new TreeNode <LiquidExpression>( new LiquidExpression { Expression = args[1].Value })); var iterable = iterableFactory.Eval(templateContext).ToList(); result = IterateBlock(renderingVisitor, varname, templateContext, iterable, liquidBlock); } finally { templateContext.SymbolTableStack.Pop(); } return(LiquidString.Create("START CUSTOM FOR LOOP" + result.StringVal + "END CUSTOM FOR LOOP")); }
public void It_Should_Render_An_Array_Element_From_A_Crazy_Chain_of_Nested_Indexes() { // Arrange TemplateContext templateContext = new TemplateContext(); var arrayofnums = new LiquidCollection { LiquidNumeric.Create(0), LiquidNumeric.Create(1) }; var array1 = new LiquidCollection { arrayofnums }; var array2 = new LiquidCollection { array1 }; var arrayofstr = new LiquidCollection { LiquidString.Create("aaa"), LiquidString.Create("bbb") }; //templateContext.Define("arrayofnums", new LiquidNumeric(1)); templateContext.DefineLocalVariable("arrayofnums", arrayofnums); templateContext.DefineLocalVariable("array1", array1); templateContext.DefineLocalVariable("array2", array2); templateContext.DefineLocalVariable("arrayofstr", arrayofstr); // Act String result = GenerateAndRender("Result : {{ arrayofstr[array2[0][0][arrayofnums[arrayofnums[1]]]] }}", templateContext); // Assert Assert.Equal("Result : bbb", result); }
private static LiquidString Reverse(string result) { var words = result.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); return(LiquidString.Create(String.Join(" ", words.Select(x => new String(x.Reverse().ToArray()))))); }
public void It_Should_Iterate_Through_A_Dictionary(String expected) { // SEE: https://github.com/Shopify/liquid/wiki/Liquid-for-Designers // Arrange TemplateContext ctx = new TemplateContext(); ctx.DefineLocalVariable("dict", new LiquidHash { { "one", LiquidString.Create("ONE") }, { "two", LiquidString.Create("TWO") }, { "three", LiquidString.Create("THREE") }, { "four", LiquidString.Create("FOUR") } }); var template = LiquidTemplate.Create( "Result : {% for item in dict %}<li>{{ item[0] }} : {{ item[1] }}</li>{% endfor %}"); // Act String result = template.LiquidTemplate.Render(ctx).Result; // Assert Assert.Contains(expected, result); }
public SolidityStruct(Entity entity) { En = entity; structName = LiquidString.Create(entity.Name); body = new List <SolidityComponent>(); }
public void It_Should_Compare_Against_Null() { // Arrange var str = LiquidString.Create("hello"); // Act Assert.That(new EasyValueComparer().Equals(null, str), Is.False); }
LiquidString InheritanceToLiquid() { if (inheritance.Count == 0) { return(LiquidString.Create("")); } return(LiquidString.Create(string.Join(", ", inheritance))); }
public void It_Should_Retrieve_Values() { var dict = new LiquidHash { { "key", LiquidString.Create("test") } }; Assert.Equal(1, dict.Values.Count); }
public void It_Should_Not_Allow_Null_Creation() { // Arrange var stringSymbol = LiquidString.Create(null); // Assert Assert.That(stringSymbol, Is.Null); }
public void It_Should_Compare_Two_Identical_Values() { // Arrange var str = LiquidString.Create("hello"); // Act Assert.That(new EasyValueComparer().Equals(str, str), Is.True); }
public override Task <string> RenderLoremSimpleOuput() { var context = new Liquid.NET.TemplateContext(); context.DefineLocalVariable("image", LiquidString.Create("kitten.jpg")); var parsingResult = LiquidTemplate.Create(_source4); return(Task.FromResult(parsingResult.LiquidTemplate.Render(context).Result)); }
private LiquidCollection CreateArrayValues() { return(new LiquidCollection { LiquidString.Create("a string"), LiquidNumeric.Create(123), LiquidNumeric.Create(456m), new LiquidBoolean(false) }); }
public string RenderLoreSimpleOuputLiquidNet() { var context = new Liquid.NET.TemplateContext(); context.DefineLocalVariable("image", LiquidString.Create("kitten.jpg")); var parsingResult = LiquidTemplate.Create(_source4); return(parsingResult.LiquidTemplate.Render(context).Result); }
public override string ToString(int indent = 0) { ITemplateContext ctx = new TemplateContext(); ctx.DefineLocalVariable("indent", CreateIndent(indent)). DefineLocalVariable("name", LiquidString.Create(structName)). DefineLocalVariable("body", BodyToLiquid(indent)); return(template.Render(ctx).Result); }
public void It_Should_Store_The_Value() { // Arrange var stringSymbol = LiquidString.Create("String Test"); var result = stringSymbol.Value; // Assert Assert.That(result, Is.EqualTo("String Test")); }
public void It_Should_Find_An_Element_By_Value() { var liquidCollection = new LiquidCollection { LiquidString.Create("test") }; var index = liquidCollection.IndexOf(LiquidString.Create("test")); Assert.That(index, Is.EqualTo(0)); }
public void It_Should_Remove_An_Element_At_An_Index_In_An_Array() { var liquidCollection = new LiquidCollection { LiquidString.Create("test") }; liquidCollection.RemoveAt(0); Assert.That(liquidCollection.Count, Is.EqualTo(0)); }
public void It_Should_Clear_An_Array() { var liquidCollection = new LiquidCollection { LiquidString.Create("test") }; liquidCollection.Clear(); Assert.That(liquidCollection.Count, Is.EqualTo(0)); }
public void It_Should_Set_An_Element() { var liquidCollection = new LiquidCollection { LiquidString.Create("test") }; liquidCollection[0] = LiquidString.Create("test 1"); Assert.That(liquidCollection.IndexOf(LiquidString.Create("test 1")), Is.EqualTo(0)); }
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); }
private Option <ILiquidValue> FromPrimitive(Object obj) { if (obj is bool) { return(new LiquidBoolean((bool)obj)); } if (IsInt32Like(obj)) { var val = System.Convert.ToInt32(obj); return(LiquidNumeric.Create(val)); } if (IsLong(obj)) { var val = System.Convert.ToInt64(obj); return(LiquidNumeric.Create(val)); } if (obj is DateTime) { var val = System.Convert.ToDateTime(obj); return(new LiquidDate(val)); } if (IsDecimalLike(obj)) { var val = System.Convert.ToDecimal(obj); return(LiquidNumeric.Create(val)); } if (obj is BigInteger) { var val = (BigInteger)obj; return(LiquidNumeric.Create(val)); } var str = obj as String; if (str != null) { return(LiquidString.Create(str)); } if (IsList(obj)) { var val = obj as IList; return(CreateCollection(val)); } if (IsDictionary(obj)) { var val = obj as IDictionary; return(CreateHash(val)); } return(null); }
public static LiquidHash CreateDictionary(int id, string field1, string field2) { return(new LiquidHash { { "id", LiquidNumeric.Create(id) }, { "field1", LiquidString.Create(field1) }, { "field2", LiquidString.Create(field2) }, }); }
public void It_Should_Convert_Guid_To_LiquidString() { var guid = Guid.NewGuid(); var val = _converter.Convert(guid); Assert.True(val.HasValue); Assert.IsType <LiquidString>(val.Value); Assert.Equal(LiquidString.Create(guid.ToString("D")), val.Value); }
public void It_Should_Convert_Enum_To_LiquidString() { var testEnum = TestEnum.One; var val = _converter.Convert(testEnum); Assert.True(val.HasValue); Assert.IsType <LiquidString>(val.Value); Assert.Equal(LiquidString.Create(Enum.GetName(testEnum.GetType(), testEnum)), val.Value); }