Reserve future support for comment line before a tag name

.rubocop.yml

@@ -1,7 +1,5 @@
-inherit_gem:
-  rubocop-shopify: rubocop.yml
-
 inherit_from:
+  - 'https://shopify.github.io/ruby-style-guide/rubocop.yml'
   - .rubocop_todo.yml
 
 require: rubocop-performance
@@ -10,7 +8,7 @@ Performance:
   Enabled: true
 
 AllCops:
-  TargetRubyVersion: 2.5
+  TargetRubyVersion: 2.4
   NewCops: disable
   Exclude:
     - 'vendor/bundle/**/*'
@@ -18,7 +16,3 @@ AllCops:
 Naming/MethodName:
   Exclude:
     - 'example/server/liquid_servlet.rb'
-
-# Backport https://github.com/Shopify/ruby-style-guide/pull/258
-Layout/BeginEndAlignment:
-  Enabled: true

CONTRIBUTING.md

@@ -5,7 +5,6 @@
 * Bugfixes
 * Performance improvements
 * Features that are likely to be useful to the majority of Liquid users
-* Documentation updates that are concise and likely to be useful to the majority of Liquid users
 
 ## Things we won't merge
 
@@ -15,14 +14,12 @@
 * Features that can easily be implemented on top of Liquid (for example as a custom filter or custom filesystem)
 * Code that does not include tests
 * Code that breaks existing tests
-* Documentation changes that are verbose, incorrect or not important to most people (we want to keep it simple and easy to understand)
 
 ## Workflow
 
