Test gem installation on 1.9.x

.travis.yml

@@ -1,16 +1,17 @@
 rvm:
-  - 1.9
+  - 1.9.3
-  - 2.0
+  - 2.0.0
   - 2.1
+  - 2.1.1
   - jruby-19mode
   - jruby-head
-  - rbx-2
+  - rbx-19mode
 matrix:
   allow_failures:
-    - rvm: rbx-2
+    - rvm: rbx-19mode
     - rvm: jruby-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

@@ -3,12 +3,7 @@
 ## 3.0.0 / not yet released / branch "master"
 
 * ...
-* Fixed condition with wrong data types, see #423 [Bogdan Gusiev]
+* Add error messages for missing variables when :strict, see #352 [Daniel Gaiottino]
-* 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] 
 * 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]
@@ -35,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"
+## 2.6.0 / 2013-11-25 / 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
 
 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.
@@ -65,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"
+## 2.5.4 / 2013-11-11 / 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
 
 * Fix "can't convert Fixnum into String" for "replace", see #173, [wǒ_is神仙, jsw0528]
 

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)
@@ -18,44 +18,41 @@ module Liquid
       @children = []
 
       while token = tokens.shift
-        unless token.empty?
+        case token
-          case
+        when IsTag
-          when token.start_with?(TAGSTART)
+          if token =~ FullToken
-            if token =~ FullToken
 
-              # if we found the proper block delimiter just end parsing here and let the outer block
+            # if we found the proper block delimiter just end parsing here and let the outer block
-              # proceed
+            # proceed
-              if block_delimiter == $1
+            if block_delimiter == $1
-                end_tag
+              end_tag
-                return
+              return
-              end
+            end
-
+
-              # fetch the tag from registered blocks
+            # fetch the tag from registered blocks
-              if tag = Template.tags[$1]
+            if tag = Template.tags[$1]
-                markup = token.is_a?(Token) ? token.child($2) : $2
+              new_tag = tag.parse($1, $2, tokens, @options)
-                new_tag = tag.parse($1, markup, tokens, @options)
+              @blank &&= new_tag.blank?
-                new_tag.line_number = token.line_number if token.is_a?(Token)
+              @nodelist << new_tag
-                @blank &&= new_tag.blank?
+              @children << new_tag
-                @nodelist << new_tag
+            else
-                @children << new_tag
+              # this tag is not registered with the system
-              else
+              # pass it to the current block for special handling or error reporting
-                # this tag is not registered with the system
+              unknown_tag($1, $2, tokens)
-                # 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
-            @children << new_var
-            @blank = false
           else
-            @nodelist << token
+            raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination".freeze, :token => token, :tag_end => TagEnd.inspect))
-            @blank &&= (token =~ /\A\s*\z/)
           end
+        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
 
@@ -94,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(content.first, @options)
-        return Variable.new(markup, @options)
       end
       raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination".freeze, :token => token, :tag_end => VariableEnd.inspect))
     end
@@ -138,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/condition.rb

@@ -15,9 +15,7 @@ module Liquid
       '>'.freeze  => :>,
       '>='.freeze => :>=,
       '<='.freeze => :<=,
-      'contains'.freeze => lambda { |cond, left, right|
+      'contains'.freeze => lambda { |cond, left, right| left && right ? left.include?(right) : false }
-        left && right && left.respond_to?(:include?) ? left.include?(right) : false
-      }
     }
 
     def self.operators
@@ -96,16 +94,12 @@ module Liquid
 
       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)
-          left.send(operation, right)
-        rescue ::ArgumentError => e
-          raise Liquid::ArgumentError.new(e.message)
-        end
       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)
