rubocop

Co-authored-by: Dylan Thacker-Smith <[email protected]>

.github/workflows/liquid.yml

@@ -1,10 +1,5 @@
 name: Liquid
 on: [push, pull_request]
-
-env:
-  BUNDLE_JOBS: 4
-  BUNDLE_RETRY: 3
-
 jobs:
   test:
     runs-on: ubuntu-latest
@@ -12,18 +7,22 @@ jobs:
       matrix:
         entry:
           - { ruby: 2.7, allowed-failure: false } # minimum supported
-          - { ruby: 3.2, allowed-failure: false } # latest
+          - { ruby: 3.1, allowed-failure: false } # latest
           - { ruby: ruby-head, allowed-failure: true }
-    name: Test Ruby ${{ matrix.entry.ruby }}
+    name: test (${{ matrix.entry.ruby }})
     steps:
       - uses: actions/checkout@v3
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.entry.ruby }}
-          bundler-cache: true
+      - uses: actions/cache@v1
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-gems-${{ hashFiles('Gemfile') }}
+          restore-keys: ${{ runner.os }}-gems-
+      - run: bundle install --jobs=3 --retry=3 --path=vendor/bundle
       - run: bundle exec rake
         continue-on-error: ${{ matrix.entry.allowed-failure }}
-
   memory_profile:
     runs-on: ubuntu-latest
     steps:
@@ -31,5 +30,10 @@ jobs:
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: 2.7
-          bundler-cache: true
+      - uses: actions/cache@v1
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-gems-${{ hashFiles('Gemfile') }}
+          restore-keys: ${{ runner.os }}-gems-
+      - run: bundle install --jobs=3 --retry=3 --path=vendor/bundle
       - run: bundle exec rake memory_profile:run

Gemfile

@@ -18,7 +18,6 @@ group :benchmark, :test do
 end
 
 group :test do
-  gem 'rubocop', '~> 1.44.0'
   gem 'rubocop-shopify', '~> 2.7.0', require: false
   gem 'rubocop-performance', require: false
 

README.md

@@ -5,7 +5,7 @@
 
 * [Contributing guidelines](CONTRIBUTING.md)
 * [Version history](History.md)
