Prefer string interpolation in simple cases

Co-Authored-By: Dylan Thacker-Smith <dylan.smith@shopify.com>

.rubocop.yml

@@ -1,5 +1,5 @@
 inherit_from:
-  - 'https://shopify.github.io/ruby-style-guide/rubocop.yml'
+  - https://shopify.github.io/ruby-style-guide/rubocop.yml
   - .rubocop_todo.yml
 
 require: rubocop-performance
@@ -8,10 +8,9 @@ Performance:
   Enabled: true
 
 AllCops:
-  TargetRubyVersion: 2.4
   Exclude:
     - 'vendor/bundle/**/*'
-
+      
 Naming/MethodName:
   Exclude:
-    - 'example/server/liquid_servlet.rb'
+    - 'example/server/liquid_servlet.rb'

.rubocop_todo.yml

@@ -6,6 +6,26 @@
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
+# Offense count: 2
+Lint/AmbiguousOperator:
+  Exclude:
+    - 'test/unit/condition_unit_test.rb'
+
+# Offense count: 21
+# Configuration parameters: AllowSafeAssignment.
+Lint/AssignmentInCondition:
+  Exclude:
+    - 'lib/liquid/block_body.rb'
+    - 'lib/liquid/lexer.rb'
+    - 'lib/liquid/standardfilters.rb'
+    - 'lib/liquid/tags/for.rb'
+    - 'lib/liquid/tags/if.rb'
+    - 'lib/liquid/tags/raw.rb'
+    - 'lib/liquid/variable.rb'
+    - 'performance/profile.rb'
+    - 'test/test_helper.rb'
+    - 'test/unit/tokenizer_unit_test.rb'
+
 # Offense count: 2
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyle.
@@ -14,6 +34,17 @@ Lint/InheritException:
   Exclude:
     - 'lib/liquid/interrupts.rb'
 
+# Offense count: 2
+Lint/UselessAssignment:
+  Exclude:
+    - 'performance/shopify/database.rb'
+
+# Offense count: 1
+# Configuration parameters: CheckForMethodsWithNoSideEffects.
+Lint/Void:
+  Exclude:
+    - 'lib/liquid/parse_context.rb'
+
 # Offense count: 98
 # Cop supports --auto-correct.
 # Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
@@ -45,4 +76,19 @@ Style/ClassVars:
   Exclude:
     - 'lib/liquid/condition.rb'
     - 'lib/liquid/strainer.rb'
-    - 'lib/liquid/template.rb'
+    - 'lib/liquid/template.rb'
+
+# Offense count: 1
+# Configuration parameters: AllowCoercion.
+Style/DateTime:
+  Exclude:
+    - 'test/unit/context_unit_test.rb'
+
+# Offense count: 9
+# Cop supports --auto-correct.
+# Configuration parameters: AllowAsExpressionSeparator.
+Style/Semicolon:
+  Exclude:
+    - 'test/integration/error_handling_test.rb'
+    - 'test/integration/template_test.rb'
+    - 'test/unit/context_unit_test.rb'

.travis.yml

@@ -7,6 +7,8 @@ rvm:
   - &latest_ruby 2.6
   - 2.7
   - ruby-head
+  - jruby-head
+  - truffleruby
 
 matrix:
   include:
@@ -15,6 +17,8 @@ matrix:
       name: Profiling Memory Usage
   allow_failures:
     - rvm: ruby-head
+    - rvm: jruby-head
+    - rvm: truffleruby
 
 branches:
   only:

lib/liquid.rb

@@ -78,7 +78,6 @@ require 'liquid/tokenizer'
 require 'liquid/parse_context'
 require 'liquid/partial_cache'
 require 'liquid/usage'
-require 'liquid/static_registers'
 
 # Load all the tags of the standard library
 #

lib/liquid/block_body.rb

@@ -27,7 +27,7 @@ module Liquid
     end
 
     private def parse_for_liquid_tag(tokenizer, parse_context)
-      while (token = tokenizer.shift)
+      while token = tokenizer.shift
         unless token.empty? || token =~ WhitespaceOrNothing
           unless token =~ LiquidTagToken
             # line isn't empty but didn't match tag syntax, yield and let the
@@ -36,7 +36,7 @@ module Liquid
           end
           tag_name = Regexp.last_match(1)
           markup = Regexp.last_match(2)
-          unless (tag = registered_tags[tag_name])
+          unless tag = registered_tags[tag_name]
             # end parsing if we reach an unknown tag and let the caller decide
             # determine how to proceed
             return yield tag_name, markup
@@ -52,7 +52,7 @@ module Liquid
     end
 
     private def parse_for_document(tokenizer, parse_context, &block)
-      while (token = tokenizer.shift)
+      while token = tokenizer.shift
         next if token.empty?
         case
         when token.start_with?(TAGSTART)
@@ -74,7 +74,7 @@ module Liquid
             next parse_for_liquid_tag(liquid_tag_tokenizer, parse_context, &block)
           end
 
-          unless (tag = registered_tags[tag_name])
+          unless tag = registered_tags[tag_name]
             # end parsing if we reach an unknown tag and let the caller decide
             # determine how to proceed
             return yield tag_name, markup
@@ -122,7 +122,7 @@ module Liquid
       context.resource_limits.render_score += @nodelist.length
 
       idx = 0
-      while (node = @nodelist[idx])
+      while node = @nodelist[idx]
         previous_output_size = output.bytesize
 
         case node

lib/liquid/context.rb

@@ -18,17 +18,18 @@ module Liquid
     attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters
 
     # rubocop:disable Metrics/ParameterLists