+    attr_accessor :rethrow_errors
-      @environments     = [environments].flatten
+
-      @scopes           = [(outer_scope || {})]
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = {})
-      @registers        = registers
+      @environments    = [environments].flatten
-      @errors           = []
+      @scopes          = [(outer_scope || {})]
-      @resource_limits  = resource_limits || Template.default_resource_limits
+      @registers       = registers
-      @resource_limits[:render_score_current] = 0
+      @errors          = []
-      @resource_limits[:assign_score_current] = 0
+      @rethrow_errors  = rethrow_errors
-      @parsed_expression = Hash.new{ |cache, markup| cache[markup] = Expression.parse(markup) }
+      @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
@@ -80,7 +73,7 @@ module Liquid
 
     # 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.
@@ -93,19 +86,20 @@ module Liquid
       @interrupts.pop
     end
 
-
+    def handle_error(e)
-    def handle_error(e, token=nil)
-      if e.is_a?(Liquid::Error)
-        e.set_line_number_from_token(token)
-      end
-
       errors.push(e)
-      raise if exception_handler && exception_handler.call(e)
+      raise if @rethrow_errors
-      Liquid::Error.render(e)
+
+      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
@@ -133,19 +127,11 @@ module Liquid
     #   end
     #
     #   context['var]  #=> nil
-    def stack(new_scope=nil)
+    def stack(new_scope={})
-      old_stack_used = @this_stack_used
+      push(new_scope)
-      if new_scope
-        push(new_scope)
-        @this_stack_used = true
-      else
-        @this_stack_used = false
-      end
-
       yield
     ensure
-      pop if @this_stack_used
+      pop
-      @this_stack_used = old_stack_used
     end
 
     def clear_instance_assigns
@@ -154,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
+    def [](key)
-    # Strings, digits, floats and booleans (true,false).
+      resolve(key)
-    # 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])
     end
 
     def has_key?(key)
-      self[key] != nil
+      resolve(key) != nil
     end
 
-    def evaluate(object)
+    private
-      object.respond_to?(:evaluate) ? object.evaluate(self) : object
+      LITERALS = {
-    end
+        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
+      # Look up variable, either resolve directly after considering the name. We can directly handle
-    def find_variable(key)
+      # Strings, digits, floats and booleans (true,false).
-
+      # If no match is made we lookup the variable in the current scope and
-      # This was changed from find() to find_index() because this is a very hot
+      # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
-      # path and find_index() is optimized in MRI to reduce object allocation
+      # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
-      index = @scopes.find_index { |s| s.has_key?(key) }
+      #
-      scope = @scopes[index] if index
+      # Example:
-
+      #   products == empty #=> products.empty?
-      variable = nil
+      def resolve(key)
-
+        if LITERALS.key?(key)
-      if scope.nil?
+          LITERALS[key]
-        @environments.each do |e|
+        else
-          variable = lookup_and_evaluate(e, key)
+          case key
-          unless variable.nil?
+          when /\A'(.*)'\z/m # Single quoted strings
-            scope = e
+            $1
-            break
+          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
+      # Fetches an object starting at the local scope and then moving up the hierachy
-      variable  ||= lookup_and_evaluate(scope, key)
+      def find_variable(key)
+        scope = @scopes.find { |s| s.has_key?(key) }
+        variable = nil
 
-      variable = variable.to_liquid
+        if scope.nil?
-      variable.context = self if variable.respond_to?(:context=)
+          @environments.each do |e|
+            variable = lookup_and_evaluate(e, key)
+            unless variable.nil?
+              scope = e
+              break
+            end
+          end
+        end
 
-      return variable
+        scope     ||= @environments.last || @scopes.last
-    end
+        handle_not_found(key) unless scope.has_key?(key)
+        variable  ||= lookup_and_evaluate(scope, key)
 
-    def lookup_and_evaluate(obj, key)
+        variable = variable.to_liquid
-      if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
+        variable.context = self if variable.respond_to?(:context=)
-        obj[key] = (value.arity == 0) ? value.call : value.call(self)
+
-      else
+        return variable
-        value
       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|
@@ -229,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,52 +1,5 @@
 module Liquid
-  class Error < ::StandardError
+  class Error < ::StandardError; end
-    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)
-      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 ArgumentError < Error; end
   class ContextError < Error; 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