-* [Liquid documentation from Shopify](https://shopify.dev/docs/docs/api/liquid)
+* [Liquid documentation from Shopify](https://shopify.dev/api/liquid)
 * [Liquid Wiki at GitHub](https://github.com/Shopify/liquid/wiki)
 * [Website](http://liquidmarkup.org/)
 

lib/liquid.rb

@@ -41,7 +41,7 @@ module Liquid
   AnyStartingTag              = /#{TagStart}|#{VariableStart}/o
   PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
   TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
-  VariableParser              = /\[(?>[^\[\]]+|\g<0>)*\]|#{VariableSegment}+\??/o
+  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
 
   RAISE_EXCEPTION_LAMBDA = ->(_e) { raise }
 

lib/liquid/block_body.rb

@@ -109,22 +109,14 @@ module Liquid
       end
     end
 
-    private def handle_invalid_tag_token(token, parse_context)
-      if token.end_with?('%}')
-        yield token, token
-      else
-        BlockBody.raise_missing_tag_terminator(token, parse_context)
-      end
-    end
-
-    private def parse_for_document(tokenizer, parse_context, &block)
+    private def parse_for_document(tokenizer, parse_context)
       while (token = tokenizer.shift)
         next if token.empty?
         case
         when token.start_with?(TAGSTART)
           whitespace_handler(token, parse_context)
           unless token =~ FullToken
-            return handle_invalid_tag_token(token, parse_context, &block)
+            BlockBody.raise_missing_tag_terminator(token, parse_context)
           end
           tag_name = Regexp.last_match(2)
           markup   = Regexp.last_match(4)

lib/liquid/context.rb

@@ -26,7 +26,7 @@ module Liquid
       @environments = [environments]
       @environments.flatten!
 
-      @static_environments = [static_environments].flatten(1).freeze
+      @static_environments = [static_environments].flat_map(&:freeze).freeze
       @scopes              = [(outer_scope || {})]
       @registers           = registers.is_a?(Registers) ? registers : Registers.new(registers)
       @errors              = []

lib/liquid/drop.rb

@@ -25,10 +25,6 @@ module Liquid
   class Drop
     attr_writer :context
 
-    def initialize
-      @context = nil
-    end
-
     # Catch all for the method
     def liquid_method_missing(method)
       return nil unless @context&.strict_variables

lib/liquid/forloop_drop.rb

@@ -5,7 +5,7 @@ module Liquid
   # @liquid_type object
   # @liquid_name forloop
   # @liquid_summary
-  #   Information about a parent [`for` loop](/docs/api/liquid/tags/for).
+  #   Information about a parent [`for` loop](/api/liquid/tags#for).
   class ForloopDrop < Drop
     def initialize(name, length, parentloop)
       @name       = name
@@ -30,7 +30,10 @@ module Liquid
     # @liquid_return [forloop]
     attr_reader :parentloop
 
-    attr_reader :name
+    def name
+      Usage.increment('forloop_drop_name')
+      @name
+    end
 
     # @liquid_public_docs
     # @liquid_summary

lib/liquid/standardfilters.rb

@@ -6,14 +6,7 @@ require 'bigdecimal'
 
 module Liquid
   module StandardFilters
-    MAX_I32 = (1 << 31) - 1
-    private_constant :MAX_I32
-
-    MIN_I64 = -(1 << 63)
-    MAX_I64 = (1 << 63) - 1
-    I64_RANGE = MIN_I64..MAX_I64
-    private_constant :MIN_I64, :MAX_I64, :I64_RANGE
-
+    MAX_INT = (1 << 31) - 1
     HTML_ESCAPE = {
       '&' => '&amp;',
       '>' => '&gt;',
@@ -80,7 +73,7 @@ module Liquid
     # @liquid_type filter
     # @liquid_category string
     # @liquid_summary
-    #   Escapes special characters in HTML, such as `<>`, `'`, and `&`, and converts characters into escape sequences. The filter doesn't effect characters within the string that don’t have a corresponding escape sequence.".
+    #   Escapes a string.
     # @liquid_syntax string | escape
     # @liquid_return [string]
     def escape(input)
@@ -193,19 +186,10 @@ module Liquid
       offset = Utils.to_integer(offset)
       length = length ? Utils.to_integer(length) : 1
 
-      begin
-        if input.is_a?(Array)
-          input.slice(offset, length) || []
-        else
-          input.to_s.slice(offset, length) || ''
-        end
-      rescue RangeError
-        if I64_RANGE.cover?(length) && I64_RANGE.cover?(offset)
-          raise # unexpected error
-        end
-        offset = offset.clamp(I64_RANGE)
-        length = length.clamp(I64_RANGE)
-        retry
+      if input.is_a?(Array)
+        input.slice(offset, length) || []
+      else
+        input.to_s.slice(offset, length) || ''
       end
     end
 
@@ -255,9 +239,9 @@ module Liquid
       wordlist = begin
         input.split(" ", words + 1)
       rescue RangeError
-        # integer too big for String#split, but we can semantically assume no truncation is needed
-        return input if words + 1 > MAX_I32
-        raise # unexpected error
+        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
       return input if wordlist.length <= words
 
@@ -615,7 +599,7 @@ module Liquid
     # @liquid_description
     #   > Note:
     #   > The `concat` filter won't filter out duplicates. If you want to remove duplicates, then you need to use the
-    #   > [`uniq` filter](/docs/api/liquid/filters/uniq).
+    #   > [`uniq` filter](/api/liquid/filters#uniq).
     # @liquid_syntax array | concat: array
     # @liquid_return [array[untyped]]
     def concat(input, array)
@@ -757,7 +741,7 @@ module Liquid
     # @liquid_type filter
     # @liquid_category math
     # @liquid_summary
-    #   Divides a number by a given number. The `divided_by` filter produces a result of the same type as the divisor. This means if you divide by an integer, the result will be an integer, and if you divide by a float, the result will be a float.
+    #   Divides a number by a given number.
     # @liquid_syntax number | divided_by: number
     # @liquid_return [number]
     def divided_by(input, operand)
@@ -857,9 +841,9 @@ module Liquid
     # @liquid_summary
     #   Sets a default value for any variable whose value is one of the following:
     #
-    #   - [`empty`](/docs/api/liquid/basics#empty)
-    #   - [`false`](/docs/api/liquid/basics#truthy-and-falsy)
-    #   - [`nil`](/docs/api/liquid/basics#nil)
+    #   - [`empty`](/api/liquid/basics#empty)
+    #   - [`false`](/api/liquid/basics#truthy-and-falsy)
+    #   - [`nil`](/api/liquid/basics#nil)
     # @liquid_syntax variable | default: variable
     # @liquid_return [untyped]
     # @liquid_optional_param allow_false [boolean] Whether to use false values instead of the default.

lib/liquid/tablerowloop_drop.rb

@@ -5,7 +5,7 @@ module Liquid
   # @liquid_type object
   # @liquid_name tablerowloop
   # @liquid_summary
-  #   Information about a parent [`tablerow` loop](/docs/api/liquid/tags/tablerow).
+  #   Information about a parent [`tablerow` loop](/api/liquid/tags#tablerow).
   class TablerowloopDrop < Drop
     def initialize(length, cols)
       @length = length

lib/liquid/tag.rb

@@ -14,18 +14,12 @@ module Liquid
       end
 
       def disable_tags(*tag_names)
-        tag_names += disabled_tags
-        define_singleton_method(:disabled_tags) { tag_names }
+        @disabled_tags ||= []
+        @disabled_tags.concat(tag_names)
         prepend(Disabler)
       end
 
       private :new
-
-      protected
-
-      def disabled_tags
-        []
-      end
     end
 
     def initialize(tag_name, markup, parse_context)

lib/liquid/tag/disabler.rb

@@ -3,6 +3,14 @@
 module Liquid
   class Tag
     module Disabler
+      module ClassMethods
+        attr_reader :disabled_tags
+      end
+
+      def self.prepended(base)
+        base.extend(ClassMethods)
+      end
+
       def render_to_output_buffer(context, output)
         context.with_disabled_tags(self.class.disabled_tags) do
           super

lib/liquid/tags/assign.rb

@@ -8,7 +8,7 @@ module Liquid
   # @liquid_summary
   #   Creates a new variable.
   # @liquid_description
-  #   You can create variables of any [basic type](/docs/api/liquid/basics#types), [object](/docs/api/liquid/objects), or object property.
+  #   You can create variables of any [basic type](/api/liquid/basics#types), [object](/api/liquid/objects), or object property.
   # @liquid_syntax
   #   {% assign variable_name = value %}
   # @liquid_syntax_keyword variable_name The name of the variable being created.

lib/liquid/tags/break.rb

@@ -15,7 +15,7 @@ module Liquid
   # @liquid_category iteration
   # @liquid_name break
   # @liquid_summary
-  #   Stops a [`for` loop](/docs/api/liquid/tags/for) from iterating.
+  #   Stops a [`for` loop](/api/liquid/tags#for) from iterating.
   # @liquid_syntax
   #   {% break %}
   class Break < Tag

lib/liquid/tags/comment.rb

@@ -8,7 +8,7 @@ module Liquid
   # @liquid_summary
   #   Prevents an expression from being rendered or output.
   # @liquid_description
-  #   Any text inside `comment` tags won't be output, and any Liquid code will be parsed, but not executed.
+  #   Any text inside `comment` tags won't be output, and any Liquid code won't be rendered.
   # @liquid_syntax
   #   {% comment %}
   #     content

lib/liquid/tags/continue.rb

@@ -6,7 +6,7 @@ module Liquid
   # @liquid_category iteration
   # @liquid_name continue
   # @liquid_summary
-  #   Causes a [`for` loop](/docs/api/liquid/tags/for) to skip to the next iteration.
+  #   Causes a [`for` loop](/api/liquid/tags#for) to skip to the next iteration.
   # @liquid_syntax
   #   {% continue %}
   class Continue < Tag

lib/liquid/tags/cycle.rb

@@ -6,7 +6,7 @@ module Liquid
   # @liquid_category iteration
   # @liquid_name cycle
   # @liquid_summary
-  #   Loops through a group of strings and outputs them one at a time for each iteration of a [`for` loop](/docs/api/liquid/tags/for).
+  #   Loops through a group of strings and outputs them one at a time for each iteration of a [`for` loop](/api/liquid/tags#for).
   # @liquid_description
   #   The `cycle` tag must be used inside a `for` loop.
   #

lib/liquid/tags/decrement.rb

@@ -12,8 +12,8 @@ module Liquid
   #   or [section](/themes/architecture/sections) file that they're created in. However, the variable is shared across
   #   [snippets](/themes/architecture#snippets) included in the file.
   #
-  #   Similarly, variables that are created with `decrement` are independent from those created with [`assign`](/docs/api/liquid/tags/assign)
-  #   and [`capture`](/docs/api/liquid/tags/capture). However, `decrement` and [`increment`](/docs/api/liquid/tags/increment) share
+  #   Similarly, variables that are created with `decrement` are independent from those created with [`assign`](/api/liquid/tags#assign)
+  #   and [`capture`](/api/liquid/tags#capture). However, `decrement` and [`increment`](/api/liquid/tags#increment) share
   #   variables.
   # @liquid_syntax
   #   {% decrement variable_name %}

lib/liquid/tags/echo.rb

@@ -9,10 +9,10 @@ module Liquid
   #   Outputs an expression.
   # @liquid_description
   #   Using the `echo` tag is the same as wrapping an expression in curly brackets (`{{` and `}}`). However, unlike the curly
-  #   bracket method, you can use the `echo` tag inside [`liquid` tags](/docs/api/liquid/tags/liquid).
+  #   bracket method, you can use the `echo` tag inside [`liquid` tags](/api/liquid/tags#liquid).
   #
   #   > Tip:
-  #   > You can use [filters](/docs/api/liquid/filters) on expressions inside `echo` tags.
+  #   > You can use [filters](/api/liquid/filters) on expressions inside `echo` tags.
   # @liquid_syntax
   #   {% liquid
   #     echo expression

lib/liquid/tags/for.rb

@@ -9,10 +9,10 @@ module Liquid
   #   Renders an expression for every item in an array.
   # @liquid_description
   #   You can do a maximum of 50 iterations with a `for` loop. If you need to iterate over more than 50 items, then use the
-  #   [`paginate` tag](/docs/api/liquid/tags/paginate) to split the items over multiple pages.
+  #   [`paginate` tag](/api/liquid/tags#paginate) to split the items over multiple pages.
   #
   #   > Tip:
-  #   > Every `for` loop has an associated [`forloop` object](/docs/api/liquid/objects/forloop) with information about the loop.
+  #   > Every `for` loop has an associated [`forloop` object](/api/liquid/objects#forloop) with information about the loop.
   # @liquid_syntax
   #   {% for variable in array %}
   #     expression
@@ -98,12 +98,11 @@ module Liquid
       @name     = "#{@variable_name}-#{collection_name}"
       @reversed = p.id?('reversed')
 
-      while p.look(:comma) || p.look(:id)
-        p.consume?(:comma)
+      while p.look(:id) && p.look(:colon, 1)
         unless (attribute = p.id?('limit') || p.id?('offset'))
           raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute")
         end
-        p.consume(:colon)
+        p.consume
         set_attribute(attribute, p.expression)
       end
       p.consume(:end_of_string)
@@ -178,6 +177,7 @@ module Liquid
       case key
       when 'offset'
         @from = if expr == 'continue'
+          Usage.increment('for_offset_continue')
           :continue
         else
           parse_expression(expr)

lib/liquid/tags/include.rb

@@ -8,7 +8,7 @@ module Liquid
   # @liquid_summary
   #   Renders a [snippet](/themes/architecture#snippets).
   # @liquid_description
-  #   Inside the snippet, you can access and alter variables that are [created](/docs/api/liquid/tags/variable-tags) outside of the
+  #   Inside the snippet, you can access and alter variables that are [created](/api/liquid/tags#variable-tags) outside of the
   #   snippet.
   # @liquid_syntax
   #   {% include 'filename' %}
@@ -16,7 +16,7 @@ module Liquid
   # @liquid_deprecated
   #   Deprecated because the way that variables are handled reduces performance and makes code harder to both read and maintain.
   #
-  #   The `include` tag has been replaced by [`render`](/docs/api/liquid/tags/render).
+  #   The `include` tag has been replaced by [`render`](/api/liquid/tags#render).
   class Include < Tag
     prepend Tag::Disableable
 
@@ -52,7 +52,7 @@ module Liquid
 
     def render_to_output_buffer(context, output)
       template_name = context.evaluate(@template_name_expr)
-      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name.is_a?(String)
+      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name
 
       partial = PartialCache.load(
         template_name,

lib/liquid/tags/increment.rb

@@ -12,8 +12,8 @@ module Liquid
   #   or [section](/themes/architecture/sections) file that they're created in. However, the variable is shared across
   #   [snippets](/themes/architecture#snippets) included in the file.
   #
-  #   Similarly, variables that are created with `increment` are independent from those created with [`assign`](/docs/api/liquid/tags/assign)
-  #   and [`capture`](/docs/api/liquid/tags/capture). However, `increment` and [`decrement`](/docs/api/liquid/tags/decrement) share
+  #   Similarly, variables that are created with `increment` are independent from those created with [`assign`](/api/liquid/tags#assign)
+  #   and [`capture`](/api/liquid/tags#capture). However, `increment` and [`decrement`](/api/liquid/tags#decrement) share
   #   variables.
   # @liquid_syntax
   #   {% increment variable_name %}

lib/liquid/tags/inline_comment.rb

@@ -1,6 +1,19 @@
 # frozen_string_literal: true
 
 module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category syntax
+  # @liquid_name inline_comment
+  # @liquid_summary
+  #   Prevents an expression from being rendered or output.
+  # @liquid_description
+  #   Any text inside an `inline_comment` tag won't be rendered or output.
+  #
+  #   You can create multi-line inline comments. However, each line must begin with a `#`.
+  # @liquid_syntax
+  #   {% # content %}
+  # @liquid_syntax_keyword content The content of the comment.
   class InlineComment < Tag
     def initialize(tag_name, markup, options)
       super

lib/liquid/tags/raw.rb

@@ -14,7 +14,7 @@ module Liquid
   # @liquid_syntax_keyword expression The expression to be output without being rendered.
   class Raw < Block
     Syntax = /\A\s*\z/
-    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}#{WhitespaceControl}?\s*(\w+)\s*(.*)?#{WhitespaceControl}?#{TagEnd}\z/om
+    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
 
     def initialize(tag_name, markup, parse_context)
       super

lib/liquid/tags/render.rb

@@ -8,19 +8,19 @@ module Liquid
   # @liquid_summary
   #   Renders a [snippet](/themes/architecture#snippets) or [app block](/themes/architecture/sections/section-schema#render-app-blocks).
   # @liquid_description
-  #   Inside snippets and app blocks, you can't directly access variables that are [created](/docs/api/liquid/tags/variable-tags) outside
-  #   of the snippet or app block. However, you can [specify variables as parameters](/docs/api/liquid/tags/render#render-passing-variables-to-a-snippet)
+  #   Inside snippets and app blocks, you can't directly access variables that are [created](/api/liquid/tags#variable-tags) outside
+  #   of the snippet or app block. However, you can [specify variables as parameters](/api/liquid/tags#render-passing-variables-to-snippets)
   #   to pass outside variables to snippets.
   #
   #   While you can't directly access created variables, you can access global objects, as well as any objects that are
   #   directly accessible outside the snippet or app block. For example, a snippet or app block inside the [product template](/themes/architecture/templates/product)
-  #   can access the [`product` object](/docs/api/liquid/objects/product), and a snippet or app block inside a [section](/themes/architecture/sections)
-  #   can access the [`section` object](/docs/api/liquid/objects/section).
+  #   can access the [`product` object](/api/liquid/objects#product), and a snippet or app block inside a [section](/themes/architecture/sections)
+  #   can access the [`section` object](/api/liquid/objects#section).
   #
   #   Outside a snippet or app block, you can't access variables created inside the snippet or app block.
   #
   #   > Note:
-  #   > When you render a snippet using the `render` tag, you can't use the [`include` tag](/docs/api/liquid/tags/include)
+  #   > When you render a snippet using the `render` tag, you can't use the [`include` tag](/api/liquid/tags#include)
   #   > inside the snippet.
   # @liquid_syntax
   #   {% render 'filename' %}
@@ -33,6 +33,10 @@ module Liquid
 
     attr_reader :template_name_expr, :variable_name_expr, :attributes, :alias_name
 
+    def for_loop?
+      @is_for_loop
+    end
+
     def initialize(tag_name, markup, options)
       super
 
@@ -53,10 +57,6 @@ module Liquid
       end
     end
 
-    def for_loop?
-      @is_for_loop
-    end
-
     def render_to_output_buffer(context, output)
       render_tag(context, output)
     end

lib/liquid/tags/table_row.rb

@@ -11,7 +11,7 @@ module Liquid
   #   The `tablerow` tag must be wrapped in HTML `<table>` and `</table>` tags.
   #
   #   > Tip:
-  #   > Every `tablerow` loop has an associated [`tablerowloop` object](/docs/api/liquid/objects/tablerowloop) with information about the loop.
+  #   > Every `tablerow` loop has an associated [`tablerowloop` object](/api/liquid/objects#tablerowloop) with information about the loop.
   # @liquid_syntax
   #   {% tablerow variable in array %}
   #     expression
@@ -45,13 +45,13 @@ module Liquid
     def render_to_output_buffer(context, output)
       (collection = context.evaluate(@collection_name)) || (return '')
 
-      from = @attributes.key?('offset') ? to_integer(context.evaluate(@attributes['offset'])) : 0
-      to = @attributes.key?('limit') ? from + to_integer(context.evaluate(@attributes['limit'])) : nil
+      from = @attributes.key?('offset') ? context.evaluate(@attributes['offset']).to_i : 0
+      to   = @attributes.key?('limit')  ? from + context.evaluate(@attributes['limit']).to_i : nil
 
       collection = Utils.slice_collection(collection, from, to)
       length     = collection.length
 
-      cols = @attributes.key?('cols') ? to_integer(context.evaluate(@attributes['cols'])) : length
+      cols = context.evaluate(@attributes['cols']).to_i
 
       output << "<tr class=\"row1\">\n"
       context.stack do
@@ -82,14 +82,6 @@ module Liquid
         super + @node.attributes.values + [@node.collection_name]
       end
     end
-
-    private
-
-    def to_integer(value)
-      value.to_i
-    rescue NoMethodError
-      raise Liquid::ArgumentError, "invalid integer"
-    end
   end
 
   Template.register_tag('tablerow', TableRow)

lib/liquid/tags/unless.rb

@@ -11,7 +11,7 @@ module Liquid
   #   Renders an expression unless a specific condition is `true`.
   # @liquid_description
   #   > Tip:
-  #   > Similar to the [`if` tag](/docs/api/liquid/tags/if), you can use `elsif` to add more conditions to an `unless` tag.
+  #   > Similar to the [`if` tag](/api/liquid/tags#if), you can use `elsif` to add more conditions to an `unless` tag.
   # @liquid_syntax
   #   {% unless condition %}
   #     expression

lib/liquid/tokenizer.rb

@@ -8,15 +8,11 @@ module Liquid
       @source         = source.to_s.to_str
       @line_number    = line_number || (line_numbers ? 1 : nil)
       @for_liquid_tag = for_liquid_tag
-      @offset         = 0
       @tokens         = tokenize
     end
 
     def shift
-      token = @tokens[@offset]
-      return nil unless token
-
-      @offset += 1
+      (token = @tokens.shift) || return
 
       if @line_number
         @line_number += @for_liquid_tag ? 1 : token.count("\n")
@@ -35,9 +31,7 @@ module Liquid
       tokens = @source.split(TemplateParser)
 
       # removes the rogue empty element at the beginning of the array
-      if tokens[0]&.empty?
-        @offset += 1
-      end
+      tokens.shift if tokens[0]&.empty?
 
       tokens
     end

lib/liquid/utils.rb

@@ -16,11 +16,7 @@ module Liquid
 
       # Maintains Ruby 1.8.7 String#each behaviour on 1.9
       if collection.is_a?(String)
-        return [] if collection.empty?
-        if from > 0 || to == 0
-          Usage.increment("string_slice_bug")
-        end
-        return [collection]
+        return collection.empty? ? [] : [collection]
       end
       return [] unless collection.respond_to?(:each)
 

performance/shopify/database.rb

@@ -49,3 +49,8 @@ module Database
     end
   end
 end
+
+if __FILE__ == $PROGRAM_NAME
+  p(Database.tables['collections']['frontpage'].keys)
+  # p Database.tables['blog']['articles']
+end

test/integration/blank_test.rb

@@ -27,7 +27,7 @@ class BlankTest < Minitest::Test
 
   def test_new_tags_are_not_blank_by_default
     with_custom_tag('foobar', FoobarTag) do
-      assert_equal(" " * N, Liquid::Template.parse(wrap_in_for("{% foobar %}")).render!)
+      assert_template_result(" " * N, wrap_in_for("{% foobar %}"))
     end
   end
 

test/integration/context_test.rb

@@ -262,7 +262,7 @@ class ContextTest < Minitest::Test
     assigns = { 'product' => { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] } }
     assert_template_result("draft151cm", '{{ product["variants"][0]["title"] }}', assigns)
     assert_template_result("element151cm", '{{ product["variants"][1]["title"] }}', assigns)
-    assert_template_result("draft151cm", '{{ product["variants"].first["title"] }}', assigns)
+    assert_template_result("draft151cm", '{{ product["variants"][0]["title"] }}', assigns)
     assert_template_result("element151cm", '{{ product["variants"].last["title"] }}', assigns)
   end
 

test/integration/standard_filter_test.rb

@@ -109,10 +109,6 @@ class StandardFiltersTest < Minitest::Test
     assert_raises(Liquid::ArgumentError) do
       @filters.slice('foobar', 0, "")
     end
-    assert_equal("", @filters.slice("foobar", 0, -(1 << 64)))
-    assert_equal("foobar", @filters.slice("foobar", 0, 1 << 63))
-    assert_equal("", @filters.slice("foobar", 1 << 63, 6))
-    assert_equal("", @filters.slice("foobar", -(1 << 63), 6))
   end
 
   def test_slice_on_arrays
@@ -127,10 +123,6 @@ class StandardFiltersTest < Minitest::Test
     assert_equal(%w(r), @filters.slice(input, -1))
     assert_equal(%w(), @filters.slice(input, 100, 10))
     assert_equal(%w(), @filters.slice(input, -100, 10))
-    assert_equal([], @filters.slice(input, 0, -(1 << 64)))
-    assert_equal(input, @filters.slice(input, 0, 1 << 63))
-    assert_equal([], @filters.slice(input, 1 << 63, 6))
-    assert_equal([], @filters.slice(input, -(1 << 63), 6))
   end
 
   def test_truncate
@@ -140,8 +132,6 @@ class StandardFiltersTest < Minitest::Test
     assert_equal('1234567890', @filters.truncate('1234567890'))
     assert_equal("测试...", @filters.truncate("测试测试测试测试", 5))
     assert_equal('12341', @filters.truncate("1234567890", 5, 1))
-    assert_equal("foobar", @filters.truncate("foobar", 1 << 63))
-    assert_equal("...", @filters.truncate("foobar", -(1 << 63)))
   end
 
   def test_split
@@ -237,8 +227,10 @@ class StandardFiltersTest < Minitest::Test
     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))
-    assert_equal('one two three four', @filters.truncatewords("one two three four", 1 << 31))
-    assert_equal('one...', @filters.truncatewords("one two three four", -(1 << 32)))
+    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
@@ -477,8 +469,8 @@ class StandardFiltersTest < Minitest::Test
   def test_map_over_proc
     drop  = TestDrop.new(value: "testfoo")
     p     = proc { drop }
-    output = Liquid::Template.parse('{{ procs | map: "value" }}').render!({ "procs" => [p] })
-    assert_equal("testfoo", output)
+    templ = '{{ procs | map: "value" }}'
+    assert_template_result("testfoo", templ, { "procs" => [p] })
   end
 
   def test_map_over_drops_returning_procs
@@ -490,13 +482,12 @@ class StandardFiltersTest < Minitest::Test
         "proc" => -> { "bar" },
       },
     ]