-    def self.build(environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_environments: {})
-      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_environments)
+    def self.build(environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_registers: {}, static_environments: {})
+      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_registers, static_environments)
     end
 
-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_environments = {})
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_registers = {}, static_environments = {})
       @environments = [environments]
       @environments.flatten!
 
       @static_environments = [static_environments].flat_map(&:freeze).freeze
       @scopes              = [(outer_scope || {})]
       @registers           = registers
+      @static_registers    = static_registers.freeze
       @errors              = []
       @partial             = false
       @strict_variables    = false
@@ -136,7 +137,7 @@ module Liquid
       Context.build(
         resource_limits: resource_limits,
         static_environments: static_environments,
-        registers: StaticRegisters.new(registers)
+        static_registers: static_registers
       ).tap do |subcontext|
         subcontext.base_scope_depth = base_scope_depth + 1
         subcontext.exception_renderer = exception_renderer

lib/liquid/drop.rb

@@ -69,7 +69,7 @@ module Liquid
 
         if include?(Enumerable)
           blacklist += Enumerable.public_instance_methods
-          blacklist -= [:sort, :count, :first, :min, :max]
+          blacklist -= [:sort, :count, :first, :min, :max, :include?]
         end
 
         whitelist = [:to_liquid] + (public_instance_methods - blacklist)

lib/liquid/file_system.rb

@@ -59,7 +59,7 @@ module Liquid
     end
 
     def full_path(template_path)
-      raise FileSystemError, "Illegal template name '#{template_path}'" unless %r{\A[^./][a-zA-Z0-9_/]+\z}.match?(template_path)
+      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ %r{\A[^./][a-zA-Z0-9_/]+\z}
 
       full_path = if template_path.include?('/')
         File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))

lib/liquid/lexer.rb

@@ -33,21 +33,15 @@ module Liquid
       until @ss.eos?
         @ss.skip(WHITESPACE_OR_NOTHING)
         break if @ss.eos?
-        tok = if (t = @ss.scan(COMPARISON_OPERATOR))
-          [:comparison, t]
-        elsif (t = @ss.scan(SINGLE_STRING_LITERAL))
-          [:string, t]
-        elsif (t = @ss.scan(DOUBLE_STRING_LITERAL))
-          [:string, t]
-        elsif (t = @ss.scan(NUMBER_LITERAL))
-          [:number, t]
-        elsif (t = @ss.scan(IDENTIFIER))
-          [:id, t]
-        elsif (t = @ss.scan(DOTDOT))
-          [:dotdot, t]
+        tok = if t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
+        elsif t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
+        elsif t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
+        elsif t = @ss.scan(NUMBER_LITERAL) then [:number, t]
+        elsif t = @ss.scan(IDENTIFIER) then [:id, t]
+        elsif t = @ss.scan(DOTDOT) then [:dotdot, t]
         else
           c = @ss.getch
-          if (s = SPECIALS[c])
+          if s = SPECIALS[c]
             [s, c]
           else
             raise SyntaxError, "Unexpected character #{c}"

lib/liquid/parse_context.rb

@@ -21,6 +21,7 @@ module Liquid
       @partial = value
       @options = value ? partial_options : @template_options
       @error_mode = @options[:error_mode] || Template.error_mode
+      value
     end
 
     def partial_options

lib/liquid/standardfilters.rb

@@ -327,7 +327,7 @@ module Liquid
     def date(input, format)
       return input if format.to_s.empty?
 
-      return input unless (date = Utils.to_date(input))
+      return input unless date = Utils.to_date(input)
 
       date.strftime(format.to_s)
     end

lib/liquid/static_registers.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class StaticRegisters
-    attr_reader :static, :registers
-
-    def initialize(registers = {})
-      @static = registers.is_a?(StaticRegisters) ? registers.static : registers
-      @registers = {}
-    end
-
-    def []=(key, value)
-      @registers[key] = value
-    end
-
-    def [](key)
-      if @registers.key?(key)
-        @registers[key]
-      else
-        @static[key]
-      end
-    end
-
-    def delete(key)
-      @registers.delete(key)
-    end
-
-    def fetch(key, default = nil)
-      key?(key) ? self[key] : default
-    end
-
-    def key?(key)
-      @registers.key?(key) || @static.key?(key)
-    end
-  end
-end

lib/liquid/tags/for.rb

@@ -111,7 +111,7 @@ module Liquid
       @reversed = p.id?('reversed')
 
       while p.look(:id) && p.look(:colon, 1)
-        unless (attribute = p.id?('limit') || p.id?('offset'))
+        unless attribute = p.id?('limit') || p.id?('offset')
           raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute")
         end
         p.consume

lib/liquid/tags/if.rb

@@ -94,7 +94,7 @@ module Liquid
     def parse_binary_comparisons(p)
       condition = parse_comparison(p)
       first_condition = condition
-      while (op = (p.id?('and') || p.id?('or')))
+      while op = (p.id?('and') || p.id?('or'))
         child_condition = parse_comparison(p)
         condition.send(op, child_condition)
         condition = child_condition
@@ -104,7 +104,7 @@ module Liquid
 
     def parse_comparison(p)
       a = Expression.parse(p.expression)
-      if (op = p.consume?(:comparison))
+      if op = p.consume?(:comparison)
         b = Expression.parse(p.expression)
         Condition.new(a, op, b)
       else

lib/liquid/tags/raw.rb

@@ -13,7 +13,7 @@ module Liquid
 
     def parse(tokens)
       @body = +''
-      while (token = tokens.shift)
+      while token = tokens.shift
         if token =~ FullTokenPossiblyInvalid
           @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
           return if block_delimiter == Regexp.last_match(2)
