liquid-c 4.0.1 → 4.1.0

data/test/unit/variable_test.rb

@@ -1,110 +1,262 @@
 # encoding: utf-8
-require 'test_helper'
+# frozen_string_literal: true
 
-class VariableTest < MiniTest::Unit::TestCase
+require "test_helper"
+
+class VariableTest < Minitest::Test
   def test_variable_parse
-    assert_equal [lookup('hello'), []], variable_parse('hello')
-    assert_equal ['world', []], variable_parse(' "world" ')
-    assert_equal [lookup('hello["world"]'), []], variable_parse(' hello["world"] ')
-    assert_equal [nil, []], variable_parse('')
-    assert_equal [lookup('question?'), []], variable_parse('question?')
-    assert_equal [lookup('[meta]'), []], variable_parse('[meta]')
-    assert_equal [lookup('a-b'), []], variable_parse('a-b')
-    assert_equal [lookup('a-2'), []], variable_parse('a-2')
+    assert_equal("world", variable_strict_parse("hello").render!({ "hello" => "world" }))
+    assert_equal("world", variable_strict_parse('"world"').render!)
+    assert_equal("answer", variable_strict_parse('hello["world"]').render!({ "hello" => { "world" => "answer" } }))
+    assert_equal("answer", variable_strict_parse("question?").render!({ "question?" => "answer" }))
+    assert_equal("value", variable_strict_parse("[meta]").render!({ "meta" => "key", "key" => "value" }))
+    assert_equal("result", variable_strict_parse("a-b").render!({ "a-b" => "result" }))
+    assert_equal("result", variable_strict_parse("a-2").render!({ "a-2" => "result" }))
   end
 
   def test_strictness
-    assert_raises(Liquid::SyntaxError) { variable_parse(' hello["world\']" ') }
-    assert_raises(Liquid::SyntaxError) { variable_parse('-..') }
-    assert_raises(Liquid::SyntaxError) { variable_parse('question?mark') }
-    assert_raises(Liquid::SyntaxError) { variable_parse('123.foo') }
-    assert_raises(Liquid::SyntaxError) { variable_parse(' | nothing') }
-
-    ['a .b', 'a. b', 'a . b'].each do |var|
-      assert_raises(Liquid::SyntaxError) { variable_parse(var) }
-    end
+    assert_raises(Liquid::SyntaxError) { variable_strict_parse(' hello["world\']" ') }
+    assert_raises(Liquid::SyntaxError) { variable_strict_parse(" -..") }
+    assert_raises(Liquid::SyntaxError) { variable_strict_parse("question?mark") }
+    assert_raises(Liquid::SyntaxError) { variable_strict_parse("123.foo") }
+    assert_raises(Liquid::SyntaxError) { variable_strict_parse(" | nothing") }
 
-    ['a -b', 'a- b', 'a - b'].each do |var|
-      assert_raises(Liquid::SyntaxError) { variable_parse(var) }
+    ["a -b", "a- b", "a - b"].each do |var|
+      assert_raises(Liquid::SyntaxError) { variable_strict_parse(var) }
     end
   end
 
   def test_literals
-    assert_equal [true, []], variable_parse('true')
-    assert_equal [nil, []], variable_parse('nil')
-    assert_equal [123.4, []], variable_parse('123.4')
+    assert_equal("", variable_strict_parse("").render!)
+    assert_equal("true", variable_strict_parse("true").render!)
+    assert_equal("", variable_strict_parse("nil").render!)
+    assert_equal("123.4", variable_strict_parse("123.4").render!)
 
-    assert_equal [lookup('[blank]'), []], variable_parse('[blank]')
-    assert_equal [lookup(false, true, [Liquid::Expression::LITERALS['blank']], 0), []], variable_parse('[true][blank]')
-    assert_equal [lookup('[true][blank]'), []], variable_parse('[true][blank]')
-    assert_equal [lookup('x["size"]'), []], variable_parse('x["size"]')
+    assert_equal("blank_value", variable_strict_parse("[blank]").render!({ "" => "blank_value" }))
+    assert_equal("result", variable_strict_parse("[true][blank]").render!({ true => { "" => "result" } }))
+    assert_equal("result", variable_strict_parse('x["size"]').render!({ "x" => { "size" => "result" } }))
+    assert_equal("result", variable_strict_parse("blank.x").render!({ "blank" => { "x" => "result" } }))
+    assert_equal("result", variable_strict_parse('blank["x"]').render!({ "blank" => { "x" => "result" } }))
+  end
+
+  module InspectCallFilters
+    def filter1(input, *args)
+      inspect_call(__method__, input, args)
+    end
+
+    def filter2(input, *args)
+      inspect_call(__method__, input, args)
+    end
+
+    private
+
+    def inspect_call(filter_name, input, args)
+      "{ filter: #{filter_name.inspect}, input: #{input.inspect}, args: #{args.inspect} }"
+    end
   end
 
   def test_variable_filter
