Test gem installation on 1.9.x

.travis.yml

@@ -1,19 +1,17 @@
 rvm:
-  - 1.9
-  - 2.0
+  - 1.9.3
+  - 2.0.0
   - 2.1
-  - 2.2
-  - ruby-head
+  - 2.1.1
   - jruby-19mode
   - jruby-head
-  - rbx-2
+  - rbx-19mode
 matrix:
   allow_failures:
-    - rvm: rbx-2
+    - rvm: rbx-19mode
     - rvm: jruby-head
-    - rvm: ruby-head
 
-script: "rake test"
+script: "gem build liquid.gemspec && gem install liquid-3.0.0.gem"
 
 notifications:
   disable: true

Gemfile

@@ -1,9 +1,3 @@
 source 'https://rubygems.org'
 
 gemspec
-gem 'stackprof', platforms: :mri_21
-
-group :test do
-  gem 'spy', '0.4.1'
-  gem 'benchmark-ips'
-end

History.md

@@ -1,27 +1,9 @@
 # Liquid Version History
 
-## 3.0.3 / 2015-05-28 / branch "3-0-stable"
+## 3.0.0 / not yet released / branch "master"
 
-* Fix condition parse order in strict mode (#569) [Justin Li, pushrax]
-
-## 3.0.2 / 2015-04-24
-
-* Expose VariableLookup private members (#551) [Justin Li, pushrax]
-* Documentation fixes
-
-## 3.0.1 / 2015-01-23
-
-* Remove duplicate `index0` key in TableRow tag (#502) [Alfred Xing]
-
-## 3.0.0 / 2014-11-12
-
-* Removed Block#end_tag. Instead, override parse with `super` followed by your code. See #446 [Dylan Thacker-Smith, dylanahsmith]
-* Fixed condition with wrong data types, see #423 [Bogdan Gusiev]
-* Add url_encode to standard filters, see #421 [Derrick Reimer, djreimer]
-* Add uniq to standard filters [Florian Weingarten, fw42]
-* Add exception_handler feature, see #397 and #254 [Bogdan Gusiev, bogdan and Florian Weingarten, fw42]
-* Optimize variable parsing to avoid repeated regex evaluation during template rendering #383 [Jason Hiltz-Laforge, jasonhl]
-* Optimize checking for block interrupts to reduce object allocation #380 [Jason Hiltz-Laforge, jasonhl] 
+* ...
+* Add error messages for missing variables when :strict, see #352 [Daniel Gaiottino]
 * Properly set context rethrow_errors on render! #349 [Thierry Joyal, tjoyal]
 * Fix broken rendering of variables which are equal to false, see #345 [Florian Weingarten, fw42]
 * Remove ActionView template handler [Dylan Thacker-Smith, dylanahsmith]
@@ -48,13 +30,7 @@
 * Make map filter work on enumerable drops, see #233 [Florian Weingarten, fw42]
 * Improved whitespace stripping for blank blocks, related to #216 [Florian Weingarten, fw42]
 
-## 2.6.1 / 2014-01-10 / branch "2-6-stable"
-
-Security fix, cherry-picked from master (4e14a65):
-* Don't call to_sym when creating conditions for security reasons, see #273 [Bouke van der Bijl, bouk]
-* Prevent arbitrary method invocation on condition objects, see #274 [Dylan Thacker-Smith, dylanahsmith]
-
-## 2.6.0 / 2013-11-25
+## 2.6.0 / 2013-11-25 / branch "2.6-stable"
 
 IMPORTANT: Liquid 2.6 is going to be the last version of Liquid which maintains explicit Ruby 1.8 compatability.
 The following releases will only be tested against Ruby 1.9 and Ruby 2.0 and are likely to break on Ruby 1.8.
@@ -78,13 +54,7 @@ The following releases will only be tested against Ruby 1.9 and Ruby 2.0 and are
 * Better documentation for 'include' tag (closes #163) [Peter Schröder, phoet]
 * Use of BigDecimal on filters to have better precision (closes #155) [Arthur Nogueira Neves, arthurnn]
 
-## 2.5.5 / 2014-01-10 / branch "2-5-stable"
-
-Security fix, cherry-picked from master (4e14a65):
-* Don't call to_sym when creating conditions for security reasons, see #273 [Bouke van der Bijl, bouk]
-* Prevent arbitrary method invocation on condition objects, see #274 [Dylan Thacker-Smith, dylanahsmith]
-
-## 2.5.4 / 2013-11-11
+## 2.5.4 / 2013-11-11 / branch "2.5-stable"
 
 * Fix "can't convert Fixnum into String" for "replace", see #173, [wǒ_is神仙, jsw0528]
 

README.md

@@ -1,5 +1,5 @@
-[![Build Status](https://api.travis-ci.org/Shopify/liquid.svg?branch=master)](http://travis-ci.org/Shopify/liquid)
-[![Inline docs](http://inch-ci.org/github/Shopify/liquid.svg?branch=master)](http://inch-ci.org/github/Shopify/liquid)
+[![Build Status](https://secure.travis-ci.org/Shopify/liquid.png?branch=master)](http://travis-ci.org/Shopify/liquid)
+[![Inline docs](http://inch-ci.org/github/Shopify/liquid.png)](http://inch-ci.org/github/Shopify/liquid)
 
 # Liquid template engine
 

example/server/liquid_servlet.rb

@@ -11,8 +11,7 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
   private
 
   def handle(type, req, res)
-    @request = req
-    @response = res
+    @request, @response = req, res
 
     @request.path_info =~ /(\w+)\z/
     @action = $1 || 'index'

example/server/templates/index.liquid

@@ -3,4 +3,4 @@
 <p>It is {{date}}</p>
 
 
-<p>Check out the <a href="/products">Products</a> screen </p>
+<p>Check out the <a href="http://localhost:3000/products">Products</a> screen </p>

lib/liquid.rb

@@ -38,9 +38,6 @@ module Liquid
   PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
   TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
   VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
-
-  singleton_class.send(:attr_accessor, :cache_classes)
-  self.cache_classes = true
 end
 
 require "liquid/version"
@@ -52,26 +49,18 @@ require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
 require 'liquid/strainer'
-require 'liquid/expression'
 require 'liquid/context'
-require 'liquid/parser_switching'
 require 'liquid/tag'
 require 'liquid/block'
 require 'liquid/document'
 require 'liquid/variable'
-require 'liquid/variable_lookup'
-require 'liquid/range_lookup'
 require 'liquid/file_system'
 require 'liquid/template'
 require 'liquid/standardfilters'
 require 'liquid/condition'
 require 'liquid/module_ex'
 require 'liquid/utils'
-require 'liquid/token'
 
 # Load all the tags of the standard library
 #
 Dir[File.dirname(__FILE__) + '/liquid/tags/*.rb'].each { |f| require f }
-
-require 'liquid/profiler'
-require 'liquid/profiler/hooks'

lib/liquid/block.rb

@@ -1,12 +1,12 @@
 module Liquid
   class Block < Tag
+    IsTag             = /\A#{TagStart}/o
+    IsVariable        = /\A#{VariableStart}/o
     FullToken         = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
     ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
-    TAGSTART = "{%".freeze
-    VARSTART = "{{".freeze
 
     def blank?
-      @blank
+      @blank || false
     end
 
     def parse(tokens)
@@ -14,45 +14,45 @@ module Liquid
       @nodelist ||= []
       @nodelist.clear
 
+      # All child tags of the current block.
+      @children = []
+
       while token = tokens.shift
-        begin
-          unless token.empty?
-            case
-            when token.start_with?(TAGSTART)
-              if token =~ FullToken
+        case token
+        when IsTag
+          if token =~ FullToken
 
-                # if we found the proper block delimiter just end parsing here and let the outer block
-                # proceed
-                return if block_delimiter == $1
-
-                # fetch the tag from registered blocks
-                if tag = Template.tags[$1]
-                  markup = token.is_a?(Token) ? token.child($2) : $2
-                  new_tag = tag.parse($1, markup, tokens, @options)
-                  new_tag.line_number = token.line_number if token.is_a?(Token)
-                  @blank &&= new_tag.blank?
-                  @nodelist << new_tag
-                else
-                  # this tag is not registered with the system
-                  # pass it to the current block for special handling or error reporting
-                  unknown_tag($1, $2, tokens)
-                end
-              else
-                raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination".freeze, :token => token, :tag_end => TagEnd.inspect))
-              end
-            when token.start_with?(VARSTART)
-              new_var = create_variable(token)
-              new_var.line_number = token.line_number if token.is_a?(Token)
-              @nodelist << new_var
-              @blank = false
-            else
-              @nodelist << token
-              @blank &&= (token =~ /\A\s*\z/)
+            # if we found the proper block delimiter just end parsing here and let the outer block
+            # proceed
+            if block_delimiter == $1
+              end_tag
+              return
             end
+
+            # fetch the tag from registered blocks
+            if tag = Template.tags[$1]
+              new_tag = tag.parse($1, $2, tokens, @options)
+              @blank &&= new_tag.blank?
+              @nodelist << new_tag
+              @children << new_tag
+            else
+              # this tag is not registered with the system
+              # pass it to the current block for special handling or error reporting
+              unknown_tag($1, $2, tokens)
+            end
+          else
+            raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination".freeze, :token => token, :tag_end => TagEnd.inspect))
           end
-        rescue SyntaxError => e
-          e.set_line_number_from_token(token)
-          raise
+        when IsVariable
+          new_var = create_variable(token)
+          @nodelist << new_var
+          @children << new_var
+          @blank = false
+        when ''.freeze
+          # pass
+        else
+          @nodelist << token
+          @blank &&= (token =~ /\A\s*\z/)
         end
       end
 
@@ -67,13 +67,16 @@ module Liquid
       all_warnings = []
       all_warnings.concat(@warnings) if @warnings
 
-      (nodelist || []).each do |node|
-        all_warnings.concat(node.warnings || []) if node.respond_to?(:warnings)
+      (@children || []).each do |node|
+        all_warnings.concat(node.warnings || [])
       end
 
       all_warnings
     end
 
+    def end_tag
+    end
+
     def unknown_tag(tag, params, tokens)
       case tag
       when 'else'.freeze
@@ -88,18 +91,17 @@ module Liquid
       end
     end
 
+    def block_delimiter
+      "end#{block_name}"
+    end
+
     def block_name
       @tag_name
     end
 
-    def block_delimiter
-      @block_delimiter ||= "end#{block_name}"
-    end
-
     def create_variable(token)
       token.scan(ContentOfVariable) do |content|
-        markup = token.is_a?(Token) ? token.child(content.first) : content.first
-        return Variable.new(markup, @options)
+        return Variable.new(content.first, @options)
       end
       raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination".freeze, :token => token, :tag_end => VariableEnd.inspect))
     end
@@ -132,29 +134,23 @@ module Liquid
             break
           end
 
-          token_output = render_token(token, context)
-
+          token_output = (token.respond_to?(:render) ? token.render(context) : token)
+          context.increment_used_resources(:render_length_current, token_output)
+          if context.resource_limits_reached?
+            context.resource_limits[:reached] = true
+            raise MemoryError.new("Memory limits exceeded".freeze)
+          end
           unless token.is_a?(Block) && token.blank?
             output << token_output
           end
         rescue MemoryError => e
           raise e
         rescue ::StandardError => e
-          output << (context.handle_error(e, token))
+          output << (context.handle_error(e))
         end
       end
 
       output.join
     end
-
-    def render_token(token, context)
-      token_output = (token.respond_to?(:render) ? token.render(context) : token)
-      context.increment_used_resources(:render_length_current, token_output)
-      if context.resource_limits_reached?
-        context.resource_limits[:reached] = true
-        raise MemoryError.new("Memory limits exceeded".freeze)
-      end
-      token_output
-    end
   end
 end

lib/liquid/block_body.rb

@@ -1,123 +0,0 @@
-module Liquid
-  class BlockBody
-    FullToken = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
-    ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
-    TAGSTART = "{%".freeze
-    VARSTART = "{{".freeze
-
-    attr_reader :nodelist
-
-    def initialize
-      @nodelist = []
-      @blank = true
-    end
-
-    def parse(tokens, options)
-      while token = tokens.shift
-        begin
-          unless token.empty?
-            case
-            when token.start_with?(TAGSTART)
-              if token =~ FullToken
-                tag_name = $1
-                markup = $2
-                # fetch the tag from registered blocks
-                if tag = Template.tags[tag_name]
-                  markup = token.child(markup) if token.is_a?(Token)
-                  new_tag = tag.parse(tag_name, markup, tokens, options)
-                  new_tag.line_number = token.line_number if token.is_a?(Token)
-                  @blank &&= new_tag.blank?
-                  @nodelist << new_tag
-                else
-                  # end parsing if we reach an unknown tag and let the caller decide
-                  # determine how to proceed
-                  return yield tag_name, markup
-                end
-              else
-                raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination".freeze, :token => token, :tag_end => TagEnd.inspect))
-              end
-            when token.start_with?(VARSTART)
-              new_var = create_variable(token, options)
-              new_var.line_number = token.line_number if token.is_a?(Token)
-              @nodelist << new_var
-              @blank = false
-            else
-              @nodelist << token
-              @blank &&= !!(token =~ /\A\s*\z/)
-            end
-          end
-        rescue SyntaxError => e
-          e.set_line_number_from_token(token)
-          raise
-        end
-      end
-
-      yield nil, nil
-    end
-
-    def blank?
-      @blank
-    end
-
-    def warnings
-      all_warnings = []
-      nodelist.each do |node|
-        all_warnings.concat(node.warnings) if node.respond_to?(:warnings) && node.warnings
-      end
-      all_warnings
-    end
-
-    def render(context)
-      output = []
-      context.resource_limits[:render_length_current] = 0
-      context.resource_limits[:render_score_current] += @nodelist.length
-
-      @nodelist.each do |token|
-        # Break out if we have any unhanded interrupts.
-        break if context.has_interrupt?
-
-        begin
-          # If we get an Interrupt that means the block must stop processing. An
-          # Interrupt is any command that stops block execution such as {% break %}
-          # or {% continue %}
-          if token.is_a?(Continue) or token.is_a?(Break)
-            context.push_interrupt(token.interrupt)
-            break
-          end
-
-          token_output = render_token(token, context)
-
-          unless token.is_a?(Block) && token.blank?
-            output << token_output
-          end
-        rescue MemoryError => e
-          raise e
-        rescue ::StandardError => e
-          output << context.handle_error(e, token)
-        end
-      end
-
-      output.join
-    end
-
-    private
-
-    def render_token(token, context)
-      token_output = (token.respond_to?(:render) ? token.render(context) : token)
-      context.increment_used_resources(:render_length_current, token_output)
-      if context.resource_limits_reached?
-        context.resource_limits[:reached] = true
-        raise MemoryError.new("Memory limits exceeded".freeze)
-      end
-      token_output
-    end
-
-    def create_variable(token, options)
-      token.scan(ContentOfVariable) do |content|
-        markup = token.is_a?(Token) ? token.child(content.first) : content.first
-        return Variable.new(markup, options)
-      end
-      raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination".freeze, :token => token, :tag_end => VariableEnd.inspect))
-    end
-  end
-end

lib/liquid/condition.rb

@@ -15,9 +15,7 @@ module Liquid
       '>'.freeze  => :>,
       '>='.freeze => :>=,
       '<='.freeze => :<=,
-      'contains'.freeze => lambda { |cond, left, right|
-        left && right && left.respond_to?(:include?) ? left.include?(right) : false
-      }
+      'contains'.freeze => lambda { |cond, left, right| left && right ? left.include?(right) : false }
     }
 
     def self.operators
@@ -28,9 +26,7 @@ module Liquid
     attr_accessor :left, :operator, :right
 
     def initialize(left = nil, operator = nil, right = nil)
-      @left = left
-      @operator = operator
-      @right = right
+      @left, @operator, @right = left, operator, right
       @child_relation  = nil
       @child_condition = nil
     end
@@ -49,13 +45,11 @@ module Liquid
     end
 
     def or(condition)
-      @child_relation = :or
-      @child_condition = condition
+      @child_relation, @child_condition = :or, condition
     end
 
     def and(condition)
-      @child_relation = :and
-      @child_condition = condition
+      @child_relation, @child_condition = :and, condition
     end
 
     def attach(attachment)
@@ -98,19 +92,14 @@ module Liquid
       # return this as the result.
       return context[left] if op == nil
 
-      left = context[left]
-      right = context[right]
+      left, right = context[left], context[right]
 
-      operation = self.class.operators[op] || raise(Liquid::ArgumentError.new("Unknown operator #{op}"))
+      operation = self.class.operators[op] || raise(ArgumentError.new("Unknown operator #{op}"))
 
       if operation.respond_to?(:call)
         operation.call(self, left, right)
       elsif left.respond_to?(operation) and right.respond_to?(operation)
-        begin
-          left.send(operation, right)
-        rescue ::ArgumentError => e
-          raise Liquid::ArgumentError.new(e.message)
-        end
+        left.send(operation, right)
       else
         nil
       end

lib/liquid/context.rb

@@ -14,25 +14,18 @@ module Liquid
   #   context['bob']  #=> nil  class Context
   class Context
     attr_reader :scopes, :errors, :registers, :environments, :resource_limits
-    attr_accessor :exception_handler
 
-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
-      @environments     = [environments].flatten
-      @scopes           = [(outer_scope || {})]
-      @registers        = registers
-      @errors           = []
-      @resource_limits  = resource_limits || Template.default_resource_limits.dup
-      @resource_limits[:render_score_current] = 0
-      @resource_limits[:assign_score_current] = 0
-      @parsed_expression = Hash.new{ |cache, markup| cache[markup] = Expression.parse(markup) }
+    attr_accessor :rethrow_errors
+
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = {})
+      @environments    = [environments].flatten
+      @scopes          = [(outer_scope || {})]
+      @registers       = registers
+      @errors          = []
+      @rethrow_errors  = rethrow_errors
+      @resource_limits = (resource_limits || {}).merge!({ :render_score_current => 0, :assign_score_current => 0 })
       squash_instance_assigns_with_environments
 
-      @this_stack_used = false
-
-      if rethrow_errors
-        self.exception_handler = ->(e) { true }
-      end
-
       @interrupts = []
       @filters = []
     end
@@ -61,13 +54,26 @@ module Liquid
     # for that
     def add_filters(filters)
       filters = [filters].flatten.compact
-      @filters += filters
-      @strainer = nil
+      filters.each do |f|
+        raise ArgumentError, "Expected module but got: #{f.class}" unless f.is_a?(Module)
+        Strainer.add_known_filter(f)
+      end
+
+      # If strainer is already setup then there's no choice but to use a runtime
+      # extend call. If strainer is not yet created, we can utilize strainers
+      # cached class based API, which avoids busting the method cache.
+      if @strainer
+        filters.each do |f|
+          strainer.extend(f)
+        end
+      else
+        @filters.concat filters
+      end
     end
 
     # are there any not handled interrupts?
     def has_interrupt?
-      !@interrupts.empty?
+      @interrupts.any?
     end
 
     # push an interrupt to the stack. this interrupt is considered not handled.
@@ -80,19 +86,20 @@ module Liquid
       @interrupts.pop
     end
 
-
-    def handle_error(e, token=nil)
-      if e.is_a?(Liquid::Error)
-        e.set_line_number_from_token(token)
-      end
-
+    def handle_error(e)
       errors.push(e)
-      raise if exception_handler && exception_handler.call(e)
-      Liquid::Error.render(e)
+      raise if @rethrow_errors
+
+      case e
+      when SyntaxError
+        "Liquid syntax error: #{e.message}"
+      else
+        "Liquid error: #{e.message}"
+      end
     end
 
     def invoke(method, *args)
-      strainer.invoke(method, *args).to_liquid
+      strainer.invoke(method, *args)
     end
 
     # Push new local scope on the stack. use <tt>Context#stack</tt> instead
@@ -120,19 +127,11 @@ module Liquid
     #   end
     #
     #   context['var]  #=> nil
-    def stack(new_scope=nil)
-      old_stack_used = @this_stack_used
-      if new_scope
-        push(new_scope)
-        @this_stack_used = true
-      else
-        @this_stack_used = false
-      end
-
+    def stack(new_scope={})
+      push(new_scope)
       yield
     ensure
-      pop if @this_stack_used
-      @this_stack_used = old_stack_used
+      pop
     end
 
     def clear_instance_assigns
@@ -141,71 +140,141 @@ module Liquid
 
     # Only allow String, Numeric, Hash, Array, Proc, Boolean or <tt>Liquid::Drop</tt>
     def []=(key, value)
-      unless @this_stack_used
-        @this_stack_used = true
-        push({})
-      end
       @scopes[0][key] = value
     end
 
-    # Look up variable, either resolve directly after considering the name. We can directly handle
-    # Strings, digits, floats and booleans (true,false).
-    # If no match is made we lookup the variable in the current scope and
-    # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
-    # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
-    #
-    # Example:
-    #   products == empty #=> products.empty?
-    def [](expression)
-      evaluate(@parsed_expression[expression])
+    def [](key)
+      resolve(key)
     end
 
     def has_key?(key)
-      self[key] != nil
+      resolve(key) != nil
     end
 
-    def evaluate(object)
-      object.respond_to?(:evaluate) ? object.evaluate(self) : object
-    end
+    private
+      LITERALS = {
+        nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
+        'true'.freeze  => true,
+        'false'.freeze => false,
+        'blank'.freeze => :blank?,
+        'empty'.freeze => :empty?
+      }
 
-    # Fetches an object starting at the local scope and then moving up the hierachy
-    def find_variable(key)
-
-      # This was changed from find() to find_index() because this is a very hot
-      # path and find_index() is optimized in MRI to reduce object allocation
-      index = @scopes.find_index { |s| s.has_key?(key) }
-      scope = @scopes[index] if index
-
-      variable = nil
-
-      if scope.nil?
-        @environments.each do |e|
-          variable = lookup_and_evaluate(e, key)
-          unless variable.nil?
-            scope = e
-            break
+      # Look up variable, either resolve directly after considering the name. We can directly handle
+      # Strings, digits, floats and booleans (true,false).
+      # If no match is made we lookup the variable in the current scope and
+      # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
+      # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
+      #
+      # Example:
+      #   products == empty #=> products.empty?
+      def resolve(key)
+        if LITERALS.key?(key)
+          LITERALS[key]
+        else
+          case key
+          when /\A'(.*)'\z/m # Single quoted strings
+            $1
+          when /\A"(.*)"\z/m # Double quoted strings
+            $1
+          when /\A(-?\d+)\z/ # Integer and floats
+            $1.to_i
+          when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
+            (resolve($1).to_i..resolve($2).to_i)
+          when /\A(-?\d[\d\.]+)\z/ # Floats
+            $1.to_f
+          else
+            variable(key)
           end
         end
       end
 
-      scope     ||= @environments.last || @scopes.last
-      variable  ||= lookup_and_evaluate(scope, key)
+      # Fetches an object starting at the local scope and then moving up the hierachy
+      def find_variable(key)
+        scope = @scopes.find { |s| s.has_key?(key) }
+        variable = nil
 
-      variable = variable.to_liquid
-      variable.context = self if variable.respond_to?(:context=)
+        if scope.nil?
+          @environments.each do |e|
+            variable = lookup_and_evaluate(e, key)
+            unless variable.nil?
+              scope = e
+              break
+            end
+          end
+        end
 
-      return variable
-    end
+        scope     ||= @environments.last || @scopes.last
+        handle_not_found(key) unless scope.has_key?(key)
+        variable  ||= lookup_and_evaluate(scope, key)
 
-    def lookup_and_evaluate(obj, key)
-      if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
-        obj[key] = (value.arity == 0) ? value.call : value.call(self)
-      else
-        value
+        variable = variable.to_liquid
+        variable.context = self if variable.respond_to?(:context=)
+
+        return variable
       end
-    end
 
-    private
+      # Resolves namespaced queries gracefully.
+      #
+      # Example
+      #  @context['hash'] = {"name" => 'tobi'}
+      #  assert_equal 'tobi', @context['hash.name']
+      #  assert_equal 'tobi', @context['hash["name"]']
+      def variable(markup)
+        parts = markup.scan(VariableParser)
+        square_bracketed = /\A\[(.*)\]\z/m
+
+        first_part = parts.shift
+
+        if first_part =~ square_bracketed
+          first_part = resolve($1)
+        end
+
+        if object = find_variable(first_part)
+
+          parts.each do |part|
+            part = resolve($1) if part_resolved = (part =~ square_bracketed)
+
+            # 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?(:[]) and
+              ((object.respond_to?(:has_key?) and object.has_key?(part)) or
+               (object.respond_to?(:fetch) and part.is_a?(Integer)))
+
+              # if its a proc we will replace the entry with the proc
+              res = lookup_and_evaluate(object, part)
+              object = res.to_liquid
+
+              # Some special cases. If the part wasn't in square brackets and
+              # no key with the same name was found we interpret following calls
+              # as commands and call them on the current object
+            elsif !part_resolved and object.respond_to?(part) and ['size'.freeze, 'first'.freeze, 'last'.freeze].include?(part)
+
+              object = object.send(part.intern).to_liquid
+
+              # No key was present with the desired value and it wasn't one of the directly supported
+              # keywords either. The only thing we got left is to return nil
+            else
+              handle_not_found(markup)
+              return nil
+            end
+
+            # If we are dealing with a drop here we have to
+            object.context = self if object.respond_to?(:context=)
+          end
+        end
+
+        object
+      end # variable
+
+      def lookup_and_evaluate(obj, key)
+        if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
+          obj[key] = (value.arity == 0) ? value.call : value.call(self)
+        else
+          value
+        end
+      end # lookup_and_evaluate
+
       def squash_instance_assigns_with_environments
         @scopes.last.each_key do |k|
           @environments.each do |env|
@@ -216,5 +285,10 @@ module Liquid
           end
         end
       end # squash_instance_assigns_with_environments
+
+      def handle_not_found(variable)
+        @errors << "Variable {{#{variable}}} not found" if Template.error_mode == :strict
+      end
   end # Context
+
 end # Liquid

lib/liquid/errors.rb

@@ -1,60 +1,12 @@
 module Liquid
-  class Error < ::StandardError
-    attr_accessor :line_number
-    attr_accessor :markup_context
-
-    def to_s(with_prefix=true)
-      str = ""
-      str << message_prefix if with_prefix
-      str << super()
-
-      if markup_context
-        str << " "
-        str << markup_context
-      end
-
-      str
-    end
-
-    def set_line_number_from_token(token)
-      return unless token.respond_to?(:line_number)
-      return if self.line_number
-      self.line_number = token.line_number
-    end
-
-    def self.render(e)
-      if e.is_a?(Liquid::Error)
-        e.to_s
-      else
-        "Liquid error: #{e.to_s}"
-      end
-    end
-
-    private
-
-    def message_prefix
-      str = ""
-      if is_a?(SyntaxError)
-        str << "Liquid syntax error"
-      else
-        str << "Liquid error"
-      end
-
-      if line_number
-        str << " (line #{line_number})"
-      end
-
-      str << ": "
-      str
-    end
-  end
+  class Error < ::StandardError; end
 
   class ArgumentError < Error; end
   class ContextError < Error; end
+  class FilterNotFound < Error; end
   class FileSystemError < Error; end
   class StandardError < Error; end
   class SyntaxError < Error; end
   class StackLevelError < Error; end
-  class TaintedError < Error; end
   class MemoryError < Error; end
 end

lib/liquid/expression.rb

@@ -1,33 +0,0 @@
-module Liquid
-  class Expression
-    LITERALS = {
-      nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
-      'true'.freeze  => true,
-      'false'.freeze => false,
-      'blank'.freeze => :blank?,
-      'empty'.freeze => :empty?
-    }
-
-    def self.parse(markup)
-      if LITERALS.key?(markup)
-        LITERALS[markup]
-      else
-        case markup
-        when /\A'(.*)'\z/m # Single quoted strings
-          $1
-        when /\A"(.*)"\z/m # Double quoted strings
-          $1
-        when /\A(-?\d+)\z/ # Integer and floats
-          $1.to_i
-        when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
-          RangeLookup.parse($1, $2)
-        when /\A(-?\d[\d\.]+)\z/ # Floats
-          $1.to_f
-        else
-          VariableLookup.parse(markup)
-        end
-      end
-    end
-
-  end
-end

lib/liquid/parser_switching.rb

@@ -1,31 +0,0 @@
-module Liquid
-  module ParserSwitching
-    def parse_with_selected_parser(markup)
-      case @options[:error_mode] || Template.error_mode
-      when :strict then strict_parse_with_error_context(markup)
-      when :lax    then lax_parse(markup)
-      when :warn
-        begin
-          return strict_parse_with_error_context(markup)
-        rescue SyntaxError => e
-          e.set_line_number_from_token(markup)
-          @warnings ||= []
-          @warnings << e
-          return lax_parse(markup)
-        end
-      end
-    end
-
-    private
-    def strict_parse_with_error_context(markup)
-      strict_parse(markup)
-    rescue SyntaxError => e
-      e.markup_context = markup_context(markup)
-      raise e
-    end
-
-    def markup_context(markup)
-      "in \"#{markup.strip}\""
-    end
-  end
-end

lib/liquid/profiler.rb

@@ -1,159 +0,0 @@
-module Liquid
-
-  # Profiler enables support for profiling template rendering to help track down performance issues.
-  #
-  # To enable profiling, pass the <tt>profile: true</tt> option to <tt>Liquid::Template.parse</tt>. Then, after
-  # <tt>Liquid::Template#render</tt> is called, the template object makes available an instance of this
-  # class via the <tt>Liquid::Template#profiler</tt> method.
-  #
-  #   template = Liquid::Template.parse(template_content, profile: true)
-  #   output  = template.render
-  #   profile = template.profiler
-  #
-  # This object contains all profiling information, containing information on what tags were rendered,
-  # where in the templates these tags live, and how long each tag took to render.
-  #
-  # This is a tree structure that is Enumerable all the way down, and keeps track of tags and rendering times
-  # inside of <tt>{% include %}</tt> tags.
-  #
-  #   profile.each do |node|
-  #     # Access to the token itself
-  #     node.code
-  #
-  #     # Which template and line number of this node.
-  #     # If top level, this will be "<root>".
-  #     node.partial
-  #     node.line_number
-  #
-  #     # Render time in seconds of this node
-  #     node.render_time
-  #
-  #     # If the template used {% include %}, this node will also have children.
-  #     node.children.each do |child2|
-  #       # ...
-  #     end
-  #   end
-  #
-  # Profiler also exposes the total time of the template's render in <tt>Liquid::Profiler#total_render_time</tt>.
-  #
-  # All render times are in seconds. There is a small performance hit when profiling is enabled.
-  #
-  class Profiler
-    include Enumerable
-
-    class Timing
-      attr_reader :code, :partial, :line_number, :children
-
-      def initialize(token, partial)
-        @code        = token.respond_to?(:raw) ? token.raw : token
-        @partial     = partial
-        @line_number = token.respond_to?(:line_number) ? token.line_number : nil
-        @children    = []
-      end
-
-      def self.start(token, partial)
-        new(token, partial).tap do |t|
-          t.start
-        end
-      end
-
-      def start
-        @start_time = Time.now
-      end
-
-      def finish
-        @end_time = Time.now
-      end
-
-      def render_time
-        @end_time - @start_time
-      end
-    end
-
-    def self.profile_token_render(token)
-      if Profiler.current_profile && token.respond_to?(:render)
-        Profiler.current_profile.start_token(token)
-        output = yield
-        Profiler.current_profile.end_token(token)
-        output
-      else
-        yield
-      end
-    end
-
-    def self.profile_children(template_name)
-      if Profiler.current_profile
-        Profiler.current_profile.push_partial(template_name)
-        output = yield
-        Profiler.current_profile.pop_partial
-        output
-      else
-        yield
-      end
-    end
-
-    def self.current_profile
-      Thread.current[:liquid_profiler]
-    end
-
-    def initialize
-      @partial_stack = ["<root>"]
-
-      @root_timing = Timing.new("", current_partial)
-      @timing_stack = [@root_timing]
-
-      @render_start_at = Time.now
-      @render_end_at = @render_start_at
-    end
-
-    def start
-      Thread.current[:liquid_profiler] = self
-      @render_start_at = Time.now
-    end
-
-    def stop
-      Thread.current[:liquid_profiler] = nil
-      @render_end_at = Time.now
-    end
-
-    def total_render_time
-      @render_end_at - @render_start_at
-    end
-
-    def each(&block)
-      @root_timing.children.each(&block)
-    end
-
-    def [](idx)
-      @root_timing.children[idx]
-    end
-
-    def length
-      @root_timing.children.length
-    end
-
-    def start_token(token)
-      @timing_stack.push(Timing.start(token, current_partial))
-    end
-
-    def end_token(token)
-      timing = @timing_stack.pop
-      timing.finish
-
-      @timing_stack.last.children << timing
-    end
-
-    def current_partial
-      @partial_stack.last
-    end
-
-    def push_partial(partial_name)
-      @partial_stack.push(partial_name)
-    end
-
-    def pop_partial
-      @partial_stack.pop
-    end
-
-  end
-end

lib/liquid/profiler/hooks.rb

@@ -1,23 +0,0 @@
-module Liquid
-  class Block < Tag
-    def render_token_with_profiling(token, context)
-      Profiler.profile_token_render(token) do
-        render_token_without_profiling(token, context)
-      end
-    end
-
-    alias_method :render_token_without_profiling, :render_token
-    alias_method :render_token, :render_token_with_profiling
-  end
-
-  class Include < Tag
-    def render_with_profiling(context)
-      Profiler.profile_children(@template_name) do
-        render_without_profiling(context)
-      end
-    end
-
-    alias_method :render_without_profiling, :render
-    alias_method :render, :render_with_profiling
-  end
-end

lib/liquid/range_lookup.rb

@@ -1,22 +0,0 @@
-module Liquid
-  class RangeLookup
-    def self.parse(start_markup, end_markup)
-      start_obj = Expression.parse(start_markup)
-      end_obj = Expression.parse(end_markup)
-      if start_obj.respond_to?(:evaluate) || end_obj.respond_to?(:evaluate)
-        new(start_obj, end_obj)
-      else
-        start_obj.to_i..end_obj.to_i
-      end
-    end
-
-    def initialize(start_obj, end_obj)
-      @start_obj = start_obj
-      @end_obj = end_obj
-    end
-
-    def evaluate(context)
-      context.evaluate(@start_obj).to_i..context.evaluate(@end_obj).to_i
-    end
-  end
-end

lib/liquid/standardfilters.rb

@@ -34,28 +34,14 @@ module Liquid
     end
 
     def escape(input)
-      CGI.escapeHTML(input).untaint rescue input
+      CGI.escapeHTML(input) rescue input
     end
-    alias_method :h, :escape
 
     def escape_once(input)
       input.to_s.gsub(HTML_ESCAPE_ONCE_REGEXP, HTML_ESCAPE)
     end
 
-    def url_encode(input)
-      CGI.escape(input) rescue input
-    end
-
-    def slice(input, offset, length=nil)
-      offset = Integer(offset)
-      length = length ? Integer(length) : 1
-
-      if input.is_a?(Array)
-        input.slice(offset, length) || []
-      else
-        input.to_s.slice(offset, length) || ''
-      end
-    end
+    alias_method :h, :escape
 
     # Truncate a string down to x characters
     def truncate(input, length = 50, truncate_string = "...".freeze)
@@ -79,7 +65,7 @@ module Liquid
     #   <div class="summary">{{ post | split '//' | first }}</div>
     #
     def split(input, pattern)
-      input.to_s.split(pattern)
+      input.split(pattern)
     end
 
     def strip(input)
@@ -106,42 +92,31 @@ module Liquid
 
     # Join elements of the array with certain character between them
     def join(input, glue = ' '.freeze)
-      InputIterator.new(input).join(glue)
+      [input].flatten.join(glue)
     end
 
     # Sort elements of the array
     # provide optional property with which to sort an array of hashes or drops
     def sort(input, property = nil)
-      ary = InputIterator.new(input)
+      ary = flatten_if_necessary(input)
       if property.nil?
         ary.sort
-      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
+      elsif ary.first.respond_to?('[]'.freeze) and !ary.first[property].nil?
         ary.sort {|a,b| a[property] <=> b[property] }
       elsif ary.first.respond_to?(property)
         ary.sort {|a,b| a.send(property) <=> b.send(property) }
       end
     end
 
-    # Remove duplicate elements from an array
-    # provide optional property with which to determine uniqueness
-    def uniq(input, property = nil)
-      ary = InputIterator.new(input)
-      if property.nil?
-        input.uniq
-      elsif input.first.respond_to?(:[])
-        input.uniq{ |a| a[property] }
-      end
-    end
-
     # Reverse the elements of an array
     def reverse(input)
-      ary = InputIterator.new(input)
+      ary = [input].flatten
       ary.reverse
     end
 
     # map/collect on a given property
     def map(input, property)
-      InputIterator.new(input).map do |e|
+      flatten_if_necessary(input).map do |e|
         e = e.call if e.is_a?(Proc)
 
         if property == "to_liquid".freeze
@@ -290,6 +265,17 @@ module Liquid
 
     private
 
+    def flatten_if_necessary(input)
+      ary = if input.is_a?(Array)
+        input.flatten
+      elsif input.is_a?(Enumerable) && !input.is_a?(Hash)
+        input
+      else
+        [input].flatten
+      end
+      ary.map{ |e| e.respond_to?(:to_liquid) ? e.to_liquid : e }
+    end
+
     def to_number(obj)
       case obj
       when Float
@@ -324,36 +310,6 @@ module Liquid
       result = to_number(input).send(operation, to_number(operand))
       result.is_a?(BigDecimal) ? result.to_f : result
     end
-
-    class InputIterator
-      include Enumerable
-
-      def initialize(input)
-        @input = if input.is_a?(Array)
-          input.flatten
-        elsif input.is_a?(Hash)
-          [input]
-        elsif input.is_a?(Enumerable)
-          input
-        else
-          Array(input)
-        end
-      end
-
-      def join(glue)
-        to_a.join(glue)
-      end
-
-      def reverse
-        reverse_each.to_a
-      end
-
-      def each
-        @input.each do |e|
-          yield(e.respond_to?(:to_liquid) ? e.to_liquid : e)
-        end
-      end
-    end
   end
 
   Template.register_filter(StandardFilters)

lib/liquid/strainer.rb

@@ -8,13 +8,12 @@ module Liquid
   # The Strainer only allows method calls defined in filters given to it via Strainer.global_filter,
   # Context#add_filters or Template.register_filter
   class Strainer #:nodoc:
-    @@global_strainer = Class.new(Strainer) do
-      @filter_methods = Set.new
-    end
+    @@filters = []
+    @@known_filters = Set.new
+    @@known_methods = Set.new
     @@strainer_class_cache = Hash.new do |hash, filters|
-      hash[filters] = Class.new(@@global_strainer) do
-        @filter_methods = @@global_strainer.filter_methods.dup
-        filters.each { |f| add_filter(f) }
+      hash[filters] = Class.new(Strainer) do
+        filters.each { |f| include f }
       end
     end
 
@@ -22,32 +21,33 @@ module Liquid
       @context = context
     end
 
-    def self.filter_methods
-      @filter_methods
+    def self.global_filter(filter)
+      raise ArgumentError, "Passed filter is not a module" unless filter.is_a?(Module)
+      add_known_filter(filter)
+      @@filters << filter unless @@filters.include?(filter)
     end
 
-    def self.add_filter(filter)
-      raise ArgumentError, "Expected module but got: #{f.class}" unless filter.is_a?(Module)
-      unless self.class.include?(filter)
-        self.send(:include, filter)
-        @filter_methods.merge(filter.public_instance_methods.map(&:to_s))
+    def self.add_known_filter(filter)
+      unless @@known_filters.include?(filter)
+        @@method_blacklist ||= Set.new(Strainer.instance_methods.map(&:to_s))
+        new_methods = filter.instance_methods.map(&:to_s)
+        new_methods.reject!{ |m| @@method_blacklist.include?(m) }
+        @@known_methods.merge(new_methods)
+        @@known_filters.add(filter)
       end
     end
 
-    def self.global_filter(filter)
-      @@global_strainer.add_filter(filter)
-    end
-
-    def self.invokable?(method)
-      @filter_methods.include?(method.to_s)
+    def self.strainer_class_cache
+      @@strainer_class_cache
     end
 
     def self.create(context, filters = [])
-      @@strainer_class_cache[filters].new(context)
+      filters = @@filters + filters
+      strainer_class_cache[filters].new(context)
     end
 
     def invoke(method, *args)
-      if self.class.invokable?(method)
+      if invokable?(method)
         send(method, *args)
       else
         args.first
@@ -55,5 +55,9 @@ module Liquid
     rescue ::ArgumentError => e
       raise Liquid::ArgumentError.new(e.message)
     end
+
+    def invokable?(method)
+      @@known_methods.include?(method.to_s) && respond_to?(method)
+    end
   end
 end

lib/liquid/tag.rb

@@ -1,8 +1,7 @@
 module Liquid
   class Tag
-    attr_accessor :options, :line_number
+    attr_accessor :options
     attr_reader :nodelist, :warnings
-    include ParserSwitching
 
     class << self
       def parse(tag_name, markup, tokens, options)
@@ -23,10 +22,6 @@ module Liquid
     def parse(tokens)
     end
 
-    def raw
-      "#{@tag_name} #{@markup}"
-    end
-
     def name
       self.class.name.downcase
     end
@@ -36,7 +31,30 @@ module Liquid
     end
 
     def blank?
-      false
+      @blank || false
     end
-  end
-end
+
+    def parse_with_selected_parser(markup)
+      case @options[:error_mode] || Template.error_mode
+      when :strict then strict_parse_with_error_context(markup)
+      when :lax    then lax_parse(markup)
+      when :warn
+        begin
+          return strict_parse_with_error_context(markup)
+        rescue SyntaxError => e
+          @warnings ||= []
+          @warnings << e
+          return lax_parse(markup)
+        end
+      end
+    end
+
+    private
+    def strict_parse_with_error_context(markup)
+      strict_parse(markup)
+    rescue SyntaxError => e
+      e.message << " in \"#{markup.strip}\"" 
+      raise e
+    end
+  end # Tag
+end # Liquid

lib/liquid/tags/assign.rb

@@ -15,8 +15,7 @@ module Liquid
       super
       if markup =~ Syntax
         @to = $1
-        @from = Variable.new($2,options)
-        @from.line_number = line_number
+        @from = Variable.new($2)
       else
         raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
       end

lib/liquid/tags/capture.rb

@@ -1,4 +1,5 @@
 module Liquid
+
   # Capture stores the result of a block into a variable without rendering it inplace.
   #
   #   {% capture heading %}
@@ -11,7 +12,7 @@ module Liquid
   # in a sidebar or footer.
   #
   class Capture < Block
-    Syntax = /(#{VariableSignature}+)/o
+    Syntax = /(\w+)/
 
     def initialize(tag_name, markup, options)
       super

lib/liquid/tags/case.rb

@@ -15,7 +15,7 @@ module Liquid
     end
 
     def nodelist
-      @blocks.flat_map(&:attachment)
+      @blocks.map(&:attachment).flatten
     end
 
     def unknown_tag(tag, markup, tokens)

lib/liquid/tags/cycle.rb

@@ -43,8 +43,11 @@ module Liquid
       end
     end
 
-    private
+    def blank?
+      false
+    end
 
+    private
     def variables_from_string(markup)
       markup.split(',').collect do |var|
         var =~ /\s*(#{QuotedFragment})\s*/o

lib/liquid/tags/if.rb

@@ -21,7 +21,7 @@ module Liquid
     end
 
     def nodelist
-      @blocks.flat_map(&:attachment)
+      @blocks.map(&:attachment).flatten
     end
 
     def unknown_tag(tag, markup, tokens)
@@ -57,15 +57,15 @@ module Liquid
       end
 
       def lax_parse(markup)
-        expressions = markup.scan(ExpressionsAndOperators)
-        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax
+        expressions = markup.scan(ExpressionsAndOperators).reverse
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.shift =~ Syntax
 
         condition = Condition.new($1, $2, $3)
 
         while not expressions.empty?
-          operator = expressions.pop.to_s.strip
+          operator = (expressions.shift).to_s.strip
 
-          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax
+          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.shift.to_s =~ Syntax
 
           new_condition = Condition.new($1, $2, $3)
           raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
@@ -78,16 +78,16 @@ module Liquid
 
       def strict_parse(markup)
         p = Parser.new(markup)
-        condition = parse_binary_comparison(p)
-        p.consume(:end_of_string)
-        condition
-      end
 
-      def parse_binary_comparison(p)
         condition = parse_comparison(p)
-        if op = (p.id?('and'.freeze) || p.id?('or'.freeze))
-          condition.send(op, parse_binary_comparison(p))
+
+        while op = (p.id?('and'.freeze) || p.id?('or'.freeze))
+          new_cond = parse_comparison(p)
+          new_cond.send(op, condition)
+          condition = new_cond
         end
+        p.consume(:end_of_string)
+
         condition
       end
 

lib/liquid/tags/ifchanged.rb

@@ -4,7 +4,7 @@ module Liquid
     def render(context)
       context.stack do
 
-        output = super
+        output = render_all(@nodelist, context)
 
         if output != context.registers[:ifchanged]
           context.registers[:ifchanged] = output

lib/liquid/tags/include.rb

@@ -38,6 +38,10 @@ module Liquid
     def parse(tokens)
     end
 
+    def blank?
+      false
+    end
+
     def render(context)
       partial = load_cached_partial(context)
       variable = context[@variable_name || @template_name[1..-2]]
@@ -69,7 +73,7 @@ module Liquid
           return cached
         end
         source = read_template_from_file_system(context)
-        partial = Liquid::Template.parse(source, pass_options)
+        partial = Liquid::Template.parse(source)
         cached_partials[template_name] = partial
         context.registers[:cached_partials] = cached_partials
         partial
@@ -88,16 +92,6 @@ module Liquid
           raise ArgumentError, "file_system.read_template_file expects two parameters: (template_name, context)"
         end
       end
-
-      def pass_options
-        dont_pass = @options[:include_options_blacklist]
-        return {locale: @options[:locale]} if dont_pass == true
-        opts = @options.merge(included: true, include_options_blacklist: false)
-        if dont_pass.is_a?(Array)
-          dont_pass.each {|o| opts.delete(o)}
-        end
-        opts
-      end
   end
 
   Template.register_tag('include'.freeze, Include)

lib/liquid/tags/increment.rb

@@ -25,6 +25,10 @@ module Liquid
       context.environments.first[@variable] = value + 1
       value.to_s
     end
+
+    def blank?
+      false
+    end
   end
 
   Template.register_tag('increment'.freeze, Increment)

lib/liquid/tags/raw.rb

@@ -8,7 +8,10 @@ module Liquid
       while token = tokens.shift
         if token =~ FullTokenPossiblyInvalid
           @nodelist << $1 if $1 != "".freeze
-          return if block_delimiter == $2
+          if block_delimiter == $2
+            end_tag
+            return
+          end
         end
         @nodelist << token if not token.empty?
       end

lib/liquid/tags/table_row.rb

@@ -42,6 +42,7 @@ module Liquid
             'index0'.freeze    => index,
             'col'.freeze       => col + 1,
             'col0'.freeze      => col,
+            'index0'.freeze    => index,
             'rindex'.freeze    => length - index,
             'rindex0'.freeze   => length - index - 1,
             'first'.freeze     => (index == 0),
@@ -53,7 +54,7 @@ module Liquid
 
           col += 1
 
-          result << "<td class=\"col#{col}\">" << super << '</td>'
+          result << "<td class=\"col#{col}\">" << render_all(@nodelist, context) << '</td>'
 
           if col == cols and (index != length - 1)
             col  = 0

lib/liquid/tags/unless.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/if'
 module Liquid
   # Unless is a conditional just like 'if' but works on the inverse logic.
   #
-  #   {% unless x < 0 %} x is greater than zero {% endunless %}
+  #   {% unless x < 0 %} x is greater than zero {% end %}
   #
   class Unless < If
     def render(context)

lib/liquid/template.rb

@@ -21,38 +21,6 @@ module Liquid
     attr_accessor :root, :resource_limits
     @@file_system = BlankFileSystem.new
 
-    class TagRegistry
-      def initialize
-        @tags  = {}
-        @cache = {}
-      end
-
-      def [](tag_name)
-        return nil unless @tags.has_key?(tag_name)
-        return @cache[tag_name] if Liquid.cache_classes
-
-        lookup_class(@tags[tag_name]).tap { |o| @cache[tag_name] = o }
-      end
-
-      def []=(tag_name, klass)
-        @tags[tag_name]  = klass.name
-        @cache[tag_name] = klass
-      end
-
-      def delete(tag_name)
-        @tags.delete(tag_name)
-        @cache.delete(tag_name)
-      end
-
-      private
-
-      def lookup_class(name)
-        name.split("::").reject(&:empty?).reduce(Object) { |scope, const| scope.const_get(const) }
-      end
-    end
-
-    attr_reader :profiler
-
     class << self
       # Sets how strict the parser should be.
       # :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
@@ -60,12 +28,6 @@ module Liquid
       # :strict will enforce correct syntax.
       attr_writer :error_mode
 
-      # Sets how strict the taint checker should be.
-      # :lax is the default, and ignores the taint flag completely
-      # :warn adds a warning, but does not interrupt the rendering
-      # :error raises an error when tainted output is used
-      attr_writer :taint_mode
-
       def file_system
         @@file_system
       end
@@ -79,46 +41,34 @@ module Liquid
       end
 
       def tags
-        @tags ||= TagRegistry.new
+        @tags ||= {}
       end
 
       def error_mode
         @error_mode || :lax
       end
 
-      def taint_mode
-        @taint_mode || :lax
-      end
-
       # Pass a module with filter methods which should be available
       # to all liquid views. Good for registering the standard library
       def register_filter(mod)
         Strainer.global_filter(mod)
       end
 
-      def default_resource_limits
-        @default_resource_limits ||= {}
-      end
-
       # creates a new <tt>Template</tt> object from liquid source code
-      # To enable profiling, pass in <tt>profile: true</tt> as an option.
-      # See Liquid::Profiler for more information
       def parse(source, options = {})
         template = Template.new
         template.parse(source, options)
       end
     end
 
+    # creates a new <tt>Template</tt> from an array of tokens. Use <tt>Template.parse</tt> instead
     def initialize
-      @resource_limits = self.class.default_resource_limits.dup
+      @resource_limits = {}
     end
 
     # Parse source code.
     # Returns self for easy chaining
     def parse(source, options = {})
-      @options = options
-      @profiling = options[:profile]
-      @line_numbers = options[:line_numbers] || @profiling
       @root = Document.parse(tokenize(source), DEFAULT_OPTIONS.merge(options))
       @warnings = nil
       self
@@ -150,9 +100,6 @@ module Liquid
     # if you use the same filters over and over again consider registering them globally
     # with <tt>Template.register_filter</tt>
     #
-    # if profiling was enabled in <tt>Template#parse</tt> then the resulting profiling information
-    # will be available via <tt>Template#profiler</tt>
-    #
     # Following options can be passed:
     #
     #  * <tt>filters</tt> : array with local filters
@@ -165,11 +112,7 @@ module Liquid
       context = case args.first
       when Liquid::Context
         c = args.shift
-
-        if @rethrow_errors
-          c.exception_handler = ->(e) { true }
-        end
-
+        c.rethrow_errors = true if @rethrow_errors
         c
       when Liquid::Drop
         drop = args.shift
@@ -194,9 +137,6 @@ module Liquid
           context.add_filters(options[:filters])
         end
 
-        if options[:exception_handler]
-          context.exception_handler = options[:exception_handler]
-        end
       when Module
         context.add_filters(args.pop)
       when Array
@@ -206,9 +146,7 @@ module Liquid
       begin
         # render the nodelist.
         # for performance reasons we get an array back here. join will make a string out of it.
-        result = with_profiling do
-          @root.render(context)
-        end
+        result = @root.render(context)
         result.respond_to?(:join) ? result.join : result
       rescue Liquid::MemoryError => e
         context.handle_error(e)
@@ -228,8 +166,7 @@ module Liquid
     def tokenize(source)
       source = source.source if source.respond_to?(:source)
       return [] if source.to_s.empty?
-
-      tokens = calculate_line_numbers(source.split(TemplateParser))
+      tokens = source.split(TemplateParser)
 
       # removes the rogue empty element at the beginning of the array
       tokens.shift if tokens[0] and tokens[0].empty?
@@ -237,30 +174,5 @@ module Liquid
       tokens
     end
 
-    def calculate_line_numbers(raw_tokens)
-      return raw_tokens unless @line_numbers
-
-      current_line = 1
-      raw_tokens.map do |token|
-        Token.new(token, current_line).tap do
-          current_line += token.count("\n")
-        end
-      end
-    end
-
-    def with_profiling
-      if @profiling && !@options[:included]
-        @profiler = Profiler.new
-        @profiler.start
-
-        begin
-          yield
-        ensure
-          @profiler.stop
-        end
-      else
-        yield
-      end
-    end
   end
 end

lib/liquid/token.rb

@@ -1,18 +0,0 @@
-module Liquid
-  class Token < String
-    attr_reader :line_number
-
-    def initialize(content, line_number)
-      super(content)
-      @line_number = line_number
-    end
-
-    def raw
-      "<raw>"
-    end
-
-    def child(string)
-      Token.new(string, @line_number)
-    end
-  end
-end

lib/liquid/variable.rb

@@ -11,41 +11,40 @@ module Liquid
   #   {{ user | link }}
   #
   class Variable
-    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
+    FilterParser = /(?:#{FilterSeparator}|(?:\s*(?:#{QuotedFragment}|#{ArgumentSeparator})\s*)+)/o
     EasyParse = /\A *(\w+(?:\.\w+)*) *\z/
     attr_accessor :filters, :name, :warnings
-    attr_accessor :line_number
-    include ParserSwitching
 
     def initialize(markup, options = {})
       @markup  = markup
       @name    = nil
       @options = options || {}
 
-      parse_with_selected_parser(markup)
-    end
-
-    def raw
-      @markup
-    end
-
-    def markup_context(markup)
-      "in \"{{#{markup}}}\""
+      case @options[:error_mode] || Template.error_mode
+      when :strict then strict_parse(markup)
+      when :lax    then lax_parse(markup)
+      when :warn
+        begin
+          strict_parse(markup)
+        rescue SyntaxError => e
+          @warnings ||= []
+          @warnings << e
+          lax_parse(markup)
+        end
+      end
     end
 
     def lax_parse(markup)
       @filters = []
-      if markup =~ /(#{QuotedFragment})(.*)/om
-        name_markup = $1
-        filter_markup = $2
-        @name = Expression.parse(name_markup)
-        if filter_markup =~ /#{FilterSeparator}\s*(.*)/om
-          filters = $1.scan(FilterParser)
+      if match = markup.match(/\s*(#{QuotedFragment})(.*)/om)
+        @name = match[1]
+        if match[2].match(/#{FilterSeparator}\s*(.*)/om)
+          filters = Regexp.last_match(1).scan(FilterParser)
           filters.each do |f|
-            if f =~ /\w+/
-              filtername = Regexp.last_match(0)
+            if matches = f.match(/\s*(\w+)/)
+              filtername = matches[1]
               filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
-              @filters << parse_filter_expressions(filtername, filterargs)
+              @filters << [filtername, filterargs]
             end
           end
         end
@@ -55,7 +54,7 @@ module Liquid
     def strict_parse(markup)
       # Very simple valid cases
       if markup =~ EasyParse
-        @name = Expression.parse($1)
+        @name = $1
         @filters = []
         return
       end
@@ -63,13 +62,16 @@ module Liquid
       @filters = []
       p = Parser.new(markup)
       # Could be just filters with no input
-      @name = p.look(:pipe) ? nil : Expression.parse(p.expression)
+      @name = p.look(:pipe) ? ''.freeze : p.expression
       while p.consume?(:pipe)
         filtername = p.consume(:id)
         filterargs = p.consume?(:colon) ? parse_filterargs(p) : []
-        @filters << parse_filter_expressions(filtername, filterargs)
+        @filters << [filtername, filterargs]
       end
       p.consume(:end_of_string)
+    rescue SyntaxError => e
+      e.message << " in \"{{#{markup}}}\""
+      raise e
     end
 
     def parse_filterargs(p)
@@ -83,51 +85,22 @@ module Liquid
     end
 
     def render(context)
-      @filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
-        filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
-        output = context.invoke(filter_name, output, *filter_args)
-      end.tap{ |obj| taint_check(obj) }
-    end
-
-    private
-
-    def parse_filter_expressions(filter_name, unparsed_args)
-      filter_args = []
-      keyword_args = {}
-      unparsed_args.each do |a|
-        if matches = a.match(/\A#{TagAttributes}\z/o)
-          keyword_args[matches[1]] = Expression.parse(matches[2])
-        else
-          filter_args << Expression.parse(a)
+      return ''.freeze if @name.nil?
+      @filters.inject(context[@name]) do |output, filter|
+        filterargs = []
+        keyword_args = {}
+        filter[1].to_a.each do |a|
+          if matches = a.match(/\A#{TagAttributes}\z/o)
+            keyword_args[matches[1]] = context[matches[2]]
+          else
+            filterargs << context[a]
+          end
         end
-      end
-      result = [filter_name, filter_args]
-      result << keyword_args unless keyword_args.empty?
-      result
-    end
-
-    def evaluate_filter_expressions(context, filter_args, filter_kwargs)
-      parsed_args = filter_args.map{ |expr| context.evaluate(expr) }
-      if filter_kwargs
-        parsed_kwargs = {}
-        filter_kwargs.each do |key, expr|
-          parsed_kwargs[key] = context.evaluate(expr)
-        end
-        parsed_args << parsed_kwargs
-      end
-      parsed_args
-    end
-
-    def taint_check(obj)
-      if obj.tainted?
-        @markup =~ QuotedFragment
-        name = Regexp.last_match(0)
-        case Template.taint_mode
-        when :warn
-          @warnings ||= []
-          @warnings << "variable '#{name}' is tainted and was not escaped"
-        when :error
-          raise TaintedError, "Error - variable '#{name}' is tainted and was not escaped"
+        filterargs << keyword_args unless keyword_args.empty?
+        begin
+          output = context.invoke(filter[0], output, *filterargs)
+        rescue FilterNotFound
+          raise FilterNotFound, "Error - filter '#{filter[0]}' in '#{@markup.strip}' could not be found."
         end
       end
     end

lib/liquid/variable_lookup.rb

@@ -1,80 +0,0 @@
-module Liquid
-  class VariableLookup
-    SQUARE_BRACKETED = /\A\[(.*)\]\z/m
-    COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze]
-
-    attr_reader :name, :lookups
-
-    def self.parse(markup)
-      new(markup)
-    end
-
-    def initialize(markup)
-      lookups = markup.scan(VariableParser)
-
-      name = lookups.shift
-      if name =~ SQUARE_BRACKETED
-        name = Expression.parse($1)
-      end
-      @name = name
-
-      @lookups = lookups
-      @command_flags = 0
-
-      @lookups.each_index do |i|
-        lookup = lookups[i]
-        if lookup =~ SQUARE_BRACKETED
-          lookups[i] = Expression.parse($1)
-        elsif COMMAND_METHODS.include?(lookup)
-          @command_flags |= 1 << i
-        end
-      end
-    end
-
-    def evaluate(context)
-      name = context.evaluate(@name)
-      object = context.find_variable(name)
-
-      @lookups.each_index do |i|
-        key = context.evaluate(@lookups[i])
-
-        # 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?(:[]) &&
-          ((object.respond_to?(:has_key?) && object.has_key?(key)) ||
-           (object.respond_to?(:fetch) && key.is_a?(Integer)))
-
-          # if its a proc we will replace the entry with the proc
-          res = context.lookup_and_evaluate(object, key)
-          object = res.to_liquid
-
-          # Some special cases. If the part wasn't in square brackets and
-          # no key with the same name was found we interpret following calls
-          # as commands and call them on the current object
-        elsif @command_flags & (1 << i) != 0 && object.respond_to?(key)
-          object = object.send(key).to_liquid
-
-          # No key was present with the desired value and it wasn't one of the directly supported
-          # keywords either. The only thing we got left is to return nil
-        else
-          return nil
-        end
-
-        # If we are dealing with a drop here we have to
-        object.context = context if object.respond_to?(:context=)
-      end
-
-      object
-    end
-
-    def ==(other)
-      self.class == other.class && self.state == other.state
-    end
-
-    protected
-
-    def state
-      [@name, @lookups, @command_flags]
-    end
-  end
-end

lib/liquid/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module Liquid
-  VERSION = "3.0.3"
+  VERSION = "3.0.0".freeze
 end

liquid.gemspec

@@ -24,6 +24,6 @@ Gem::Specification.new do |s|
 
   s.require_path = "lib"
 
+  s.add_development_dependency 'stackprof' if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.1.0")
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'minitest'
 end

performance/benchmark.rb

@@ -1,17 +1,11 @@
-require 'benchmark/ips'
+require 'benchmark'
 require File.dirname(__FILE__) + '/theme_runner'
 
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 
-Benchmark.ips do |x|
-  x.time = 60
-  x.warmup = 5
-
-  puts
-  puts "Running benchmark for #{x.time} seconds (with #{x.warmup} seconds warmup)."
-  puts
-
-  x.report("parse:") { profiler.compile }
-  x.report("parse & run:") { profiler.run }
+Benchmark.bmbm do |x|
+  x.report("parse:")   { 100.times { profiler.compile } }
+  x.report("parse & run:")   { 100.times { profiler.run } }
 end
+

performance/profile.rb

@@ -4,14 +4,10 @@ require File.dirname(__FILE__) + '/theme_runner'
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 profiler.run
-
-[:cpu, :object].each do |profile_type|
-  puts "Profiling in #{profile_type.to_s} mode..."
-  results = StackProf.run(mode: profile_type) do
-    100.times do
-      profiler.run
-    end
+results = StackProf.run(mode: :cpu) do
+  100.times do
+    profiler.run
   end
-  StackProf::Report.new(results).print_text(false, 20)
-  File.write(ENV['FILENAME'] + "." + profile_type.to_s, Marshal.dump(results)) if ENV['FILENAME']
 end
+StackProf::Report.new(results).print_text(false, 20)
+File.write(ENV['FILENAME'], Marshal.dump(results)) if ENV['FILENAME']

performance/shopify/paginate.rb

@@ -4,6 +4,8 @@ class Paginate < Liquid::Block
   def initialize(tag_name, markup, options)
     super
 
+    @nodelist = []
+
     if markup =~ Syntax
       @collection_name = $1
       @page_size = if $2
@@ -71,7 +73,7 @@ class Paginate < Liquid::Block
         end
       end
 
-      super
+      render_all(@nodelist, context)
     end
   end
 

test/integration/assign_test.rb

@@ -1,18 +1,8 @@
 require 'test_helper'
 
-class AssignTest < Minitest::Test
+class AssignTest < Test::Unit::TestCase
   include Liquid
 
-  def test_assign_with_hyphen_in_variable_name
-    template_source = <<-END_TEMPLATE
-    {% assign this-thing = 'Print this-thing' %}
-    {{ this-thing }}
-    END_TEMPLATE
-    template = Template.parse(template_source)
-    rendered = template.render!
-    assert_equal "Print this-thing", rendered.strip
-  end
-
   def test_assigned_variable
     assert_template_result('.foo.',
                            '{% assign foo = values %}.{{ foo[0] }}.',
@@ -34,15 +24,4 @@ class AssignTest < Minitest::Test
                        '{% assign foo not values %}.',
                        'values' => "foo,bar,baz")
   end
-
-  def test_assign_uses_error_mode
-    with_error_mode(:strict) do
-      assert_raises(SyntaxError) do
-        Template.parse("{% assign foo = ('X' | downcase) %}")
-      end
-    end
-    with_error_mode(:lax) do
-      assert Template.parse("{% assign foo = ('X' | downcase) %}")
-    end
-  end
 end # AssignTest

test/integration/blank_test.rb

@@ -14,7 +14,7 @@ class BlankTestFileSystem
   end
 end
 
-class BlankTest < Minitest::Test
+class BlankTest < Test::Unit::TestCase
   include Liquid
   N = 10
 

test/integration/capture_test.rb

@@ -1,22 +1,12 @@
 require 'test_helper'
 
-class CaptureTest < Minitest::Test
+class CaptureTest < Test::Unit::TestCase
   include Liquid
 
   def test_captures_block_content_in_variable
     assert_template_result("test string", "{% capture 'var' %}test string{% endcapture %}{{var}}", {})
   end
 
-  def test_capture_with_hyphen_in_variable_name
-    template_source = <<-END_TEMPLATE
-    {% capture this-thing %}Print this-thing{% endcapture %}
-    {{ this-thing }}
-    END_TEMPLATE
-    template = Template.parse(template_source)
-    rendered = template.render!
-    assert_equal "Print this-thing", rendered.strip
-  end
-
   def test_capture_to_variable_from_outer_scope_if_existing
     template_source = <<-END_TEMPLATE
     {% assign var = '' %}

test/integration/context_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ContextTest < Minitest::Test
+class ContextTest < Test::Unit::TestCase
   include Liquid
 
   def test_override_global_filter
@@ -16,17 +16,8 @@ class ContextTest < Minitest::Test
       end
     end
 
-    with_global_filter(global) do
-      assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
-      assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, :filters => [local])
-    end
-  end
-
-  def test_has_key_will_not_add_an_error_for_missing_keys
-    with_error_mode :strict do
-      context = Context.new
-      context.has_key?('unknown')
-      assert_empty context.errors
-    end
+    Template.register_filter(global)
+    assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
+    assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, :filters => [local])
   end
 end

test/integration/drop_test.rb

@@ -48,10 +48,6 @@ class ProductDrop < Liquid::Drop
     ContextDrop.new
   end
 
-  def user_input
-    "foo".taint
-  end
-
   protected
     def callmenot
       "protected"
@@ -104,34 +100,12 @@ class RealEnumerableDrop < Liquid::Drop
   end
 end
 
-class DropsTest < Minitest::Test
+class DropsTest < Test::Unit::TestCase
   include Liquid
 
   def test_product_drop
-    tpl = Liquid::Template.parse('  ')
-    assert_equal '  ', tpl.render!('product' => ProductDrop.new)
-  end
-
-  def test_rendering_raises_on_tainted_attr
-    with_taint_mode(:error) do
-      tpl = Liquid::Template.parse('{{ product.user_input }}')
-      assert_raises TaintedError do
-        tpl.render!('product' => ProductDrop.new)
-      end
-    end
-  end
-
-  def test_rendering_warns_on_tainted_attr
-    with_taint_mode(:warn) do
-      tpl = Liquid::Template.parse('{{ product.user_input }}')
-      tpl.render!('product' => ProductDrop.new)
-      assert_match /tainted/, tpl.warnings.first
-    end
-  end
-
-  def test_rendering_doesnt_raise_on_escaped_tainted_attr
-    with_taint_mode(:error) do
-      tpl = Liquid::Template.parse('{{ product.user_input | escape }}')
+    assert_nothing_raised do
+      tpl = Liquid::Template.parse( '  '  )
       tpl.render!('product' => ProductDrop.new)
     end
   end

test/integration/error_handling_test.rb

@@ -19,189 +19,92 @@ class ErrorDrop < Liquid::Drop
 
 end
 
-class ErrorHandlingTest < Minitest::Test
+class ErrorHandlingTest < Test::Unit::TestCase
   include Liquid
 
-  def test_templates_parsed_with_line_numbers_renders_them_in_errors
-    template = <<-LIQUID
-      Hello,
-
-      {{ errors.standard_error }} will raise a standard error.
-
-      Bla bla test.
-
-      {{ errors.syntax_error }} will raise a syntax error.
-
-      This is an argument error: {{ errors.argument_error }}
-
-      Bla.
-    LIQUID
-
-    expected = <<-TEXT
-      Hello,
-
-      Liquid error (line 3): standard error will raise a standard error.
-
-      Bla bla test.
-
-      Liquid syntax error (line 7): syntax error will raise a syntax error.
-
-      This is an argument error: Liquid error (line 9): argument error
-
-      Bla.
-    TEXT
-
-    output = Liquid::Template.parse(template, line_numbers: true).render('errors' => ErrorDrop.new)
-    assert_equal expected, output
-  end
-
   def test_standard_error
-    template = Liquid::Template.parse( ' {{ errors.standard_error }} '  )
-    assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
+    assert_nothing_raised do
+      template = Liquid::Template.parse( ' {{ errors.standard_error }} '  )
+      assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
 
-    assert_equal 1, template.errors.size
-    assert_equal StandardError, template.errors.first.class
+      assert_equal 1, template.errors.size
+      assert_equal StandardError, template.errors.first.class
+    end
   end
 
   def test_syntax
-    template = Liquid::Template.parse( ' {{ errors.syntax_error }} '  )
-    assert_equal ' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new)
 
-    assert_equal 1, template.errors.size
-    assert_equal SyntaxError, template.errors.first.class
+    assert_nothing_raised do
+
+      template = Liquid::Template.parse( ' {{ errors.syntax_error }} '  )
+      assert_equal ' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new)
+
+      assert_equal 1, template.errors.size
+      assert_equal SyntaxError, template.errors.first.class
+
+    end
   end
 
   def test_argument
-    template = Liquid::Template.parse( ' {{ errors.argument_error }} '  )
-    assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
+    assert_nothing_raised do
 
-    assert_equal 1, template.errors.size
-    assert_equal ArgumentError, template.errors.first.class
+      template = Liquid::Template.parse( ' {{ errors.argument_error }} '  )
+      assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
+
+      assert_equal 1, template.errors.size
+      assert_equal ArgumentError, template.errors.first.class
+    end
   end
 
   def test_missing_endtag_parse_time_error
-    assert_raises(Liquid::SyntaxError) do
+    assert_raise(Liquid::SyntaxError) do
       Liquid::Template.parse(' {% for a in b %} ... ')
     end
   end
 
   def test_unrecognized_operator
     with_error_mode(:strict) do
-      assert_raises(SyntaxError) do
+      assert_raise(SyntaxError) do
         Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
       end
     end
   end
-
+  
   def test_lax_unrecognized_operator
-    template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :lax)
-    assert_equal ' Liquid error: Unknown operator =! ', template.render
-    assert_equal 1, template.errors.size
-    assert_equal Liquid::ArgumentError, template.errors.first.class
-  end
-
-  def test_with_line_numbers_adds_numbers_to_parser_errors
-    err = assert_raises(SyntaxError) do
-      template = Liquid::Template.parse(%q{
-          foobar
-
-          {% "cat" | foobar %}
-
-          bla
-        },
-        :line_numbers => true
-      )
+    assert_nothing_raised do
+      template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :lax)
+      assert_equal ' Liquid error: Unknown operator =! ', template.render
+      assert_equal 1, template.errors.size
+      assert_equal Liquid::ArgumentError, template.errors.first.class
     end
-
-    assert_match /Liquid syntax error \(line 4\)/, err.message
-  end
-
-  def test_parsing_warn_with_line_numbers_adds_numbers_to_lexer_errors
-    template = Liquid::Template.parse(%q{
-        foobar
-
-        {% if 1 =! 2 %}ok{% endif %}
-
-        bla
-      },
-      :error_mode => :warn,
-      :line_numbers => true
-    )
-
-    assert_equal ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
-      template.warnings.map(&:message)
-  end
-
-  def test_parsing_strict_with_line_numbers_adds_numbers_to_lexer_errors
-    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse(%q{
-          foobar
-
-          {% if 1 =! 2 %}ok{% endif %}
-
-          bla
-        },
-        :error_mode => :strict,
-        :line_numbers => true
-      )
-    end
-
-    assert_equal 'Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message
-  end
-
-  def test_syntax_errors_in_nested_blocks_have_correct_line_number
-    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse(%q{
-          foobar
-
-          {% if 1 != 2 %}
-            {% foo %}
-          {% endif %}
-
-          bla
-        },
-        :line_numbers => true
-      )
-    end
-
-    assert_equal "Liquid syntax error (line 5): Unknown tag 'foo'", err.message
   end
 
   def test_strict_error_messages
-    err = assert_raises(SyntaxError) do
+    err = assert_raise(SyntaxError) do
       Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :strict)
     end
-    assert_equal 'Liquid syntax error: Unexpected character = in "1 =! 2"', err.message
+    assert_equal 'Unexpected character = in "1 =! 2"', err.message
 
-    err = assert_raises(SyntaxError) do
+    err = assert_raise(SyntaxError) do
       Liquid::Template.parse('{{%%%}}', :error_mode => :strict)
     end
-    assert_equal 'Liquid syntax error: Unexpected character % in "{{%%%}}"', err.message
+    assert_equal 'Unexpected character % in "{{%%%}}"', err.message
   end
 
   def test_warnings
     template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', :error_mode => :warn)
     assert_equal 3, template.warnings.size
-    assert_equal 'Unexpected character ~ in "~~~"', template.warnings[0].to_s(false)
-    assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false)
-    assert_equal 'Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false)
+    assert_equal 'Unexpected character ~ in "~~~"', template.warnings[0].message
+    assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].message
+    assert_equal 'Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message
     assert_equal '', template.render
   end
 
-  def test_warning_line_numbers
-    template = Liquid::Template.parse("{% if ~~~ %}\n{{%%%}}{% else %}\n{{ hello. }}{% endif %}", :error_mode => :warn, :line_numbers => true)
-    assert_equal 'Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message
-    assert_equal 'Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message
-    assert_equal 'Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message
-    assert_equal 3, template.warnings.size
-    assert_equal [1,2,3], template.warnings.map(&:line_number)
-  end
-
   # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
   def test_exceptions_propagate
-    assert_raises Exception do
-      template = Liquid::Template.parse('{{ errors.exception }}')
+    assert_raise Exception do
+      template = Liquid::Template.parse( ' {{ errors.exception }} '  )
       template.render('errors' => ErrorDrop.new)
     end
   end
-end
+end # ErrorHandlingTest

test/integration/filter_test.rb

@@ -22,15 +22,9 @@ module SubstituteFilter
   end
 end
 
-class FiltersTest < Minitest::Test
+class FiltersTest < Test::Unit::TestCase
   include Liquid
 
-  module OverrideObjectMethodFilter
-    def tap(input)
-      "tap overridden"
-    end
-  end
-
   def setup
     @context = Context.new
   end
@@ -73,12 +67,12 @@ class FiltersTest < Minitest::Test
     @context['value'] = 3
     @context['numbers'] = [2,1,4,3]
     @context['words'] = ['expected', 'as', 'alphabetic']
-    @context['arrays'] = ['flower', 'are']
+    @context['arrays'] = [['flattened'], ['are']]
 
     assert_equal [1,2,3,4], Variable.new("numbers | sort").render(@context)
     assert_equal ['alphabetic', 'as', 'expected'], Variable.new("words | sort").render(@context)
     assert_equal [3], Variable.new("value | sort").render(@context)
-    assert_equal ['are', 'flower'], Variable.new("arrays | sort").render(@context)
+    assert_equal ['are', 'flattened'], Variable.new("arrays | sort").render(@context)
   end
 
   def test_strip_html
@@ -111,24 +105,17 @@ class FiltersTest < Minitest::Test
     output = Variable.new(%! 'hello %{first_name}, %{last_name}' | substitute: first_name: surname, last_name: 'doe' !).render(@context)
     assert_equal 'hello john, doe', output
   end
-
-  def test_override_object_method_in_filter
-    assert_equal "tap overridden", Template.parse("{{var | tap}}").render!({ 'var' => 1000 }, :filters => [OverrideObjectMethodFilter])
-
-    # tap still treated as a non-existent filter
-    assert_equal "1000", Template.parse("{{var | tap}}").render!({ 'var' => 1000 })
-  end
 end
 
-class FiltersInTemplate < Minitest::Test
+class FiltersInTemplate < Test::Unit::TestCase
   include Liquid
 
   def test_local_global
-    with_global_filter(MoneyFilter) do
-      assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render!(nil, nil)
-      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => CanadianMoneyFilter)
-      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => [CanadianMoneyFilter])
-    end
+    Template.register_filter(MoneyFilter)
+
+    assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render!(nil, nil)
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => CanadianMoneyFilter)
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => [CanadianMoneyFilter])
   end
 
   def test_local_filter_with_deprecated_syntax

test/integration/hash_ordering_test.rb

@@ -12,12 +12,14 @@ module CanadianMoneyFilter
   end
 end
 
-class HashOrderingTest < Minitest::Test
+class HashOrderingTest < Test::Unit::TestCase
   include Liquid
 
-  def test_global_register_order
-    with_global_filter(MoneyFilter, CanadianMoneyFilter) do
-      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, nil)
-    end
-  end
+ def test_global_register_order
+    Template.register_filter(MoneyFilter)
+    Template.register_filter(CanadianMoneyFilter)
+
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, nil)
+ end
+
 end

test/integration/output_test.rb

@@ -27,7 +27,7 @@ module FunnyFilter
 
 end
 
-class OutputTest < Minitest::Test
+class OutputTest < Test::Unit::TestCase
   include Liquid
 
   def setup

test/integration/parsing_quirks_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ParsingQuirksTest < Minitest::Test
+class ParsingQuirksTest < Test::Unit::TestCase
   include Liquid
 
   def test_parsing_css
@@ -9,28 +9,30 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_raise_on_single_close_bracet
-    assert_raises(SyntaxError) do
+    assert_raise(SyntaxError) do
       Template.parse("text {{method} oh nos!")
     end
   end
 
   def test_raise_on_label_and_no_close_bracets
-    assert_raises(SyntaxError) do
+    assert_raise(SyntaxError) do
       Template.parse("TEST {{ ")
     end
   end
 
   def test_raise_on_label_and_no_close_bracets_percent
-    assert_raises(SyntaxError) do
+    assert_raise(SyntaxError) do
       Template.parse("TEST {% ")
     end
   end
 
   def test_error_on_empty_filter
-    assert Template.parse("{{test}}")
-    assert Template.parse("{{|test}}")
+    assert_nothing_raised do
+      Template.parse("{{test}}")
+      Template.parse("{{|test}}")
+    end
     with_error_mode(:strict) do
-      assert_raises(SyntaxError) do
+      assert_raise(SyntaxError) do
         Template.parse("{{test |a|b|}}")
       end
     end
@@ -38,7 +40,7 @@ class ParsingQuirksTest < Minitest::Test
 
   def test_meaningless_parens_error
     with_error_mode(:strict) do
-      assert_raises(SyntaxError) do
+      assert_raise(SyntaxError) do
         markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
         Template.parse("{% if #{markup} %} YES {% endif %}")
       end
@@ -47,11 +49,11 @@ class ParsingQuirksTest < Minitest::Test
 
   def test_unexpected_characters_syntax_error
     with_error_mode(:strict) do
-      assert_raises(SyntaxError) do
+      assert_raise(SyntaxError) do
         markup = "true && false"
         Template.parse("{% if #{markup} %} YES {% endif %}")
       end
-      assert_raises(SyntaxError) do
+      assert_raise(SyntaxError) do
         markup = "false || true"
         Template.parse("{% if #{markup} %} YES {% endif %}")
       end
@@ -59,9 +61,11 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_no_error_on_lax_empty_filter
-    assert Template.parse("{{test |a|b|}}", :error_mode => :lax)
-    assert Template.parse("{{test}}", :error_mode => :lax)
-    assert Template.parse("{{|test|}}", :error_mode => :lax)
+    assert_nothing_raised do
+      Template.parse("{{test |a|b|}}", :error_mode => :lax)
+      Template.parse("{{test}}", :error_mode => :lax)
+      Template.parse("{{|test|}}", :error_mode => :lax)
+    end
   end
 
   def test_meaningless_parens_lax
@@ -80,37 +84,4 @@ class ParsingQuirksTest < Minitest::Test
       assert_template_result('',"{% if #{markup} %} YES {% endif %}")
     end
   end
-
-  def test_raise_on_invalid_tag_delimiter
-    assert_raises(Liquid::SyntaxError) do
-      Template.new.parse('{% end %}')
-    end
-  end
-
-  def test_unanchored_filter_arguments
-    with_error_mode(:lax) do
-      assert_template_result('hi',"{{ 'hi there' | split$$$:' ' | first }}")
-
-      assert_template_result('x', "{{ 'X' | downcase) }}")
-
-      # After the messed up quotes a filter without parameters (reverse) should work
-      # but one with parameters (remove) shouldn't be detected.
-      assert_template_result('here',  "{{ 'hi there' | split:\"t\"\" | reverse | first}}")
-      assert_template_result('hi ',  "{{ 'hi there' | split:\"t\"\" | remove:\"i\" | first}}")
-    end
-  end
-
-  def test_invalid_variables_work
-    with_error_mode(:lax) do
-      assert_template_result('bar', "{% assign 123foo = 'bar' %}{{ 123foo }}")
-      assert_template_result('123', "{% assign 123 = 'bar' %}{{ 123 }}")
-    end
-  end
-
-  def test_extra_dots_in_ranges
-    with_error_mode(:lax) do
-      assert_template_result('12345', "{% for i in (1...5) %}{{ i }}{% endfor %}")
-    end
-  end
-
 end # ParsingQuirksTest

test/integration/render_profiling_test.rb

@@ -1,154 +0,0 @@
-require 'test_helper'
-
-class RenderProfilingTest < Minitest::Test
-  include Liquid
-
-  class ProfilingFileSystem
-    def read_template_file(template_path, context)
-      "Rendering template {% assign template_name = '#{template_path}'%}\n{{ template_name }}"
-    end
-  end
-
-  def setup
-    Liquid::Template.file_system = ProfilingFileSystem.new
-  end
-
-  def test_template_allows_flagging_profiling
-    t = Template.parse("{{ 'a string' | upcase }}")
-    t.render!
-
-    assert_nil t.profiler
-  end
-
-  def test_parse_makes_available_simple_profiling
-    t = Template.parse("{{ 'a string' | upcase }}", :profile => true)
-    t.render!
-
-    assert_equal 1, t.profiler.length
-
-    node = t.profiler[0]
-    assert_equal " 'a string' | upcase ", node.code
-  end
-
-  def test_render_ignores_raw_strings_when_profiling
-    t = Template.parse("This is raw string\nstuff\nNewline", :profile => true)
-    t.render!
-
-    assert_equal 0, t.profiler.length
-  end
-
-  def test_profiling_includes_line_numbers_of_liquid_nodes
-    t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", :profile => true)
-    t.render!
-    assert_equal 2, t.profiler.length
-
-    # {{ 'a string' | upcase }}
-    assert_equal 1, t.profiler[0].line_number
-    # {{ increment test }}
-    assert_equal 2, t.profiler[1].line_number
-  end
-
-  def test_profiling_includes_line_numbers_of_included_partials
-    t = Template.parse("{% include 'a_template' %}", :profile => true)
-    t.render!
-
-    included_children = t.profiler[0].children
-
-    # {% assign template_name = 'a_template' %}
-    assert_equal 1, included_children[0].line_number
-    # {{ template_name }}
-    assert_equal 2, included_children[1].line_number
-  end
-
-  def test_profiling_times_the_rendering_of_tokens
-    t = Template.parse("{% include 'a_template' %}", :profile => true)
-    t.render!
-
-    node = t.profiler[0]
-    refute_nil node.render_time
-  end
-
-  def test_profiling_times_the_entire_render
-    t = Template.parse("{% include 'a_template' %}", :profile => true)
-    t.render!
-
-    assert t.profiler.total_render_time >= 0, "Total render time was not calculated"
-  end
-
-  def test_profiling_uses_include_to_mark_children
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", :profile => true)
-    t.render!
-
-    include_node = t.profiler[1]
-    assert_equal 2, include_node.children.length
-  end
-
-  def test_profiling_marks_children_with_the_name_of_included_partial
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", :profile => true)
-    t.render!
-
-    include_node = t.profiler[1]
-    include_node.children.each do |child|
-      assert_equal "'a_template'", child.partial
-    end
-  end
-
-  def test_profiling_supports_multiple_templates
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'b_template' %}", :profile => true)
-    t.render!
-
-    a_template = t.profiler[1]
-    a_template.children.each do |child|
-      assert_equal "'a_template'", child.partial
-    end
-
-    b_template = t.profiler[2]
-    b_template.children.each do |child|
-      assert_equal "'b_template'", child.partial
-    end
-  end
-
-  def test_profiling_supports_rendering_the_same_partial_multiple_times
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'a_template' %}", :profile => true)
-    t.render!
-
-    a_template1 = t.profiler[1]
-    a_template1.children.each do |child|
-      assert_equal "'a_template'", child.partial
-    end
-
-    a_template2 = t.profiler[2]
-    a_template2.children.each do |child|
-      assert_equal "'a_template'", child.partial
-    end
-  end
-
-  def test_can_iterate_over_each_profiling_entry
-    t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", :profile => true)
-    t.render!
-
-    timing_count = 0
-    t.profiler.each do |timing|
-      timing_count += 1
-    end
-
-    assert_equal 2, timing_count
-  end
-
-  def test_profiling_marks_children_of_if_blocks
-    t = Template.parse("{% if true %} {% increment test %} {{ test }} {% endif %}", :profile => true)
-    t.render!
-
-    assert_equal 1, t.profiler.length
-    assert_equal 2, t.profiler[0].children.length
-  end
-
-  def test_profiling_marks_children_of_for_blocks
-    t = Template.parse("{% for item in collection %} {{ item }} {% endfor %}", :profile => true)
-    t.render!({"collection" => ["one", "two"]})
-
-    assert_equal 1, t.profiler.length
-    # Will profile each invocation of the for block
-    assert_equal 2, t.profiler[0].children.length
-  end
-end

test/integration/security_test.rb

@@ -6,7 +6,7 @@ module SecurityFilter
   end
 end
 
-class SecurityTest < Minitest::Test
+class SecurityTest < Test::Unit::TestCase
   include Liquid
 
   def test_no_instance_eval

test/integration/standard_filter_test.rb

@@ -7,8 +7,6 @@ class Filters
 end
 
 class TestThing
-  attr_reader :foo
-
   def initialize
     @foo = 0
   end
@@ -41,7 +39,7 @@ class TestEnumerable < Liquid::Drop
   end
 end
 
-class StandardFiltersTest < Minitest::Test
+class StandardFiltersTest < Test::Unit::TestCase
   include Liquid
 
   def setup
@@ -64,34 +62,6 @@ class StandardFiltersTest < Minitest::Test
     assert_equal '', @filters.upcase(nil)
   end
 
-  def test_slice
-    assert_equal 'oob', @filters.slice('foobar', 1, 3)
-    assert_equal 'oobar', @filters.slice('foobar', 1, 1000)
-    assert_equal '', @filters.slice('foobar', 1, 0)
-    assert_equal 'o', @filters.slice('foobar', 1, 1)
-    assert_equal 'bar', @filters.slice('foobar', 3, 3)
-    assert_equal 'ar', @filters.slice('foobar', -2, 2)
-    assert_equal 'ar', @filters.slice('foobar', -2, 1000)
-    assert_equal 'r', @filters.slice('foobar', -1)
-    assert_equal '', @filters.slice(nil, 0)
-    assert_equal '', @filters.slice('foobar', 100, 10)
-    assert_equal '', @filters.slice('foobar', -100, 10)
-  end
-
-  def test_slice_on_arrays
-    input = 'foobar'.split(//)
-    assert_equal %w{o o b}, @filters.slice(input, 1, 3)
-    assert_equal %w{o o b a r}, @filters.slice(input, 1, 1000)
-    assert_equal %w{}, @filters.slice(input, 1, 0)
-    assert_equal %w{o}, @filters.slice(input, 1, 1)
-    assert_equal %w{b a r}, @filters.slice(input, 3, 3)
-    assert_equal %w{a r}, @filters.slice(input, -2, 2)
-    assert_equal %w{a r}, @filters.slice(input, -2, 1000)
-    assert_equal %w{r}, @filters.slice(input, -1)
-    assert_equal %w{}, @filters.slice(input, 100, 10)
-    assert_equal %w{}, @filters.slice(input, -100, 10)
-  end
-
   def test_truncate
     assert_equal '1234...', @filters.truncate('1234567890', 7)
     assert_equal '1234567890', @filters.truncate('1234567890', 20)
@@ -106,7 +76,6 @@ class StandardFiltersTest < Minitest::Test
     assert_equal ['A?Z'], @filters.split('A?Z', '~')
     # Regexp works although Liquid does not support.
     assert_equal ['A','Z'], @filters.split('AxZ', /x/)
-    assert_equal [], @filters.split(nil, ' ')
   end
 
   def test_escape
@@ -118,11 +87,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_url_encode
-    assert_equal 'foo%2B1%40example.com', @filters.url_encode('foo+1@example.com')
-    assert_equal nil, @filters.url_encode(nil)
-  end
-
   def test_truncatewords
     assert_equal 'one two three', @filters.truncatewords('one two three', 4)
     assert_equal 'one two...', @filters.truncatewords('one two three', 2)
@@ -151,10 +115,6 @@ class StandardFiltersTest < Minitest::Test
     assert_equal [{"a" => 1}, {"a" => 2}, {"a" => 3}, {"a" => 4}], @filters.sort([{"a" => 4}, {"a" => 3}, {"a" => 1}, {"a" => 2}], "a")
   end
 
-  def test_legacy_sort_hash
-    assert_equal [{a:1, b:2}], @filters.sort({a:1, b:2})
-  end
-
   def test_numerical_vs_lexicographical_sort
     assert_equal [2, 10], @filters.sort([10, 2])
     assert_equal [{"a" => 2}, {"a" => 10}], @filters.sort([{"a" => 10}, {"a" => 2}], "a")
@@ -162,21 +122,10 @@ class StandardFiltersTest < Minitest::Test
     assert_equal [{"a" => "10"}, {"a" => "2"}], @filters.sort([{"a" => "10"}, {"a" => "2"}], "a")
   end
 
-  def test_uniq
-    assert_equal [1,3,2,4], @filters.uniq([1,1,3,2,3,1,4,3,2,1])
-    assert_equal [{"a" => 1}, {"a" => 3}, {"a" => 2}], @filters.uniq([{"a" => 1}, {"a" => 3}, {"a" => 1}, {"a" => 2}], "a")
-    testdrop = TestDrop.new
-    assert_equal [testdrop], @filters.uniq([testdrop, TestDrop.new], 'test')
-  end
-
   def test_reverse
     assert_equal [4,3,2,1], @filters.reverse([1,2,3,4])
   end
 
-  def test_legacy_reverse_hash
-    assert_equal [{a:1, b:2}], @filters.reverse(a:1, b:2)
-  end
-
   def test_map
     assert_equal [1,2,3,4], @filters.map([{"a" => 1}, {"a" => 2}, {"a" => 3}, {"a" => 4}], 'a')
     assert_template_result 'abc', "{{ ary | map:'foo' | map:'bar' }}",
@@ -198,16 +147,9 @@ class StandardFiltersTest < Minitest::Test
       "thing" => { "foo" => [ { "bar" => 42 }, { "bar" => 17 } ] }
   end
 
-  def test_legacy_map_on_hashes_with_dynamic_key
-    template = "{% assign key = 'foo' %}{{ thing | map: key | map: 'bar' }}"
-    hash = { "foo" => { "bar" => 42 } }
-    assert_template_result "42", template, "thing" => hash
-  end
-
   def test_sort_calls_to_liquid
     t = TestThing.new
-    Liquid::Template.parse('{{ foo | sort: "whatever" }}').render("foo" => [t])
-    assert t.foo > 0
+    assert_template_result "woot: 1", '{{ foo | sort: "whatever" }}', "foo" => [t]
   end
 
   def test_map_over_proc
@@ -225,11 +167,6 @@ class StandardFiltersTest < Minitest::Test
     assert_template_result "213", '{{ foo | sort: "bar" | map: "foo" }}', "foo" => TestEnumerable.new
   end
 
-  def test_first_and_last_call_to_liquid
-    assert_template_result 'foobar', '{{ foo | first }}', 'foo' => [ThingWithToLiquid.new]
-    assert_template_result 'foobar', '{{ foo | last }}', 'foo' => [ThingWithToLiquid.new]
-  end
-
   def test_date
     assert_equal 'May', @filters.date(Time.parse("2006-05-05 10:00:00"), "%B")
     assert_equal 'June', @filters.date(Time.parse("2006-06-05 10:00:00"), "%B")

test/integration/tags/break_tag_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class BreakTagTest < Minitest::Test
+class BreakTagTest < Test::Unit::TestCase
   include Liquid
 
   # tests that no weird errors are raised if break is called outside of a

test/integration/tags/continue_tag_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ContinueTagTest < Minitest::Test
+class ContinueTagTest < Test::Unit::TestCase
   include Liquid
 
   # tests that no weird errors are raised if continue is called outside of a

test/integration/tags/for_tag_test.rb

@@ -6,7 +6,7 @@ class ThingWithValue < Liquid::Drop
   end
 end
 
-class ForTagTest < Minitest::Test
+class ForTagTest < Test::Unit::TestCase
   include Liquid
 
   def test_for
@@ -303,7 +303,7 @@ HERE
   end
 
   def test_bad_variable_naming_in_for_loop
-    assert_raises(Liquid::SyntaxError) do
+    assert_raise(Liquid::SyntaxError) do
       Liquid::Template.parse('{% for a/b in x %}{% endfor %}')
     end
   end

test/integration/tags/if_else_tag_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class IfElseTagTest < Minitest::Test
+class IfElseTagTest < Test::Unit::TestCase
   include Liquid
 
   def test_if
@@ -10,11 +10,6 @@ class IfElseTagTest < Minitest::Test
     assert_template_result('  you rock ?','{% if false %} you suck {% endif %} {% if true %} you rock {% endif %}?')
   end
 
-  def test_literal_comparisons
-    assert_template_result(' NO ','{% assign v = false %}{% if v %} YES {% else %} NO {% endif %}')
-    assert_template_result(' YES ','{% assign v = nil %}{% if v == nil %} YES {% else %} NO {% endif %}')
-  end
-
   def test_if_else
     assert_template_result(' YES ','{% if false %} NO {% else %} YES {% endif %}')
     assert_template_result(' YES ','{% if true %} YES {% else %} NO {% endif %}')
@@ -42,19 +37,25 @@ class IfElseTagTest < Minitest::Test
   end
 
   def test_comparison_of_strings_containing_and_or_or
-    awful_markup = "a == 'and' and b == 'or' and c == 'foo and bar' and d == 'bar or baz' and e == 'foo' and foo and bar"
-    assigns = {'a' => 'and', 'b' => 'or', 'c' => 'foo and bar', 'd' => 'bar or baz', 'e' => 'foo', 'foo' => true, 'bar' => true}
-    assert_template_result(' YES ',"{% if #{awful_markup} %} YES {% endif %}", assigns)
+    assert_nothing_raised do
+      awful_markup = "a == 'and' and b == 'or' and c == 'foo and bar' and d == 'bar or baz' and e == 'foo' and foo and bar"
+      assigns = {'a' => 'and', 'b' => 'or', 'c' => 'foo and bar', 'd' => 'bar or baz', 'e' => 'foo', 'foo' => true, 'bar' => true}
+      assert_template_result(' YES ',"{% if #{awful_markup} %} YES {% endif %}", assigns)
+    end
   end
 
   def test_comparison_of_expressions_starting_with_and_or_or
     assigns = {'order' => {'items_count' => 0}, 'android' => {'name' => 'Roy'}}
-    assert_template_result( "YES",
-                            "{% if android.name == 'Roy' %}YES{% endif %}",
-                            assigns)
-    assert_template_result( "YES",
-                            "{% if order.items_count == 0 %}YES{% endif %}",
-                            assigns)
+    assert_nothing_raised do
+      assert_template_result( "YES",
+                              "{% if android.name == 'Roy' %}YES{% endif %}",
+                              assigns)
+    end
+    assert_nothing_raised do
+      assert_template_result( "YES",
+                              "{% if order.items_count == 0 %}YES{% endif %}",
+                              assigns)
+    end
   end
 
   def test_if_and
@@ -134,57 +135,32 @@ class IfElseTagTest < Minitest::Test
   end
 
   def test_syntax_error_no_variable
-    assert_raises(SyntaxError){ assert_template_result('', '{% if jerry == 1 %}')}
+    assert_raise(SyntaxError){ assert_template_result('', '{% if jerry == 1 %}')}
   end
 
   def test_syntax_error_no_expression
-    assert_raises(SyntaxError) { assert_template_result('', '{% if %}') }
+    assert_raise(SyntaxError) { assert_template_result('', '{% if %}') }
   end
 
   def test_if_with_custom_condition
-    original_op = Condition.operators['contains']
     Condition.operators['contains'] = :[]
 
     assert_template_result('yes', %({% if 'bob' contains 'o' %}yes{% endif %}))
     assert_template_result('no', %({% if 'bob' contains 'f' %}yes{% else %}no{% endif %}))
   ensure
-    Condition.operators['contains'] = original_op
+    Condition.operators.delete 'contains'
   end
 
   def test_operators_are_ignored_unless_isolated
-    original_op = Condition.operators['contains']
     Condition.operators['contains'] = :[]
 
     assert_template_result('yes',
                            %({% if 'gnomeslab-and-or-liquid' contains 'gnomeslab-and-or-liquid' %}yes{% endif %}))
-  ensure
-    Condition.operators['contains'] = original_op
   end
 
   def test_operators_are_whitelisted
-    assert_raises(SyntaxError) do
+    assert_raise(SyntaxError) do
       assert_template_result('', %({% if 1 or throw or or 1 %}yes{% endif %}))
     end
   end
-
-  def test_multiple_conditions
-    tpl = "{% if a or b and c %}true{% else %}false{% endif %}"
-
-    tests = {
-      [true, true, true] => true,
-      [true, true, false] => true,
-      [true, false, true] => true,
-      [true, false, false] => true,
-      [false, true, true] => true,
-      [false, true, false] => false,
-      [false, false, true] => false,
-      [false, false, false] => false,
-    }
-
-    tests.each do |vals, expected|
-      a, b, c = vals
-      assigns = { 'a' => a, 'b' => b, 'c' => c }
-      assert_template_result expected.to_s, tpl, assigns, assigns.to_s
-    end
-  end
 end

test/integration/tags/include_tag_test.rb

@@ -27,9 +27,6 @@ class TestFileSystem
     when "pick_a_source"
       "from TestFileSystem"
 
-    when 'assignments'
-      "{% assign foo = 'bar' %}"
-
     else
       template_path
     end
@@ -63,12 +60,16 @@ class CustomInclude < Liquid::Tag
   def parse(tokens)
   end
 
+  def blank?
+    false
+  end
+
   def render(context)
     @template_name[1..-2]
   end
 end
 
-class IncludeTagTest < Minitest::Test
+class IncludeTagTest < Test::Unit::TestCase
   include Liquid
 
   def setup
@@ -111,10 +112,6 @@ class IncludeTagTest < Minitest::Test
       'echo1' => 'test123', 'more_echos' => { "echo2" => 'test321'}
   end
 
-  def test_included_templates_assigns_variables
-    assert_template_result "bar", "{% include 'assignments' %}{{ foo }}"
-  end
-
   def test_nested_include_tag
     assert_template_result "body body_detail", "{% include 'body' %}"
 
@@ -139,7 +136,7 @@ class IncludeTagTest < Minitest::Test
 
     Liquid::Template.file_system = infinite_file_system.new
 
-    assert_raises(Liquid::StackLevelError, SystemStackError) do
+    assert_raise(Liquid::StackLevelError) do
       Template.parse("{% include 'loop' %}").render!
     end
 
@@ -208,27 +205,4 @@ class IncludeTagTest < Minitest::Test
       Liquid::Template.tags['include'] = original_tag
     end
   end
-
-  def test_does_not_add_error_in_strict_mode_for_missing_variable
-    Liquid::Template.file_system = TestFileSystem.new
-
-    a = Liquid::Template.parse(' {% include "nested_template" %}')
-    a.render!
-    assert_empty a.errors
-  end
-
-  def test_passing_options_to_included_templates
-    assert_raises(Liquid::SyntaxError) do
-      Template.parse("{% include template %}", error_mode: :strict).render!("template" => '{{ "X" || downcase }}')
-    end
-    with_error_mode(:lax) do
-      assert_equal 'x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: true).render!("template" => '{{ "X" || downcase }}')
-    end
-    assert_raises(Liquid::SyntaxError) do
-      Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:locale]).render!("template" => '{{ "X" || downcase }}')
-    end
-    with_error_mode(:lax) do
-      assert_equal 'x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:error_mode]).render!("template" => '{{ "X" || downcase }}')
-    end
-  end
 end # IncludeTagTest

test/integration/tags/increment_tag_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class IncrementTagTest < Minitest::Test
+class IncrementTagTest < Test::Unit::TestCase
   include Liquid
 
   def test_inc

test/integration/tags/raw_tag_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class RawTagTest < Minitest::Test
+class RawTagTest < Test::Unit::TestCase
   include Liquid
 
   def test_tag_in_raw

test/integration/tags/standard_tag_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class StandardTagTest < Minitest::Test
+class StandardTagTest < Test::Unit::TestCase
   include Liquid
 
   def test_no_transform
@@ -66,7 +66,7 @@ class StandardTagTest < Minitest::Test
   end
 
   def test_capture_detects_bad_syntax
-    assert_raises(SyntaxError) do
+    assert_raise(SyntaxError) do
       assert_template_result('content foo content foo ',
                              '{{ var2 }}{% capture %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
                              {'var' => 'content' })
@@ -229,11 +229,11 @@ class StandardTagTest < Minitest::Test
   end
 
   def test_case_detects_bad_syntax
-    assert_raises(SyntaxError) do
+    assert_raise(SyntaxError) do
       assert_template_result('',  '{% case false %}{% when %}true{% endcase %}', {})
     end
 
-    assert_raises(SyntaxError) do
+    assert_raise(SyntaxError) do
       assert_template_result('',  '{% case false %}{% huh %}true{% endcase %}', {})
     end
 

test/integration/tags/statements_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class StatementsTest < Minitest::Test
+class StatementsTest < Test::Unit::TestCase
   include Liquid
 
   def test_true_eql_true

test/integration/tags/table_row_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class TableRowTest < Minitest::Test
+class TableRowTest < Test::Unit::TestCase
   include Liquid
 
   class ArrayDrop < Liquid::Drop

test/integration/tags/unless_else_tag_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class UnlessElseTagTest < Minitest::Test
+class UnlessElseTagTest < Test::Unit::TestCase
   include Liquid
 
   def test_unless

test/integration/template_test.rb

@@ -28,7 +28,7 @@ class ErroneousDrop < Liquid::Drop
   end
 end
 
-class TemplateTest < Minitest::Test
+class TemplateTest < Test::Unit::TestCase
   include Liquid
 
   def test_instance_assigns_persist_on_same_template_object_between_parses
@@ -93,7 +93,7 @@ class TemplateTest < Minitest::Test
     assert t.resource_limits[:reached]
     t.resource_limits = { :render_length_limit => 10 }
     assert_equal "0123456789", t.render!()
-    refute_nil t.resource_limits[:render_length_current]
+    assert_not_nil t.resource_limits[:render_length_current]
   end
 
   def test_resource_limits_render_score
@@ -107,7 +107,7 @@ class TemplateTest < Minitest::Test
     assert t.resource_limits[:reached]
     t.resource_limits = { :render_score_limit => 200 }
     assert_equal (" foo " * 100), t.render!()
-    refute_nil t.resource_limits[:render_score_current]
+    assert_not_nil t.resource_limits[:render_score_current]
   end
 
   def test_resource_limits_assign_score
@@ -117,7 +117,7 @@ class TemplateTest < Minitest::Test
     assert t.resource_limits[:reached]
     t.resource_limits = { :assign_score_limit => 2 }
     assert_equal "", t.render!()
-    refute_nil t.resource_limits[:assign_score_current]
+    assert_not_nil t.resource_limits[:assign_score_current]
   end
 
   def test_resource_limits_aborts_rendering_after_first_error
@@ -135,18 +135,6 @@ class TemplateTest < Minitest::Test
     assert t.resource_limits[:render_length_current] > 0
   end
 
-  def test_default_resource_limits_unaffected_by_render_with_context
-    context = Context.new
-    t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
-    t.render!(context)
-    assert context.resource_limits[:assign_score_current] > 0
-    assert context.resource_limits[:render_score_current] > 0
-    assert context.resource_limits[:render_length_current] > 0
-    refute Template.default_resource_limits.key?(:assign_score_current)
-    refute Template.default_resource_limits.key?(:render_score_current)
-    refute Template.default_resource_limits.key?(:render_length_current)
-  end
-
   def test_can_use_drop_as_context
     t = Template.new
     t.registers['lulz'] = 'haha'
@@ -165,18 +153,4 @@ class TemplateTest < Minitest::Test
     end
     assert_equal 'ruby error in drop', e.message
   end
-
-  def test_exception_handler_doesnt_reraise_if_it_returns_false
-    exception = nil
-    Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_handler: ->(e) { exception = e; false })
-    assert exception.is_a?(ZeroDivisionError)
-  end
-
-  def test_exception_handler_does_reraise_if_it_returns_true
-    exception = nil
-    assert_raises(ZeroDivisionError) do
-      Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_handler: ->(e) { exception = e; true })
-    end
-    assert exception.is_a?(ZeroDivisionError)
-  end
 end

test/integration/variable_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class VariableTest < Minitest::Test
+class VariableTest < Test::Unit::TestCase
   include Liquid
 
   def test_simple_variable
@@ -9,10 +9,6 @@ class VariableTest < Minitest::Test
     assert_equal 'worked wonderfully', template.render!('test' => 'worked wonderfully')
   end
 
-  def test_variable_render_calls_to_liquid
-    assert_template_result 'foobar', '{{ foo }}', 'foo' => ThingWithToLiquid.new
-  end
-
   def test_simple_with_whitespaces
     template = Template.parse(%|  {{ test }}  |)
     assert_equal '  worked  ', template.render!('test' => 'worked')
@@ -31,12 +27,6 @@ class VariableTest < Minitest::Test
 
   def test_false_renders_as_false
     assert_equal 'false', Template.parse("{{ foo }}").render!('foo' => false)
-    assert_equal 'false', Template.parse("{{ false }}").render!
-  end
-
-  def test_nil_renders_as_empty_string
-    assert_equal '', Template.parse("{{ nil }}").render!
-    assert_equal 'cat', Template.parse("{{ nil | append: 'cat' }}").render!
   end
 
   def test_preset_assigns

test/test_helper.rb

@@ -1,8 +1,7 @@
 #!/usr/bin/env ruby
 
-ENV["MT_NO_EXPECTATIONS"] = "1"
-require 'minitest/autorun'
-require 'spy/integration'
+require 'test/unit'
+require 'test/unit/assertions'
 
 $:.unshift(File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib'))
 require 'liquid.rb'
@@ -14,76 +13,41 @@ if env_mode = ENV['LIQUID_PARSER_MODE']
 end
 Liquid::Template.error_mode = mode
 
-if Minitest.const_defined?('Test')
-  # We're on Minitest 5+. Nothing to do here.
-else
-  # Minitest 4 doesn't have Minitest::Test yet.
-  Minitest::Test = MiniTest::Unit::TestCase
-end
 
-module Minitest
-  class Test
-    def fixture(name)
-      File.join(File.expand_path(File.dirname(__FILE__)), "fixtures", name)
-    end
-  end
-
-  module Assertions
-    include Liquid
-
-    def assert_template_result(expected, template, assigns = {}, message = nil)
-      assert_equal expected, Template.parse(template).render!(assigns), message
-    end
-
-    def assert_template_result_matches(expected, template, assigns = {}, message = nil)
-      return assert_template_result(expected, template, assigns, message) unless expected.is_a? Regexp
-
-      assert_match expected, Template.parse(template).render!(assigns), message
-    end
-
-    def assert_match_syntax_error(match, template, registers = {})
-      exception = assert_raises(Liquid::SyntaxError) {
-        Template.parse(template).render(assigns)
-      }
-      assert_match match, exception.message
-    end
-
-    def with_global_filter(*globals)
-      original_global_strainer = Liquid::Strainer.class_variable_get(:@@global_strainer)
-      Liquid::Strainer.class_variable_set(:@@global_strainer, Class.new(Liquid::Strainer) do
-        @filter_methods = Set.new
-      end)
-      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
-
-      globals.each do |global|
-        Liquid::Template.register_filter(global)
+module Test
+  module Unit
+    class TestCase
+      def fixture(name)
+        File.join(File.expand_path(File.dirname(__FILE__)), "fixtures", name)
       end
-      yield
-    ensure
-      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
-      Liquid::Strainer.class_variable_set(:@@global_strainer, original_global_strainer)
     end
 
-    def with_taint_mode(mode)
-      old_mode = Liquid::Template.taint_mode
-      Liquid::Template.taint_mode = mode
-      yield
-    ensure
-      Liquid::Template.taint_mode = old_mode
-    end
+    module Assertions
+      include Liquid
 
-    def with_error_mode(mode)
-      old_mode = Liquid::Template.error_mode
-      Liquid::Template.error_mode = mode
-      yield
-    ensure
-      Liquid::Template.error_mode = old_mode
-    end
-  end
-end
+      def assert_template_result(expected, template, assigns = {}, message = nil)
+        assert_equal expected, Template.parse(template).render!(assigns)
+      end
 
-class ThingWithToLiquid
-  def to_liquid
-    'foobar'
-  end
-end
+      def assert_template_result_matches(expected, template, assigns = {}, message = nil)
+        return assert_template_result(expected, template, assigns, message) unless expected.is_a? Regexp
+
+        assert_match expected, Template.parse(template).render!(assigns)
+      end
+
+      def assert_match_syntax_error(match, template, registers = {})
+        exception = assert_raise(Liquid::SyntaxError) {
+          Template.parse(template).render(assigns)
+        }
+        assert_match match, exception.message
+      end
+
+      def with_error_mode(mode)
+        old_mode = Liquid::Template.error_mode
+        Liquid::Template.error_mode = mode
+        yield
+        Liquid::Template.error_mode = old_mode
+      end
+    end # Assertions
+  end # Unit
+end # Test

test/unit/block_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class BlockUnitTest < Minitest::Test
+class BlockUnitTest < Test::Unit::TestCase
   include Liquid
 
   def test_blankspace
@@ -45,7 +45,10 @@ class BlockUnitTest < Minitest::Test
 
   def test_with_custom_tag
     Liquid::Template.register_tag("testtag", Block)
-    assert Liquid::Template.parse( "{% testtag %} {% endtesttag %}")
+
+    assert_nothing_thrown do
+      template = Liquid::Template.parse( "{% testtag %} {% endtesttag %}")
+    end
   end
 
   private

test/unit/condition_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ConditionUnitTest < Minitest::Test
+class ConditionUnitTest < Test::Unit::TestCase
   include Liquid
 
   def test_basic_condition
@@ -49,17 +49,6 @@ class ConditionUnitTest < Minitest::Test
     assert_evalutes_false "'bob'", 'contains', "'---'"
   end
 
-  def test_invalid_comparation_operator
-    assert_evaluates_argument_error "1", '~~', '0'
-  end
-
-  def test_comparation_of_int_and_str
-    assert_evaluates_argument_error "'1'", '>', '0'
-    assert_evaluates_argument_error "'1'", '<', '0'
-    assert_evaluates_argument_error "'1'", '>=', '0'
-    assert_evaluates_argument_error "'1'", '<=', '0'
-  end
-
   def test_contains_works_on_arrays
     @context = Liquid::Context.new
     @context['array'] = [1,2,3,4,5]
@@ -80,10 +69,6 @@ class ConditionUnitTest < Minitest::Test
     assert_evalutes_false "0", 'contains', 'not_assigned'
   end
 
-  def test_contains_return_false_on_wrong_data_type
-    assert_evalutes_false "1", 'contains', '0'
-  end
-
   def test_or_condition
     condition = Condition.new('1', '==', '2')
 
@@ -139,11 +124,4 @@ class ConditionUnitTest < Minitest::Test
       assert !Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),
              "Evaluated true: #{left} #{op} #{right}"
     end
-
-    def assert_evaluates_argument_error(left, op, right)
-      assert_raises(Liquid::ArgumentError) do
-        Condition.new(left, op, right).evaluate(@context || Liquid::Context.new)
-      end
-    end
-
 end # ConditionTest

test/unit/context_unit_test.rb

@@ -63,17 +63,13 @@ class ArrayLike
   end
 end
 
-class ContextUnitTest < Minitest::Test
+class ContextUnitTest < Test::Unit::TestCase
   include Liquid
 
   def setup
     @context = Liquid::Context.new
   end
 
-  def teardown
-    Spy.teardown
-  end
-
   def test_variables
     @context['string'] = 'string'
     assert_equal 'string', @context['string']
@@ -107,14 +103,16 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_scoping
-    @context.push
-    @context.pop
-
-    assert_raises(Liquid::ContextError) do
+    assert_nothing_raised do
+      @context.push
       @context.pop
     end
 
-    assert_raises(Liquid::ContextError) do
+    assert_raise(Liquid::ContextError) do
+      @context.pop
+    end
+
+    assert_raise(Liquid::ContextError) do
       @context.push
       @context.pop
       @context.pop
@@ -460,33 +458,21 @@ class ContextUnitTest < Minitest::Test
     assert_equal @context, @context['category'].context
   end
 
-  def test_use_empty_instead_of_any_in_interrupt_handling_to_avoid_lots_of_unnecessary_object_allocations
-    mock_any = Spy.on_instance_method(Array, :any?)
-    mock_empty = Spy.on_instance_method(Array, :empty?)
-    mock_has_interrupt = Spy.on(@context, :has_interrupt?).and_call_through
-
-    @context.has_interrupt?
-
-    refute mock_any.has_been_called?
-    assert mock_empty.has_been_called?
-  end 
-
-  def test_variable_lookup_caches_markup
-    mock_scan = Spy.on_instance_method(String, :scan).and_return(["string"])
-
-    @context['string'] = 'string'
-    @context['string']
-    @context['string']
-
-    assert_equal 1, mock_scan.calls.size
+  def test_strict_variables_not_found
+    with_error_mode(:strict) do
+      @context['does_not_exist']
+      assert(@context.errors.length == 1)
+      assert_equal(@context.errors[0], 'Variable {{does_not_exist}} not found')
+    end
   end
 
-  def test_context_initialization_with_a_proc_in_environment
-    contx = Context.new([:test => lambda { |c| c['poutine']}], {:test => :foo})
-
-    assert contx
-    assert_nil contx['poutine']
+  def test_strict_nested_variables_not_found
+    with_error_mode(:strict) do
+      @context['hash'] = {'this' => 'exists'}
+      @context['hash.does_not_exist']
+      assert(@context.errors.length == 1)
+      assert_equal(@context.errors[0], 'Variable {{hash.does_not_exist}} not found')
+    end
   end
 
-
 end # ContextTest

test/unit/file_system_unit_test.rb

@@ -1,10 +1,10 @@
 require 'test_helper'
 
-class FileSystemUnitTest < Minitest::Test
+class FileSystemUnitTest < Test::Unit::TestCase
   include Liquid
 
   def test_default
-    assert_raises(FileSystemError) do
+    assert_raise(FileSystemError) do
       BlankFileSystem.new.read_template_file("dummy", {'dummy'=>'smarty'})
     end
   end
@@ -14,15 +14,15 @@ class FileSystemUnitTest < Minitest::Test
     assert_equal "/some/path/_mypartial.liquid"    , file_system.full_path("mypartial")
     assert_equal "/some/path/dir/_mypartial.liquid", file_system.full_path("dir/mypartial")
 
-    assert_raises(FileSystemError) do
+    assert_raise(FileSystemError) do
       file_system.full_path("../dir/mypartial")
     end
 
-    assert_raises(FileSystemError) do
+    assert_raise(FileSystemError) do
       file_system.full_path("/dir/../../dir/mypartial")
     end
 
-    assert_raises(FileSystemError) do
+    assert_raise(FileSystemError) do
       file_system.full_path("/etc/passwd")
     end
   end

test/unit/i18n_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class I18nUnitTest < Minitest::Test
+class I18nUnitTest < Test::Unit::TestCase
   include Liquid
 
   def setup
@@ -20,13 +20,13 @@ class I18nUnitTest < Minitest::Test
   end
 
   # def test_raises_translation_error_on_undefined_interpolation_key
-  #   assert_raises I18n::TranslationError do
+  #   assert_raise I18n::TranslationError do
   #     @i18n.translate("whatever", :oopstypos => "yes")
   #   end
   # end
   
   def test_raises_unknown_translation
-    assert_raises I18n::TranslationError do
+    assert_raise I18n::TranslationError do
       @i18n.translate("doesnt_exist")
     end
   end

test/unit/lexer_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class LexerUnitTest < Minitest::Test
+class LexerUnitTest < Test::Unit::TestCase
   include Liquid
 
   def test_strings

test/unit/module_ex_unit_test.rb

@@ -36,7 +36,7 @@ class TestClassC::LiquidDropClass
   end
 end
 
-class ModuleExUnitTest < Minitest::Test
+class ModuleExUnitTest < Test::Unit::TestCase
   include Liquid
 
   def setup

test/unit/parser_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ParserUnitTest < Minitest::Test
+class ParserUnitTest < Test::Unit::TestCase
   include Liquid
 
   def test_consume

test/unit/regexp_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class RegexpUnitTest < Minitest::Test
+class RegexpUnitTest < Test::Unit::TestCase
   include Liquid
 
   def test_empty

test/unit/strainer_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class StrainerUnitTest < Minitest::Test
+class StrainerUnitTest < Test::Unit::TestCase
   include Liquid
 
   module AccessScopeFilters
@@ -31,11 +31,11 @@ class StrainerUnitTest < Minitest::Test
 
   def test_strainer_only_invokes_public_filter_methods
     strainer = Strainer.create(nil)
-    assert_equal false, strainer.class.invokable?('__test__')
-    assert_equal false, strainer.class.invokable?('test')
-    assert_equal false, strainer.class.invokable?('instance_eval')
-    assert_equal false, strainer.class.invokable?('__send__')
-    assert_equal true, strainer.class.invokable?('size') # from the standard lib
+    assert_equal false, strainer.invokable?('__test__')
+    assert_equal false, strainer.invokable?('test')
+    assert_equal false, strainer.invokable?('instance_eval')
+    assert_equal false, strainer.invokable?('__send__')
+    assert_equal true, strainer.invokable?('size') # from the standard lib
   end
 
   def test_strainer_returns_nil_if_no_filter_method_found
@@ -57,13 +57,14 @@ class StrainerUnitTest < Minitest::Test
   end
 
   def test_strainer_uses_a_class_cache_to_avoid_method_cache_invalidation
-    a = Module.new
-    b = Module.new
+    a, b = Module.new, Module.new
     strainer = Strainer.create(nil, [a,b])
     assert_kind_of Strainer, strainer
     assert_kind_of a, strainer
     assert_kind_of b, strainer
-    assert_kind_of Liquid::StandardFilters, strainer
+    Strainer.class_variable_get(:@@filters).each do |m|
+      assert_kind_of m, strainer
+    end
   end
 
 end # StrainerTest

test/unit/tag_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class TagUnitTest < Minitest::Test
+class TagUnitTest < Test::Unit::TestCase
   include Liquid
 
   def test_tag
@@ -8,9 +8,4 @@ class TagUnitTest < Minitest::Test
     assert_equal 'liquid::tag', tag.name
     assert_equal '', tag.render(Context.new)
   end
-
-  def test_return_raw_text_of_tag
-    tag = Tag.parse("long_tag", "param1, param2, param3", [], {})
-    assert_equal("long_tag param1, param2, param3", tag.raw)
-  end
 end

test/unit/tags/case_tag_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class CaseTagUnitTest < Minitest::Test
+class CaseTagUnitTest < Test::Unit::TestCase
   include Liquid
 
   def test_case_nodelist

test/unit/tags/for_tag_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ForTagUnitTest < Minitest::Test
+class ForTagUnitTest < Test::Unit::TestCase
   def test_for_nodelist
     template = Liquid::Template.parse('{% for item in items %}FOR{% endfor %}')
     assert_equal ['FOR'], template.root.nodelist[0].nodelist

test/unit/tags/if_tag_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class IfTagUnitTest < Minitest::Test
+class IfTagUnitTest < Test::Unit::TestCase
   def test_if_nodelist
     template = Liquid::Template.parse('{% if true %}IF{% else %}ELSE{% endif %}')
     assert_equal ['IF', 'ELSE'], template.root.nodelist[0].nodelist

test/unit/template_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class TemplateUnitTest < Minitest::Test
+class TemplateUnitTest < Test::Unit::TestCase
   include Liquid
 
   def test_sets_default_localization_in_document
@@ -16,54 +16,4 @@ class TemplateUnitTest < Minitest::Test
     assert_instance_of I18n, t.root.options[:locale]
     assert_equal fixture("en_locale.yml"), t.root.options[:locale].path
   end
-
-  def test_with_cache_classes_tags_returns_the_same_class
-    original_cache_setting = Liquid.cache_classes
-    Liquid.cache_classes = true
-
-    original_klass = Class.new
-    Object.send(:const_set, :CustomTag, original_klass)
-    Template.register_tag('custom', CustomTag)
-
-    Object.send(:remove_const, :CustomTag)
-
-    new_klass = Class.new
-    Object.send(:const_set, :CustomTag, new_klass)
-
-    assert Template.tags['custom'].equal?(original_klass)
-  ensure
-    Object.send(:remove_const, :CustomTag)
-    Template.tags.delete('custom')
-    Liquid.cache_classes = original_cache_setting
-  end
-
-  def test_without_cache_classes_tags_reloads_the_class
-    original_cache_setting = Liquid.cache_classes
-    Liquid.cache_classes = false
-
-    original_klass = Class.new
-    Object.send(:const_set, :CustomTag, original_klass)
-    Template.register_tag('custom', CustomTag)
-
-    Object.send(:remove_const, :CustomTag)
-
-    new_klass = Class.new
-    Object.send(:const_set, :CustomTag, new_klass)
-
-    assert Template.tags['custom'].equal?(new_klass)
-  ensure
-    Object.send(:remove_const, :CustomTag)
-    Template.tags.delete('custom')
-    Liquid.cache_classes = original_cache_setting
-  end
-
-  class FakeTag; end
-
-  def test_tags_delete
-    Template.register_tag('fake', FakeTag)
-    assert_equal FakeTag, Template.tags['fake']
-
-    Template.tags.delete('fake')
-    assert_nil Template.tags['fake']
-  end
 end

test/unit/tokenizer_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class TokenizerTest < Minitest::Test
+class TokenizerTest < Test::Unit::TestCase
   def test_tokenize_strings
     assert_equal [' '], tokenize(' ')
     assert_equal ['hello world'], tokenize('hello world')
@@ -21,15 +21,6 @@ class TokenizerTest < Minitest::Test
     assert_equal ['  ', '{% comment %}', ' ', '{% endcomment %}', ' '], tokenize("  {% comment %} {% endcomment %} ")
   end
 
-  def test_calculate_line_numbers_per_token_with_profiling
-    template = Liquid::Template.parse("", :profile => true)
-
-    assert_equal [1],       template.send(:tokenize, "{{funk}}").map(&:line_number)
-    assert_equal [1, 1, 1], template.send(:tokenize, " {{funk}} ").map(&:line_number)
-    assert_equal [1, 2, 2], template.send(:tokenize, "\n{{funk}}\n").map(&:line_number)
-    assert_equal [1, 1, 3], template.send(:tokenize, " {{\n funk \n}} ").map(&:line_number)
-  end
-
   private
 
   def tokenize(source)

test/unit/variable_unit_test.rb

@@ -1,127 +1,129 @@
 require 'test_helper'
 
-class VariableUnitTest < Minitest::Test
+class VariableUnitTest < Test::Unit::TestCase
   include Liquid
 
   def test_variable
     var = Variable.new('hello')
-    assert_equal VariableLookup.new('hello'), var.name
+    assert_equal 'hello', var.name
   end
 
   def test_filters
     var = Variable.new('hello | textileze')
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['textileze',[]]], var.filters
+    assert_equal 'hello', var.name
+    assert_equal [["textileze",[]]], var.filters
 
     var = Variable.new('hello | textileze | paragraph')
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['textileze',[]], ['paragraph',[]]], var.filters
+    assert_equal 'hello', var.name
+    assert_equal [["textileze",[]], ["paragraph",[]]], var.filters
 
     var = Variable.new(%! hello | strftime: '%Y'!)
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['strftime',['%Y']]], var.filters
+    assert_equal 'hello', var.name
+    assert_equal [["strftime",["'%Y'"]]], var.filters
 
     var = Variable.new(%! 'typo' | link_to: 'Typo', true !)