@@ -40,7 +40,7 @@ module Liquid
     protected
 
     def ensure_valid_markup(tag_name, markup, parse_context)
-      unless Syntax.match?(markup)
+      unless markup =~ Syntax
         raise SyntaxError, parse_context.locale.t("errors.syntax.tag_unexpected_args", tag: tag_name)
       end
     end

lib/liquid/tokenizer.rb

@@ -28,84 +28,12 @@ module Liquid
 
       return @source.split("\n") if @for_liquid_tag
 
-      tokens = tokenize_new(@source)
-      # tokens = @source.split(TemplateParser)
+      tokens = @source.split(TemplateParser)
 
       # removes the rogue empty element at the beginning of the array
       tokens.shift if tokens[0]&.empty?
 
       tokens
     end
-
-    T_TAG_OPEN = "{%"
-    T_VAR_OPEN = "{{"
-    T_SIN_QUOT = "'"
-    T_DOU_QUOT = '"'
-    T_TAG_CLOS = "%}"
-    T_VAR_CLOS = "}}"
-    T_VAR_CLO2 = "}"
-
-    S_NIL = 0
-    S_TAG = 1
-    S_VAR = 2
-    S_TAG_SIN = 3
-    S_TAG_DOU = 4
-    S_VAR_SIN = 5
-    S_VAR_DOU = 6
-
-    def tokenize_new(source)
-      output = []
-      s = S_NIL
-      current = +""
-      source.split(/({%|{{|"|'|}}|%}|})/om).each do |t|
-        if t == T_TAG_OPEN && s <= S_VAR
-          s = S_TAG
-          output << current
-          current = t
-        elsif t == T_VAR_OPEN && s <= S_VAR
-          s = S_VAR
-          output << current
-          current = t
-        elsif t == T_SIN_QUOT && s == S_TAG
-          s = S_TAG_SIN
-          current += t
-        elsif t == T_SIN_QUOT && s == S_TAG_SIN
-          s = S_TAG
-          current += t
-        elsif t == T_DOU_QUOT && s == S_TAG
-          s = S_TAG_DOU
-          current += t
-        elsif t == T_DOU_QUOT && s == S_TAG_DOU
-          s = S_TAG
-          current += t
-        elsif t == T_SIN_QUOT && s == S_VAR
-          s = S_VAR_SIN
-          current += t
-        elsif t == T_SIN_QUOT && s == S_VAR_SIN
-          s = S_VAR
-          current += t
-        elsif t == T_DOU_QUOT && s == S_VAR
-          s = S_VAR_DOU
-          current += t
-        elsif t == T_DOU_QUOT && s == S_VAR_DOU
-          s = S_VAR
-          current += t
-        elsif t == T_TAG_CLOS && s == S_TAG
-          s = S_NIL
-          current += t
-          output << current
-          current = +""
-        elsif (t == T_VAR_CLOS || t == T_VAR_CLO2) && s == S_VAR
-          s = S_NIL
-          current += t
-          output << current
-          current = +""
-        else
-          current += t
-        end
-      end
-      output << current unless current == ""
-      output
-    end
   end
 end

lib/liquid/utils.rb

@@ -52,7 +52,7 @@ module Liquid
       when Numeric
         obj
       when String
-        /\A-?\d+\.\d+\z/.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
+        obj.strip =~ /\A-?\d+\.\d+\z/ ? BigDecimal(obj) : obj.to_i
       else
         if obj.respond_to?(:to_number)
           obj.to_number

lib/liquid/variable.rb

@@ -110,7 +110,7 @@ module Liquid
       filter_args = []
       keyword_args = nil
       unparsed_args.each do |a|
-        if (matches = a.match(JustTagAttributes))
+        if matches = a.match(JustTagAttributes)
           keyword_args ||= {}
           keyword_args[matches[1]] = Expression.parse(matches[2])
         else

performance/profile.rb

@@ -15,7 +15,7 @@ profiler.run
     end
   end
 
-  if profile_type == :cpu && (graph_filename = ENV['GRAPH_FILENAME'])
+  if profile_type == :cpu && graph_filename = ENV['GRAPH_FILENAME']
     File.open(graph_filename, 'w') do |f|
       StackProf::Report.new(results).print_graphviz(nil, f)
     end

performance/shopify/database.rb

@@ -32,8 +32,8 @@ module Database
       db['article']    = db['blog']['articles'].first
 
       db['cart']       = {
-        'total_price' => db['line_items'].values.inject(0) { |sum, item| sum + item['line_price'] * item['quantity'] },
-        'item_count' => db['line_items'].values.inject(0) { |sum, item| sum + item['quantity'] },
+        'total_price' => db['line_items'].values.inject(0) { |sum, item| sum += item['line_price'] * item['quantity'] },
+        'item_count' => db['line_items'].values.inject(0) { |sum, item| sum += item['quantity'] },
         'items' => db['line_items'].values,
       }
 

test/integration/drop_test.rb

@@ -272,11 +272,4 @@ class DropsTest < Minitest::Test
     assert_equal 'ProductDrop', Liquid::Template.parse("{{ product }}").render!('product' => ProductDrop.new)
     assert_equal 'EnumerableDrop', Liquid::Template.parse('{{ collection }}').render!('collection' => EnumerableDrop.new)
   end
-
-  def test_invokable_methods
-    assert_equal %w(to_liquid catchall user_input context texts).to_set, ProductDrop.invokable_methods
-    assert_equal %w(to_liquid scopes_as_array loop_pos scopes).to_set, ContextDrop.invokable_methods
-    assert_equal %w(to_liquid size max min first count).to_set, EnumerableDrop.invokable_methods
-    assert_equal %w(to_liquid max min sort count first).to_set, RealEnumerableDrop.invokable_methods
-  end
 end # DropsTest

test/integration/error_handling_test.rb

@@ -211,10 +211,7 @@ class ErrorHandlingTest < Minitest::Test
   def test_setting_default_exception_renderer
     old_exception_renderer = Liquid::Template.default_exception_renderer
     exceptions = []
-    Liquid::Template.default_exception_renderer = ->(e) {
-      exceptions << e
-      ''
-    }
+    Liquid::Template.default_exception_renderer = ->(e) { exceptions << e; '' }
     template = Liquid::Template.parse('This is a runtime error: {{ errors.argument_error }}')
 
     output = template.render('errors' => ErrorDrop.new)
@@ -228,10 +225,7 @@ class ErrorHandlingTest < Minitest::Test
   def test_exception_renderer_exposing_non_liquid_error
     template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
     exceptions = []
-    handler = ->(e) {
-      exceptions << e
-      e.cause
-    }
+    handler = ->(e) { exceptions << e; e.cause }
 
     output = template.render({ 'errors' => ErrorDrop.new }, exception_renderer: handler)
 

test/integration/tags/assign_tag_test.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class AssignTagTest < Minitest::Test
-  include Liquid
-
-  def test_assign
-    assert_template_result('monkey', "{% assign foo = 'monkey' %}{{ foo }}")
-  end
-
-  def test_string_with_end_tag
-    assert_template_result("{% quoted %}", "{% assign string = '{% quoted %}' %}{{ string }}")
-  end
-
-  def test_liquid_issue_701
-    assert_template_result(" contents: _{% endraw %}_", "{% assign endraw = '{% endraw %}' %} contents: _{{endraw}}_")
-  end
-end

test/integration/tags/raw_tag_test.rb

@@ -23,17 +23,11 @@ class RawTagTest < Minitest::Test
     assert_template_result ' Foobar {% {% {% ', '{% raw %} Foobar {% {% {% {% endraw %}'
     assert_template_result ' test {% raw %} {% endraw %}', '{% raw %} test {% raw %} {% {% endraw %}endraw %}'
     assert_template_result ' Foobar {{ invalid 1', '{% raw %} Foobar {{ invalid {% endraw %}{{ 1 }}'
-    assert_template_result ' Foobar {{ invalid 12', '{% raw %} Foobar {{ invalid {% endraw %}{{ 1 }}{{ 2 }}'
-    assert_template_result ' Foobar {{ invalid 1', '{% raw %} Foobar {{ invalid {% endraw %}{{ 1 }}'
-  end
-
-  def test_nested_tag_in_raw
-    assert_template_result '{{ {% test %} }}', '{% raw %}{{ {% test %} }}{% endraw %}'
   end
 
   def test_invalid_raw
     assert_match_syntax_error(/tag was never closed/, '{% raw %} foo')
-    assert_match_syntax_error(/was not properly terminated/, '{% raw } foo {% endraw %}')
+    assert_match_syntax_error(/Valid syntax/, '{% raw } foo {% endraw %}')
     assert_match_syntax_error(/Valid syntax/, '{% raw } foo %}{% endraw %}')
   end
 end

test/integration/template_test.rb

@@ -81,10 +81,7 @@ class TemplateTest < Minitest::Test
 
   def test_lambda_is_called_once_from_persistent_assigns_over_multiple_parses_and_renders
     t = Template.new
-    t.assigns['number'] = -> {
-      @global ||= 0
-      @global += 1
-    }
+    t.assigns['number'] = -> { @global ||= 0; @global += 1 }
     assert_equal '1', t.parse("{{number}}").render!
     assert_equal '1', t.parse("{{number}}").render!
     assert_equal '1', t.render!
@@ -93,10 +90,7 @@ class TemplateTest < Minitest::Test
 
   def test_lambda_is_called_once_from_custom_assigns_over_multiple_parses_and_renders
     t = Template.new
-    assigns = { 'number' => -> {
-                              @global ||= 0
-                              @global += 1
-                            } }
+    assigns = { 'number' => -> { @global ||= 0; @global += 1 } }
     assert_equal '1', t.parse("{{number}}").render!(assigns)
     assert_equal '1', t.parse("{{number}}").render!(assigns)
     assert_equal '1', t.render!(assigns)
@@ -243,10 +237,7 @@ class TemplateTest < Minitest::Test
 
   def test_exception_renderer_that_returns_string
     exception = nil
-    handler = ->(e) {
-      exception = e
-      '<!-- error -->'
-    }
+    handler = ->(e) { exception = e; '<!-- error -->' }
 
     output = Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_renderer: handler)
 
@@ -257,10 +248,7 @@ class TemplateTest < Minitest::Test
   def test_exception_renderer_that_raises
     exception = nil
     assert_raises(Liquid::ZeroDivisionError) do
-      Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_renderer: ->(e) {
-                                                                                 exception = e
-                                                                                 raise
-                                                                               })
+      Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_renderer: ->(e) { exception = e; raise })
     end
     assert exception.is_a?(Liquid::ZeroDivisionError)
   end
@@ -361,9 +349,4 @@ class TemplateTest < Minitest::Test
     result = t.render('x' => 1, 'y' => 5)
     assert_equal '12345', result
   end
-
-  def test_curly_braces
-    assert_template_result "{}", "{{ '{}' }}"
-    assert_template_result "{}", "{% assign test = '{}' %}{{ test }}"
-  end
 end

test/integration/variable_test.rb

@@ -95,21 +95,4 @@ class VariableTest < Minitest::Test
   def test_render_symbol
     assert_template_result 'bar', '{{ foo }}', 'foo' => :bar
   end
-
-  def test_quoted_single_curly_braces
-    assert_template_result "{user}", "{{ variable | prepend: '{' | append: '}' }}", 'variable' => 'user'
-  end
-
-  def test_string_with_curly_brackets
-    json = '{ "key": { "nested": "value" }}'
-    assert_template_result(json, "{{ '#{json}' }}")
-  end
-
-  def test_liquid_issue_344
-    assert_template_result "blah xx yy }}", "{{ 'blah {{ yy }}' | replace: '{{', 'xx' }}"
-  end
-
-  def test_liquid_issue_213
-    assert_template_result "blah", "{{ 'blah}' | remove: '}' }}"
-  end
 end

test/test_helper.rb

@@ -9,7 +9,7 @@ require 'liquid.rb'
 require 'liquid/profiler'
 
 mode = :strict
-if (env_mode = ENV['LIQUID_PARSER_MODE'])
+if env_mode = ENV['LIQUID_PARSER_MODE']
   puts "-- #{env_mode.upcase} ERROR MODE"
   mode = env_mode.to_sym
 end

test/unit/condition_unit_test.rb

@@ -26,9 +26,9 @@ class ConditionUnitTest < Minitest::Test
     assert_evaluates_true 1, '<=', 1
     # negative numbers
     assert_evaluates_true 1, '>', -1
-    assert_evaluates_true(-1, '<', 1)
+    assert_evaluates_true -1, '<', 1
     assert_evaluates_true 1.0, '>', -1.0
-    assert_evaluates_true(-1.0, '<', 1.0)
+    assert_evaluates_true -1.0, '<', 1.0
   end
 
   def test_default_operators_evalute_false

test/unit/context_unit_test.rb

@@ -85,7 +85,7 @@ class ContextUnitTest < Minitest::Test
     @context['date'] = Date.today
     assert_equal Date.today, @context['date']
 
-    now = Time.now
+    now = DateTime.now
     @context['datetime'] = now
     assert_equal now, @context['datetime']
 
@@ -405,11 +405,7 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_lambda_is_called_once
-    @context['callcount'] = proc {
-      @global ||= 0
-      @global += 1
-      @global.to_s
-    }
+    @context['callcount'] = proc { @global ||= 0; @global += 1; @global.to_s }
 
     assert_equal '1', @context['callcount']
     assert_equal '1', @context['callcount']
@@ -419,11 +415,7 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_nested_lambda_is_called_once
-    @context['callcount'] = { "lambda" => proc {
-                                            @global ||= 0
-                                            @global += 1
-                                            @global.to_s
-                                          } }
+    @context['callcount'] = { "lambda" => proc { @global ||= 0; @global += 1; @global.to_s } }
 
     assert_equal '1', @context['callcount.lambda']
     assert_equal '1', @context['callcount.lambda']
@@ -433,11 +425,7 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_lambda_in_array_is_called_once
-    @context['callcount'] = [1, 2, proc {
-                                     @global ||= 0
-                                     @global += 1
-                                     @global.to_s
-                                   }, 4, 5]
+    @context['callcount'] = [1, 2, proc { @global ||= 0; @global += 1; @global.to_s }, 4, 5]
 
     assert_equal '1', @context['callcount[2]']
     assert_equal '1', @context['callcount[2]']
@@ -530,23 +518,15 @@ class ContextUnitTest < Minitest::Test
     registers = {
       my_register: :my_value,
     }
-    super_context = Context.new({}, {}, StaticRegisters.new(registers))
-    super_context.registers[:my_register] = :my_alt_value
+    super_context = Context.new({}, {}, registers)
     subcontext = super_context.new_isolated_subcontext
-    assert_equal :my_value, subcontext.registers[:my_register]
+    assert_nil subcontext.registers[:my_register]
   end
 
   def test_new_isolated_subcontext_inherits_static_registers
-    super_context = Context.build(registers: { my_register: :my_value })
+    super_context = Context.build(static_registers: { my_register: :my_value })
     subcontext = super_context.new_isolated_subcontext
-    assert_equal :my_value, subcontext.registers[:my_register]
-  end
-
-  def test_new_isolated_subcontext_registers_do_not_pollute_context
-    super_context = Context.build(registers: { my_register: :my_value })
-    subcontext = super_context.new_isolated_subcontext
-    subcontext.registers[:my_register] = :my_alt_value
-    assert_equal :my_value, super_context.registers[:my_register]
+    assert_equal :my_value, subcontext.static_registers[:my_register]
   end
 
   def test_new_isolated_subcontext_inherits_filters

test/unit/static_registers_unit_test.rb

@@ -1,248 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class StaticRegistersUnitTest < Minitest::Test
-  include Liquid
-
-  def set
-    static_register = StaticRegisters.new
-    static_register[nil] = true
-    static_register[1] = :one
-    static_register[:one] = "one"
-    static_register["two"] = "three"
-    static_register["two"] = 3
-    static_register[false] = nil
-
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.registers)
-
-    static_register
-  end
-
-  def test_get
-    static_register = set
-
-    assert_equal true, static_register[nil]
-    assert_equal :one, static_register[1]
-    assert_equal "one", static_register[:one]
-    assert_equal 3, static_register["two"]
-    assert_nil static_register[false]
-    assert_nil static_register["unknown"]
-  end
-
-  def test_delete
-    static_register = set
-
-    assert_equal true, static_register.delete(nil)
-    assert_equal :one, static_register.delete(1)
-    assert_equal "one", static_register.delete(:one)
-    assert_equal 3, static_register.delete("two")
-    assert_nil static_register.delete(false)
-    assert_nil static_register.delete("unknown")
-
-    assert_equal({}, static_register.registers)
-  end
-
-  def test_fetch
-    static_register = set
-
-    assert_equal true, static_register.fetch(nil)
-    assert_equal :one, static_register.fetch(1)
-    assert_equal "one", static_register.fetch(:one)
-    assert_equal 3, static_register.fetch("two")
-    assert_nil static_register.fetch(false)
-    assert_nil static_register.fetch("unknown")
-  end
-
-  def test_fetch_default
-    static_register = StaticRegisters.new
-
-    assert_equal true, static_register.fetch(nil, true)
-    assert_equal :one, static_register.fetch(1, :one)
-    assert_equal "one", static_register.fetch(:one, "one")
-    assert_equal 3, static_register.fetch("two", 3)
-    assert_nil static_register.fetch(false, nil)
-  end
-
-  def test_key
-    static_register = set
-
-    assert_equal true, static_register.key?(nil)
-    assert_equal true, static_register.key?(1)
-    assert_equal true, static_register.key?(:one)
-    assert_equal true, static_register.key?("two")
-    assert_equal true, static_register.key?(false)
-    assert_equal false, static_register.key?("unknown")
-    assert_equal false, static_register.key?(true)
-  end
-
-  def set_with_static
-    static_register = StaticRegisters.new(nil => true, 1 => :one, :one => "one", "two" => 3, false => nil)
-    static_register[nil] = false
-    static_register["two"] = 4
-    static_register[true] = "foo"
-
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.static)
-    assert_equal({ nil => false, "two" => 4, true => "foo" }, static_register.registers)
-
-    static_register
-  end
-
-  def test_get_with_static
-    static_register = set_with_static
-
-    assert_equal false, static_register[nil]
-    assert_equal :one, static_register[1]
-    assert_equal "one", static_register[:one]
-    assert_equal 4, static_register["two"]
-    assert_equal "foo", static_register[true]
-    assert_nil static_register[false]
-  end
-
-  def test_delete_with_static
-    static_register = set_with_static
-
-    assert_equal false, static_register.delete(nil)
-    assert_equal 4, static_register.delete("two")
-    assert_equal "foo", static_register.delete(true)
-    assert_nil static_register.delete("unknown")
-    assert_nil static_register.delete(:one)
-
-    assert_equal({}, static_register.registers)
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.static)
-  end
-
-  def test_fetch_with_static
-    static_register = set_with_static
-
-    assert_equal false, static_register.fetch(nil)
-    assert_equal :one, static_register.fetch(1)
-    assert_equal "one", static_register.fetch(:one)
-    assert_equal 4, static_register.fetch("two")
-    assert_equal "foo", static_register.fetch(true)
-    assert_nil static_register.fetch(false)
-  end
-
-  def test_key_with_static
-    static_register = set_with_static
-
-    assert_equal true, static_register.key?(nil)
-    assert_equal true, static_register.key?(1)
-    assert_equal true, static_register.key?(:one)
-    assert_equal true, static_register.key?("two")
-    assert_equal true, static_register.key?(false)
-    assert_equal false, static_register.key?("unknown")
-    assert_equal true, static_register.key?(true)
-  end
-
-  def test_static_register_can_be_frozen
-    static_register = set_with_static
-
-    static = static_register.static.freeze
-
-    assert_raises(RuntimeError) do
-      static["two"] = "foo"
-    end
-
-    assert_raises(RuntimeError) do
-      static["unknown"] = "foo"
-    end
-
-    assert_raises(RuntimeError) do
-      static.delete("two")
-    end
-  end
-
-  def test_new_static_retains_static
-    static_register = StaticRegisters.new(nil => true, 1 => :one, :one => "one", "two" => 3, false => nil)
-    static_register["one"] = 1
-    static_register["two"] = 2
-    static_register["three"] = 3
-
-    new_register = StaticRegisters.new(static_register)
-    assert_equal({}, new_register.registers)
-
-    new_register["one"] = 4
-    new_register["two"] = 5
-    new_register["three"] = 6
-
-    newest_register = StaticRegisters.new(new_register)
-    assert_equal({}, newest_register.registers)
-
-    newest_register["one"] = 7
-    newest_register["two"] = 8
-    newest_register["three"] = 9
-
-    assert_equal({ "one" => 1, "two" => 2, "three" => 3 }, static_register.registers)
-    assert_equal({ "one" => 4, "two" => 5, "three" => 6 }, new_register.registers)
-    assert_equal({ "one" => 7, "two" => 8, "three" => 9 }, newest_register.registers)
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.static)
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, new_register.static)
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, newest_register.static)
-  end
-
-  def test_multiple_instances_are_unique
-    static_register = StaticRegisters.new(nil => true, 1 => :one, :one => "one", "two" => 3, false => nil)
-    static_register["one"] = 1
-    static_register["two"] = 2
-    static_register["three"] = 3
-
-    new_register = StaticRegisters.new(foo: :bar)
-    assert_equal({}, new_register.registers)
-
-    new_register["one"] = 4
-    new_register["two"] = 5
-    new_register["three"] = 6
-
-    newest_register = StaticRegisters.new(bar: :foo)
-    assert_equal({}, newest_register.registers)
-
-    newest_register["one"] = 7
-    newest_register["two"] = 8
-    newest_register["three"] = 9
-
-    assert_equal({ "one" => 1, "two" => 2, "three" => 3 }, static_register.registers)
-    assert_equal({ "one" => 4, "two" => 5, "three" => 6 }, new_register.registers)
-    assert_equal({ "one" => 7, "two" => 8, "three" => 9 }, newest_register.registers)
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.static)
-    assert_equal({ foo: :bar }, new_register.static)
-    assert_equal({ bar: :foo }, newest_register.static)
-  end
-
-  def test_can_update_static_directly_and_updates_all_instances
-    static_register = StaticRegisters.new(nil => true, 1 => :one, :one => "one", "two" => 3, false => nil)
-    static_register["one"] = 1
-    static_register["two"] = 2
-    static_register["three"] = 3
-
-    new_register = StaticRegisters.new(static_register)
-    assert_equal({}, new_register.registers)
-
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.static)
-
-    new_register["one"] = 4
-    new_register["two"] = 5
-    new_register["three"] = 6
-    new_register.static["four"] = 10
-
-    newest_register = StaticRegisters.new(new_register)
-    assert_equal({}, newest_register.registers)
-
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil, "four" => 10 }, new_register.static)
-
-    newest_register["one"] = 7
-    newest_register["two"] = 8
-    newest_register["three"] = 9
-    new_register.static["four"] = 5
-    new_register.static["five"] = 15
-
-    assert_equal({ "one" => 1, "two" => 2, "three" => 3 }, static_register.registers)
-    assert_equal({ "one" => 4, "two" => 5, "three" => 6 }, new_register.registers)
-    assert_equal({ "one" => 7, "two" => 8, "three" => 9 }, newest_register.registers)
-
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil, "four" => 5, "five" => 15 }, newest_register.static)
-
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil, "four" => 5, "five" => 15 }, static_register.static)
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil, "four" => 5, "five" => 15 }, new_register.static)
-  end
-end