@@ -36,26 +36,12 @@ module Liquid
     def escape(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)
+    alias_method :h, :escape
-      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
 
     # 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/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 = Variable.new($2)
-        @from.line_number = line_number
       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 %}

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/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/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.
@@ -73,7 +41,7 @@ module Liquid
       end
 
       def tags
-        @tags ||= TagRegistry.new
+        @tags ||= {}
       end
 
       def error_mode
@@ -86,29 +54,21 @@ module Liquid
         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
@@ -140,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
@@ -155,11 +112,7 @@ module Liquid
       context = case args.first
       when Liquid::Context
         c = args.shift
-
+        c.rethrow_errors = true if @rethrow_errors
-        if @rethrow_errors
-          c.exception_handler = ->(e) { true }
-        end
-
         c
       when Liquid::Drop
         drop = args.shift
@@ -184,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
@@ -196,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
+        result = @root.render(context)
-          @root.render(context)
-        end
         result.respond_to?(:join) ? result.join : result
       rescue Liquid::MemoryError => e
         context.handle_error(e)
@@ -218,8 +166,7 @@ module Liquid
     def tokenize(source)
       source = source.source if source.respond_to?(:source)
       return [] if source.to_s.empty?
-
+      tokens = source.split(TemplateParser)
-      tokens = calculate_line_numbers(source.split(TemplateParser))
 
       # removes the rogue empty element at the beginning of the array
       tokens.shift if tokens[0] and tokens[0].empty?
@@ -227,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,37 +11,38 @@ 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)
+      case @options[:error_mode] || Template.error_mode
-    end
+      when :strict then strict_parse(markup)
-
+      when :lax    then lax_parse(markup)
-    def raw
+      when :warn
-      @markup
+        begin
-    end
+          strict_parse(markup)
-
+        rescue SyntaxError => e
-    def markup_context(markup)
+          @warnings ||= []
-      "in \"{{#{markup}}}\""
+          @warnings << e
+          lax_parse(markup)
+        end
+      end
     end
 
     def lax_parse(markup)
       @filters = []
