Add test for spaces in square brackets

Fix case where a variable name is falsy

Gemfile

@@ -5,4 +5,5 @@ gem 'stackprof', platforms: :mri_21
 
 group :test do
   gem 'spy', '0.4.1'
+  gem 'benchmark-ips'
 end

History.md

@@ -3,6 +3,10 @@
 ## 3.0.0 / not yet released / branch "master"
 
 * ...
+* Removed Block#end_tag. Instead, override parse with `super` followed by your code. See #446 [Dylan Thacker-Smith, dylanahsmith]
+* Fixed condition with wrong data types, see #423 [Bogdan Gusiev]
+* Add url_encode to standard filters, see #421 [Derrick Reimer, djreimer]
+* Add uniq to standard filters [Florian Weingarten, fw42]
 * Add exception_handler feature, see #397 and #254 [Bogdan Gusiev, bogdan and Florian Weingarten, fw42]
 * Optimize variable parsing to avoid repeated regex evaluation during template rendering #383 [Jason Hiltz-Laforge, jasonhl]
 * Optimize checking for block interrupts to reduce object allocation #380 [Jason Hiltz-Laforge, jasonhl] 

example/server/liquid_servlet.rb

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

lib/liquid.rb

@@ -52,18 +52,26 @@ 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

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

@@ -3,7 +3,7 @@ module Liquid
   #
   # Example:
   #
-  #   c = Condition.new('1', '==', '1')
+  #   c = Condition.new(1, '==', 1)
   #   c.evaluate #=> true
   #
   class Condition #:nodoc:
@@ -15,7 +15,9 @@ module Liquid
       '>'.freeze  => :>,
       '>='.freeze => :>=,
       '<='.freeze => :<=,
-      'contains'.freeze => lambda { |cond, left, right| left && right ? left.include?(right) : false }
+      'contains'.freeze => lambda { |cond, left, right|
+        left && right && left.respond_to?(:include?) ? left.include?(right) : false
+      }
     }
 
     def self.operators
@@ -26,7 +28,9 @@ module Liquid
     attr_accessor :left, :operator, :right
 
     def initialize(left = nil, operator = nil, right = nil)
-      @left, @operator, @right = left, operator, right
+      @left = left
+      @operator = operator
+      @right = right
       @child_relation  = nil
       @child_condition = nil
     end
@@ -45,11 +49,13 @@ module Liquid
     end
 
     def or(condition)
-      @child_relation, @child_condition = :or, condition
+      @child_relation = :or
+      @child_condition = condition
     end
 
     def and(condition)
-      @child_relation, @child_condition = :and, condition
+      @child_relation = :and
+      @child_condition = condition
     end
 
     def attach(attachment)
@@ -90,9 +96,10 @@ module Liquid
       # If the operator is empty this means that the decision statement is just
       # a single variable. We can just poll this variable from the context and
       # return this as the result.
-      return context[left] if op == nil
+      return context.evaluate(left) if op == nil
 
-      left, right = context[left], context[right]
+      left = context.evaluate(left)
+      right = context.evaluate(right)
 
       operation = self.class.operators[op] || raise(Liquid::ArgumentError.new("Unknown operator #{op}"))
 

lib/liquid/context.rb

@@ -16,23 +16,24 @@ module Liquid
     attr_reader :scopes, :errors, :registers, :environments, :resource_limits
     attr_accessor :exception_handler
 
-    SQUARE_BRACKETED = /\A\[(.*)\]\z/m
-
-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = {})
-      @environments    = [environments].flatten
-      @scopes          = [(outer_scope || {})]
-      @registers       = registers
-      @errors          = []
-      @resource_limits = (resource_limits || {}).merge!({ :render_score_current => 0, :assign_score_current => 0 })
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
+      @environments     = [environments].flatten
+      @scopes           = [(outer_scope || {})]
+      @registers        = registers
+      @errors           = []
+      @resource_limits  = resource_limits || Template.default_resource_limits.dup
+      @resource_limits[:render_score_current] = 0
+      @resource_limits[:assign_score_current] = 0
       squash_instance_assigns_with_environments
 
+      @this_stack_used = false
+
       if rethrow_errors
         self.exception_handler = ->(e) { true }
       end
 
       @interrupts = []
       @filters = []
-      @parsed_variables = Hash.new{ |cache, markup| cache[markup] = variable_parse(markup) } 
     end
 
     def increment_used_resources(key, obj)
@@ -91,21 +92,19 @@ module Liquid
       @interrupts.pop
     end
 
-    def handle_error(e)
-      errors.push(e)
 
-      raise if exception_handler && exception_handler.call(e)
-
-      case e
-      when SyntaxError
-        "Liquid syntax error: #{e.message}"
-      else
-        "Liquid error: #{e.message}"
+    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)
+      Liquid::Error.render(e)
     end
 
     def invoke(method, *args)
-      strainer.invoke(method, *args)
+      strainer.invoke(method, *args).to_liquid
     end
 
     # Push new local scope on the stack. use <tt>Context#stack</tt> instead
@@ -133,11 +132,19 @@ module Liquid
     #   end
     #
     #   context['var]  #=> nil
-    def stack(new_scope={})
-      push(new_scope)
+    def stack(new_scope=nil)
+      old_stack_used = @this_stack_used
+      if new_scope
+        push(new_scope)
+        @this_stack_used = true
+      else
+        @this_stack_used = false
+      end
+
       yield
     ensure
-      pop
+      pop if @this_stack_used
+      @this_stack_used = old_stack_used
     end
 
     def clear_instance_assigns
@@ -146,152 +153,71 @@ 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
 
-    def [](key)
-      resolve(key)
+    # Look up variable, either resolve directly after considering the name. We can directly handle
+    # Strings, digits, floats and booleans (true,false).
+    # If no match is made we lookup the variable in the current scope and
+    # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
+    # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
+    #
+    # Example:
+    #   products == empty #=> products.empty?
+    def [](expression)
+      evaluate(Expression.parse(expression))
     end
 
     def has_key?(key)
-      resolve(key) != nil
+      self[key] != nil
+    end
+
+    def evaluate(object)
+      object.respond_to?(:evaluate) ? object.evaluate(self) : object
+    end
+
+    # Fetches an object starting at the local scope and then moving up the hierachy
+    def find_variable(key)
+
+      # This was changed from find() to find_index() because this is a very hot
+      # path and find_index() is optimized in MRI to reduce object allocation
+      index = @scopes.find_index { |s| s.has_key?(key) }
+      scope = @scopes[index] if index
+
+      variable = nil
+
+      if scope.nil?
+        @environments.each do |e|
+          variable = lookup_and_evaluate(e, key)
+          unless variable.nil?
+            scope = e
+            break
+          end
+        end
+      end
+
+      scope     ||= @environments.last || @scopes.last
+      variable  ||= lookup_and_evaluate(scope, key)
+
+      variable = variable.to_liquid
+      variable.context = self if variable.respond_to?(:context=)
+
+      return variable
+    end
+
+    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
 
     private