-    assert_equal 'typo', var.name
-    assert_equal [['link_to',['Typo', true]]], var.filters
+    assert_equal %!'typo'!, var.name
+    assert_equal [["link_to",["'Typo'", "true"]]], var.filters
 
     var = Variable.new(%! 'typo' | link_to: 'Typo', false !)
-    assert_equal 'typo', var.name
-    assert_equal [['link_to',['Typo', false]]], var.filters
+    assert_equal %!'typo'!, var.name
+    assert_equal [["link_to",["'Typo'", "false"]]], var.filters
 
     var = Variable.new(%! 'foo' | repeat: 3 !)
-    assert_equal 'foo', var.name
-    assert_equal [['repeat',[3]]], var.filters
+    assert_equal %!'foo'!, var.name
+    assert_equal [["repeat",["3"]]], var.filters
 
     var = Variable.new(%! 'foo' | repeat: 3, 3 !)
-    assert_equal 'foo', var.name
-    assert_equal [['repeat',[3,3]]], var.filters
+    assert_equal %!'foo'!, var.name
+    assert_equal [["repeat",["3","3"]]], var.filters
 
     var = Variable.new(%! 'foo' | repeat: 3, 3, 3 !)
-    assert_equal 'foo', var.name
-    assert_equal [['repeat',[3,3,3]]], var.filters
+    assert_equal %!'foo'!, var.name
+    assert_equal [["repeat",["3","3","3"]]], var.filters
 
     var = Variable.new(%! hello | strftime: '%Y, okay?'!)
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['strftime',['%Y, okay?']]], var.filters
+    assert_equal 'hello', var.name
+    assert_equal [["strftime",["'%Y, okay?'"]]], var.filters
 
     var = Variable.new(%! hello | things: "%Y, okay?", 'the other one'!)
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['things',['%Y, okay?','the other one']]], var.filters
+    assert_equal 'hello', var.name
+    assert_equal [["things",["\"%Y, okay?\"","'the other one'"]]], var.filters
   end
 
   def test_filter_with_date_parameter