-      if markup =~ /\s*(#{QuotedFragment})(.*)/om
+      if match = markup.match(/\s*(#{QuotedFragment})(.*)/om)
-        @name = Regexp.last_match(1)
+        @name = match[1]
-        if Regexp.last_match(2) =~ /#{FilterSeparator}\s*(.*)/om
+        if match[2].match(/#{FilterSeparator}\s*(.*)/om)
           filters = Regexp.last_match(1).scan(FilterParser)
           filters.each do |f|
-            if f =~ /\w+/
+            if matches = f.match(/\s*(\w+)/)
-              filtername = Regexp.last_match(0)
+              filtername = matches[1]
               filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
               @filters << [filtername, filterargs]
             end
@@ -68,6 +69,9 @@ module Liquid
         @filters << [filtername, filterargs]
       end
       p.consume(:end_of_string)
+    rescue SyntaxError => e
+      e.message << " in \"{{#{markup}}}\""
+      raise e
     end
 
     def parse_filterargs(p)

lib/liquid/variable_lookup.rb

@@ -1,68 +0,0 @@
-module Liquid
-  class VariableLookup
-    SQUARE_BRACKETED = /\A\[(.*)\]\z/m
-    COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze]
-
-    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
-  end
-end

lib/liquid/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module Liquid
-  VERSION = "3.0.0"
+  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

@@ -4,11 +4,8 @@ require File.dirname(__FILE__) + '/theme_runner'
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 
-N = 100
 Benchmark.bmbm do |x|
-  x.report("parse:")                 { N.times { profiler.parse } }
+  x.report("parse:")   { 100.times { profiler.compile } }
-  x.report("marshal load:")          { N.times { profiler.marshal_load } }
+  x.report("parse & run:")   { 100.times { profiler.run } }
-  x.report("render:")                { N.times { profiler.render } }
-  x.report("marshal load & render:") { N.times { profiler.load_and_render } }
-  x.report("parse & render:")        { N.times { profiler.parse_and_render } }
 end
+

performance/profile.rb

@@ -3,15 +3,11 @@ require File.dirname(__FILE__) + '/theme_runner'
 
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
-profiler.parse_and_render
+profiler.run
-
+results = StackProf.run(mode: :cpu) do
-[:cpu, :object].each do |profile_type|
+  100.times do
-  puts "Profiling in #{profile_type.to_s} mode..."
+    profiler.run
-  results = StackProf.run(mode: profile_type) do
-    100.times do
-      profiler.parse_and_render
-    end
   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/theme_runner.rb

@@ -32,59 +32,45 @@ class ThemeRunner
 
       [File.read(test), (File.file?(theme_path) ? File.read(theme_path) : nil), test]
     end.compact
-    @parsed = @tests.map do |liquid, layout, template_name|
-      [Liquid::Template.parse(liquid), Liquid::Template.parse(layout), template_name]
-    end
-    @marshaled = @parsed.map do |liquid, layout, template_name|
-      [Marshal.dump(liquid), Marshal.dump(layout), template_name]
-    end
   end
 
-  def parse
+  def compile
+    # Dup assigns because will make some changes to them
+
     @tests.each do |liquid, layout, template_name|
-      Liquid::Template.parse(liquid)
+
-      Liquid::Template.parse(layout)
+      tmpl = Liquid::Template.new
+      tmpl.parse(liquid)
+      tmpl = Liquid::Template.new
+      tmpl.parse(layout)
     end
   end
 
-  def marshal_load
+   def run
-    @marshaled.each do |liquid, layout, template_name|
-      Marshal.load(liquid)
-      Marshal.load(layout)
-    end
-  end
-
-  def render
-    @parsed.each do |liquid, layout, template_name|
-      render_once(liquid, layout, template_name)
-    end
-  end
-
-  def load_and_render
-    @marshaled.each do |liquid, layout, template_name|
-      render_once(Marshal.load(liquid), Marshal.load(layout), template_name)
-    end
-  end
-
-  def parse_and_render
-    @tests.each do |liquid, layout, template_name|
-      render_once(Liquid::Template.parse(liquid), Liquid::Template.parse(layout), template_name)
-    end
-  end
-
-  def render_once(template, layout, template_name)
     # Dup assigns because will make some changes to them
     assigns = Database.tables.dup
 
-    assigns['page_title'] = 'Page title'
+    @tests.each do |liquid, layout, template_name|
-    assigns['template'] = File.basename(template_name, File.extname(template_name))
-    template.registers[:file_system] = ThemeRunner::FileSystem.new(File.dirname(template_name))
 
-    content_for_layout = template.render!(assigns)
+      # Compute page_tempalte outside of profiler run, uninteresting to profiler
+      page_template = File.basename(template_name, File.extname(template_name))
+      compile_and_render(liquid, layout, assigns, page_template, template_name)
+
+    end
+  end
+
+
+  def compile_and_render(template, layout, assigns, page_template, template_file)
+    tmpl = Liquid::Template.new
+    tmpl.assigns['page_title'] = 'Page title'
+    tmpl.assigns['template'] = page_template
+    tmpl.registers[:file_system] = ThemeRunner::FileSystem.new(File.dirname(template_file))
+
+    content_for_layout = tmpl.parse(template).render!(assigns)
 
     if layout
       assigns['content_for_layout'] = content_for_layout
-      layout.render!(assigns)
+      tmpl.parse(layout).render!(assigns)
     else
       content_for_layout
     end

test/integration/assign_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class AssignTest < Minitest::Test
+class AssignTest < Test::Unit::TestCase
   include Liquid
 
   def test_assigned_variable
@@ -24,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,6 +1,6 @@
 require 'test_helper'
 
-class CaptureTest < Minitest::Test
+class CaptureTest < Test::Unit::TestCase
   include Liquid
 
   def test_captures_block_content_in_variable

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,19 +16,8 @@ class ContextTest < Minitest::Test
       end
     end
 
-    with_global_filter(global) do
+    Template.register_filter(global)
-      assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
+    assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
-      assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, :filters => [local])
+    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
-    Template.error_mode = :strict
-
-    context = Context.new
-
-    context.has_key?('unknown')
-
-    assert_empty context.errors
   end
 end

test/integration/drop_test.rb

@@ -100,12 +100,14 @@ 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_nothing_raised do
-    assert_equal '  ', tpl.render!('product' => ProductDrop.new)
+      tpl = Liquid::Template.parse( '  '  )
+      tpl.render!('product' => ProductDrop.new)
+    end
   end
 
   def test_drop_does_only_respond_to_whitelisted_methods

test/integration/error_handling_test.rb

@@ -19,122 +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_nothing_raised do
-    assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
+      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 1, template.errors.size
-    assert_equal StandardError, template.errors.first.class
+      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_nothing_raised do
-    assert_equal SyntaxError, template.errors.first.class
+
+      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_nothing_raised do
-    assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
 
-    assert_equal 1, template.errors.size
+      template = Liquid::Template.parse( ' {{ errors.argument_error }} '  )
-    assert_equal ArgumentError, template.errors.first.class
+      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_nothing_raised do
-    assert_equal ' Liquid error: Unknown operator =! ', template.render
+      template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :lax)
-    assert_equal 1, template.errors.size
+      assert_equal ' Liquid error: Unknown operator =! ', template.render
-    assert_equal Liquid::ArgumentError, template.errors.first.class
+      assert_equal 1, template.errors.size
+      assert_equal Liquid::ArgumentError, template.errors.first.class
+    end
   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[0].message
-    assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false)
+    assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].message
-    assert_equal 'Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false)
+    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
+    assert_raise Exception do
-      template = Liquid::Template.parse('{{ errors.exception }}')
+      template = Liquid::Template.parse( ' {{ errors.exception }} '  )
       template.render('errors' => ErrorDrop.new)
     end
   end