test/unit/tokenizer_unit_test.rb

@@ -30,73 +30,12 @@ class TokenizerTest < Minitest::Test
     assert_equal [1, 1, 3], tokenize_line_numbers(" {{\n funk \n}} ")
   end
 
-  def test_tokenize_quirks
-    assert_equal ['{%comment%}'], tokenize('{%comment%}')
-    assert_equal [' ', '{%comment%}', ' '], tokenize(' {%comment%} ')
-
-    assert_equal [' ', '{%comment%}', ' ', '{%endcomment%}', ' '], tokenize(' {%comment%} {%endcomment%} ')
-    assert_equal ['  ', '{% "{% comment" %}', ' ', '{% endcomment %}', ' '], tokenize('  {% "{% comment" %} {% endcomment %} ')
-    assert_equal ['  ', '{% "{% comment %}" %}', ' ', '{% endcomment %}', ' '], tokenize('  {% "{% comment %}" %} {% endcomment %} ')
-    assert_equal ['  ', '{% "comment %}" %}', ' ', '{% endcomment %}', ' '], tokenize('  {% "comment %}" %} {% endcomment %} ')
-    assert_equal ['  ', '{% "{{ comment" %}', ' ', '{% endcomment %}', ' '], tokenize('  {% "{{ comment" %} {% endcomment %} ')
-    assert_equal ['  ', '{% "{{ comment }}" %}', ' ', '{% endcomment %}', ' '], tokenize('  {% "{{ comment }}" %} {% endcomment %} ')
-    assert_equal ['  ', '{% "comment }}" %}', ' ', '{% endcomment %}', ' '], tokenize('  {% "comment }}" %} {% endcomment %} ')
-    assert_equal ['  ', '{% "comment }" %}', ' ', '{% endcomment %}', ' '], tokenize('  {% "comment }" %} {% endcomment %} ')
-
-    assert_equal [" ", "{%comment%}", " ", "{%endcomment%}", " "], tokenize(" {%comment%} {%endcomment%} ")
-    assert_equal ["  ", "{% '{% comment' %}", " ", "{% endcomment %}", " "], tokenize("  {% '{% comment' %} {% endcomment %} ")
-    assert_equal ["  ", "{% '{% comment %}' %}", " ", "{% endcomment %}", " "], tokenize("  {% '{% comment %}' %} {% endcomment %} ")
-    assert_equal ["  ", "{% 'comment %}' %}", " ", "{% endcomment %}", " "], tokenize("  {% 'comment %}' %} {% endcomment %} ")
-    assert_equal ["  ", "{% '{{ comment' %}", " ", "{% endcomment %}", " "], tokenize("  {% '{{ comment' %} {% endcomment %} ")
-    assert_equal ["  ", "{% '{{ comment }}' %}", " ", "{% endcomment %}", " "], tokenize("  {% '{{ comment }}' %} {% endcomment %} ")
-    assert_equal ["  ", "{% 'comment }}' %}", " ", "{% endcomment %}", " "], tokenize("  {% 'comment }}' %} {% endcomment %} ")
-    assert_equal ["  ", "{% 'comment }' %}", " ", "{% endcomment %}", " "], tokenize("  {% 'comment }' %} {% endcomment %} ")
-
-    assert_equal [' ', '{{comment}}', ' ', '{{endcomment}}', ' '], tokenize(' {{comment}} {{endcomment}} ')
-    assert_equal ['  ', '{{ "{{ comment" }}', ' ', '{{ endcomment }}', ' '], tokenize('  {{ "{{ comment" }} {{ endcomment }} ')
-    assert_equal ['  ', '{{ "{{ comment }}" }}', ' ', '{{ endcomment }}', ' '], tokenize('  {{ "{{ comment }}" }} {{ endcomment }} ')
-    assert_equal ['  ', '{{ "comment }}" }}', ' ', '{{ endcomment }}', ' '], tokenize('  {{ "comment }}" }} {{ endcomment }} ')
-    assert_equal ['  ', '{{ "{{ comment" }}', ' ', '{{ endcomment }}', ' '], tokenize('  {{ "{{ comment" }} {{ endcomment }} ')
-    assert_equal ['  ', '{{ "{{ comment }}" }}', ' ', '{{ endcomment }}', ' '], tokenize('  {{ "{{ comment }}" }} {{ endcomment }} ')
-    assert_equal ['  ', '{{ "comment }}" }}', ' ', '{{ endcomment }}', ' '], tokenize('  {{ "comment }}" }} {{ endcomment }} ')
-    assert_equal ['  ', '{{ "comment }" }}', ' ', '{{ endcomment }}', ' '], tokenize('  {{ "comment }" }} {{ endcomment }} ')
-
-    assert_equal [" ", "{{comment}}", " ", "{{endcomment}}", " "], tokenize(" {{comment}} {{endcomment}} ")
-    assert_equal ["  ", "{{ '{% comment' }}", " ", "{{ endcomment }}", " "], tokenize("  {{ '{% comment' }} {{ endcomment }} ")
-    assert_equal ["  ", "{{ '{% comment }}' }}", " ", "{{ endcomment }}", " "], tokenize("  {{ '{% comment }}' }} {{ endcomment }} ")
-    assert_equal ["  ", "{{ 'comment }}' }}", " ", "{{ endcomment }}", " "], tokenize("  {{ 'comment }}' }} {{ endcomment }} ")
-    assert_equal ["  ", "{{ '{{ comment' }}", " ", "{{ endcomment }}", " "], tokenize("  {{ '{{ comment' }} {{ endcomment }} ")
-    assert_equal ["  ", "{{ '{{ comment }}' }}", " ", "{{ endcomment }}", " "], tokenize("  {{ '{{ comment }}' }} {{ endcomment }} ")
-    assert_equal ["  ", "{{ 'comment }}' }}", " ", "{{ endcomment }}", " "], tokenize("  {{ 'comment }}' }} {{ endcomment }} ")
-    assert_equal ["  ", "{{ 'comment }' }}", " ", "{{ endcomment }}", " "], tokenize("  {{ 'comment }' }} {{ endcomment }} ")
-
-    assert_equal [' ', '{{comment}', ' ', '{{endcomment}', ' '], tokenize(' {{comment} {{endcomment} ')
-    assert_equal ['  ', '{{ "{% comment" }', ' ', '{{ endcomment }', ' '], tokenize('  {{ "{% comment" } {{ endcomment } ')
-    assert_equal ['  ', '{{ "{% comment }" }', ' ', '{{ endcomment }', ' '], tokenize('  {{ "{% comment }" } {{ endcomment } ')
-    assert_equal ['  ', '{{ "comment }" }', ' ', '{{ endcomment }', ' '], tokenize('  {{ "comment }" } {{ endcomment } ')
-    assert_equal ['  ', '{{ "{{ comment" }', ' ', '{{ endcomment }', ' '], tokenize('  {{ "{{ comment" } {{ endcomment } ')
-    assert_equal ['  ', '{{ "{{ comment }}" }', ' ', '{{ endcomment }', ' '], tokenize('  {{ "{{ comment }}" } {{ endcomment } ')
-    assert_equal ['  ', '{{ "comment }}" }', ' ', '{{ endcomment }', ' '], tokenize('  {{ "comment }}" } {{ endcomment } ')
-    assert_equal ['  ', '{{ "comment }" }', ' ', '{{ endcomment }', ' '], tokenize('  {{ "comment }" } {{ endcomment } ')
-
-    assert_equal [" ", "{{comment}", " ", "{{endcomment}", " "], tokenize(" {{comment} {{endcomment} ")
-    assert_equal ["  ", "{{ '{{ comment' }", " ", "{{ endcomment }", " "], tokenize("  {{ '{{ comment' } {{ endcomment } ")
-    assert_equal ["  ", "{{ '{{ comment }' }", " ", "{{ endcomment }", " "], tokenize("  {{ '{{ comment }' } {{ endcomment } ")
-    assert_equal ["  ", "{{ 'comment }' }", " ", "{{ endcomment }", " "], tokenize("  {{ 'comment }' } {{ endcomment } ")
-    assert_equal ["  ", "{{ '{{ comment' }", " ", "{{ endcomment }", " "], tokenize("  {{ '{{ comment' } {{ endcomment } ")
-    assert_equal ["  ", "{{ '{{ comment }}' }", " ", "{{ endcomment }", " "], tokenize("  {{ '{{ comment }}' } {{ endcomment } ")
-    assert_equal ["  ", "{{ 'comment }}' }", " ", "{{ endcomment }", " "], tokenize("  {{ 'comment }}' } {{ endcomment } ")
-    assert_equal ["  ", "{{ 'comment }' }", " ", "{{ endcomment }", " "], tokenize("  {{ 'comment }' } {{ endcomment } ")
-
-    assert_equal ['{{funk | replace: "}", \'}}\' }}'], tokenize('{{funk | replace: "}", \'}}\' }}')
-  end
-
   private
 
   def tokenize(source)
     tokenizer = Liquid::Tokenizer.new(source)
     tokens = []
-    while (t = tokenizer.shift)
+    while t = tokenizer.shift
       tokens << t
     end
     tokens

test/unit/variable_unit_test.rb

@@ -156,12 +156,6 @@ class VariableUnitTest < Minitest::Test
     assert_equal ['b', 'c'], lookup.lookups
   end
 
-  def test_filters_with_properly_quoted_curlies
-    var = create_variable("hello | replace: \"}\", '}}'")
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['replace', ['}', '}}']]], var.filters
-  end
-
   private
 
   def create_variable(markup, options = {})