-      LITERALS = {
-        nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
-        'true'.freeze  => true,
-        'false'.freeze => false,
-        'blank'.freeze => :blank?,
-        'empty'.freeze => :empty?
-      }
-
-      # Look up variable, either resolve directly after considering the name. We can directly handle
-      # Strings, digits, floats and booleans (true,false).
-      # If no match is made we lookup the variable in the current scope and
-      # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
-      # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
-      #
-      # Example:
-      #   products == empty #=> products.empty?
-      def resolve(key)
-        if LITERALS.key?(key)
-          LITERALS[key]
-        else
-          case key
-          when /\A'(.*)'\z/m # Single quoted strings
-            $1
-          when /\A"(.*)"\z/m # Double quoted strings
-            $1
-          when /\A(-?\d+)\z/ # Integer and floats
-            $1.to_i
-          when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
-            (resolve($1).to_i..resolve($2).to_i)
-          when /\A(-?\d[\d\.]+)\z/ # Floats
-            $1.to_f
-          else
-            variable(key)
-          end
-        end
-      end
-
-      # Fetches an object starting at the local scope and then moving up the hierachy
-      def find_variable(key)
-
-        # This was changed from find() to find_index() because this is a very hot
-        # path and find_index() is optimized in MRI to reduce object allocation
-        index = @scopes.find_index { |s| s.has_key?(key) }
-        scope = @scopes[index] if index
-
-        variable = nil
-
-        if scope.nil?
-          @environments.each do |e|
-            variable = lookup_and_evaluate(e, key)
-            unless variable.nil?
-              scope = e
-              break
-            end
-          end
-        end
-
-        scope     ||= @environments.last || @scopes.last
-        variable  ||= lookup_and_evaluate(scope, key)
-
-        variable = variable.to_liquid
-        variable.context = self if variable.respond_to?(:context=)
-
-        return variable
-      end
-
-      def variable_parse(markup)
-        parts = markup.scan(VariableParser)
-        needs_resolution = false
-        if parts.first =~ SQUARE_BRACKETED 
-          needs_resolution = true
-          parts[0] = $1
-        end
-        {:first => parts.shift, :needs_resolution => needs_resolution, :rest => parts} 
-      end
-
-      # 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 = @parsed_variables[markup]
-
-        first_part = parts[:first] 
-        if parts[:needs_resolution]
-          first_part = resolve(parts[:first])
-        end
-
-        if object = find_variable(first_part)
-
-          parts[:rest].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
-              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|

lib/liquid/errors.rb

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

lib/liquid/expression.rb

@@ -0,0 +1,33 @@
+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/lexer.rb

@@ -9,9 +9,11 @@ module Liquid
       '['.freeze => :open_square,
       ']'.freeze => :close_square,
       '('.freeze => :open_round,
-      ')'.freeze => :close_round
+      ')'.freeze => :close_round,
+      '?'.freeze => :question,
+      '-'.freeze => :dash
     }
-    IDENTIFIER = /[\w\-?!]+/
+    IDENTIFIER = /\w+/
     SINGLE_STRING_LITERAL = /'[^\']*'/
     DOUBLE_STRING_LITERAL = /"[^\"]*"/
     NUMBER_LITERAL = /-?\d+(\.\d+)?/

lib/liquid/parser.rb

@@ -75,6 +75,13 @@ module Liquid
 
     def variable_signature
       str = consume(:id)
+      while consume?(:dash)
+        str << "-".freeze
+        str << consume(:id)
+      end
+      if consume?(:question)
+        str << "?".freeze
+      end
       if look(:open_square)
         str << consume
         str << expression

lib/liquid/parser_switching.rb

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,159 @@
+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

@@ -0,0 +1,23 @@
+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(context.evaluate(@template_name).to_s) 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

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

lib/liquid/standardfilters.rb

@@ -34,14 +34,28 @@ module Liquid
     end
 
     def escape(input)
-      CGI.escapeHTML(input) rescue input
+      CGI.escapeHTML(input).untaint rescue input
     end
+    alias_method :h, :escape
 
     def escape_once(input)
       input.to_s.gsub(HTML_ESCAPE_ONCE_REGEXP, HTML_ESCAPE)
     end
 
-    alias_method :h, :escape
+    def url_encode(input)
+      CGI.escape(input) rescue input
+    end
+
+    def slice(input, offset, length=nil)
+      offset = Integer(offset)
+      length = length ? Integer(length) : 1
+
+      if input.is_a?(Array)
+        input.slice(offset, length) || []
+      else
+        input.to_s.slice(offset, length) || ''
+      end
+    end
 
     # Truncate a string down to x characters
     def truncate(input, length = 50, truncate_string = "...".freeze)
@@ -65,7 +79,7 @@ module Liquid
     #   <div class="summary">{{ post | split '//' | first }}</div>
     #
     def split(input, pattern)
-      input.split(pattern)
+      input.to_s.split(pattern)
     end
 
     def strip(input)
@@ -101,13 +115,24 @@ module Liquid
       ary = InputIterator.new(input)
       if property.nil?
         ary.sort
-      elsif ary.first.respond_to?('[]'.freeze) && !ary.first[property].nil?
+      elsif ary.first.respond_to?(:[]) && !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)

lib/liquid/tag.rb

@@ -1,7 +1,8 @@
 module Liquid
   class Tag
-    attr_accessor :options
+    attr_accessor :options, :line_number
     attr_reader :nodelist, :warnings
+    include ParserSwitching
 
     class << self
       def parse(tag_name, markup, tokens, options)
@@ -22,6 +23,10 @@ module Liquid
     def parse(tokens)
     end
 
+    def raw
+      "#{@tag_name} #{@markup}"
+    end
+
     def name
       self.class.name.downcase
     end
@@ -33,29 +38,5 @@ module Liquid
     def blank?
       false
     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
 end

lib/liquid/tags/assign.rb

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

lib/liquid/tags/case.rb

@@ -8,14 +8,14 @@ module Liquid
       @blocks = []
 
       if markup =~ Syntax
-        @left = $1
+        @left = Expression.parse($1)
       else
         raise SyntaxError.new(options[:locale].t("errors.syntax.case".freeze))
       end
     end
 
     def nodelist
-      @blocks.map(&:attachment).flatten
+      @blocks.flat_map(&:attachment)
     end
 
     def unknown_tag(tag, markup, tokens)
@@ -58,7 +58,7 @@ module Liquid
 
         markup = $2
 
-        block = Condition.new(@left, '=='.freeze, $1)
+        block = Condition.new(@left, '=='.freeze, Expression.parse($1))
         block.attach(@nodelist)
         @blocks.push(block)
       end

lib/liquid/tags/cycle.rb

