Use Parlot (#245)

sebastienros · Jan 19, 2021 · 9ca3e09 · 9ca3e09
1 parent b4400c4
commit 9ca3e09
Show file tree

Hide file tree

Showing 101 changed files with 2,217 additions and 3,417 deletions.
diff --git a/Assets/benchmarks.jpg b/Assets/benchmarks.jpg
diff --git a/Fluid.Benchmarks/BaseBenchmarks.cs b/Fluid.Benchmarks/BaseBenchmarks.cs
@@ -1,4 +1,6 @@
 using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
 
 namespace Fluid.Benchmarks
 {
@@ -10,17 +12,25 @@ public abstract class BaseBenchmarks
 
         protected const string Lorem = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum";
 
-        protected const string TextTemplate = @"
-<ul id='products'>
-  {% for product in products %}
-    <li>
-      <h2>{{ product.name }}</h2>
-           Only {{ product.price }}
-           {{ product.description | truncate: 15 }}
-    </li>
-  {% endfor %}
-</ul>
-";
+        protected readonly static string ProductTemplate;
+        protected readonly static string BlogPostTemplate;
+
+        static BaseBenchmarks()
+        {
+            var assembly = typeof(BaseBenchmarks).Assembly;
+
+            using (var stream = assembly.GetManifestResourceStream("Fluid.Benchmarks.product.liquid"))
+            {
+                using var streamReader = new StreamReader(stream);
+                ProductTemplate = streamReader.ReadToEnd();
+            }
+
+            using (var stream = assembly.GetManifestResourceStream("Fluid.Benchmarks.blogpost.liquid"))
+            {
+                using var streamReader = new StreamReader(stream);
+                BlogPostTemplate = streamReader.ReadToEnd();
+            }
+        }
 
         public BaseBenchmarks()
         {
@@ -32,6 +42,7 @@ public BaseBenchmarks()
         }
 
         public abstract object Parse();
+        public abstract object ParseBig();
 
         public abstract string Render();
 

diff --git a/Fluid.Benchmarks/ComparisonBenchmarks.cs b/Fluid.Benchmarks/ComparisonBenchmarks.cs
@@ -0,0 +1,86 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Configs;
+
+namespace Fluid.Benchmarks
+{
+    [MemoryDiagnoser, GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory), ShortRunJob]
+    public class ComparisonBenchmarks
+    {
+        private FluidBenchmarks _fluidBenchmarks = new FluidBenchmarks();
+        private DotLiquidBenchmarks _dotLiquidBenchmarks = new DotLiquidBenchmarks();
+        private LiquidNetBenchmarks _liquidNetBenchmarks = new LiquidNetBenchmarks();
+        private ScribanBenchmarks _scribanBenchmarks = new ScribanBenchmarks();
+
+        [Benchmark(Baseline = true), BenchmarkCategory("Parse")]
+        public object Fluid_Parse()
+        {
+            return _fluidBenchmarks.Parse();
+        }
+
+        [Benchmark(Baseline = true), BenchmarkCategory("ParseBig")]
+        public object Fluid_ParseBig()
+        {
+            return _fluidBenchmarks.ParseBig();
+        }
+
+        [Benchmark(Baseline = true), BenchmarkCategory("Render")]
+        public string Fluid_Render()
+        {
+            return _fluidBenchmarks.Render();
+        }
+
+        [Benchmark, BenchmarkCategory("Parse")]
+        public object Scriban_Parse()
+        {
+            return _scribanBenchmarks.Parse();
+        }
+
+        [Benchmark, BenchmarkCategory("ParseBig")]
+        public object Scriban_ParseBig()
+        {
+            return _scribanBenchmarks.ParseBig();
+        }
+
+        [Benchmark, BenchmarkCategory("Render")]
+        public string Scriban_Render()
+        {
+            return _scribanBenchmarks.Render();
+        }
+
+        [Benchmark, BenchmarkCategory("Parse")]
+        public object DotLiquid_Parse()
+        {
+            return _dotLiquidBenchmarks.Parse();
+        }
+
+        [Benchmark, BenchmarkCategory("ParseBig")]
+        public object DotLiquid_ParseBig()
+        {
+            return _dotLiquidBenchmarks.ParseBig();
+        }
+
+        [Benchmark, BenchmarkCategory("Render")]
+        public string DotLiquid_Render()
+        {
+            return _dotLiquidBenchmarks.Render();
+        }
+
+        [Benchmark, BenchmarkCategory("Parse")]
+        public object LiquidNet_Parse()
+        {
+            return _liquidNetBenchmarks.Parse();
+        }
+
+        [Benchmark, BenchmarkCategory("ParseBig")]
+        public object LiquidNet_ParseBig()
+        {
+            return _liquidNetBenchmarks.ParseBig();
+        }
+
+        [Benchmark, BenchmarkCategory("Render")]
+        public string LiquidNet_Render()
+        {
+            return _liquidNetBenchmarks.Render();
+        }
+    }
+}
diff --git a/Fluid.Benchmarks/DotLiquidBenchmarks.cs b/Fluid.Benchmarks/DotLiquidBenchmarks.cs
@@ -1,21 +1,16 @@
-using BenchmarkDotNet.Attributes;
-using DotLiquid;
+using DotLiquid;
 using System.Linq;
 
 namespace Fluid.Benchmarks
 {
-    [MemoryDiagnoser]
     public class DotLiquidBenchmarks : BaseBenchmarks
     {
-
-        private Template _dotLiquidTemplate;
-        private Hash _products;
+        private readonly Template _dotLiquidTemplate;
 
         public DotLiquidBenchmarks()
         {
-            _dotLiquidTemplate = Template.Parse(TextTemplate);
+            _dotLiquidTemplate = Template.Parse(ProductTemplate);
             _dotLiquidTemplate.MakeThreadSafe();
-            _products = MakeProducts();
         }
 
         private Hash MakeProducts()
@@ -31,23 +26,27 @@ private Hash MakeProducts()
             });
         }
 