+
     var = Variable.new(%! '2006-06-06' | date: "%m/%d/%Y"!)
-    assert_equal '2006-06-06', var.name
-    assert_equal [['date',['%m/%d/%Y']]], var.filters
+    assert_equal "'2006-06-06'", var.name
+    assert_equal [["date",["\"%m/%d/%Y\""]]], var.filters
+
   end
 
   def test_filters_without_whitespace
     var = Variable.new('hello | textileze | paragraph')
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['textileze',[]], ['paragraph',[]]], var.filters
+    assert_equal 'hello', var.name
+    assert_equal [["textileze",[]], ["paragraph",[]]], var.filters
 
     var = Variable.new('hello|textileze|paragraph')
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['textileze',[]], ['paragraph',[]]], var.filters
+    assert_equal 'hello', var.name
+    assert_equal [["textileze",[]], ["paragraph",[]]], var.filters
 
     var = Variable.new("hello|replace:'foo','bar'|textileze")
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['replace', ['foo', 'bar']], ['textileze', []]], var.filters
+    assert_equal 'hello', var.name
+    assert_equal [["replace", ["'foo'", "'bar'"]], ["textileze", []]], var.filters
   end
 
   def test_symbol
     var = Variable.new("http://disney.com/logo.gif | image: 'med' ", :error_mode => :lax)