-* [Sign the CLA](https://cla.shopify.com/) if you haven't already
 * Fork the Liquid repository
 * Create a new branch in your fork
-  * For updating [Liquid documentation](https://shopify.github.io/liquid/), create it from `gh-pages` branch. (You can skip tests.)
 * If it makes sense, add tests for your code and/or run a performance benchmark
 * Make sure all tests pass (`bundle exec rake`)
 * Create a pull request
+

Gemfile

@@ -19,10 +19,9 @@ end
 
 group :test do
   gem 'rubocop', '~> 1.4', require: false
-  gem 'rubocop-shopify', '~> 1.0.7', require: false
   gem 'rubocop-performance', require: false
 
   platform :mri, :truffleruby do
-    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'master'
+    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'inline-comment'
   end
 end

History.md

@@ -1,25 +1,9 @@
 # Liquid Change Log
 
-## 5.1.0 / 2021-09-09
+## Unreleased
 
 ### Features
-* Add `base64_encode`, `base64_decode`, `base64_url_safe_encode`, and `base64_url_safe_decode` filters (#1450) [Daniel Insley]
-* Introduce `to_liquid_value` in `Liquid::Drop` (#1441) [Michael Go]
-
-### Fixes
-* Fix support for using a String subclass for the liquid source (#1421) [Dylan Thacker-Smith]
-* Add `ParseTreeVisitor` to `RangeLookup` (#1470) [CP Clermont]
-* Translate `RangeError` to `Liquid::Error` for `truncatewords` with large int (#1431) [Dylan Thacker-Smith]
-
-## 5.0.1 / 2021-03-24
-
-### Fixes
-* Add ParseTreeVisitor to Echo tag (#1414) [CP Clermont]
-* Test with ruby 3.0 as the latest ruby version (#1398) [Dylan Thacker-Smith]
-* Handle carriage return in newlines_to_br (#1391) [Unending]
-
-### Performance Improvements
-* Use split limit in truncatewords (#1361) [Dylan Thacker-Smith]
+* Allow `#` to be used as an inline comment tag (#1401) [Dylan Thacker-Smith]
 
 ## 5.0.0 / 2021-01-06
 

lib/liquid/block_body.rb

@@ -4,8 +4,8 @@ require 'English'
 
 module Liquid
   class BlockBody
-    LiquidTagToken      = /\A\s*(\w+)\s*(.*?)\z/o
-    FullToken           = /\A#{TagStart}#{WhitespaceControl}?(\s*)(\w+)(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
+    LiquidTagToken      = /\A\s*(\w+|#)\s*(.*?)\z/o
+    FullToken           = /\A#{TagStart}#{WhitespaceControl}?(\s*)(\w+|#)(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
     ContentOfVariable   = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
     WhitespaceOrNothing = /\A\s*\z/
     TAGSTART            = "{%"

lib/liquid/condition.rb

@@ -8,7 +8,7 @@ module Liquid
   #   c = Condition.new(1, '==', 1)
   #   c.evaluate #=> true
   #
-  class Condition # :nodoc:
+  class Condition #:nodoc:
     @@operators = {
       '==' => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
       '!=' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
@@ -134,8 +134,8 @@ module Liquid
       # return this as the result.
       return context.evaluate(left) if op.nil?
 
-      left  = Liquid::Utils.to_liquid_value(context.evaluate(left))
-      right = Liquid::Utils.to_liquid_value(context.evaluate(right))
+      left  = context.evaluate(left)
+      right = context.evaluate(right)
 
       operation = self.class.operators[op] || raise(Liquid::ArgumentError, "Unknown operator #{op}")
 

lib/liquid/context.rb

@@ -124,7 +124,7 @@ module Liquid
     #      context['var'] = 'hi'
     #   end
     #
-    #   context['var']  #=> nil
+    #   context['var]  #=> nil
     def stack(new_scope = {})
       push(new_scope)
       yield

lib/liquid/locales/en.yml

@@ -22,6 +22,7 @@
       tag_never_closed: "'%{block_name}' tag was never closed"
       table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
       render: "Syntax error in tag 'render' - Template name must be a quoted string"
+      inline_comment_invalid: "Syntax error in tag '#' - Each line of comments must be prefixed by the '#' character"
     argument:
       include: "Argument error in tag 'include' - Illegal template name"
     disabled:

lib/liquid/range_lookup.rb

@@ -12,8 +12,6 @@ module Liquid
       end
     end
 
-    attr_reader :start_obj, :end_obj
-
     def initialize(start_obj, end_obj)
       @start_obj = start_obj
       @end_obj   = end_obj
@@ -37,11 +35,5 @@ module Liquid
         Utils.to_integer(input)
       end
     end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [@node.start_obj, @node.end_obj]
-      end
-    end
   end
 end

lib/liquid/standardfilters.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
 require 'cgi'
-require 'base64'
 require 'bigdecimal'
 
 module Liquid
   module StandardFilters
-    MAX_INT = (1 << 31) - 1
     HTML_ESCAPE = {
       '&' => '&amp;',
       '>' => '&gt;',
@@ -64,26 +62,6 @@ module Liquid
       result
     end
 
-    def base64_encode(input)
-      Base64.strict_encode64(input.to_s)
-    end
-
-    def base64_decode(input)
-      Base64.strict_decode64(input.to_s)
-    rescue ::ArgumentError
-      raise Liquid::ArgumentError, "invalid base64 provided to base64_decode"
-    end
-
-    def base64_url_safe_encode(input)
-      Base64.urlsafe_encode64(input.to_s)
-    end
-
-    def base64_url_safe_decode(input)
-      Base64.urlsafe_decode64(input.to_s)
-    rescue ::ArgumentError
-      raise Liquid::ArgumentError, "invalid base64 provided to base64_url_safe_decode"
-    end
-
     def slice(input, offset, length = nil)
       offset = Utils.to_integer(offset)
       length = length ? Utils.to_integer(length) : 1
@@ -115,13 +93,7 @@ module Liquid
       words = Utils.to_integer(words)
       words = 1 if words <= 0
 
-      wordlist = begin
-        input.split(" ", words + 1)
-      rescue RangeError
-        raise if words + 1 < MAX_INT
-        # e.g. integer #{words} too big to convert to `int'
-        raise Liquid::ArgumentError, "integer #{words} too big for truncatewords"
-      end
+      wordlist = input.split(" ", words + 1)
       return input if wordlist.length <= words
 
       wordlist.pop
@@ -468,7 +440,7 @@ module Liquid
     #
     def default(input, default_value = '', options = {})
       options = {} unless options.is_a?(Hash)
-      false_check = options['allow_false'] ? input.nil? : !Liquid::Utils.to_liquid_value(input)
+      false_check = options['allow_false'] ? input.nil? : !input
       false_check || (input.respond_to?(:empty?) && input.empty?) ? default_value : input
     end
 

lib/liquid/tags/case.rb

@@ -52,14 +52,7 @@ module Liquid
       @blocks.each do |block|
         if block.else?
           block.attachment.render_to_output_buffer(context, output) if execute_else_block
-          next
-        end
-
-        result = Liquid::Utils.to_liquid_value(
-          block.evaluate(context)
-        )
-
-        if result
+        elsif block.evaluate(context)
           execute_else_block = false
           block.attachment.render_to_output_buffer(context, output)
         end

lib/liquid/tags/comment.rb

@@ -2,19 +2,6 @@
 
 module Liquid
   class Comment < Block
-    # Potential fix
-    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}#{WhitespaceControl}?\s*(\w+)\s*(.*)?#{WhitespaceControl}?#{TagEnd}\z/om
-
-    def parse(tokens)
-      while (token = tokens.shift)
-        if token =~ FullTokenPossiblyInvalid && block_delimiter == Regexp.last_match(2)
-          return
-        end
-      end
-
-      raise_tag_never_closed(block_name)
-    end
-
     def render_to_output_buffer(_context, output)
       output
     end

lib/liquid/tags/echo.rb

@@ -12,26 +12,14 @@ module Liquid
   #   {% echo user | link %}
   #
   class Echo < Tag
-    attr_reader :variable
-
     def initialize(tag_name, markup, parse_context)
-      puts "Initializing Echo tag"
       super
       @variable = Variable.new(markup, parse_context)
     end
 
     def render(context)
-      puts "Render Echo tag"
       @variable.render_to_output_buffer(context, +'')
     end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      puts "ParseTreeVisitor Echo tag"
-
-      def children
-        [@node.variable]
-      end
-    end
   end
 
   Template.register_tag('echo', Echo)

lib/liquid/tags/if.rb

@@ -50,11 +50,7 @@ module Liquid
 
     def render_to_output_buffer(context, output)
       @blocks.each do |block|
-        result = Liquid::Utils.to_liquid_value(
-          block.evaluate(context)
-        )
-
-        if result
+        if block.evaluate(context)
           return block.attachment.render_to_output_buffer(context, output)
         end
       end

lib/liquid/tags/inline_comment.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Liquid
+  class InlineComment < Tag
+    def initialize(tag_name, markup, options)
+      super
+      # Semantically, a comment should only ignore everything after it on the line.
+      # Currently, this implementation doesn't support mixing a comment with another tag
+      # but we need to reserve future support for this.
+      if markup.match?(/\n\s*[^#]/)
+        raise SyntaxError, options[:locale].t("errors.syntax.inline_comment_invalid")
+      end
+    end
+
+    def render_to_output_buffer(_context, output)
+      output
+    end
+
+    def blank?
+      true
+    end
+  end
+
+  Template.register_tag('#', InlineComment)
+end

lib/liquid/tags/unless.rb

@@ -11,21 +11,13 @@ module Liquid
     def render_to_output_buffer(context, output)
       # First condition is interpreted backwards ( if not )
       first_block = @blocks.first
-      result = Liquid::Utils.to_liquid_value(
-        first_block.evaluate(context)
-      )
-
-      unless result
+      unless first_block.evaluate(context)
         return first_block.attachment.render_to_output_buffer(context, output)
       end
 
       # After the first condition unless works just like if
       @blocks[1..-1].each do |block|
-        result = Liquid::Utils.to_liquid_value(
-          block.evaluate(context)
-        )
-
-        if result
+        if block.evaluate(context)
           return block.attachment.render_to_output_buffer(context, output)
         end
       end

lib/liquid/tokenizer.rb

@@ -5,7 +5,7 @@ module Liquid
     attr_reader :line_number, :for_liquid_tag
 
     def initialize(source, line_numbers = false, line_number: nil, for_liquid_tag: false)
-      @source         = source.to_s.to_str
+      @source         = source
       @line_number    = line_number || (line_numbers ? 1 : nil)
       @for_liquid_tag = for_liquid_tag
       @tokens         = tokenize
@@ -24,7 +24,7 @@ module Liquid
     private
 
     def tokenize
-      return [] if @source.empty?
+      return [] if @source.to_s.empty?
 
       return @source.split("\n") if @for_liquid_tag
 

lib/liquid/utils.rb

@@ -81,13 +81,5 @@ module Liquid
     rescue ::ArgumentError
       nil
     end
-
-    def self.to_liquid_value(obj)
-      # Enable "obj" to represent itself as a primitive value like integer, string, or boolean
-      return obj.to_liquid_value if obj.respond_to?(:to_liquid_value)
-
-      # Otherwise return the object itself
-      obj
-    end
   end
 end

lib/liquid/variable_lookup.rb

@@ -40,9 +40,6 @@ module Liquid
       @lookups.each_index do |i|
         key = context.evaluate(@lookups[i])
 
-        # Cast "key" to its liquid value to enable it to act as a primitive value
-        key = Liquid::Utils.to_liquid_value(key)
-
         # If object is a hash- or array-like object we look for the
         # presence of the key and if its available we return it
         if object.respond_to?(:[]) &&

lib/liquid/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Liquid
-  VERSION = "5.1.0"
+  VERSION = "5.0.0"
 end

performance/shopify/database.rb

@@ -3,19 +3,11 @@
 require 'yaml'
 
 module Database
-  DATABASE_FILE_PATH = "#{__dir__}/vision.database.yml"
-
   # Load the standard vision toolkit database and re-arrage it to be simply exportable
   # to liquid as assigns. All this is based on Shopify
   def self.tables
     @tables ||= begin
-      db =
-        if YAML.respond_to?(:unsafe_load_file) # Only Psych 4+ can use unsafe_load_file
-          # unsafe_load_file is needed for YAML references
-          YAML.unsafe_load_file(DATABASE_FILE_PATH)
-        else
-          YAML.load_file(DATABASE_FILE_PATH)
-        end
+      db = YAML.load_file("#{__dir__}/vision.database.yml")
 
       # From vision source
       db['products'].each do |product|

test/integration/standard_filter_test.rb

@@ -145,40 +145,6 @@ class StandardFiltersTest < Minitest::Test
     assert_equal('&lt;strong&gt;Hulk&lt;/strong&gt;', @filters.escape_once('&lt;strong&gt;Hulk</strong>'))
   end
 
-  def test_base64_encode
-    assert_equal('b25lIHR3byB0aHJlZQ==', @filters.base64_encode('one two three'))
-    assert_equal('', @filters.base64_encode(nil))
-  end
-
-  def test_base64_decode
-    assert_equal('one two three', @filters.base64_decode('b25lIHR3byB0aHJlZQ=='))
-
-    exception = assert_raises(Liquid::ArgumentError) do
-      @filters.base64_decode("invalidbase64")
-    end
-
-    assert_equal('Liquid error: invalid base64 provided to base64_decode', exception.message)
-  end
-
-  def test_base64_url_safe_encode
-    assert_equal(
-      'YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXogQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVogMTIzNDU2Nzg5MCAhQCMkJV4mKigpLT1fKy8_Ljo7W117fVx8',
-      @filters.base64_url_safe_encode('abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 !@#$%^&*()-=_+/?.:;[]{}\|')
-    )
-    assert_equal('', @filters.base64_url_safe_encode(nil))
-  end
-
-  def test_base64_url_safe_decode
-    assert_equal(
-      'abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 !@#$%^&*()-=_+/?.:;[]{}\|',
-      @filters.base64_url_safe_decode('YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXogQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVogMTIzNDU2Nzg5MCAhQCMkJV4mKigpLT1fKy8_Ljo7W117fVx8')
-    )
-    exception = assert_raises(Liquid::ArgumentError) do
-      @filters.base64_url_safe_decode("invalidbase64")
-    end
-    assert_equal('Liquid error: invalid base64 provided to base64_url_safe_decode', exception.message)
-  end
-
   def test_url_encode
     assert_equal('foo%2B1%40example.com', @filters.url_encode('[email protected]'))
     assert_equal('1', @filters.url_encode(1))
@@ -205,17 +171,13 @@ class StandardFiltersTest < Minitest::Test
     assert_equal('one two three', @filters.truncatewords('one two three'))
     assert_equal(
       'Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221;...',
-      @filters.truncatewords('Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221; x 16&#8221; x 10.5&#8221; high) with cover.', 15)
+        @filters.truncatewords('Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221; x 16&#8221; x 10.5&#8221; high) with cover.', 15)
     )
     assert_equal("测试测试测试测试", @filters.truncatewords('测试测试测试测试', 5))
     assert_equal('one two1', @filters.truncatewords("one two three", 2, 1))
     assert_equal('one two three...', @filters.truncatewords("one  two\tthree\nfour", 3))
     assert_equal('one two...', @filters.truncatewords("one two three four", 2))
     assert_equal('one...', @filters.truncatewords("one two three four", 0))
-    exception = assert_raises(Liquid::ArgumentError) do
-      @filters.truncatewords("one two three four", 1 << 31)
-    end
-    assert_equal("Liquid error: integer #{1 << 31} too big for truncatewords", exception.message)
   end
 
   def test_strip_html
@@ -728,8 +690,6 @@ class StandardFiltersTest < Minitest::Test
     assert_equal("bar", @filters.default([], "bar"))
     assert_equal("bar", @filters.default({}, "bar"))
     assert_template_result('bar', "{{ false | default: 'bar' }}")
-    assert_template_result('bar', "{{ drop | default: 'bar' }}", 'drop' => BooleanDrop.new(false))
-    assert_template_result('Yay', "{{ drop | default: 'bar' }}", 'drop' => BooleanDrop.new(true))
   end
 
   def test_default_handle_false
@@ -740,8 +700,6 @@ class StandardFiltersTest < Minitest::Test
     assert_equal("bar", @filters.default([], "bar", "allow_false" => true))
     assert_equal("bar", @filters.default({}, "bar", "allow_false" => true))
     assert_template_result('false', "{{ false | default: 'bar', allow_false: true }}")
-    assert_template_result('Nay', "{{ drop | default: 'bar', allow_false: true }}", 'drop' => BooleanDrop.new(false))
-    assert_template_result('Yay', "{{ drop | default: 'bar', allow_false: true }}", 'drop' => BooleanDrop.new(true))
   end
 
   def test_cannot_access_private_methods
@@ -770,18 +728,6 @@ class StandardFiltersTest < Minitest::Test
     assert_equal(expectation, @filters.where(input, "ok"))
   end
 
-  def test_where_string_keys
-    input = [
-      "alpha", "beta", "gamma", "delta"
-    ]
-
-    expectation = [
-      "beta",
-    ]
-
-    assert_equal(expectation, @filters.where(input, "be"))
-  end
-
   def test_where_no_key_set
     input = [
       { "handle" => "alpha", "ok" => true },

test/integration/tags/comment_tag_test.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class CommentTagTest < Minitest::Test
-  include Liquid
-
-  def test_single_line_comments_parse
-    assert_template_result('Before comment', <<~LIQUID)
-      Before comment
-      {%- comment -%}
-        Regular text comment
-        Liquid in comment: {% echo 'Hi from comment' %}
-      {%- endcomment -%}
-    LIQUID
-  end
-
-  def test_multi_line_comments_parse
-    assert_template_result('Before comment', <<~LIQUID)
-      Before comment
-      {%- comment -%} Regular text comment {%- endcomment -%}
-      {%- comment -%} Liquid in comment: {% echo 'Hi from comment' %} {%- endcomment -%}
-    LIQUID
-  end
-end # CommentTagTest

test/integration/tags/include_tag_test.rb

@@ -96,12 +96,12 @@ class IncludeTagTest < Minitest::Test
 
   def test_include_tag_with_alias
     assert_template_result("Product: Draft 151cm ",
-      "{% include 'product_alias' with products[0] as product %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
+                           "{% include 'product_alias' with products[0] as product %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
   end
 
   def test_include_tag_for_alias
     assert_template_result("Product: Draft 151cm Product: Element 155cm ",
-      "{% include 'product_alias' for products as product %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
+                           "{% include 'product_alias' for products as product %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
   end
 
   def test_include_tag_with_default_name

test/integration/tags/inline_comment_test.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class InlineCommentTest < Minitest::Test
+  include Liquid
+
+  def test_tag_in_different_styles
+    assert_template_result('', '{% # This text gets ignored %}')
+    assert_template_result('', '{%# This text gets ignored #%}')
+    assert_template_result('', '{%# This text gets ignored %}')
+    assert_template_result('', '{%#- This text gets ignored -#%}')
+  end
+
+  def test_test_syntax_error
+    assert_template_result('fail', '{% #This doesnt work %}')
+
+    assert false 
+  rescue 
+    # ok good
+  end
+
+  def test_tag_ws_stripping
+    assert_template_result('', '   {%#- This text gets ignored -#%}    ')
+  end
+
+  def test_comment_inline_tag
+    assert_template_result('ok', '{% echo "ok" # output something from a tag %}')
+  end
+
+  def test_comment_line_before_tag
+    assert_template_result('ok', '{% # this sort of comment also
+      echo "ok" %}')
+  end
+
+  def test_comment_inline_variable
+    assert_template_result('ok', '{{ "ok" # output something from a variable }}')
+    assert_template_result('ok', '{{ "OK" | downcase # output something from a variable }}')
+  end
+
+  def test_inside_liquid_tag
+    source = <<~LIQUID
+      {%- liquid
+        echo "before("
+        # This text gets ignored
+        echo ")after"
+      -%}
+    LIQUID
+    assert_template_result('before()after', source)
+  end
+
+  def test_multiline
+    assert_template_result('', '{% # this sort of comment also
+      # will just work, because it parses
+      # as a single call to the "#" tag %}')   
+
+  end
+
+end

test/integration/tags/render_tag_test.rb

@@ -151,7 +151,7 @@ class RenderTagTest < Minitest::Test
     )
 
     assert_template_result("Product: Draft 151cm ",
-      "{% render 'product' with products[0] %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
+                           "{% render 'product' with products[0] %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
   end
 
   def test_render_tag_with_alias
@@ -161,7 +161,7 @@ class RenderTagTest < Minitest::Test
     )
 
     assert_template_result("Product: Draft 151cm ",
-      "{% render 'product_alias' with products[0] as product %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
+                           "{% render 'product_alias' with products[0] as product %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
   end
 
   def test_render_tag_for_alias
@@ -171,7 +171,7 @@ class RenderTagTest < Minitest::Test
     )
 
     assert_template_result("Product: Draft 151cm Product: Element 155cm ",
-      "{% render 'product_alias' for products as product %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
+                           "{% render 'product_alias' for products as product %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
   end
 
   def test_render_tag_for
@@ -181,7 +181,7 @@ class RenderTagTest < Minitest::Test
     )
 
     assert_template_result("Product: Draft 151cm Product: Element 155cm ",
-      "{% render 'product' for products %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
+                           "{% render 'product' for products %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
   end
 
   def test_render_tag_forloop
@@ -190,7 +190,7 @@ class RenderTagTest < Minitest::Test
     )
 
     assert_template_result("Product: Draft 151cm first  index:1 Product: Element 155cm  last index:2 ",
-      "{% render 'product' for products %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
+                           "{% render 'product' for products %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
   end
 
   def test_render_tag_for_drop
@@ -199,7 +199,7 @@ class RenderTagTest < Minitest::Test
     )
 
     assert_template_result("123",
-      "{% render 'loop' for loop as value %}", "loop" => TestEnumerable.new)
+                           "{% render 'loop' for loop as value %}", "loop" => TestEnumerable.new)
   end
 
   def test_render_tag_with_drop
@@ -208,6 +208,6 @@ class RenderTagTest < Minitest::Test
     )
 
     assert_template_result("TestEnumerable",
-      "{% render 'loop' with loop as value %}", "loop" => TestEnumerable.new)
+                           "{% render 'loop' with loop as value %}", "loop" => TestEnumerable.new)
   end
 end

test/integration/template_test.rb

@@ -323,18 +323,4 @@ class TemplateTest < Minitest::Test
     result = t.render('x' => 1, 'y' => 5)
     assert_equal('12345', result)
   end
-
-  def test_source_string_subclass
-    string_subclass = Class.new(String) do
-      # E.g. ActiveSupport::SafeBuffer does this, so don't just rely on to_s to return a String
-      def to_s
-        self
-      end
-    end
-    source = string_subclass.new("{% assign x = 2 -%} x= {{- x }}")
-    assert_instance_of(string_subclass, source)
-    output = Template.parse(source).render!
-    assert_equal("x=2", output)
-    assert_instance_of(String, output)
-  end
 end

test/integration/variable_test.rb

@@ -15,33 +15,6 @@ class VariableTest < Minitest::Test
     assert_template_result('foobar', '{{ foo }}', 'foo' => ThingWithToLiquid.new)
   end
 
-  def test_variable_lookup_calls_to_liquid_value
-    assert_template_result('1', '{{ foo }}', 'foo' => IntegerDrop.new('1'))
-    assert_template_result('2', '{{ list[foo] }}', 'foo' => IntegerDrop.new('1'), 'list' => [1, 2, 3])
-    assert_template_result('one', '{{ list[foo] }}', 'foo' => IntegerDrop.new('1'), 'list' => { 1 => 'one' })
-    assert_template_result('Yay', '{{ foo }}', 'foo' => BooleanDrop.new(true))
-    assert_template_result('YAY', '{{ foo | upcase }}', 'foo' => BooleanDrop.new(true))
-  end
-
-  def test_if_tag_calls_to_liquid_value
-    assert_template_result('one', '{% if foo == 1 %}one{% endif %}', 'foo' => IntegerDrop.new('1'))
-    assert_template_result('one', '{% if 0 < foo %}one{% endif %}', 'foo' => IntegerDrop.new('1'))
-    assert_template_result('one', '{% if foo > 0 %}one{% endif %}', 'foo' => IntegerDrop.new('1'))
-    assert_template_result('true', '{% if foo == true %}true{% endif %}', 'foo' => BooleanDrop.new(true))
-    assert_template_result('true', '{% if foo %}true{% endif %}', 'foo' => BooleanDrop.new(true))
-
-    assert_template_result('', '{% if foo %}true{% endif %}', 'foo' => BooleanDrop.new(false))
-    assert_template_result('', '{% if foo == true %}True{% endif %}', 'foo' => BooleanDrop.new(false))
-  end
-
-  def test_unless_tag_calls_to_liquid_value
-    assert_template_result('', '{% unless foo %}true{% endunless %}', 'foo' => BooleanDrop.new(true))
-  end
-
-  def test_case_tag_calls_to_liquid_value
-    assert_template_result('One', '{% case foo %}{% when 1 %}One{% endcase %}', 'foo' => IntegerDrop.new('1'))
-  end
-
   def test_simple_with_whitespaces
     template = Template.parse(%(  {{ test }}  ))
     assert_equal('  worked  ', template.render!('test' => 'worked'))
@@ -131,8 +104,4 @@ class VariableTest < Minitest::Test
   def test_dynamic_find_var
     assert_template_result('bar', '{{ [key] }}', 'key' => 'foo', 'foo' => 'bar')
   end
-
-  def test_raw_value_variable
-    assert_template_result('bar', '{{ [key] }}', 'key' => 'foo', 'foo' => 'bar')
-  end
 end

test/test_helper.rb

@@ -119,44 +119,6 @@ class ThingWithToLiquid
   end
 end
 
-class IntegerDrop < Liquid::Drop
-  def initialize(value)
-    super()
-    @value = value.to_i
-  end
-
-  def ==(other)
-    @value == other
-  end
-
-  def to_s
-    @value.to_s
-  end
-
-  def to_liquid_value
-    @value
-  end
-end
-
-class BooleanDrop < Liquid::Drop
-  def initialize(value)
-    super()
-    @value = value
-  end
-
-  def ==(other)
-    @value == other
-  end
-
-  def to_liquid_value
-    @value
-  end
-
-  def to_s
-    @value ? "Yay" : "Nay"
-  end
-end
-
 class ErrorDrop < Liquid::Drop
   def standard_error
     raise Liquid::StandardError, 'standard error'

test/unit/parse_tree_visitor_test.rb

@@ -26,13 +26,6 @@ class ParseTreeVisitorTest < Minitest::Test
     )
   end
 
-  def test_echo
-    assert_equal(
-      ["test"],
-      visit(%({% echo test %}))
-    )
-  end
-
   def test_if_condition
     assert_equal(
       ["test"],
@@ -159,13 +152,6 @@ class ParseTreeVisitorTest < Minitest::Test
     )
   end
 
-  def test_for_range
-    assert_equal(
-      ["test"],
-      visit(%({% for x in (1..test) %}{% endfor %}))
-    )
-  end
-
   def test_tablerow_in
     assert_equal(
       ["test"],