-    name = lookup('name')
-    assert_equal [name, [['filter', []]]], variable_parse(' name | filter ')
-    assert_equal [name, [['filter1', []], ['filter2', []]]], variable_parse(' name | filter1 | filter2 ')
+    context = { "name" => "Bob" }
+
+    filter1_output = variable_strict_parse("name | filter1").render!(context, filters: [InspectCallFilters])
+    assert_equal('{ filter: :filter1, input: "Bob", args: [] }', filter1_output)
+
+    filter2_output = variable_strict_parse("name | filter1 | filter2").render!(context, filters: [InspectCallFilters])
+    assert_equal("{ filter: :filter2, input: #{filter1_output.inspect}, args: [] }", filter2_output)
   end
 
   def test_variable_filter_args
-    name = lookup('name')
-    abc = lookup('abc')
+    context = { "name" => "Bob", "abc" => "xyz" }
+    render_opts = { filters: [InspectCallFilters] }
+
+    filter1_output = variable_strict_parse("name | filter1: abc").render!(context, render_opts)
+    assert_equal('{ filter: :filter1, input: "Bob", args: ["xyz"] }', filter1_output)
 
-    assert_equal [name, [['filter', [abc]]]], variable_parse(' name | filter: abc ')
+    filter2_output = variable_strict_parse("name | filter1: abc | filter2: abc").render!(context, render_opts)
+    assert_equal("{ filter: :filter2, input: #{filter1_output.inspect}, args: [\"xyz\"] }", filter2_output)
 
-    assert_equal [name, [['filter1', [abc]], ['filter2', [abc]]]],
-      variable_parse(' name | filter1: abc | filter2: abc ')
+    context = { "name" => "Bob", "a" => 1, "c" => 3, "e" => 5 }
 
-    assert_equal [name, [['filter', [lookup('a')], {'b' => lookup('c'), 'd' => lookup('e')}]]],
-      variable_parse('name | filter : a , b : c , d : e')
+    output = variable_strict_parse("name | filter1 : a , b : c , d : e").render!(context, render_opts)
+    assert_equal('{ filter: :filter1, input: "Bob", args: [1, {"b"=>3, "d"=>5}] }', output)
 
-    assert_raises Liquid::SyntaxError do
-      variable_parse('name | filter : a : b : c : d : e')
+    assert_raises(Liquid::SyntaxError) do
+      variable_strict_parse("name | filter : a : b : c : d : e")
     end
   end
 
   def test_unicode_strings
-    assert_equal ['å߀êùｉｄｈｔлｓԁѵ߀ｒáƙìｓｔɦｅƅêｓｔｐｃｍáѕｔｅｒｒãｃêｃհèｒｒ', []],
-      variable_parse('"å߀êùｉｄｈｔлｓԁѵ߀ｒáƙìｓｔɦｅƅêｓｔｐｃｍáѕｔｅｒｒãｃêｃհèｒｒ"')
+    string_content = "å߀êùｉｄｈｔлｓԁѵ߀ｒáƙìｓｔɦｅƅêｓｔｐｃｍáѕｔｅｒｒãｃêｃհèｒｒ"
+    assert_equal(string_content, variable_strict_parse("\"#{string_content}\"").render!)
   end
 
   def test_broken_unicode_errors
     err = assert_raises(Liquid::SyntaxError) do
       Liquid::Template.parse("test {{ \xC2\xA0 test }}", error_mode: :strict)
     end
-    assert err.message
+    assert(err.message)
   end
 
   def test_callbacks
-    variable_parses = 0
     variable_fallbacks = 0
 
     callbacks = {
-      variable_parse: lambda { variable_parses += 1 },
-      variable_fallback: lambda { variable_fallbacks += 1 }
+      variable_fallback: lambda { variable_fallbacks += 1 },
     }
 
-    create_variable('abc', error_mode: :lax, stats_callbacks: callbacks)
-    assert_equal 1, variable_parses
-    assert_equal 0, variable_fallbacks
+    Liquid::Template.parse("{{abc}}", error_mode: :lax, stats_callbacks: callbacks)
+    assert_equal(0, variable_fallbacks)
 
-    create_variable('@!#', error_mode: :lax, stats_callbacks: callbacks)
-    assert_equal 2, variable_parses
-    assert_equal 1, variable_fallbacks
+    Liquid::Template.parse("{{@!#}}", error_mode: :lax, stats_callbacks: callbacks)
+    assert_equal(1, variable_fallbacks)
   end
 