-    assert_equal VariableLookup.new('http://disney.com/logo.gif'), var.name
-    assert_equal [['image',['med']]], var.filters
+    assert_equal "http://disney.com/logo.gif", var.name
+    assert_equal [["image",["'med'"]]], var.filters
   end
 
   def test_string_to_filter
     var = Variable.new("'http://disney.com/logo.gif' | image: 'med' ")
-    assert_equal 'http://disney.com/logo.gif', var.name
-    assert_equal [['image',['med']]], var.filters
+    assert_equal "'http://disney.com/logo.gif'", var.name
+    assert_equal [["image",["'med'"]]], var.filters
   end
 
   def test_string_single_quoted
     var = Variable.new(%| "hello" |)
-    assert_equal 'hello', var.name
+    assert_equal '"hello"', var.name
   end
 
   def test_string_double_quoted
     var = Variable.new(%| 'hello' |)
-    assert_equal 'hello', var.name
+    assert_equal "'hello'", var.name
   end
 
   def test_integer
     var = Variable.new(%| 1000 |)
-    assert_equal 1000, var.name
+    assert_equal "1000", var.name
   end
 
   def test_float
     var = Variable.new(%| 1000.01 |)
-    assert_equal 1000.01, var.name
+    assert_equal "1000.01", var.name
   end
 
   def test_string_with_special_chars
     var = Variable.new(%| 'hello! $!@.;"ddasd" ' |)