-end
+end # ErrorHandlingTest

test/integration/filter_test.rb

@@ -22,7 +22,7 @@ module SubstituteFilter
   end
 end
 
-class FiltersTest < Minitest::Test
+class FiltersTest < Test::Unit::TestCase
   include Liquid
 
   def setup
@@ -67,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
@@ -107,15 +107,15 @@ class FiltersTest < Minitest::Test
   end
 end
 
-class FiltersInTemplate < Minitest::Test
+class FiltersInTemplate < Test::Unit::TestCase
   include Liquid
 
   def test_local_global
-    with_global_filter(MoneyFilter) do
+    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$ ", 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
+    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
+ def test_global_register_order
-    with_global_filter(MoneyFilter, CanadianMoneyFilter) do
+    Template.register_filter(MoneyFilter)
-      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, nil)
+    Template.register_filter(CanadianMoneyFilter)
-    end
+
-  end
+    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_nothing_raised do
-    assert Template.parse("{{|test}}")
+      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_nothing_raised do
-    assert Template.parse("{{test}}", :error_mode => :lax)
+      Template.parse("{{test |a|b|}}", :error_mode => :lax)
-    assert Template.parse("{{|test|}}", :error_mode => :lax)
+      Template.parse("{{test}}", :error_mode => :lax)
+      Template.parse("{{|test|}}", :error_mode => :lax)
+    end
   end
 
   def test_meaningless_parens_lax
@@ -80,24 +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
-
 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_template_result "woot: 1", '{{ foo | sort: "whatever" }}', "foo" => [t]
-    assert t.foo > 0
   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