-    output = Liquid::Template.parse('{{ drops | map: "proc" }}').render!({ "drops" => drops })
-    assert_equal("foobar", output)
+    templ = '{{ drops | map: "proc" }}'
+    assert_template_result("foobar", templ, { "drops" => drops })
   end
 
   def test_map_works_on_enumerables
-    output = Liquid::Template.parse('{{ foo | map: "foo" }}').render!({ "foo" => TestEnumerable.new })
-    assert_equal("123", output)
+    assert_template_result("123", '{{ foo | map: "foo" }}', { "foo" => TestEnumerable.new })
   end
 
   def test_map_returns_empty_on_2d_input_array

test/integration/tags/break_tag_test.rb

@@ -9,8 +9,8 @@ class BreakTagTest < Minitest::Test
   # block
   def test_break_with_no_block
     assigns  = { 'i' => 1 }
-    markup   = 'before{% break %}after'
-    expected = 'before'
+    markup   = '{% break %}'
+    expected = ''
 
     assert_template_result(expected, markup, assigns)
   end

test/integration/tags/for_tag_test.rb

@@ -103,7 +103,6 @@ HERE
     assert_template_result('1234', '{%for i in array limit:4 %}{{ i }}{%endfor%}', assigns)
     assert_template_result('3456', '{%for i in array limit:4 offset:2 %}{{ i }}{%endfor%}', assigns)
     assert_template_result('3456', '{%for i in array limit: 4 offset: 2 %}{{ i }}{%endfor%}', assigns)