-  private
+  def test_write_string
+    output = Liquid::Template.parse("{{ str }}").render({ "str" => "foo" })
+    assert_equal("foo", output)
+  end
+
+  def test_write_fixnum
+    output = Liquid::Template.parse("{{ num }}").render({ "num" => 123456 })
+    assert_equal("123456", output)
+  end
+
+  def test_write_array
+    output = Liquid::Template.parse("{{ ary }}").render({ "ary" => ["foo", 123, ["nested", "ary"], nil, 0.5] })
+    assert_equal("foo123nestedary0.5", output)
+  end
+
+  def test_write_nil
+    output = Liquid::Template.parse("{{ obj }}").render({ "obj" => nil })
+    assert_equal("", output)
+  end
+
+  class StringConvertible
+    def initialize(as_string)
+      @as_string = as_string
+    end
+
+    def to_s
+      @as_string
+    end
+
+    def to_liquid
+      self
+    end
+  end
+
+  def test_write_to_s_convertible_object
+    output = Liquid::Template.parse("{{ obj }}").render!({ "obj" => StringConvertible.new("foo") })
+    assert_equal("foo", output)
+  end
+
+  def test_write_object_with_broken_to_s
+    template = Liquid::Template.parse("{{ obj }}")
+    exc = assert_raises(TypeError) do
+      template.render!({ "obj" => StringConvertible.new(123) })
+    end
+    assert_equal(
+      "VariableTest::StringConvertible#to_s returned a non-String convertible value of type Integer",
+      exc.message
+    )
+  end
+
+  class DerivedString < String
+    def to_s
+      self
+    end
+  end
+
+  def test_write_derived_string
+    output = Liquid::Template.parse("{{ obj }}").render!({ "obj" => DerivedString.new("bar") })
+    assert_equal("bar", output)
+  end
+
+  def test_filter_without_args
+    output = Liquid::Template.parse("{{ var | upcase }}").render({ "var" => "Hello" })
+    assert_equal("HELLO", output)
+  end
+
+  def test_filter_with_const_arg
+    output = Liquid::Template.parse("{{ x | plus: 2 }}").render({ "x" => 3 })
+    assert_equal("5", output)
+  end
+
+  def test_filter_with_variable_arg
+    output = Liquid::Template.parse("{{ x | plus: y }}").render({ "x" => 10, "y" => 123 })
+    assert_equal("133", output)
+  end
+
+  def test_filter_with_variable_arg_after_const_arg
+    output = Liquid::Template.parse("{{ ary | slice: 1, 2 }}").render({ "ary" => [1, 2, 3, 4] })
+    assert_equal("23", output)
+  end
+
+  def test_filter_with_const_keyword_arg
+    output = Liquid::Template.parse("{{ value | default: 'None' }}").render({ "value" => false })
+    assert_equal("None", output)
+
+    output = Liquid::Template.parse("{{ value | default: 'None', allow_false: true }}").render({ "value" => false })
+    assert_equal("false", output)
+  end
+
+  def test_filter_with_variable_keyword_arg
+    template = Liquid::Template.parse("{{ value | default: 'None', allow_false: false_allowed }}")
+
+    assert_equal("None", template.render({ "value" => false, "false_allowed" => false }))
+    assert_equal("false", template.render({ "value" => false, "false_allowed" => true }))
+  end
 
-  def create_variable(markup, options={})
-    Liquid::Variable.new(markup, Liquid::ParseContext.new(options))
+  def test_filter_error
+    output = Liquid::Template.parse("before ({{ ary | concat: 2 }}) after").render({ "ary" => [1] })
+    assert_equal("before (Liquid error: concat filter requires an array argument) after", output)
   end
 
-  def variable_parse(markup)
-    name = Liquid::Variable.c_strict_parse(markup, filters = [])
-    [name, filters]
+  def test_render_variable_object
+    variable = Liquid::Variable.new("ary | concat: ary2", Liquid::ParseContext.new)
+    assert_instance_of(Liquid::C::VariableExpression, variable.name)
+
+    context = Liquid::Context.new("ary" => [1], "ary2" => [2])
+    assert_equal([1, 2], variable.render(context))
+
+    context["ary2"] = 2
+    exc = assert_raises(Liquid::ArgumentError) do
+      variable.render(context)
+    end
+    assert_equal("Liquid error: concat filter requires an array argument", exc.message)
   end
 
-  def lookup(*args)
-    Liquid::VariableLookup.new(*args)
+  def test_filter_argument_error_translation
+    variable = Liquid::Variable.new("'some words' | split", Liquid::ParseContext.new)
+    context = Liquid::Context.new
+    exc = assert_raises(Liquid::ArgumentError) { variable.render(context) }
+    assert_equal("Liquid error: wrong number of arguments (given 1, expected 2)", exc.message)
+  end
+
+  class IntegerDrop < Liquid::Drop
+    def initialize(value)
+      super()
+      @value = value.to_i
+    end
+
+    def to_liquid_value
+      @value
+    end
+  end
+
+  def test_to_liquid_value_on_variable_lookup
+    context = {
+      "number" => IntegerDrop.new("1"),
+      "list" => [1, 2, 3, 4, 5],
+    }
+
+    output = variable_strict_parse("list[number]").render!(context)
+    assert_equal("2", output)
+  end
+
+  private
+
+  def variable_strict_parse(markup)
+    Liquid::Template.parse("{{#{markup}}}", error_mode: :strict)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: liquid-c
 version: !ruby/object:Gem::Version