@@ -20,10 +20,10 @@ module Liquid
       case markup
       when NamedSyntax
         @variables = variables_from_string($2)
-        @name = $1
+        @name = Expression.parse($1)
       when SimpleSyntax
         @variables = variables_from_string(markup)
-        @name = "'#{@variables.to_s}'"
+        @name = @variables.to_s
       else
         raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze))
       end
@@ -33,9 +33,9 @@ module Liquid
       context.registers[:cycle] ||= Hash.new(0)
 
       context.stack do
-        key = context[@name]
+        key = context.evaluate(@name)
         iteration = context.registers[:cycle][key]
-        result = context[@variables[iteration]]
+        result = context.evaluate(@variables[iteration])
         iteration += 1
         iteration  = 0  if iteration >= @variables.size
         context.registers[:cycle][key] = iteration
@@ -48,7 +48,7 @@ module Liquid
     def variables_from_string(markup)
       markup.split(',').collect do |var|
         var =~ /\s*(#{QuotedFragment})\s*/o
-        $1 ? $1 : nil
+        $1 ? Expression.parse($1) : nil
       end.compact
     end
   end

lib/liquid/tags/for.rb

@@ -68,19 +68,19 @@ module Liquid
     def render(context)
       context.registers[:for] ||= Hash.new(0)
 
-      collection = context[@collection_name]
+      collection = context.evaluate(@collection_name)
       collection = collection.to_a if collection.is_a?(Range)
 
       # Maintains Ruby 1.8.7 String#each behaviour on 1.9
       return render_else(context) unless iterable?(collection)
 
-      from = if @attributes['offset'.freeze] == 'continue'.freeze
+      from = if @from == :continue
         context.registers[:for][@name].to_i
       else
-        context[@attributes['offset'.freeze]].to_i
+        context.evaluate(@from).to_i
       end
 
-      limit = context[@attributes['limit'.freeze]]
+      limit = context.evaluate(@limit)
       to    = limit ? limit.to_i + from : nil
 
       segment = Utils.slice_collection(collection, from, to)
@@ -128,12 +128,12 @@ module Liquid
     def lax_parse(markup)
       if markup =~ Syntax
         @variable_name = $1
-        @collection_name = $2
-        @name = "#{$1}-#{$2}"
+        collection_name = $2
         @reversed = $3
-        @attributes = {}
+        @name = "#{@variable_name}-#{collection_name}"
+        @collection_name = Expression.parse(collection_name)
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = value
+          set_attribute(key, value)
         end
       else
         raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze))
@@ -144,24 +144,36 @@ module Liquid
       p = Parser.new(markup)
       @variable_name = p.consume(:id)
       raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_in".freeze))  unless p.id?('in'.freeze)
-      @collection_name = p.expression
-      @name = "#{@variable_name}-#{@collection_name}"
+      collection_name = p.expression
+      @name = "#{@variable_name}-#{collection_name}"
+      @collection_name = Expression.parse(collection_name)
       @reversed = p.id?('reversed'.freeze)
 
-      @attributes = {}
       while p.look(:id) && p.look(:colon, 1)
         unless attribute = p.id?('limit'.freeze) || p.id?('offset'.freeze)
           raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute".freeze))
         end
         p.consume
-        val = p.expression
-        @attributes[attribute] = val
+        set_attribute(attribute, p.expression)
       end
       p.consume(:end_of_string)
     end
 
     private
 
+    def set_attribute(key, expr)
+      case key
+      when 'offset'.freeze
+        @from = if expr == 'continue'.freeze
+          :continue
+        else
+          Expression.parse(expr)
+        end
+      when 'limit'.freeze
+        @limit = Expression.parse(expr)
+      end
+    end
+
     def render_else(context)
       return @else_block ? [render_all(@else_block, context)] : ''.freeze
     end

lib/liquid/tags/if.rb

@@ -21,7 +21,7 @@ module Liquid
     end
 
     def nodelist
-      @blocks.map(&:attachment).flatten
+      @blocks.flat_map(&:attachment)
     end
 
     def unknown_tag(tag, markup, tokens)
@@ -57,17 +57,17 @@ module Liquid
       end
 
       def lax_parse(markup)
-        expressions = markup.scan(ExpressionsAndOperators).reverse
-        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.shift =~ Syntax
+        expressions = markup.scan(ExpressionsAndOperators)
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax
 
-        condition = Condition.new($1, $2, $3)
+        condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
 
         while not expressions.empty?
-          operator = (expressions.shift).to_s.strip
+          operator = expressions.pop.to_s.strip
 
-          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.shift.to_s =~ Syntax
+          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax
 
-          new_condition = Condition.new($1, $2, $3)
+          new_condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
           raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
           new_condition.send(operator, condition)
           condition = new_condition
@@ -92,9 +92,9 @@ module Liquid
       end
 
       def parse_comparison(p)
-        a = p.expression
+        a = Expression.parse(p.expression)
         if op = p.consume?(:comparison)
-          b = p.expression
+          b = Expression.parse(p.expression)
           Condition.new(a, op, b)
         else
           Condition.new(a)

lib/liquid/tags/ifchanged.rb

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

lib/liquid/tags/include.rb

@@ -22,12 +22,16 @@ module Liquid
 
       if markup =~ Syntax
 
-        @template_name = $1
-        @variable_name = $3
+        template_name = $1
+        variable_name = $3
+
+        @variable_name = Expression.parse(variable_name || template_name[1..-2])
+        @context_variable_name = template_name[1..-2].split('/'.freeze).last
+        @template_name = Expression.parse(template_name)
         @attributes    = {}
 
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = value
+          @attributes[key] = Expression.parse(value)
         end
 
       else
@@ -40,21 +44,20 @@ module Liquid
 
     def render(context)
       partial = load_cached_partial(context)
-      variable = context[@variable_name || @template_name[1..-2]]
+      variable = context.evaluate(@variable_name)
 
       context.stack do
         @attributes.each do |key, value|
-          context[key] = context[value]
+          context[key] = context.evaluate(value)
         end
 
-        context_variable_name = @template_name[1..-2].split('/'.freeze).last
         if variable.is_a?(Array)
           variable.collect do |var|
-            context[context_variable_name] = var
+            context[@context_variable_name] = var
             partial.render(context)
           end
         else
-          context[context_variable_name] = variable
+          context[@context_variable_name] = variable
           partial.render(context)
         end
       end
@@ -63,13 +66,13 @@ module Liquid
     private
       def load_cached_partial(context)
         cached_partials = context.registers[:cached_partials] || {}
-        template_name = context[@template_name]
+        template_name = context.evaluate(@template_name)
 
         if cached = cached_partials[template_name]
           return cached
         end
         source = read_template_from_file_system(context)
-        partial = Liquid::Template.parse(source)
+        partial = Liquid::Template.parse(source, pass_options)
         cached_partials[template_name] = partial
         context.registers[:cached_partials] = cached_partials
         partial