-    assert_template_result('3456', '{%for i in array, limit: 4, offset: 2 %}{{ i }}{%endfor%}', assigns)
   end
 
   def test_limiting_with_invalid_limit
@@ -264,19 +263,6 @@ HERE
     assert_template_result(expected, markup, assigns)
   end
 
-  def test_for_with_break_after_nested_loop
-    source = <<~LIQUID.chomp
-      {% for i in (1..2) -%}
-        {% for j in (1..2) -%}
-          {{ i }}-{{ j }},
-        {%- endfor -%}
-        {% break -%}
-      {% endfor -%}
-      after
-    LIQUID
-    assert_template_result("1-1,1-2,after", source)
-  end
-
   def test_for_with_continue
     assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5] } }
 
@@ -451,4 +437,30 @@ HERE
 
     assert(context.registers[:for_stack].empty?)
   end
+
+  def test_instrument_for_offset_continue
+    assert_usage_increment('for_offset_continue') do
+      Template.parse('{% for item in items offset:continue %}{{item}}{% endfor %}')
+    end
+
+    assert_usage_increment('for_offset_continue', times: 0) do
+      Template.parse('{% for item in items offset:2 %}{{item}}{% endfor %}')
+    end
+  end
+
+  def test_instrument_forloop_drop_name
+    assigns = { 'items' => [1, 2, 3, 4, 5] }
+
+    assert_usage_increment('forloop_drop_name', times: 5) do
+      Template.parse('{% for item in items %}{{forloop.name}}{% endfor %}').render!(assigns)
+    end
+
+    assert_usage_increment('forloop_drop_name', times: 0) do
+      Template.parse('{% for item in items %}{{forloop.index}}{% endfor %}').render!(assigns)
+    end
+
+    assert_usage_increment('forloop_drop_name', times: 0) do
+      Template.parse('{% for item in items %}{{item}}{% endfor %}').render!(assigns)
+    end
+  end
 end

test/integration/tags/if_else_tag_test.rb

@@ -62,7 +62,7 @@ class IfElseTagTest < Minitest::Test
   def test_if_and
     assert_template_result(' YES ', '{% if true and true %} YES {% endif %}')
     assert_template_result('', '{% if false and true %} YES {% endif %}')
-    assert_template_result('', '{% if true and false %} YES {% endif %}')
+    assert_template_result('', '{% if false and true %} YES {% endif %}')
   end
 
   def test_hash_miss_generates_false

test/integration/tags/include_tag_test.rb

@@ -3,13 +3,44 @@
 require 'test_helper'
 
 class TestFileSystem
-  PARTIALS = {
-    "nested_template" => "{% include 'header' %} {% include 'body' %} {% include 'footer' %}",
-    "body" => "body {% include 'body_detail' %}",
-  }
-
   def read_template_file(template_path)
-    PARTIALS[template_path] || template_path
+    case template_path
+    when "product"
+      "Product: {{ product.title }} "
+
+    when "product_alias"
+      "Product: {{ product.title }} "
+
+    when "locale_variables"
+      "Locale: {{echo1}} {{echo2}}"
+
+    when "variant"
+      "Variant: {{ variant.title }}"
+
+    when "nested_template"
+      "{% include 'header' %} {% include 'body' %} {% include 'footer' %}"
+
+    when "body"
+      "body {% include 'body_detail' %}"
+
+    when "nested_product_template"
+      "Product: {{ nested_product_template.title }} {%include 'details'%} "
+
+    when "recursively_nested_template"
+      "-{% include 'recursively_nested_template' %}"
+
+    when "pick_a_source"
+      "from TestFileSystem"
+
+    when 'assignments'
+      "{% assign foo = 'bar' %}"
+
+    when 'break'
+      "{% break %}"
+
+    else
+      template_path
+    end
   end
 end
 