@@ -37,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"
+    assert_nothing_raised do
-    assigns = {'a' => 'and', 'b' => 'or', 'c' => 'foo and bar', 'd' => 'bar or baz', 'e' => 'foo', 'foo' => true, 'bar' => true}
+      awful_markup = "a == 'and' and b == 'or' and c == 'foo and bar' and d == 'bar or baz' and e == 'foo' and foo and bar"
-    assert_template_result(' YES ',"{% if #{awful_markup} %} YES {% endif %}", assigns)
+      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",
+    assert_nothing_raised do
-                            "{% if android.name == 'Roy' %}YES{% endif %}",
+      assert_template_result( "YES",
-                            assigns)
+                              "{% if android.name == 'Roy' %}YES{% endif %}",
-    assert_template_result( "YES",
+                              assigns)
-                            "{% if order.items_count == 0 %}YES{% endif %}",
+    end
-                            assigns)
+    assert_nothing_raised do
+      assert_template_result( "YES",
+                              "{% if order.items_count == 0 %}YES{% endif %}",
+                              assigns)
+    end
   end
 
   def test_if_and
@@ -129,35 +135,31 @@ 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

test/integration/tags/include_tag_test.rb

@@ -60,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
@@ -132,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
 
@@ -201,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
@@ -153,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')

test/test_helper.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-require 'minitest/autorun'
+require 'test/unit'
-require 'spy/integration'
+require 'test/unit/assertions'
 
 $:.unshift(File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib'))
 require 'liquid.rb'
@@ -13,62 +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
+module Test
-  class Test
+  module Unit
-    def fixture(name)
+    class TestCase
-      File.join(File.expand_path(File.dirname(__FILE__)), "fixtures", name)
+      def fixture(name)
-    end
+        File.join(File.expand_path(File.dirname(__FILE__)), "fixtures", name)
-  end
-
-  module Assertions
-    include Liquid
-
-    def assert_template_result(expected, template, assigns = {}, message = nil)
-      assert_equal expected, Template.parse(template).render!(assigns)
-    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_raises(Liquid::SyntaxError) {
-        Template.parse(template).render(assigns)
-      }
-      assert_match match, exception.message
-    end
-
-    def with_global_filter(*globals)
-      original_filters = Array.new(Liquid::Strainer.class_variable_get(:@@filters))
-      globals.each do |global|
-        Liquid::Template.register_filter(global)
       end
-      yield
-    ensure
-      Liquid::Strainer.class_variable_set(:@@filters, original_filters)
     end
 
-    def with_error_mode(mode)
+    module Assertions
-      old_mode = Liquid::Template.error_mode
+      include Liquid
-      Liquid::Template.error_mode = mode
-      yield
-    ensure
-      Liquid::Template.error_mode = old_mode
-    end
-  end
-end
 
-class ThingWithToLiquid
+      def assert_template_result(expected, template, assigns = {}, message = nil)
-  def to_liquid
+        assert_equal expected, Template.parse(template).render!(assigns)
-    'foobar'
+      end
-  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
+    assert_nothing_raised do
-    @context.pop
+      @context.push
-
-    assert_raises(Liquid::ContextError) do
       @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
+  def test_strict_variables_not_found
-    mock_any = Spy.on_instance_method(Array, :any?)
+    with_error_mode(:strict) do
-    mock_empty = Spy.on_instance_method(Array, :empty?)
+      @context['does_not_exist']
-    mock_has_interrupt = Spy.on(@context, :has_interrupt?).and_call_through
+      assert(@context.errors.length == 1)
-
+      assert_equal(@context.errors[0], 'Variable {{does_not_exist}} not found')
-    @context.has_interrupt?
+    end
-
-    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
   end
 
-  def test_context_initialization_with_a_proc_in_environment
+  def test_strict_nested_variables_not_found
-    contx = Context.new([:test => lambda { |c| c['poutine']}], {:test => :foo})
+    with_error_mode(:strict) do
-
+      @context['hash'] = {'this' => 'exists'}
-    assert contx
+      @context['hash.does_not_exist']
-    assert_nil contx['poutine']
+      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

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,6 +1,6 @@
 require 'test_helper'
 
-class VariableUnitTest < Minitest::Test
+class VariableUnitTest < Test::Unit::TestCase
   include Liquid
 
   def test_variable
@@ -133,9 +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
 end