@@ -81,13 +84,23 @@ module Liquid
         # make read_template_file call backwards-compatible.
         case file_system.method(:read_template_file).arity
         when 1
-          file_system.read_template_file(context[@template_name])
+          file_system.read_template_file(context.evaluate(@template_name))
         when 2
-          file_system.read_template_file(context[@template_name], context)
+          file_system.read_template_file(context.evaluate(@template_name), context)
         else
           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/raw.rb

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

lib/liquid/tags/table_row.rb

@@ -6,10 +6,10 @@ module Liquid
       super
       if markup =~ Syntax
         @variable_name = $1
-        @collection_name = $2
+        @collection_name = Expression.parse($2)
         @attributes = {}
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = value
+          @attributes[key] = Expression.parse(value)
         end
       else
         raise SyntaxError.new(options[:locale].t("errors.syntax.table_row".freeze))
@@ -17,16 +17,16 @@ module Liquid
     end
 
     def render(context)
-      collection = context[@collection_name] or return ''.freeze
+      collection = context.evaluate(@collection_name) or return ''.freeze
 
-      from = @attributes['offset'.freeze] ? context[@attributes['offset'.freeze]].to_i : 0
-      to = @attributes['limit'.freeze] ? from + context[@attributes['limit'.freeze]].to_i : nil
+      from = @attributes.key?('offset'.freeze) ? context.evaluate(@attributes['offset'.freeze]).to_i : 0
+      to = @attributes.key?('limit'.freeze) ? from + context.evaluate(@attributes['limit'.freeze]).to_i : nil
 
       collection = Utils.slice_collection(collection, from, to)
 
       length = collection.length
 
-      cols = context[@attributes['cols'.freeze]].to_i
+      cols = context.evaluate(@attributes['cols'.freeze]).to_i
 
       row = 1
       col = 0
@@ -54,7 +54,7 @@ module Liquid
 
           col += 1
 
-          result << "<td class=\"col#{col}\">" << render_all(@nodelist, context) << '</td>'
+          result << "<td class=\"col#{col}\">" << super << '</td>'
 
           if col == cols and (index != length - 1)
             col  = 0

lib/liquid/template.rb

@@ -51,6 +51,8 @@ module Liquid
       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.
@@ -58,6 +60,12 @@ module Liquid
       # :strict will enforce correct syntax.
       attr_writer :error_mode
 
+      # Sets how strict the taint checker should be.
+      # :lax is the default, and ignores the taint flag completely
+      # :warn adds a warning, but does not interrupt the rendering
+      # :error raises an error when tainted output is used
+      attr_writer :taint_mode
+
       def file_system
         @@file_system
       end
@@ -78,27 +86,39 @@ module Liquid
         @error_mode || :lax
       end
 
+      def taint_mode
+        @taint_mode || :lax
+      end
+
       # Pass a module with filter methods which should be available
       # to all liquid views. Good for registering the standard library
       def register_filter(mod)
         Strainer.global_filter(mod)
       end
 
+      def default_resource_limits
+        @default_resource_limits ||= {}
+      end
+
       # creates a new <tt>Template</tt> object from liquid source code
+      # To enable profiling, pass in <tt>profile: true</tt> as an option.
+      # See Liquid::Profiler for more information
       def parse(source, options = {})
         template = Template.new
         template.parse(source, options)
       end
     end
 
-    # creates a new <tt>Template</tt> from an array of tokens. Use <tt>Template.parse</tt> instead
     def initialize
-      @resource_limits = {}
+      @resource_limits = self.class.default_resource_limits.dup
     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
@@ -130,6 +150,9 @@ 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
@@ -183,7 +206,9 @@ module Liquid
       begin
         # render the nodelist.
         # for performance reasons we get an array back here. join will make a string out of it.
-        result = @root.render(context)
+        result = with_profiling do
+          @root.render(context)
+        end
         result.respond_to?(:join) ? result.join : result
       rescue Liquid::MemoryError => e
         context.handle_error(e)
@@ -203,7 +228,8 @@ 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?
@@ -211,5 +237,30 @@ 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

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

lib/liquid/variable_lookup.rb

@@ -0,0 +1,78 @@
+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
+
+    def ==(other)
+      self.class == other.class && self.state == other.state
+    end
+
+    protected
+
+    def state
+      [@name, @lookups, @command_flags]
+    end
+  end
+end

lib/liquid/version.rb

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

liquid.gemspec

@@ -25,4 +25,5 @@ Gem::Specification.new do |s|
   s.require_path = "lib"
 
   s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest'
 end

performance/benchmark.rb

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

performance/shopify/paginate.rb

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

test/integration/assign_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class AssignTest < Test::Unit::TestCase
+class AssignTest < Minitest::Test
   include Liquid
 
   def test_assigned_variable
@@ -24,4 +24,15 @@ class AssignTest < Test::Unit::TestCase
                        '{% 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 < Test::Unit::TestCase
+class BlankTest < Minitest::Test
   include Liquid
   N = 10
 

test/integration/capture_test.rb

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

test/integration/context_test.rb

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

test/integration/drop_test.rb

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

test/integration/error_handling_test.rb

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

test/integration/filter_test.rb

@@ -22,7 +22,7 @@ module SubstituteFilter
   end
 end
 
-class FiltersTest < Test::Unit::TestCase
+class FiltersTest < Minitest::Test
   include Liquid
 
   def setup
@@ -107,15 +107,15 @@ class FiltersTest < Test::Unit::TestCase
   end
 end
 
-class FiltersInTemplate < Test::Unit::TestCase
+class FiltersInTemplate < Minitest::Test
   include Liquid
 
   def test_local_global
-    Template.register_filter(MoneyFilter)
-
-    assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render!(nil, nil)
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => CanadianMoneyFilter)
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => [CanadianMoneyFilter])
+    with_global_filter(MoneyFilter) do
+      assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render!(nil, nil)
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => CanadianMoneyFilter)
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => [CanadianMoneyFilter])
+    end
   end
 
   def test_local_filter_with_deprecated_syntax

test/integration/hash_ordering_test.rb

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

test/integration/output_test.rb

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

test/integration/parsing_quirks_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ParsingQuirksTest < Test::Unit::TestCase
+class ParsingQuirksTest < Minitest::Test
   include Liquid
 
   def test_parsing_css
@@ -9,30 +9,28 @@ class ParsingQuirksTest < Test::Unit::TestCase
   end
 
   def test_raise_on_single_close_bracet
-    assert_raise(SyntaxError) do
+    assert_raises(SyntaxError) do
       Template.parse("text {{method} oh nos!")
     end
   end
 
   def test_raise_on_label_and_no_close_bracets
-    assert_raise(SyntaxError) do
+    assert_raises(SyntaxError) do
       Template.parse("TEST {{ ")
     end
   end
 
   def test_raise_on_label_and_no_close_bracets_percent