@@ -50,11 +81,7 @@ class IncludeTagTest < Minitest::Test
   include Liquid
 
   def setup
-    @default_file_system = Liquid::Template.file_system
-  end
-
-  def teardown
-    Liquid::Template.file_system = @default_file_system
+    Liquid::Template.file_system = TestFileSystem.new
   end
 
   def test_include_tag_looks_for_file_system_in_registers_first
@@ -65,85 +92,63 @@ class IncludeTagTest < Minitest::Test
   def test_include_tag_with
     assert_template_result("Product: Draft 151cm ",
       "{% include 'product' with products[0] %}",
-      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] },
-      partials: { "product" => "Product: {{ product.title }} " })
+      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] })
   end
 
   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' }] },
-      partials: { "product_alias" => "Product: {{ product.title }} " })
+      { "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' }] },
-      partials: { "product_alias" => "Product: {{ product.title }} " })
+      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] })
   end
 
   def test_include_tag_with_default_name
     assert_template_result("Product: Draft 151cm ",
-      "{% include 'product' %}", { "product" => { 'title' => 'Draft 151cm' } },
-      partials: { "product" => "Product: {{ product.title }} " })
+      "{% include 'product' %}", { "product" => { 'title' => 'Draft 151cm' } })
   end
 
   def test_include_tag_for
     assert_template_result("Product: Draft 151cm Product: Element 155cm ",
       "{% include 'product' for products %}",
-      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] },
-      partials: { "product" => "Product: {{ product.title }} " })
+      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] })
   end
 
   def test_include_tag_with_local_variables
-    assert_template_result("Locale: test123 ", "{% include 'locale_variables' echo1: 'test123' %}",
-      partials: { "locale_variables" => "Locale: {{echo1}} {{echo2}}" })
+    assert_template_result("Locale: test123 ", "{% include 'locale_variables' echo1: 'test123' %}")
   end
 
   def test_include_tag_with_multiple_local_variables
     assert_template_result("Locale: test123 test321",
-      "{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}",
-      partials: { "locale_variables" => "Locale: {{echo1}} {{echo2}}" })
+      "{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}")
   end
 
   def test_include_tag_with_multiple_local_variables_from_context
     assert_template_result("Locale: test123 test321",
       "{% include 'locale_variables' echo1: echo1, echo2: more_echos.echo2 %}",
-      { 'echo1' => 'test123', 'more_echos' => { "echo2" => 'test321' } },
-      partials: { "locale_variables" => "Locale: {{echo1}} {{echo2}}" })
+      { 'echo1' => 'test123', 'more_echos' => { "echo2" => 'test321' } })
   end
 
   def test_included_templates_assigns_variables
-    assert_template_result("bar", "{% include 'assignments' %}{{ foo }}",
-      partials: { 'assignments' => "{% assign foo = 'bar' %}" })
+    assert_template_result("bar", "{% include 'assignments' %}{{ foo }}")
   end
 
   def test_nested_include_tag
-    partials = { "body" => "body {% include 'body_detail' %}", "body_detail" => "body_detail" }
-    assert_template_result("body body_detail", "{% include 'body' %}", partials: partials)
+    assert_template_result("body body_detail", "{% include 'body' %}")
 
-    partials = partials.merge({
-      "nested_template" => "{% include 'header' %} {% include 'body' %} {% include 'footer' %}",
-      "header" => "header",
-      "footer" => "footer",
-    })
-    assert_template_result("header body body_detail footer", "{% include 'nested_template' %}", partials: partials)
+    assert_template_result("header body body_detail footer", "{% include 'nested_template' %}")
   end
 
   def test_nested_include_with_variable
-    partials = {
-      "nested_product_template" => "Product: {{ nested_product_template.title }} {%include 'details'%} ",
-      "details" => "details",
-    }
-
     assert_template_result("Product: Draft 151cm details ",
-      "{% include 'nested_product_template' with product %}", { "product" => { "title" => 'Draft 151cm' } },
-      partials: partials)
+      "{% include 'nested_product_template' with product %}", { "product" => { "title" => 'Draft 151cm' } })
 
     assert_template_result("Product: Draft 151cm details Product: Element 155cm details ",
-      "{% include 'nested_product_template' for products %}", { "products" => [{ "title" => 'Draft 151cm' }, { "title" => 'Element 155cm' }] },
-      partials: partials)
+      "{% include 'nested_product_template' for products %}", { "products" => [{ "title" => 'Draft 151cm' }, { "title" => 'Element 155cm' }] })
   end
 
   def test_recursively_included_template_does_not_produce_endless_loop
@@ -161,15 +166,11 @@ class IncludeTagTest < Minitest::Test
   end
 
   def test_dynamically_choosen_template
-    assert_template_result("Test123", "{% include template %}", { "template" => 'Test123' },
-      partials: { "Test123" => "Test123" })
-
-    assert_template_result("Test321", "{% include template %}", { "template" => 'Test321' },
-      partials: { "Test321" => "Test321" })
+    assert_template_result("Test123", "{% include template %}", { "template" => 'Test123' })
+    assert_template_result("Test321", "{% include template %}", { "template" => 'Test321' })
 
     assert_template_result("Product: Draft 151cm ", "{% include template for product %}",
-      { "template" => 'product', 'product' => { 'title' => 'Draft 151cm' } },
-      partials: { "product" => "Product: {{ product.title }} " })
+      { "template" => 'product', 'product' => { 'title' => 'Draft 151cm' } })
   end
 
   def test_include_tag_caches_second_read_of_same_partial
@@ -191,8 +192,7 @@ class IncludeTagTest < Minitest::Test
   end
 
   def test_include_tag_within_if_statement
-    assert_template_result("foo_if_true", "{% if true %}{% include 'foo_if_true' %}{% endif %}",
-      partials: { "foo_if_true" => "foo_if_true" })
+    assert_template_result("foo_if_true", "{% if true %}{% include 'foo_if_true' %}{% endif %}")
   end
 
   def test_custom_include_tag
@@ -226,7 +226,6 @@ class IncludeTagTest < Minitest::Test
   end
 
   def test_passing_options_to_included_templates
-    Liquid::Template.file_system = TestFileSystem.new
     assert_raises(Liquid::SyntaxError) do
       Template.parse("{% include template %}", error_mode: :strict).render!("template" => '{{ "X" || downcase }}')
     end
@@ -242,35 +241,27 @@ class IncludeTagTest < Minitest::Test
   end
 
   def test_render_raise_argument_error_when_template_is_undefined
-    assert_template_result("Liquid error (line 1): Argument error in tag 'include' - Illegal template name",
-      "{% include undefined_variable %}", render_errors: true)
-
-    assert_template_result("Liquid error (line 1): Argument error in tag 'include' - Illegal template name",
-      "{% include nil %}", render_errors: true)
-  end
-
-  def test_render_raise_argument_error_when_template_is_not_a_string
-    assert_template_result("Liquid error (line 1): Argument error in tag 'include' - Illegal template name",
-      "{% include 123 %}", render_errors: true)
+    assert_raises(Liquid::ArgumentError) do
+      template = Liquid::Template.parse('{% include undefined_variable %}')
+      template.render!
+    end
+    assert_raises(Liquid::ArgumentError) do
+      template = Liquid::Template.parse('{% include nil %}')
+      template.render!
+    end
   end
 
   def test_including_via_variable_value
-    assert_template_result("from TestFileSystem", "{% assign page = 'pick_a_source' %}{% include page %}",
-      partials: { "pick_a_source" => "from TestFileSystem" })
-
-    partials = { "product" => "Product: {{ product.title }} " }
+    assert_template_result("from TestFileSystem", "{% assign page = 'pick_a_source' %}{% include page %}")
 
     assert_template_result("Product: Draft 151cm ", "{% assign page = 'product' %}{% include page %}",
-      { "product" => { 'title' => 'Draft 151cm' } },
-      partials: partials)
+      { "product" => { 'title' => 'Draft 151cm' } })
 
     assert_template_result("Product: Draft 151cm ", "{% assign page = 'product' %}{% include page for foo %}",
-      { "foo" => { 'title' => 'Draft 151cm' } },
-      partials: partials)
+      { "foo" => { 'title' => 'Draft 151cm' } })
   end
 
   def test_including_with_strict_variables
