object.ToLiquid() extension

Author: mikebridge

Liquid.NET.Tests/Liquid.NET.Tests.csproj

@@ -180,6 +180,7 @@
     <Compile Include="Tags\UnlessBlockTagTests.cs" />
     <Compile Include="TemplateContextTests.cs" />
     <Compile Include="Utils\EitherTests.cs" />
+    <Compile Include="Utils\LiquidConversionExtensionsTests.cs" />
     <Compile Include="Utils\OptionTests.cs" />
     <Compile Include="Utils\LiquidValueConverterTests.cs" />
     <Compile Include="Utils\RegistryTests.cs" />

Liquid.NET.Tests/Utils/LiquidConversionExtensionsTests.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Linq;
+using Liquid.NET.Utils;
+using NUnit.Framework;
+
+namespace Liquid.NET.Tests.Utils
+{
+    [TestFixture]
+    public class LiquidConversionExtensionsTests
+    {
+        [Test]
+        public void It_Should_Extend_An_Object()
+        {
+            // Arrange
+            var obj = new LiquidValueConverterTests.ClassWithAttributes { Ok = "To Liquid" };
+            var templateContext = new TemplateContext()
+                .ErrorWhenValueMissing()
+                .DefineLocalVariable("test", obj.ToLiquid());
+
+            // Act
+            var parserResult = LiquidTemplate.Create("Hello {{ test.ok }}");
+            Assert.That(parserResult.HasParsingErrors, Is.False);
+            var renderingResult = parserResult.LiquidTemplate.Render(templateContext);
+            Assert.That(renderingResult.HasParsingErrors, Is.False);
+            Console.WriteLine(String.Join(",", renderingResult.RenderingErrors.Select(x => x.Message)));
+            Assert.That(renderingResult.HasRenderingErrors, Is.False);
+
+            // Assert
+            Assert.That(renderingResult.Result, Is.EqualTo("Hello To Liquid"));
+
+        }
+    }
+}

Liquid.NET.Tests/Utils/LiquidValueConverterTests.cs

@@ -83,6 +83,17 @@ public void It_Should_Convert_Float_To_Decimal()
             Assert.That(val.Value.Value, Is.EqualTo(123.2m));
         }
 
+        [Test]
+        public void It_Should_Convert_Nullable_Int_To_NumericValue()
+        {
+            int? nullableInt = 123;
+            var val = _converter.Convert(nullableInt);
+            Assert.That(val.HasValue, Is.True);
+            Assert.That(val.Value, Is.TypeOf<IntLiquidNumeric>());
+            Assert.That(val.Value.Value, Is.EqualTo(123));
+        }
+
+
         [Test]
         public void It_Should_Covert_BigInteger()
         {
@@ -253,6 +264,27 @@ public void It_Should_Ignore_A_Field()
             Assert.That(objAsHash.ContainsKey("ok"), Is.True);
         }
 
+        [Test]
+        [TestCase(null)]
+        [TestCase("test")]
+        public void It_Should_Ignore_A_Null_Field_When_IgnoreIfNull(String fieldValue)
+        {
+            // Act
+            var testClass = new ClassWithAttributes { SomeField = fieldValue};
+
+            var result = _converter.Convert(testClass);
+
+            Assert.That(result.HasValue);
+            var objAsHash = (LiquidHash)result.Value;
+
+            // Assert
+            Assert.That(objAsHash.ContainsKey("notnull"), Is.EqualTo(fieldValue != null));
+            if (objAsHash.ContainsKey("notnull"))
+            {
+                Assert.That(objAsHash.Value, Is.EqualTo(fieldValue.ToLiquid()));
+            }
+        }
+
         public class TestClass
         {
             public String Field1 {get; set;}
@@ -270,6 +302,10 @@ public class ClassWithAttributes
             [LiquidName("somethingelse")]
             public String Renamed { get; set; }
 
+            [LiquidName("notnull")]
+            [LiquidIgnoreIfNull]
+            public String SomeField { get; set; }
+
             public String Ok { get; set; }
 
         }

Liquid.NET/Liquid.NET.csproj

@@ -215,6 +215,7 @@
     <Compile Include="src\TemplateContext.cs" />
     <Compile Include="src\Symbols\IASTVisitor.cs" />
     <Compile Include="src\Utils\Either.cs" />
+    <Compile Include="src\Utils\LiquidConversionExtensions.cs" />
     <Compile Include="src\Utils\LiquidValueConverterAttributes.cs" />
     <Compile Include="src\Utils\LiquidExpressionResult.cs" />
     <Compile Include="src\Utils\LiquidVersionAttribute.cs" />

Liquid.NET/src/Utils/LiquidConversionExtensions.cs

@@ -0,0 +1,14 @@
+using System;
+
+using Liquid.NET.Constants;
+
+namespace Liquid.NET.Utils
+{
+    public static class LiquidConversionExtensions
+    {
+        public static Option<ILiquidValue> ToLiquid(this object obj)
+        {
+            return new LiquidValueConverter().Convert(obj);
+        }
+    }
+}

Liquid.NET/src/Utils/LiquidValueConverter.cs

@@ -37,7 +37,9 @@ private Option<ILiquidValue> FromObject(Object obj)
             var newHash = new LiquidHash();
             var kvps = obj.GetType()
                 .GetProperties()
-                .Where(property => !property.GetCustomAttributes<LiquidIgnoreAttribute>().Any())
+                .Where(property => !(property.GetCustomAttributes<LiquidIgnoreAttribute>().Any() 
+                     || (property.GetCustomAttributes<LiquidIgnoreIfNullAttribute>().Any() 
+                        && ReferenceEquals(property.GetGetMethod().Invoke(obj, null), null))))
                 .Select(property => new KeyValuePair<String, Option<ILiquidValue>> (
                     GetPropertyName(property),
                     GetPropertyValue(obj, property)));
@@ -167,7 +169,7 @@ private Boolean IsDictionary(Object value)
 
         private bool IsList(Object value)
         {
-            return value is IList; /* && value.GetType().IsGenericType*/;
+            return value is IList;
         }
 
         // http://stackoverflow.com/questions/1130698/checking-if-an-object-is-a-number-in-c-sharp#answer-1130705
@@ -190,7 +192,7 @@ private bool IsDecimalLike(object value)
         {
             return value is Single || value is Double || value is Decimal;
         }
-        
-
+       
     }
+
 }

Liquid.NET/src/Utils/LiquidValueConverterAttributes.cs

@@ -2,12 +2,18 @@
 
 namespace Liquid.NET.Utils
 {
-    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
+    [AttributeUsage(AttributeTargets.Property)]
     public class LiquidIgnoreAttribute : Attribute
     {
     }
 
-    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
+    [AttributeUsage(AttributeTargets.Property)]
+    public class LiquidIgnoreIfNullAttribute : Attribute
+    {
+    }
+
+
+    [AttributeUsage(AttributeTargets.Property)]
     public class LiquidNameAttribute : Attribute
     {
         private readonly string _key;