-    assert_raise(SyntaxError) do
+    assert_raises(SyntaxError) do
       Template.parse("TEST {% ")
     end
   end
 
   def test_error_on_empty_filter
-    assert_nothing_raised do
-      Template.parse("{{test}}")
-      Template.parse("{{|test}}")
-    end
+    assert Template.parse("{{test}}")
+    assert Template.parse("{{|test}}")
     with_error_mode(:strict) do
-      assert_raise(SyntaxError) do
+      assert_raises(SyntaxError) do
         Template.parse("{{test |a|b|}}")
       end
     end
@@ -40,7 +38,7 @@ class ParsingQuirksTest < Test::Unit::TestCase
 
   def test_meaningless_parens_error
     with_error_mode(:strict) do
-      assert_raise(SyntaxError) do
+      assert_raises(SyntaxError) do
         markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
         Template.parse("{% if #{markup} %} YES {% endif %}")
       end
@@ -49,11 +47,11 @@ class ParsingQuirksTest < Test::Unit::TestCase
 
   def test_unexpected_characters_syntax_error
     with_error_mode(:strict) do
-      assert_raise(SyntaxError) do
+      assert_raises(SyntaxError) do
         markup = "true && false"
         Template.parse("{% if #{markup} %} YES {% endif %}")
       end
-      assert_raise(SyntaxError) do
+      assert_raises(SyntaxError) do
         markup = "false || true"
         Template.parse("{% if #{markup} %} YES {% endif %}")
       end
@@ -61,11 +59,9 @@ class ParsingQuirksTest < Test::Unit::TestCase
   end
 
   def test_no_error_on_lax_empty_filter
-    assert_nothing_raised do
-      Template.parse("{{test |a|b|}}", :error_mode => :lax)
-      Template.parse("{{test}}", :error_mode => :lax)
-      Template.parse("{{|test|}}", :error_mode => :lax)
-    end
+    assert Template.parse("{{test |a|b|}}", :error_mode => :lax)
+    assert Template.parse("{{test}}", :error_mode => :lax)
+    assert Template.parse("{{|test|}}", :error_mode => :lax)
   end
 
   def test_meaningless_parens_lax
@@ -86,9 +82,22 @@ class ParsingQuirksTest < Test::Unit::TestCase
   end
 
   def test_raise_on_invalid_tag_delimiter
-    assert_raise(Liquid::SyntaxError) do
+    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

@@ -0,0 +1,154 @@
+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 < Test::Unit::TestCase
+class SecurityTest < Minitest::Test
   include Liquid
 
   def test_no_instance_eval

test/integration/standard_filter_test.rb

@@ -41,7 +41,7 @@ class TestEnumerable < Liquid::Drop
   end
 end
 
-class StandardFiltersTest < Test::Unit::TestCase
+class StandardFiltersTest < Minitest::Test
   include Liquid
 
   def setup
@@ -64,6 +64,34 @@ class StandardFiltersTest < Test::Unit::TestCase
     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)
@@ -78,6 +106,7 @@ class StandardFiltersTest < Test::Unit::TestCase
     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
@@ -89,6 +118,11 @@ class StandardFiltersTest < Test::Unit::TestCase
     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)
@@ -128,6 +162,13 @@ class StandardFiltersTest < Test::Unit::TestCase
     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
@@ -184,6 +225,11 @@ class StandardFiltersTest < Test::Unit::TestCase
     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 < Test::Unit::TestCase
+class BreakTagTest < Minitest::Test
   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 < Test::Unit::TestCase
+class ContinueTagTest < Minitest::Test
   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 < Test::Unit::TestCase
+class ForTagTest < Minitest::Test
   include Liquid
 
   def test_for
@@ -303,7 +303,7 @@ HERE
   end
 
   def test_bad_variable_naming_in_for_loop