-    Liquid::Template.file_system = StubFileSystem.new({ "simple" => "simple" })
     template = Liquid::Template.parse("{% include 'simple' %}", error_mode: :warn)
     template.render(nil, strict_variables: true)
 
@@ -279,7 +270,6 @@ class IncludeTagTest < Minitest::Test
 
   def test_break_through_include
     assert_template_result("1", "{% for i in (1..3) %}{{ i }}{% break %}{{ i }}{% endfor %}")
-    assert_template_result("1", "{% for i in (1..3) %}{{ i }}{% include 'break' %}{{ i }}{% endfor %}",
-      partials: { 'break' => "{% break %}" })
+    assert_template_result("1", "{% for i in (1..3) %}{{ i }}{% include 'break' %}{{ i }}{% endfor %}")
   end
 end # IncludeTagTest

test/integration/tags/increment_tag_test.rb

@@ -6,21 +6,20 @@ class IncrementTagTest < Minitest::Test
   include Liquid
 
   def test_inc
-    assert_template_result('0 1', '{%increment port %} {{ port }}')
-    assert_template_result(' 0 1 2', '{{port}} {%increment port %} {%increment port%} {{port}}')
+    assert_template_result('0', '{%increment port %}', {})
+    assert_template_result('0 1', '{%increment port %} {%increment port%}', {})
     assert_template_result('0 0 1 2 1',
       '{%increment port %} {%increment starboard%} ' \
       '{%increment port %} {%increment port%} ' \
-      '{%increment starboard %}')
+      '{%increment starboard %}', {})
   end
 
   def test_dec
-    assert_template_result('-1 -1', '{%decrement port %} {{ port }}', { 'port' => 10 })
-    assert_template_result(' -1 -2 -2', '{{port}} {%decrement port %} {%decrement port%} {{port}}')
-    assert_template_result('0 1 2 0 3 1 1 3',
-      '{%increment starboard %} {%increment starboard%} {%increment starboard%} ' \
+    assert_template_result('9', '{%decrement port %}', { 'port' => 10 })
+    assert_template_result('-1 -2', '{%decrement port %} {%decrement port%}', {})
+    assert_template_result('1 5 2 2 5',
       '{%increment port %} {%increment starboard%} ' \
       '{%increment port %} {%decrement port%} ' \
-      '{%decrement starboard %}')
+      '{%decrement starboard %}', { 'port' => 1, 'starboard' => 5 })
   end
 end

test/integration/tags/raw_tag_test.rb

@@ -11,8 +11,7 @@ class RawTagTest < Minitest::Test
   end
 
   def test_output_in_raw
-    # assert_template_result('{{ test }}', '{% raw %}{{ test }}{% endraw %}')
-    assert_template_result('>{{ test }}<', '> {%- raw -%}{{ test }}{%- endraw -%} <')
+    assert_template_result('{{ test }}', '{% raw %}{{ test }}{% endraw %}')
   end
 
   def test_open_tag_in_raw

test/integration/tags/render_tag_test.rb

@@ -6,52 +6,53 @@ class RenderTagTest < Minitest::Test
   include Liquid
 
   def test_render_with_no_arguments
-    assert_template_result('rendered content', '{% render "source" %}',
-      partials: { 'source' => 'rendered content' })
+    Liquid::Template.file_system = StubFileSystem.new('source' => 'rendered content')
+    assert_template_result('rendered content', '{% render "source" %}')
   end
 
   def test_render_tag_looks_for_file_system_in_registers_first
-    assert_template_result('from register file system', '{% render "pick_a_source" %}',
-      partials: { 'pick_a_source' => 'from register file system' })
+    file_system = StubFileSystem.new('pick_a_source' => 'from register file system')
+    assert_equal('from register file system',
+      Template.parse('{% render "pick_a_source" %}').render!({}, registers: { file_system: file_system }))
   end
 
   def test_render_passes_named_arguments_into_inner_scope
+    Liquid::Template.file_system = StubFileSystem.new('product' => '{{ inner_product.title }}')
     assert_template_result('My Product', '{% render "product", inner_product: outer_product %}',
-      { 'outer_product' => { 'title' => 'My Product' } },
-      partials: { 'product' => '{{ inner_product.title }}' })
+      { 'outer_product' => { 'title' => 'My Product' } })
   end
 
   def test_render_accepts_literals_as_arguments
-    assert_template_result('123', '{% render "snippet", price: 123 %}',
-      partials: { 'snippet' => '{{ price }}' })
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ price }}')
+    assert_template_result('123', '{% render "snippet", price: 123 %}')
   end
 
   def test_render_accepts_multiple_named_arguments
-    assert_template_result('1 2', '{% render "snippet", one: 1, two: 2 %}',
-      partials: { 'snippet' => '{{ one }} {{ two }}' })
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ one }} {{ two }}')
+    assert_template_result('1 2', '{% render "snippet", one: 1, two: 2 %}')
   end
 
   def test_render_does_not_inherit_parent_scope_variables
-    assert_template_result('', '{% assign outer_variable = "should not be visible" %}{% render "snippet" %}',
-      partials: { 'snippet' => '{{ outer_variable }}' })
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ outer_variable }}')
+    assert_template_result('', '{% assign outer_variable = "should not be visible" %}{% render "snippet" %}')
   end
 
   def test_render_does_not_inherit_variable_with_same_name_as_snippet
-    assert_template_result('', "{% assign snippet = 'should not be visible' %}{% render 'snippet' %}",
-      partials: { 'snippet' => '{{ snippet }}' })
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ snippet }}')
+    assert_template_result('', "{% assign snippet = 'should not be visible' %}{% render 'snippet' %}")
   end
 
   def test_render_does_not_mutate_parent_scope
-    assert_template_result('', "{% render 'snippet' %}{{ inner }}",
-      partials: { 'snippet' => '{% assign inner = 1 %}' })
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{% assign inner = 1 %}')
+    assert_template_result('', "{% render 'snippet' %}{{ inner }}")
   end
 
   def test_nested_render_tag
-    assert_template_result('one two', "{% render 'one' %}",
-      partials: {
-        'one' => "one {% render 'two' %}",
-        'two' => 'two',
-      })
+    Liquid::Template.file_system = StubFileSystem.new(
+      'one' => "one {% render 'two' %}",
+      'two' => 'two'
+    )
+    assert_template_result('one two', "{% render 'one' %}")
   end
 
   def test_recursively_rendered_template_does_not_produce_endless_loop
@@ -72,7 +73,11 @@ class RenderTagTest < Minitest::Test
   end
 
   def test_dynamically_choosen_templates_are_not_allowed
-    assert_syntax_error("{% assign name = 'snippet' %}{% render name %}")
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => 'should not be rendered')
+
+    assert_raises(Liquid::SyntaxError) do
+      Liquid::Template.parse("{% assign name = 'snippet' %}{% render name %}")
+    end
   end
 
   def test_include_tag_caches_second_read_of_same_partial
@@ -96,36 +101,36 @@ class RenderTagTest < Minitest::Test
   end
 
   def test_render_tag_within_if_statement
-    assert_template_result('my message', '{% if true %}{% render "snippet" %}{% endif %}',
-      partials: { 'snippet' => 'my message' })
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => 'my message')
+    assert_template_result('my message', '{% if true %}{% render "snippet" %}{% endif %}')
   end
 
   def test_break_through_render
-    options = { partials: { 'break' => '{% break %}' } }
-    assert_template_result('1', '{% for i in (1..3) %}{{ i }}{% break %}{{ i }}{% endfor %}', **options)
-    assert_template_result('112233', '{% for i in (1..3) %}{{ i }}{% render "break" %}{{ i }}{% endfor %}', **options)
+    Liquid::Template.file_system = StubFileSystem.new('break' => '{% break %}')
+    assert_template_result('1', '{% for i in (1..3) %}{{ i }}{% break %}{{ i }}{% endfor %}')
+    assert_template_result('112233', '{% for i in (1..3) %}{{ i }}{% render "break" %}{{ i }}{% endfor %}')
   end
 
   def test_increment_is_isolated_between_renders
-    assert_template_result('010', '{% increment %}{% increment %}{% render "incr" %}',
-      partials: { 'incr' => '{% increment %}' })
+    Liquid::Template.file_system = StubFileSystem.new('incr' => '{% increment %}')
+    assert_template_result('010', '{% increment %}{% increment %}{% render "incr" %}')
   end
 
   def test_decrement_is_isolated_between_renders