-    assert_equal 'hello! $!@.;"ddasd" ', var.name
+    assert_equal %|'hello! $!@.;"ddasd" '|, var.name
   end
 
   def test_string_dot
     var = Variable.new(%| test.test |)
-    assert_equal VariableLookup.new('test.test'), var.name
+    assert_equal 'test.test', var.name
   end
 
   def test_filter_with_keyword_arguments
     var = Variable.new(%! hello | things: greeting: "world", farewell: 'goodbye'!)
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['things', [], { 'greeting' => 'world', 'farewell' => 'goodbye' }]], var.filters
+    assert_equal 'hello', var.name
+    assert_equal [['things',["greeting: \"world\"","farewell: 'goodbye'"]]], var.filters
   end
 
   def test_lax_filter_argument_parsing
     var = Variable.new(%! number_of_comments | pluralize: 'comment': 'comments' !, :error_mode => :lax)
-    assert_equal VariableLookup.new('number_of_comments'), var.name
-    assert_equal [['pluralize',['comment','comments']]], var.filters
+    assert_equal 'number_of_comments', var.name
+    assert_equal [['pluralize',["'comment'","'comments'"]]], var.filters
   end
 
   def test_strict_filter_argument_parsing
@@ -131,15 +133,4 @@ class VariableUnitTest < Minitest::Test
       end
     end
   end
-
-  def test_output_raw_source_of_variable
-    var = Variable.new(%! name_of_variable | upcase !)
-    assert_equal " name_of_variable | upcase ", var.raw
-  end
-
-  def test_variable_lookup_interface
-    lookup = VariableLookup.new('a.b.c')
-    assert_equal 'a', lookup.name
-    assert_equal ['b', 'c'], lookup.lookups
-  end
 end