-    assert_raise(Liquid::SyntaxError) do
+    assert_raises(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 < Test::Unit::TestCase
+class IfElseTagTest < Minitest::Test
   include Liquid
 
   def test_if
@@ -10,6 +10,11 @@ class IfElseTagTest < Test::Unit::TestCase
     assert_template_result('  you rock ?','{% if false %} you suck {% endif %} {% if true %} you rock {% endif %}?')
   end
 
+  def test_literal_comparisons
+    assert_template_result(' NO ','{% assign v = false %}{% if v %} YES {% else %} NO {% endif %}')
+    assert_template_result(' YES ','{% assign v = nil %}{% if v == nil %} YES {% else %} NO {% endif %}')
+  end
+
   def test_if_else
     assert_template_result(' YES ','{% if false %} NO {% else %} YES {% endif %}')
     assert_template_result(' YES ','{% if true %} YES {% else %} NO {% endif %}')
@@ -37,25 +42,19 @@ class IfElseTagTest < Test::Unit::TestCase
   end
 
   def test_comparison_of_strings_containing_and_or_or
-    assert_nothing_raised do
-      awful_markup = "a == 'and' and b == 'or' and c == 'foo and bar' and d == 'bar or baz' and e == 'foo' and foo and bar"
-      assigns = {'a' => 'and', 'b' => 'or', 'c' => 'foo and bar', 'd' => 'bar or baz', 'e' => 'foo', 'foo' => true, 'bar' => true}
-      assert_template_result(' YES ',"{% if #{awful_markup} %} YES {% endif %}", assigns)
-    end
+    awful_markup = "a == 'and' and b == 'or' and c == 'foo and bar' and d == 'bar or baz' and e == 'foo' and foo and bar"
+    assigns = {'a' => 'and', 'b' => 'or', 'c' => 'foo and bar', 'd' => 'bar or baz', 'e' => 'foo', 'foo' => true, 'bar' => true}
+    assert_template_result(' YES ',"{% if #{awful_markup} %} YES {% endif %}", assigns)
   end
 
   def test_comparison_of_expressions_starting_with_and_or_or
     assigns = {'order' => {'items_count' => 0}, 'android' => {'name' => 'Roy'}}
-    assert_nothing_raised do
-      assert_template_result( "YES",
-                              "{% if android.name == 'Roy' %}YES{% endif %}",
-                              assigns)
-    end
-    assert_nothing_raised do
-      assert_template_result( "YES",
-                              "{% if order.items_count == 0 %}YES{% endif %}",
-                              assigns)
-    end
+    assert_template_result( "YES",
+                            "{% if android.name == 'Roy' %}YES{% endif %}",
+                            assigns)
+    assert_template_result( "YES",
+                            "{% if order.items_count == 0 %}YES{% endif %}",
+                            assigns)
   end
 
   def test_if_and
@@ -135,31 +134,35 @@ class IfElseTagTest < Test::Unit::TestCase
   end
 
   def test_syntax_error_no_variable
-    assert_raise(SyntaxError){ assert_template_result('', '{% if jerry == 1 %}')}
+    assert_raises(SyntaxError){ assert_template_result('', '{% if jerry == 1 %}')}
   end
 
   def test_syntax_error_no_expression
-    assert_raise(SyntaxError) { assert_template_result('', '{% if %}') }
+    assert_raises(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.delete 'contains'
+    Condition.operators['contains'] = original_op
   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_raise(SyntaxError) do
+    assert_raises(SyntaxError) do
       assert_template_result('', %({% if 1 or throw or or 1 %}yes{% endif %}))
     end
   end

test/integration/tags/include_tag_test.rb

@@ -27,6 +27,9 @@ class TestFileSystem
     when "pick_a_source"
       "from TestFileSystem"
 
+    when 'assignments'
+      "{% assign foo = 'bar' %}"
+
     else
       template_path
     end
@@ -65,7 +68,7 @@ class CustomInclude < Liquid::Tag
   end
 end
 
-class IncludeTagTest < Test::Unit::TestCase
+class IncludeTagTest < Minitest::Test
   include Liquid
 
   def setup
@@ -108,6 +111,10 @@ class IncludeTagTest < Test::Unit::TestCase
       'echo1' => 'test123', 'more_echos' => { "echo2" => 'test321'}
   end
 
+  def test_included_templates_assigns_variables
+    assert_template_result "bar", "{% include 'assignments' %}{{ foo }}"
+  end
+
   def test_nested_include_tag
     assert_template_result "body body_detail", "{% include 'body' %}"
 
@@ -132,7 +139,7 @@ class IncludeTagTest < Test::Unit::TestCase
 
     Liquid::Template.file_system = infinite_file_system.new
 
-    assert_raise(Liquid::StackLevelError) do
+    assert_raises(Liquid::StackLevelError, SystemStackError) do
       Template.parse("{% include 'loop' %}").render!
     end
 
@@ -209,4 +216,19 @@ class IncludeTagTest < Test::Unit::TestCase
     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 < Test::Unit::TestCase
+class IncrementTagTest < Minitest::Test
   include Liquid
 
   def test_inc

test/integration/tags/raw_tag_test.rb

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

test/integration/tags/standard_tag_test.rb

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

test/integration/tags/table_row_test.rb

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

test/integration/tags/unless_else_tag_test.rb

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

test/integration/template_test.rb

@@ -28,7 +28,7 @@ class ErroneousDrop < Liquid::Drop
   end
 end
 
-class TemplateTest < Test::Unit::TestCase
+class TemplateTest < Minitest::Test
   include Liquid
 
   def test_instance_assigns_persist_on_same_template_object_between_parses
@@ -93,7 +93,7 @@ class TemplateTest < Test::Unit::TestCase
     assert t.resource_limits[:reached]
     t.resource_limits = { :render_length_limit => 10 }
     assert_equal "0123456789", t.render!()
-    assert_not_nil t.resource_limits[:render_length_current]
+    refute_nil t.resource_limits[:render_length_current]
   end
 
   def test_resource_limits_render_score
@@ -107,7 +107,7 @@ class TemplateTest < Test::Unit::TestCase
     assert t.resource_limits[:reached]
     t.resource_limits = { :render_score_limit => 200 }
     assert_equal (" foo " * 100), t.render!()
-    assert_not_nil t.resource_limits[:render_score_current]
+    refute_nil t.resource_limits[:render_score_current]
   end
 
   def test_resource_limits_assign_score
@@ -117,7 +117,7 @@ class TemplateTest < Test::Unit::TestCase
     assert t.resource_limits[:reached]
     t.resource_limits = { :assign_score_limit => 2 }
     assert_equal "", t.render!()
-    assert_not_nil t.resource_limits[:assign_score_current]
+    refute_nil t.resource_limits[:assign_score_current]
   end
 
   def test_resource_limits_aborts_rendering_after_first_error
@@ -135,6 +135,18 @@ class TemplateTest < Test::Unit::TestCase
     assert t.resource_limits[:render_length_current] > 0
   end
 
+  def test_default_resource_limits_unaffected_by_render_with_context
+    context = Context.new
+    t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
+    t.render!(context)
+    assert context.resource_limits[:assign_score_current] > 0
+    assert context.resource_limits[:render_score_current] > 0
+    assert context.resource_limits[:render_length_current] > 0
+    refute Template.default_resource_limits.key?(:assign_score_current)
+    refute Template.default_resource_limits.key?(:render_score_current)
+    refute Template.default_resource_limits.key?(:render_length_current)
+  end
+
   def test_can_use_drop_as_context
     t = Template.new
     t.registers['lulz'] = 'haha'

test/integration/variable_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class VariableTest < Test::Unit::TestCase
+class VariableTest < Minitest::Test
   include Liquid
 
   def test_simple_variable
@@ -9,6 +9,10 @@ class VariableTest < Test::Unit::TestCase
     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')
@@ -27,6 +31,12 @@ class VariableTest < Test::Unit::TestCase
 
   def test_false_renders_as_false
     assert_equal 'false', Template.parse("{{ foo }}").render!('foo' => false)
+    assert_equal 'false', Template.parse("{{ false }}").render!
+  end
+
+  def test_nil_renders_as_empty_string
+    assert_equal '', Template.parse("{{ nil }}").render!
+    assert_equal 'cat', Template.parse("{{ nil | append: 'cat' }}").render!
   end
 
   def test_preset_assigns

test/test_helper.rb

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 
-require 'test/unit'
-require 'test/unit/assertions'
+require 'minitest/autorun'
 require 'spy/integration'
 
 $:.unshift(File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib'))
@@ -14,41 +13,70 @@ 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 Test
-  module Unit
-    class TestCase
-      def fixture(name)
-        File.join(File.expand_path(File.dirname(__FILE__)), "fixtures", name)
-      end
+module Minitest
+  class Test
+    def fixture(name)
+      File.join(File.expand_path(File.dirname(__FILE__)), "fixtures", name)
+    end
+  end
+
+  module Assertions
+    include Liquid
+
+    def assert_template_result(expected, template, assigns = {}, message = nil)
+      assert_equal expected, Template.parse(template).render!(assigns)
     end
 
-    module Assertions
-      include Liquid
+    def assert_template_result_matches(expected, template, assigns = {}, message = nil)
+      return assert_template_result(expected, template, assigns, message) unless expected.is_a? Regexp
 
-      def assert_template_result(expected, template, assigns = {}, message = nil)
-        assert_equal expected, Template.parse(template).render!(assigns)
+      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 assert_template_result_matches(expected, template, assigns = {}, message = nil)
-        return assert_template_result(expected, template, assigns, message) unless expected.is_a? Regexp
+    def with_taint_mode(mode)
+      old_mode = Liquid::Template.taint_mode
+      Liquid::Template.taint_mode = mode
+      yield
+    ensure
+      Liquid::Template.taint_mode = old_mode
+    end
 
-        assert_match expected, Template.parse(template).render!(assigns)
-      end
+    def with_error_mode(mode)
+      old_mode = Liquid::Template.error_mode
+      Liquid::Template.error_mode = mode
+      yield
+    ensure
+      Liquid::Template.error_mode = old_mode
+    end
+  end
+end
 
-      def assert_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
+class ThingWithToLiquid
+  def to_liquid
+    'foobar'
+  end
+end

test/unit/block_unit_test.rb

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

test/unit/condition_unit_test.rb

@@ -1,109 +1,114 @@
 require 'test_helper'
 
-class ConditionUnitTest < Test::Unit::TestCase
+class ConditionUnitTest < Minitest::Test
   include Liquid
 
   def test_basic_condition
-    assert_equal false, Condition.new('1', '==', '2').evaluate
-    assert_equal true,  Condition.new('1', '==', '1').evaluate
+    assert_equal false, Condition.new(1, '==', 2).evaluate
+    assert_equal true,  Condition.new(1, '==', 1).evaluate
   end
 
   def test_default_operators_evalute_true
-    assert_evalutes_true '1', '==', '1'
-    assert_evalutes_true '1', '!=', '2'
-    assert_evalutes_true '1', '<>', '2'
-    assert_evalutes_true '1', '<', '2'
-    assert_evalutes_true '2', '>', '1'
-    assert_evalutes_true '1', '>=', '1'
-    assert_evalutes_true '2', '>=', '1'
-    assert_evalutes_true '1', '<=', '2'
-    assert_evalutes_true '1', '<=', '1'
+    assert_evalutes_true 1, '==', 1
+    assert_evalutes_true 1, '!=', 2
+    assert_evalutes_true 1, '<>', 2
+    assert_evalutes_true 1, '<', 2
+    assert_evalutes_true 2, '>', 1
+    assert_evalutes_true 1, '>=', 1
+    assert_evalutes_true 2, '>=', 1
+    assert_evalutes_true 1, '<=', 2
+    assert_evalutes_true 1, '<=', 1
     # negative numbers
-    assert_evalutes_true '1', '>', '-1'
-    assert_evalutes_true '-1', '<', '1'
-    assert_evalutes_true '1.0', '>', '-1.0'
-    assert_evalutes_true '-1.0', '<', '1.0'
+    assert_evalutes_true 1, '>', -1
+    assert_evalutes_true -1, '<', 1
+    assert_evalutes_true 1.0, '>', -1.0
+    assert_evalutes_true -1.0, '<', 1.0
   end
 
   def test_default_operators_evalute_false
-    assert_evalutes_false '1', '==', '2'
-    assert_evalutes_false '1', '!=', '1'
-    assert_evalutes_false '1', '<>', '1'
-    assert_evalutes_false '1', '<', '0'
-    assert_evalutes_false '2', '>', '4'
-    assert_evalutes_false '1', '>=', '3'
-    assert_evalutes_false '2', '>=', '4'
-    assert_evalutes_false '1', '<=', '0'
-    assert_evalutes_false '1', '<=', '0'
+    assert_evalutes_false 1, '==', 2
+    assert_evalutes_false 1, '!=', 1
+    assert_evalutes_false 1, '<>', 1
+    assert_evalutes_false 1, '<', 0
+    assert_evalutes_false 2, '>', 4
+    assert_evalutes_false 1, '>=', 3
+    assert_evalutes_false 2, '>=', 4
+    assert_evalutes_false 1, '<=', 0
+    assert_evalutes_false 1, '<=', 0
   end
 
   def test_contains_works_on_strings
-    assert_evalutes_true "'bob'", 'contains', "'o'"
-    assert_evalutes_true "'bob'", 'contains', "'b'"
-    assert_evalutes_true "'bob'", 'contains', "'bo'"
-    assert_evalutes_true "'bob'", 'contains', "'ob'"
-    assert_evalutes_true "'bob'", 'contains', "'bob'"
+    assert_evalutes_true 'bob', 'contains', 'o'
+    assert_evalutes_true 'bob', 'contains', 'b'
+    assert_evalutes_true 'bob', 'contains', 'bo'
+    assert_evalutes_true 'bob', 'contains', 'ob'
+    assert_evalutes_true 'bob', 'contains', 'bob'
 
-    assert_evalutes_false "'bob'", 'contains', "'bob2'"
-    assert_evalutes_false "'bob'", 'contains', "'a'"
-    assert_evalutes_false "'bob'", 'contains', "'---'"
+    assert_evalutes_false 'bob', 'contains', 'bob2'
+    assert_evalutes_false 'bob', 'contains', 'a'
+    assert_evalutes_false 'bob', 'contains', '---'
   end
 
   def test_invalid_comparation_operator
-    assert_evaluates_argument_error "1", '~~', '0'
+    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'
+    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]
+    array_expr = VariableLookup.new("array")
 
-    assert_evalutes_false "array",  'contains', '0'
-    assert_evalutes_true "array",   'contains', '1'
-    assert_evalutes_true "array",   'contains', '2'
-    assert_evalutes_true "array",   'contains', '3'
-    assert_evalutes_true "array",   'contains', '4'
-    assert_evalutes_true "array",   'contains', '5'
-    assert_evalutes_false "array",  'contains', '6'
-    assert_evalutes_false "array",  'contains', '"1"'
+    assert_evalutes_false array_expr, 'contains', 0
+    assert_evalutes_true  array_expr, 'contains', 1
+    assert_evalutes_true  array_expr, 'contains', 2
+    assert_evalutes_true  array_expr, 'contains', 3
+    assert_evalutes_true  array_expr, 'contains', 4
+    assert_evalutes_true  array_expr, 'contains', 5
+    assert_evalutes_false array_expr, 'contains', 6
+    assert_evalutes_false array_expr, 'contains', "1"
   end
 
   def test_contains_returns_false_for_nil_operands
     @context = Liquid::Context.new
-    assert_evalutes_false "not_assigned", 'contains', '0'
-    assert_evalutes_false "0", 'contains', 'not_assigned'
+    assert_evalutes_false VariableLookup.new('not_assigned'), 'contains', '0'
+    assert_evalutes_false 0, 'contains', VariableLookup.new('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')
+    condition = Condition.new(1, '==', 2)
 
     assert_equal false, condition.evaluate
 
-    condition.or Condition.new('2', '==', '1')
+    condition.or Condition.new(2, '==', 1)
 
     assert_equal false, condition.evaluate
 
-    condition.or Condition.new('1', '==', '1')
+    condition.or Condition.new(1, '==', 1)
 
     assert_equal true, condition.evaluate
   end
 
   def test_and_condition
-    condition = Condition.new('1', '==', '1')
+    condition = Condition.new(1, '==', 1)
 
     assert_equal true, condition.evaluate
 
-    condition.and Condition.new('2', '==', '2')
+    condition.and Condition.new(2, '==', 2)
 
     assert_equal true, condition.evaluate
 
-    condition.and Condition.new('2', '==', '1')
+    condition.and Condition.new(2, '==', 1)
 
     assert_equal false, condition.evaluate
   end
@@ -111,18 +116,17 @@ class ConditionUnitTest < Test::Unit::TestCase
   def test_should_allow_custom_proc_operator
     Condition.operators['starts_with'] = Proc.new { |cond, left, right| left =~ %r{^#{right}} }
 
-    assert_evalutes_true "'bob'",   'starts_with', "'b'"
-    assert_evalutes_false "'bob'",  'starts_with', "'o'"
-
-    ensure
-      Condition.operators.delete 'starts_with'
+    assert_evalutes_true  'bob', 'starts_with', 'b'
+    assert_evalutes_false 'bob', 'starts_with', 'o'
+  ensure
+    Condition.operators.delete 'starts_with'
   end
 
   def test_left_or_right_may_contain_operators
     @context = Liquid::Context.new
     @context['one'] = @context['another'] = "gnomeslab-and-or-liquid"
 
-    assert_evalutes_true "one", '==', "another"
+    assert_evalutes_true VariableLookup.new("one"), '==', VariableLookup.new("another")
   end
 
   private

test/unit/context_unit_test.rb

@@ -63,7 +63,7 @@ class ArrayLike
   end
 end
 
-class ContextUnitTest < Test::Unit::TestCase
+class ContextUnitTest < Minitest::Test
   include Liquid
 
   def setup
@@ -107,16 +107,14 @@ class ContextUnitTest < Test::Unit::TestCase
   end
 
   def test_scoping
-    assert_nothing_raised do
-      @context.push
+    @context.push
+    @context.pop
+
+    assert_raises(Liquid::ContextError) do
       @context.pop
     end
 
-    assert_raise(Liquid::ContextError) do
-      @context.pop
-    end
-
-    assert_raise(Liquid::ContextError) do
+    assert_raises(Liquid::ContextError) do
       @context.push
       @context.pop
       @context.pop
@@ -471,16 +469,14 @@ class ContextUnitTest < Test::Unit::TestCase
 
     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
+    contx = Context.new([:test => lambda { |c| c['poutine']}], {:test => :foo})
+
+    assert contx
+    assert_nil contx['poutine']
+  end
+
+
 end # ContextTest

test/unit/file_system_unit_test.rb

@@ -1,10 +1,10 @@
 require 'test_helper'
 
-class FileSystemUnitTest < Test::Unit::TestCase
+class FileSystemUnitTest < Minitest::Test
   include Liquid
 
   def test_default
-    assert_raise(FileSystemError) do
+    assert_raises(FileSystemError) do
       BlankFileSystem.new.read_template_file("dummy", {'dummy'=>'smarty'})
     end
   end
@@ -14,15 +14,15 @@ class FileSystemUnitTest < Test::Unit::TestCase
     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_raise(FileSystemError) do
+    assert_raises(FileSystemError) do
       file_system.full_path("../dir/mypartial")
     end
 
-    assert_raise(FileSystemError) do
+    assert_raises(FileSystemError) do
       file_system.full_path("/dir/../../dir/mypartial")
     end
 
-    assert_raise(FileSystemError) do
+    assert_raises(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 < Test::Unit::TestCase
+class I18nUnitTest < Minitest::Test
   include Liquid
 
   def setup
@@ -20,13 +20,13 @@ class I18nUnitTest < Test::Unit::TestCase
   end
 
   # def test_raises_translation_error_on_undefined_interpolation_key
-  #   assert_raise I18n::TranslationError do
+  #   assert_raises I18n::TranslationError do
   #     @i18n.translate("whatever", :oopstypos => "yes")
   #   end
   # end
   
   def test_raises_unknown_translation
-    assert_raise I18n::TranslationError do
+    assert_raises I18n::TranslationError do
       @i18n.translate("doesnt_exist")
     end
   end

test/unit/lexer_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class LexerUnitTest < Test::Unit::TestCase
+class LexerUnitTest < Minitest::Test
   include Liquid
 
   def test_strings
@@ -31,8 +31,8 @@ class LexerUnitTest < Test::Unit::TestCase
   end
 
   def test_fancy_identifiers
-    tokens = Lexer.new('hi! five?').tokenize
-    assert_equal [[:id,'hi!'], [:id, 'five?'], [:end_of_string]], tokens
+    tokens = Lexer.new('hi five?').tokenize
+    assert_equal [[:id,'hi'], [:id, 'five'], [:question, '?'], [:end_of_string]], tokens
   end
 
   def test_whitespace

test/unit/module_ex_unit_test.rb

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

test/unit/parser_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ParserUnitTest < Test::Unit::TestCase
+class ParserUnitTest < Minitest::Test
   include Liquid
 
   def test_consume
@@ -44,9 +44,9 @@ class ParserUnitTest < Test::Unit::TestCase
   end
 
   def test_expressions
-    p = Parser.new("hi.there hi[5].! hi.there.bob")
+    p = Parser.new("hi.there hi?[5].there? hi.there.bob")
     assert_equal 'hi.there', p.expression
-    assert_equal 'hi[5].!', p.expression
+    assert_equal 'hi?[5].there?', p.expression
     assert_equal 'hi.there.bob', p.expression
 
     p = Parser.new("567 6.0 'lol' \"wut\"")

test/unit/regexp_unit_test.rb

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

test/unit/strainer_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class StrainerUnitTest < Test::Unit::TestCase
+class StrainerUnitTest < Minitest::Test
   include Liquid
 
   module AccessScopeFilters
@@ -57,7 +57,8 @@ class StrainerUnitTest < Test::Unit::TestCase
   end
 
   def test_strainer_uses_a_class_cache_to_avoid_method_cache_invalidation
-    a, b = Module.new, Module.new
+    a = Module.new
+    b = Module.new
     strainer = Strainer.create(nil, [a,b])
     assert_kind_of Strainer, strainer
     assert_kind_of a, strainer

test/unit/tag_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class TagUnitTest < Test::Unit::TestCase
+class TagUnitTest < Minitest::Test
   include Liquid
 
   def test_tag
@@ -8,4 +8,9 @@ class TagUnitTest < Test::Unit::TestCase
     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 < Test::Unit::TestCase
+class CaseTagUnitTest < Minitest::Test
   include Liquid
 
   def test_case_nodelist

test/unit/tags/for_tag_unit_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ForTagUnitTest < Test::Unit::TestCase
+class ForTagUnitTest < Minitest::Test
   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 < Test::Unit::TestCase
+class IfTagUnitTest < Minitest::Test
   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 < Test::Unit::TestCase
+class TemplateUnitTest < Minitest::Test
   include Liquid
 
   def test_sets_default_localization_in_document

test/unit/tokenizer_unit_test.rb

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