-    assert_template_result('-1-2-1', '{% decrement %}{% decrement %}{% render "decr" %}',
-      partials: { 'decr' => '{% decrement %}' })
+    Liquid::Template.file_system = StubFileSystem.new('decr' => '{% decrement %}')
+    assert_template_result('-1-2-1', '{% decrement %}{% decrement %}{% render "decr" %}')
   end
 
   def test_includes_will_not_render_inside_render_tag
-    assert_template_result(
-      'Liquid error (test_include line 1): include usage is not allowed in this context',
-      '{% render "test_include" %}',
-      render_errors: true,
-      partials: {
-        'foo' => 'bar',
-        'test_include' => '{% include "foo" %}',
-      }
+    Liquid::Template.file_system = StubFileSystem.new(
+      'foo' => 'bar',
+      'test_include' => '{% include "foo" %}'
     )
+
+    exc = assert_raises(Liquid::DisabledError) do
+      Liquid::Template.parse('{% render "test_include" %}').render!
+    end
+    assert_equal('Liquid error: include usage is not allowed in this context', exc.message)
   end
 
   def test_includes_will_not_render_inside_nested_sibling_tags
@@ -143,67 +148,74 @@ class RenderTagTest < Minitest::Test
   end
 
   def test_render_tag_with
+    Liquid::Template.file_system = StubFileSystem.new(
+      'product' => "Product: {{ product.title }} ",
+      'product_alias' => "Product: {{ product.title }} ",
+    )
+
     assert_template_result("Product: Draft 151cm ",
       "{% render 'product' with products[0] %}",
-      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] },
-      partials: {
-        'product' => "Product: {{ product.title }} ",
-        'product_alias' => "Product: {{ product.title }} ",
-      })
+      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] })
   end
 
   def test_render_tag_with_alias
+    Liquid::Template.file_system = StubFileSystem.new(
+      'product' => "Product: {{ product.title }} ",
+      'product_alias' => "Product: {{ product.title }} ",
+    )
+
     assert_template_result("Product: Draft 151cm ",
       "{% render 'product_alias' with products[0] as product %}",
-      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] },
-      partials: {
-        'product' => "Product: {{ product.title }} ",
-        'product_alias' => "Product: {{ product.title }} ",
-      })
+      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] })
   end
 
   def test_render_tag_for_alias
+    Liquid::Template.file_system = StubFileSystem.new(
+      'product' => "Product: {{ product.title }} ",
+      'product_alias' => "Product: {{ product.title }} ",
+    )
+
     assert_template_result("Product: Draft 151cm Product: Element 155cm ",
       "{% render 'product_alias' for products as product %}",
-      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] },
-      partials: {
-        'product' => "Product: {{ product.title }} ",
-        'product_alias' => "Product: {{ product.title }} ",
-      })
+      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] })
   end
 
   def test_render_tag_for
+    Liquid::Template.file_system = StubFileSystem.new(
+      'product' => "Product: {{ product.title }} ",
+      'product_alias' => "Product: {{ product.title }} ",
+    )
+
     assert_template_result("Product: Draft 151cm Product: Element 155cm ",
       "{% render 'product' for products %}",
-      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] },
-      partials: {
-        'product' => "Product: {{ product.title }} ",
-        'product_alias' => "Product: {{ product.title }} ",
-      })
+      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] })
   end
 
   def test_render_tag_forloop
+    Liquid::Template.file_system = StubFileSystem.new(
+      'product' => "Product: {{ product.title }} {% if forloop.first %}first{% endif %} {% if forloop.last %}last{% endif %} index:{{ forloop.index }} ",
+    )
+
     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' }] },
-      partials: {
-        'product' => "Product: {{ product.title }} {% if forloop.first %}first{% endif %} {% if forloop.last %}last{% endif %} index:{{ forloop.index }} ",
-      })
+      { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] })
   end
 
   def test_render_tag_for_drop
+    Liquid::Template.file_system = StubFileSystem.new(
+      'loop' => "{{ value.foo }}",
+    )
+
     assert_template_result("123",
-      "{% render 'loop' for loop as value %}", { "loop" => TestEnumerable.new },
-      partials: {
-        'loop' => "{{ value.foo }}",
-      })
+      "{% render 'loop' for loop as value %}", { "loop" => TestEnumerable.new })
   end
 
   def test_render_tag_with_drop
+    Liquid::Template.file_system = StubFileSystem.new(
+      'loop' => "{{ value }}",
+    )
+
     assert_template_result("TestEnumerable",
-      "{% render 'loop' with loop as value %}", { "loop" => TestEnumerable.new },
-      partials: {
-        'loop' => "{{ value }}",
-      })
+      "{% render 'loop' with loop as value %}", { "loop" => TestEnumerable.new })
   end
 end

test/integration/tags/standard_tag_test.rb

@@ -36,8 +36,6 @@ class StandardTagTest < Minitest::Test
     assert_template_result('', '{%comment%}{% endif %}{%endcomment%}')
     assert_template_result('', '{% comment %}{% endwhatever %}{% endcomment %}')
     assert_template_result('', '{% comment %}{% raw %} {{%%%%}}  }} { {% endcomment %} {% comment {% endraw %} {% endcomment %}')
-    assert_template_result('', '{% comment %}{% " %}{% endcomment %}')
-    assert_template_result('', '{% comment %}{%%}{% endcomment %}')
 
     assert_template_result('foobar', 'foo{%comment%}comment{%endcomment%}bar')
     assert_template_result('foobar', 'foo{% comment %}comment{% endcomment %}bar')

test/integration/tags/table_row_test.rb

@@ -65,116 +65,4 @@ class TableRowTest < Minitest::Test
       "{% tablerow char in characters cols:3 %}I WILL NOT BE OUTPUT{% endtablerow %}",
       { 'characters' => '' })
   end
-
-  def test_cols_nil_constant_same_as_evaluated_nil_expression
-    expect = "<tr class=\"row1\">\n" \
-      "<td class=\"col1\">false</td>" \
-      "<td class=\"col2\">false</td>" \
-      "</tr>\n"
-
-    assert_template_result(expect,
-      "{% tablerow i in (1..2) cols:nil %}{{ tablerowloop.col_last }}{% endtablerow %}")
-
-    assert_template_result(expect,
-      "{% tablerow i in (1..2) cols:var %}{{ tablerowloop.col_last }}{% endtablerow %}",
-      { "var" => nil })
-  end
-
-  def test_nil_limit_is_treated_as_zero
-    expect = "<tr class=\"row1\">\n" \
-      "</tr>\n"
-
-    assert_template_result(expect,
-      "{% tablerow i in (1..2) limit:nil %}{{ i }}{% endtablerow %}")
-
-    assert_template_result(expect,
-      "{% tablerow i in (1..2) limit:var %}{{ i }}{% endtablerow %}",
-      { "var" => nil })
-  end
-
-  def test_nil_offset_is_treated_as_zero
-    expect = "<tr class=\"row1\">\n" \
-      "<td class=\"col1\">1:false</td>" \
-      "<td class=\"col2\">2:true</td>" \
-      "</tr>\n"
-
-    assert_template_result(expect,
-      "{% tablerow i in (1..2) offset:nil %}{{ i }}:{{ tablerowloop.col_last }}{% endtablerow %}")
-
-    assert_template_result(expect,
-      "{% tablerow i in (1..2) offset:var %}{{ i }}:{{ tablerowloop.col_last }}{% endtablerow %}",
-      { "var" => nil })
-  end
-
-  def test_tablerow_loop_drop_attributes
-    template = <<~LIQUID.chomp
-      {% tablerow i in (1...2) %}
-      col: {{ tablerowloop.col }}
-      col0: {{ tablerowloop.col0 }}
-      col_first: {{ tablerowloop.col_first }}
-      col_last: {{ tablerowloop.col_last }}
-      first: {{ tablerowloop.first }}
-      index: {{ tablerowloop.index }}
-      index0: {{ tablerowloop.index0 }}
-      last: {{ tablerowloop.last }}
-      length: {{ tablerowloop.length }}
-      rindex: {{ tablerowloop.rindex }}
-      rindex0: {{ tablerowloop.rindex0 }}
-      row: {{ tablerowloop.row }}
-      {% endtablerow %}
-    LIQUID
-
-    expected_output = <<~OUTPUT
-      <tr class="row1">
-      <td class="col1">
-      col: 1
-      col0: 0
-      col_first: true
-      col_last: false
-      first: true
-      index: 1
-      index0: 0
-      last: false
-      length: 2
-      rindex: 2
-      rindex0: 1
-      row: 1
-      </td><td class="col2">
-      col: 2
-      col0: 1
-      col_first: false
-      col_last: true
-      first: false
-      index: 2
-      index0: 1
-      last: true
-      length: 2
-      rindex: 1
-      rindex0: 0
-      row: 1
-      </td></tr>
-    OUTPUT
-
-    assert_template_result(expected_output, template)
-  end
-
-  def test_table_row_renders_correct_error_message_for_invalid_parameters
-    assert_template_result(
-      "Liquid error (line 1): invalid integer",
-      '{% tablerow n in (1...10) limit:true %} {{n}} {% endtablerow %}',
-      render_errors: true,
-    )
-
-    assert_template_result(
-      "Liquid error (line 1): invalid integer",
-      '{% tablerow n in (1...10) offset:true %} {{n}} {% endtablerow %}',
-      render_errors: true,
-    )
-
-    assert_template_result(
-      "Liquid error (line 1): invalid integer",
-      '{% tablerow n in (1...10) cols:true %} {{n}} {% endtablerow %}',
-      render_errors: true,
-    )
-  end
 end