-  version: 4.0.1
+  version: 4.1.0
 platform: ruby
 authors:
 - Justin Li
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-11 00:00:00.000000000 Z
+date: 2022-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: liquid
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 5.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 5.0.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -40,7 +40,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.5'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -54,7 +54,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake-compiler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -68,7 +68,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -105,29 +105,70 @@ extra_rdoc_files: []
 files:
 - ".github/workflows/liquid.yml"
 - ".gitignore"
+- ".rubocop.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - ext/liquid_c/block.c
 - ext/liquid_c/block.h
+- ext/liquid_c/c_buffer.c
+- ext/liquid_c/c_buffer.h
+- ext/liquid_c/context.c
+- ext/liquid_c/context.h
+- ext/liquid_c/document_body.c
+- ext/liquid_c/document_body.h
+- ext/liquid_c/expression.c
+- ext/liquid_c/expression.h
 - ext/liquid_c/extconf.rb
+- ext/liquid_c/intutil.h
 - ext/liquid_c/lexer.c
 - ext/liquid_c/lexer.h
 - ext/liquid_c/liquid.c
 - ext/liquid_c/liquid.h
+- ext/liquid_c/parse_context.c
+- ext/liquid_c/parse_context.h
 - ext/liquid_c/parser.c
 - ext/liquid_c/parser.h
+- ext/liquid_c/raw.c
+- ext/liquid_c/raw.h
+- ext/liquid_c/resource_limits.c
+- ext/liquid_c/resource_limits.h
+- ext/liquid_c/stringutil.h
 - ext/liquid_c/tokenizer.c
 - ext/liquid_c/tokenizer.h
+- ext/liquid_c/usage.c
+- ext/liquid_c/usage.h
 - ext/liquid_c/variable.c
 - ext/liquid_c/variable.h
+- ext/liquid_c/variable_lookup.c
+- ext/liquid_c/variable_lookup.h
+- ext/liquid_c/vm.c
+- ext/liquid_c/vm.h
+- ext/liquid_c/vm_assembler.c
+- ext/liquid_c/vm_assembler.h
+- ext/liquid_c/vm_assembler_pool.c
+- ext/liquid_c/vm_assembler_pool.h
 - lib/liquid/c.rb
+- lib/liquid/c/compile_ext.rb
 - lib/liquid/c/version.rb
 - liquid-c.gemspec
 - performance.rb
-- test/liquid_test.rb
+- performance/c_profile.rb
+- rakelib/compile.rake
+- rakelib/integration_test.rake
+- rakelib/performance.rake
+- rakelib/rubocop.rake
+- rakelib/unit_test.rake
+- test/integration_test.rb
+- test/liquid_test_helper.rb
 - test/test_helper.rb
+- test/unit/block_test.rb
+- test/unit/context_test.rb
+- test/unit/expression_test.rb
+- test/unit/gc_stress_test.rb
+- test/unit/raw_test.rb
+- test/unit/resource_limits_test.rb
 - test/unit/tokenizer_test.rb
 - test/unit/variable_test.rb
 homepage: https://github.com/shopify/liquid-c
@@ -143,19 +184,26 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.2.20
 signing_key: 
 specification_version: 4
 summary: Liquid performance extension in C
 test_files:
-- test/liquid_test.rb
+- test/integration_test.rb
+- test/liquid_test_helper.rb
 - test/test_helper.rb
+- test/unit/block_test.rb
+- test/unit/context_test.rb
+- test/unit/expression_test.rb
+- test/unit/gc_stress_test.rb
+- test/unit/raw_test.rb
+- test/unit/resource_limits_test.rb
 - test/unit/tokenizer_test.rb
 - test/unit/variable_test.rb

data/test/liquid_test.rb

@@ -1,11 +0,0 @@
-liquid_lib_dir = $LOAD_PATH.detect{ |p| File.exist?(File.join(p, 'liquid.rb')) }
-liquid_test_dir = File.join(File.dirname(liquid_lib_dir), 'test')
-$LOAD_PATH << liquid_test_dir
-
-require 'test_helper'
-require 'liquid/c'
-
-test_files = Dir[File.join(liquid_test_dir, "integration/**/*_test.rb")]
-test_files.each do |test_file|
-  require test_file
-end