-        [Benchmark]
         public override object Parse()
         {
-            var template = Template.Parse(TextTemplate);
+            var template = Template.Parse(ProductTemplate);
+            return template;
+        }
+
+        public override object ParseBig()
+        {
+            var template = Template.Parse(BlogPostTemplate);
             return template;
         }
 
-        [Benchmark]
         public override string Render()
         {
-            return _dotLiquidTemplate.Render(_products);
+            var products = MakeProducts();
+            return _dotLiquidTemplate.Render(products);
         }
 
-        [Benchmark]
         public override string ParseAndRender()
         {
-            var template = Template.Parse(TextTemplate);
+            var template = Template.Parse(ProductTemplate);
             var products = MakeProducts();
             return template.Render(products);
         }

diff --git a/Fluid.Benchmarks/Fluid.Benchmarks.csproj b/Fluid.Benchmarks/Fluid.Benchmarks.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
     <NoWarn>$(NoWarn);NU5104</NoWarn>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
@@ -14,10 +14,20 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.12.0" />
-    <PackageReference Include="DotLiquid" Version="2.0.298" />
+    <None Remove="blogpost.liquid" />
+    <None Remove="product.liquid" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="product.liquid" />
+    <EmbeddedResource Include="blogpost.liquid" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BenchmarkDotNet" Version="0.12.1" />
+    <PackageReference Include="DotLiquid" Version="2.0.366" />
     <PackageReference Include="Liquid.NET" Version="0.10.0" />
-    <PackageReference Include="Scriban" Version="2.0.0" />
+    <PackageReference Include="Scriban" Version="3.3.2" />
   </ItemGroup>
 
   <ItemGroup>

diff --git a/Fluid.Benchmarks/FluidBenchmarks.cs b/Fluid.Benchmarks/FluidBenchmarks.cs
@@ -5,37 +5,40 @@ namespace Fluid.Benchmarks
     [MemoryDiagnoser]
     public class FluidBenchmarks : BaseBenchmarks
     {
-        private FluidTemplate _fluidTemplate;
-        private TemplateContext _context;
+        private readonly FluidParser _parser  = new FluidParser();
+        private readonly IFluidTemplate _fluidTemplate;
 
         public FluidBenchmarks()
         {
             TemplateContext.GlobalMemberAccessStrategy.MemberNameStrategy = MemberNameStrategies.CamelCase;
             TemplateContext.GlobalMemberAccessStrategy.Register<Product>();
-            FluidTemplate.TryParse(TextTemplate, out _fluidTemplate, out var errors);
-            _context = new TemplateContext().SetValue("products", Products);
+            _parser.TryParse(ProductTemplate, out _fluidTemplate, out var _);
         }
 
         [Benchmark]
         public override object Parse()
         {
-            FluidTemplate.TryParse(TextTemplate, false, out var template, out var errors);
-            return template;
+            return _parser.Parse(ProductTemplate);
+        }
+
+        [Benchmark]
+        public override object ParseBig()
+        {
+            return _parser.Parse(BlogPostTemplate);
         }
 
         [Benchmark]
         public override string Render()
         {
-            return _fluidTemplate.Render(_context);
+            var context = new TemplateContext().SetValue("products", Products);
+            return _fluidTemplate.Render(context);
         }
 
         [Benchmark]
         public override string ParseAndRender()
         {
-            FluidTemplate.TryParse(TextTemplate, false, out var template, out var errors);
-            var context = new TemplateContext()
-                .SetValue("products", Products);
-
+            _parser.TryParse(ProductTemplate, out var template);
+            var context = new TemplateContext().SetValue("products", Products);
             return template.Render(context);
         }
     }