test/integration/variable_test.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'test_helper'
-require 'timeout'
 
 class VariableTest < Minitest::Test
   include Liquid
@@ -25,22 +24,17 @@ class VariableTest < Minitest::Test
 
   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 foo == eqv %}one{% endif %}', { 'foo' => IntegerDrop.new(1), 'eqv' => 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('one', '{% if b > a %}one{% endif %}', { 'b' => IntegerDrop.new(1), 'a' => IntegerDrop.new(0) })
     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) })
-
-    assert_template_result('one', '{% if a contains x %}one{% endif %}', { 'a' => [1], 'x' => IntegerDrop.new(1) })
   end
 
   def test_unless_tag_calls_to_liquid_value
     assert_template_result('', '{% unless foo %}true{% endunless %}', { 'foo' => BooleanDrop.new(true) })
-    assert_template_result('true', '{% unless foo %}true{% endunless %}', { 'foo' => BooleanDrop.new(false) })
   end
 
   def test_case_tag_calls_to_liquid_value
@@ -136,72 +130,4 @@ class VariableTest < Minitest::Test
   def test_raw_value_variable
     assert_template_result('bar', '{{ [key] }}', { 'key' => 'foo', 'foo' => 'bar' })
   end
-
-  def test_dynamic_find_var_with_drop
-    assert_template_result(
-      'bar',
-      '{{ [list[settings.zero]] }}',
-      {
-        'list' => ['foo'],
-        'settings' => SettingsDrop.new("zero" => 0),
-        'foo' => 'bar',
-      }
-    )
-
-    assert_template_result(
-      'foo',
-      '{{ [list[settings.zero]["foo"]] }}',
-      {
-        'list' => [{ 'foo' => 'bar' }],
-        'settings' => SettingsDrop.new("zero" => 0),
-        'bar' => 'foo',
-      }
-    )
-  end
-
-  def test_double_nested_variable_lookup
-    assert_template_result(
-      'bar',
-      '{{ list[list[settings.zero]]["foo"] }}',
-      {
-        'list' => [1, { 'foo' => 'bar' }],
-        'settings' => SettingsDrop.new("zero" => 0),
-        'bar' => 'foo',
-      }
-    )
-  end
-
-  def test_variable_lookup_should_not_hang_with_invalid_syntax
-    Timeout.timeout(1) do
-      assert_template_result(
-        'bar',
-        "{{['foo'}}",
-        {
-          'foo' => 'bar',
-        },
-        error_mode: :lax,
-      )
-    end
-
-    very_long_key = "1234567890" * 100
-
-    template_list = [
-      "{{['#{very_long_key}']}}", # valid
-      "{{['#{very_long_key}'}}", # missing closing bracket
-      "{{[['#{very_long_key}']}}", # extra open bracket
-    ]
-
-    template_list.each do |template|
-      Timeout.timeout(1) do
-        assert_template_result(
-          'bar',
-          template,
-          {
-            very_long_key => 'bar',
-          },
-          error_mode: :lax,
-        )
-      end
-    end
-  end
 end

test/test_helper.rb

@@ -42,9 +42,9 @@ module Minitest
       message: nil, partials: nil, error_mode: nil, render_errors: false
     )
       template = Liquid::Template.parse(template, line_numbers: true, error_mode: error_mode&.to_sym)
-      file_system = StubFileSystem.new(partials || {})
+      file_system = StubFileSystem.new(partials) if partials
       registers = Liquid::Registers.new(file_system: file_system)
-      context = Liquid::Context.build(static_environments: assigns, rethrow_errors: !render_errors, registers: registers)
+      context = Liquid::Context.build(environments: assigns, rethrow_errors: !render_errors, registers: registers)
       output = template.render(context)
       assert_equal(expected, output, message)
     end
@@ -56,10 +56,6 @@ module Minitest
       assert_match(match, exception.message)
     end
 
-    def assert_syntax_error(template, error_mode: nil)
-      assert_match_syntax_error("", template, error_mode: error_mode)
-    end
-
     def assert_usage_increment(name, times: 1)
       old_method = Liquid::Usage.method(:increment)
       calls = 0
@@ -125,23 +121,16 @@ class ThingWithToLiquid
   end
 end
 
-class SettingsDrop < Liquid::Drop
-  def initialize(settings)
-    super()
-    @settings = settings
-  end
-
-  def liquid_method_missing(key)
-    @settings[key]
-  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
@@ -157,6 +146,10 @@ class BooleanDrop < Liquid::Drop
     @value = value
   end
 
+  def ==(other)
+    @value == other
+  end
+
   def to_liquid_value
     @value
   end

test/unit/regexp_unit_test.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'test_helper'
-require 'timeout'
 
 class RegexpUnitTest < Minitest::Test
   include Liquid
@@ -38,22 +37,10 @@ class RegexpUnitTest < Minitest::Test
 
   def test_variable_parser
     assert_equal(['var'],                               'var'.scan(VariableParser))
-    assert_equal(['[var]'],                             '[var]'.scan(VariableParser))
     assert_equal(['var', 'method'],                     'var.method'.scan(VariableParser))
     assert_equal(['var', '[method]'],                   'var[method]'.scan(VariableParser))
     assert_equal(['var', '[method]', '[0]'],            'var[method][0]'.scan(VariableParser))
     assert_equal(['var', '["method"]', '[0]'],          'var["method"][0]'.scan(VariableParser))
     assert_equal(['var', '[method]', '[0]', 'method'],  'var[method][0].method'.scan(VariableParser))
   end
-
-  def test_variable_parser_with_large_input
-    Timeout.timeout(1) { assert_equal(['[var]'], '[var]'.scan(VariableParser)) }
-
-    very_long_string = "foo" * 1000
-
-    # valid dynamic lookup
-    Timeout.timeout(1) { assert_equal(["[#{very_long_string}]"], "[#{very_long_string}]".scan(VariableParser)) }
-    # invalid dynamic lookup with missing closing bracket
-    Timeout.timeout(1) { assert_equal([very_long_string], "[#{very_long_string}".scan(VariableParser)) }
-  end
 end # RegexpTest

test/unit/tags/for_tag_unit_test.rb

@@ -12,34 +12,4 @@ class ForTagUnitTest < Minitest::Test
     template = Liquid::Template.parse('{% for item in items %}FOR{% else %}ELSE{% endfor %}')
     assert_equal(['FOR', 'ELSE'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten)
   end
-
-  def test_for_string_slice_bug_usage
-    template = Liquid::Template.parse("{% for x in str, offset: 1 %}{{ x }},{% endfor %}")
-    assert_usage("string_slice_bug") do
-      assert_equal("abc,", template.render({ "str" => "abc" }))
-    end
-  end
-
-  def test_for_string_0_limit_usage
-    template = Liquid::Template.parse("{% for x in str, limit: 0 %}{{ x }},{% endfor %}")
-    assert_usage("string_slice_bug") do
-      assert_equal("abc,", template.render({ "str" => "abc" }))
-    end
-  end
-
-  def test_for_string_no_slice_usage
-    template = Liquid::Template.parse("{% for x in str, offset: 0, limit: 1 %}{{ x }},{% endfor %}")
-    assert_usage("string_slice_bug", times: 0) do
-      assert_equal("abc,", template.render({ "str" => "abc" }))
-    end
-  end
-
-  private
-
-  def assert_usage(name, times: 1, &block)
-    count = 0
-    result = Liquid::Usage.stub(:increment, ->(n) { count += 1 if n == name }, &block)
-    assert_equal(times, count)
-    result
-  end
 end