diff --git a/Fluid.Benchmarks/LiquidNetBenchmarks.cs b/Fluid.Benchmarks/LiquidNetBenchmarks.cs
@@ -1,44 +1,39 @@
-using BenchmarkDotNet.Attributes;
-using Liquid.NET;
-using Liquid.NET.Constants;
+using Liquid.NET;
 using Liquid.NET.Utils;
 
 namespace Fluid.Benchmarks
 {
-    [MemoryDiagnoser]
     public class LiquidNetBenchmarks : BaseBenchmarks
     {
-        private LiquidParsingResult _liquidNetTemplate;
-        private Option<ILiquidValue> _products;
-        private Liquid.NET.TemplateContext _context;
+        private readonly LiquidParsingResult _liquidNetTemplate;
 
         public LiquidNetBenchmarks()
         {
-            _liquidNetTemplate = LiquidTemplate.Create(TextTemplate);
-            _products = Products.ToLiquid();
-            _context = new Liquid.NET.TemplateContext();
-            _context.DefineLocalVariable("products", _products);
+            _liquidNetTemplate = LiquidTemplate.Create(ProductTemplate);
         }
 
-        [Benchmark]
         public override object Parse()
         {
-            return LiquidTemplate.Create(TextTemplate);
+            return LiquidTemplate.Create(ProductTemplate);
+        }
+
+        public override object ParseBig()
+        {
+            return LiquidTemplate.Create(BlogPostTemplate);
         }
 
-        [Benchmark]
         public override string Render()
         {
-            return _liquidNetTemplate.LiquidTemplate.Render(_context).Result;
+            var context = new Liquid.NET.TemplateContext();
+            context.DefineLocalVariable("products", Products.ToLiquid());
+            return _liquidNetTemplate.LiquidTemplate.Render(context).Result;
         }
 
-        [Benchmark]
         public override string ParseAndRender()
         {
-            var template = LiquidTemplate.Create(TextTemplate);
-            var products = Products.ToLiquid();
+            var template = LiquidTemplate.Create(ProductTemplate);
             var context = new Liquid.NET.TemplateContext();
-            context.DefineLocalVariable("products", products);
+            context.DefineLocalVariable("products", Products.ToLiquid());
             return template.LiquidTemplate.Render(context).Result;
         }
     }

diff --git a/Fluid.Benchmarks/ScribanBenchmarks.cs b/Fluid.Benchmarks/ScribanBenchmarks.cs
@@ -1,37 +1,36 @@
-using BenchmarkDotNet.Attributes;
-using Scriban;
+using Scriban;
 using Scriban.Runtime;
 
 namespace Fluid.Benchmarks
 {
-    [MemoryDiagnoser]
     public class ScribanBenchmarks : BaseBenchmarks
     {
         private Template _scribanTemplate;
-        private ScriptObject _scriptObject;
 
         public ScribanBenchmarks()
         {
-            _scribanTemplate = Template.ParseLiquid(TextTemplate);
-            _scriptObject = new ScriptObject { { "products", Products } };
+            _scribanTemplate = Template.ParseLiquid(ProductTemplate);
         }
 
-        [Benchmark]
         public override object Parse()
         {
-            return _scribanTemplate = Template.ParseLiquid(TextTemplate);
+            return _scribanTemplate = Template.ParseLiquid(ProductTemplate);
+        }
+
+        public override object ParseBig()
+        {
+            return _scribanTemplate = Template.ParseLiquid(BlogPostTemplate);
         }
 
-        [Benchmark]
         public override string Render()
         {
-            return _scribanTemplate.Render(_scriptObject);
+            var scriptObject = new ScriptObject { { "products", Products } };
+            return _scribanTemplate.Render(scriptObject);
         }
 
-        [Benchmark]
         public override string ParseAndRender()
         {
-            var template = Template.ParseLiquid(TextTemplate);
+            var template = Template.ParseLiquid(ProductTemplate);
             var scriptObject = new ScriptObject { { "products", Products } };
             return template.Render(scriptObject);
         }