Add line numbers to warnings

.travis.yml

@@ -1,17 +1,13 @@
-language: ruby
-
 rvm:
+  - 1.9
   - 2.0
   - 2.1
-  - 2.2
-  - ruby-head
+  - jruby-19mode
   - jruby-head
   - rbx-2
-
-sudo: false
-
 matrix:
   allow_failures:
+    - rvm: rbx-2
     - rvm: jruby-head
 
 script: "rake test"

Gemfile

@@ -2,7 +2,6 @@ source 'https://rubygems.org'
 
 gemspec
 gem 'stackprof', platforms: :mri_21
-gem 'allocation_tracer', platforms: :mri_21
 
 group :test do
   gem 'spy', '0.4.1'

History.md

@@ -1,69 +1,43 @@
-# Liquid Change Log
+# Liquid Version History
 
-## 4.0.0 / not yet released / branch "master"
-### Changed
-* Add forloop.parentloop as a reference to the parent loop (#520) [Justin Li, pushrax]
-* Block parsing moved to BlockBody class (#458) [Dylan Thacker-Smith, dylanahsmith]
-* Add concat filter to concatenate arrays (#429) [Diogo Beato, dvbeato]
-* Ruby 1.9 support dropped (#491) [Justin Li, pushrax]
-* Liquid::Template.file_system's read_template_file method is no longer passed the context. (#441) [James Reid-Smith, sunblaze]
+## 3.0.0 / not yet released / branch "master"
 
-### Fixed
-* Fix capturing into variables with a hyphen in the name (#505) [Florian Weingarten, fw42]
-* Fix case sensitivity regression in date standard filter (#499) [Kelley Reynolds, kreynolds]
-* Disallow filters with no variable in strict mode (#475) [Justin Li, pushrax]
-* Disallow variable names in the strict parser that are not valid in the lax parser (#463) [Justin Li, pushrax]
-* Fix BlockBody#warnings taking exponential time to compute (#486) [Justin Li, pushrax]
-
-## 3.0.2 / 2015-04-24 / branch "3-0-stable"
-
-* Expose VariableLookup private members (#551) [Justin Li, pushrax]
-* Documentation fixes
-
-## 3.0.1 / 2015-01-23
-
-* Remove duplicate `index0` key in TableRow tag (#502) [Alfred Xing]
-
-## 3.0.0 / 2014-11-12
-
-* Removed Block#end_tag. Instead, override parse with `super` followed by your code. See #446 [Dylan Thacker-Smith, dylanahsmith]
-* Fixed condition with wrong data types (#423) [Bogdan Gusiev]
-* Add url_encode to standard filters (#421) [Derrick Reimer, djreimer]
+* ...
 * Add uniq to standard filters [Florian Weingarten, fw42]
-* Add exception_handler feature (#397) and #254 [Bogdan Gusiev, bogdan and Florian Weingarten, fw42]
+* Add exception_handler feature, see #397 and #254 [Bogdan Gusiev, bogdan and Florian Weingarten, fw42]
 * Optimize variable parsing to avoid repeated regex evaluation during template rendering #383 [Jason Hiltz-Laforge, jasonhl]
 * Optimize checking for block interrupts to reduce object allocation #380 [Jason Hiltz-Laforge, jasonhl] 
 * Properly set context rethrow_errors on render! #349 [Thierry Joyal, tjoyal]
-* Fix broken rendering of variables which are equal to false (#345) [Florian Weingarten, fw42]
+* Fix broken rendering of variables which are equal to false, see #345 [Florian Weingarten, fw42]
 * Remove ActionView template handler [Dylan Thacker-Smith, dylanahsmith]
-* Freeze lots of string literals for new Ruby 2.1 optimization (#297) [Florian Weingarten, fw42]
-* Allow newlines in tags and variables (#324) [Dylan Thacker-Smith, dylanahsmith]
+* Freeze lots of string literals for new Ruby 2.1 optimization, see #297 [Florian Weingarten, fw42]
+* Allow newlines in tags and variables, see #324 [Dylan Thacker-Smith, dylanahsmith]
 * Tag#parse is called after initialize, which now takes options instead of tokens as the 3rd argument. See #321 [Dylan Thacker-Smith, dylanahsmith]
 * Raise `Liquid::ArgumentError` instead of `::ArgumentError` when filter has wrong number of arguments #309 [Bogdan Gusiev, bogdan]
-* Add a to_s default for liquid drops (#306) [Adam Doeler, releod]
+* Add a to_s default for liquid drops, see #306 [Adam Doeler, releod]
 * Add strip, lstrip, and rstrip to standard filters [Florian Weingarten, fw42]
-* Make if, for & case tags return complete and consistent nodelists (#250) [Nick Jones, dntj]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
-* Fix resource counting bug with respond_to?(:length) (#263) [Florian Weingarten, fw42]
-* Allow specifying custom patterns for template filenames (#284) [Andrei Gladkyi, agladkyi]
-* Allow drops to optimize loading a slice of elements (#282) [Tom Burns, boourns]
-* Support for passing variables to snippets in subdirs (#271) [Joost Hietbrink, joost]
-* Add a class cache to avoid runtime extend calls (#249) [James Tucker, raggi]
-* Remove some legacy Ruby 1.8 compatibility code (#276) [Florian Weingarten, fw42]
-* Add default filter to standard filters (#267) [Derrick Reimer, djreimer]
-* Add optional strict parsing and warn parsing (#235) [Tristan Hume, trishume]
-* Add I18n syntax error translation (#241) [Simon Hørup Eskildsen, Sirupsen]
-* Make sort filter work on enumerable drops (#239) [Florian Weingarten, fw42]
-* Fix clashing method names in enumerable drops (#238) [Florian Weingarten, fw42]
-* Make map filter work on enumerable drops (#233) [Florian Weingarten, fw42]
+* Make if, for & case tags return complete and consistent nodelists, see #250 [Nick Jones, dntj]
+* Prevent arbitrary method invocation on condition objects, see #274 [Dylan Thacker-Smith, dylanahsmith]
+* Don't call to_sym when creating conditions for security reasons, see #273 [Bouke van der Bijl, bouk]
+* Fix resource counting bug with respond_to?(:length), see #263 [Florian Weingarten, fw42]
+* Allow specifying custom patterns for template filenames, see #284 [Andrei Gladkyi, agladkyi]
+* Allow drops to optimize loading a slice of elements, see #282 [Tom Burns, boourns]
+* Support for passing variables to snippets in subdirs, see #271 [Joost Hietbrink, joost]
+* Add a class cache to avoid runtime extend calls, see #249 [James Tucker, raggi]
+* Remove some legacy Ruby 1.8 compatibility code, see #276 [Florian Weingarten, fw42]
+* Add default filter to standard filters, see #267 [Derrick Reimer, djreimer]
+* Add optional strict parsing and warn parsing, see #235 [Tristan Hume, trishume]
+* Add I18n syntax error translation, see #241 [Simon Hørup Eskildsen, Sirupsen]
+* Make sort filter work on enumerable drops, see #239 [Florian Weingarten, fw42]
+* Fix clashing method names in enumerable drops, see #238 [Florian Weingarten, fw42]
+* Make map filter work on enumerable drops, see #233 [Florian Weingarten, fw42]
 * Improved whitespace stripping for blank blocks, related to #216 [Florian Weingarten, fw42]
 
 ## 2.6.1 / 2014-01-10 / branch "2-6-stable"
 
 Security fix, cherry-picked from master (4e14a65):
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
+* Don't call to_sym when creating conditions for security reasons, see #273 [Bouke van der Bijl, bouk]
+* Prevent arbitrary method invocation on condition objects, see #274 [Dylan Thacker-Smith, dylanahsmith]
 
 ## 2.6.0 / 2013-11-25
 
@@ -92,12 +66,12 @@ The following releases will only be tested against Ruby 1.9 and Ruby 2.0 and are
 ## 2.5.5 / 2014-01-10 / branch "2-5-stable"
 
 Security fix, cherry-picked from master (4e14a65):
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
+* Don't call to_sym when creating conditions for security reasons, see #273 [Bouke van der Bijl, bouk]
+* Prevent arbitrary method invocation on condition objects, see #274 [Dylan Thacker-Smith, dylanahsmith]
 
 ## 2.5.4 / 2013-11-11
 
-* Fix "can't convert Fixnum into String" for "replace" (#173), [wǒ_is神仙, jsw0528]
+* Fix "can't convert Fixnum into String" for "replace", see #173, [wǒ_is神仙, jsw0528]
 
 ## 2.5.3 / 2013-10-09
 

README.md

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

Rakefile

@@ -71,20 +71,6 @@ namespace :profile do
 
 end
 
-namespace :memory do
-
-  desc "Run the liquid memory tracer"
-  task :run do
-    ruby "./performance/memory.rb"
-  end
-
-  desc "Run the liquid memory tracer with strict parsing"
-  task :strict do
-    ruby "./performance/memory.rb strict"
-  end
-
-end
-
 desc "Run example"
 task :example do
   ruby "-w -d -Ilib example/server/server.rb"

example/server/example_servlet.rb

@@ -23,7 +23,7 @@ class Servlet < LiquidServlet
   end
 
   def products
-    { 'products' => products_list, 'more_products' => more_products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true}
+    { 'products' => products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true}
   end
 
   private
@@ -34,11 +34,6 @@ class Servlet < LiquidServlet
     {'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity'}]
   end
 
-  def more_products_list
-    [{'name' => 'Arbor Catalyst', 'price' => 39900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' },
-    {'name' => 'Arbor Fish', 'price' => 40000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape'}]
-  end
-
   def description
     "List of Products ~ This is a list of products with price and description."
   end

example/server/liquid_servlet.rb

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

example/server/templates/products.liquid

@@ -16,12 +16,12 @@
   </head>
 
   <body>
-    {% assign all_products = products | concat: more_products  %}
+
     <h1>{{ description | split: '~' | first }}</h1>
 
     <h2>{{ description | split: '~' | last }}</h2>
 
-    <h2>There are currently {{all_products | count}} products in the {{section}} catalog</h2>
+    <h2>There are currently {{products | count}} products in the {{section}} catalog</h2>
 
     {% if cool_products %}
       Cool products :)
@@ -31,7 +31,7 @@
 
     <ul id="products">
 
-      {% for product in all_products %}
+      {% for product in products %}
         <li>
           <h2>{{product.name}}</h2>
           Only {{product.price | price }}

lib/liquid.rb

@@ -57,13 +57,11 @@ require 'liquid/context'
 require 'liquid/parser_switching'
 require 'liquid/tag'
 require 'liquid/block'
-require 'liquid/block_body'
 require 'liquid/document'
 require 'liquid/variable'
 require 'liquid/variable_lookup'
 require 'liquid/range_lookup'
 require 'liquid/file_system'
-require 'liquid/resource_limits'
 require 'liquid/template'
 require 'liquid/standardfilters'
 require 'liquid/condition'
@@ -74,3 +72,6 @@ require 'liquid/token'
 # Load all the tags of the standard library
 #
 Dir[File.dirname(__FILE__) + '/liquid/tags/*.rb'].each { |f| require f }
+
+require 'liquid/profiler'
+require 'liquid/profiler/hooks'

lib/liquid/block.rb

@@ -1,26 +1,68 @@
 module Liquid
   class Block < Tag
-    def initialize(tag_name, markup, options)
-      super
-      @blank = true
-    end
-
-    def parse(tokens)
-      @body = BlockBody.new
-      while more = parse_body(@body, tokens)
-      end
-    end
-
-    def render(context)
-      @body.render(context)
-    end
+    FullToken         = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
+    ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
+    TAGSTART = "{%".freeze
+    VARSTART = "{{".freeze
 
     def blank?
       @blank
     end
 
-    def nodelist
-      @body.nodelist
+    def parse(tokens)
+      @blank = true
+      @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
+
+              # if we found the proper block delimiter just end parsing here and let the outer block
+              # proceed
+              if block_delimiter == $1
+                end_tag
+                return
+              end
+
+              # fetch the tag from registered blocks
+              if tag = Template.tags[$1]
+                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
+                @children << new_tag
+              else
+                # this tag is not registered with the system
+                # pass it to the current block for special handling or error reporting
+                unknown_tag($1, $2, tokens)
+              end
+            else
+              raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination".freeze, :token => token, :tag_end => TagEnd.inspect))
+            end
+          when token.start_with?(VARSTART)
+            new_var = create_variable(token)
+            new_var.line_number = token.line_number if token.is_a?(Token)
+            @nodelist << new_var
+            @children << new_var
+            @blank = false
+          else
+            @nodelist << token
+            @blank &&= (token =~ /\A\s*\z/)
+          end
+        end
+      end
+
+      # Make sure that it's ok to end parsing in the current block.
+      # Effectively this method will throw an exception unless the current block is
+      # of type Document
+      assert_missing_delimitation!
     end
 
     # warnings of this block and all sub-tags
@@ -28,13 +70,16 @@ module Liquid
       all_warnings = []
       all_warnings.concat(@warnings) if @warnings
 
-      (nodelist || []).each do |node|
-        all_warnings.concat(node.warnings || []) if node.respond_to?(:warnings)
+      (@children || []).each do |node|
+        all_warnings.concat(node.warnings || [])
       end
 
       all_warnings
     end
 
+    def end_tag
+    end
+
     def unknown_tag(tag, params, tokens)
       case tag
       when 'else'.freeze
@@ -57,23 +102,65 @@ module Liquid
       @block_delimiter ||= "end#{block_name}"
     end
 
+    def create_variable(token)
+      token.scan(ContentOfVariable) do |content|
+        markup = token.is_a?(Token) ? token.child(content.first) : content.first
+        return Variable.new(markup, @options)
+      end
+      raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination".freeze, :token => token, :tag_end => VariableEnd.inspect))
+    end
+
+    def render(context)
+      render_all(@nodelist, context)
+    end
+
     protected
 
-    def parse_body(body, tokens)
-      body.parse(tokens, options) do |end_tag_name, end_tag_params|
-        @blank &&= body.blank?
+    def assert_missing_delimitation!
+      raise SyntaxError.new(options[:locale].t("errors.syntax.tag_never_closed".freeze, :block_name => block_name))
+    end
 
-        return false if end_tag_name == block_delimiter
-        unless end_tag_name
-          raise SyntaxError.new(@options[:locale].t("errors.syntax.tag_never_closed".freeze, :block_name => block_name))
+    def render_all(list, context)
+      output = []
+      context.resource_limits[:render_length_current] = 0
+      context.resource_limits[:render_score_current] += list.length
+
+      list.each do |token|
+        # Break out if we have any unhanded interrupts.
+        break if context.has_interrupt?
+
+        begin
+          # If we get an Interrupt that means the block must stop processing. An
+          # Interrupt is any command that stops block execution such as {% break %}
+          # or {% continue %}
+          if token.is_a? Continue or token.is_a? Break
+            context.push_interrupt(token.interrupt)
+            break
+          end
+
+          token_output = render_token(token, context)
+
+          unless token.is_a?(Block) && token.blank?
+            output << token_output
+          end
+        rescue MemoryError => e
+          raise e
+        rescue ::StandardError => e
+          output << (context.handle_error(e, token))
         end
-
-        # this tag is not registered with the system
-        # pass it to the current block for special handling or error reporting
-        unknown_tag(end_tag_name, end_tag_params, tokens)
       end
 
-      true
+      output.join
+    end
+
+    def render_token(token, context)
+      token_output = (token.respond_to?(:render) ? token.render(context) : token)
+      context.increment_used_resources(:render_length_current, token_output)
+      if context.resource_limits_reached?
+        context.resource_limits[:reached] = true
+        raise MemoryError.new("Memory limits exceeded".freeze)
+      end
+      token_output
     end
   end
 end

lib/liquid/block_body.rb

@@ -1,132 +0,0 @@
-module Liquid
-  class BlockBody
-    FullToken = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
-    ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
-    TAGSTART = "{%".freeze
-    VARSTART = "{{".freeze
-
-    attr_reader :nodelist
-
-    def initialize
-      @nodelist = []
-      @blank = true
-    end
-
-    def parse(tokens, options)
-      while token = tokens.shift
-        begin
-          unless token.empty?
-            case
-            when token.start_with?(TAGSTART)
-              if token =~ FullToken
-                tag_name = $1
-                markup = $2
-                # fetch the tag from registered blocks
-                if tag = Template.tags[tag_name]
-                  markup = token.child(markup) if token.is_a?(Token)
-                  new_tag = tag.parse(tag_name, markup, tokens, options)
-                  new_tag.line_number = token.line_number if token.is_a?(Token)
-                  @blank &&= new_tag.blank?
-                  @nodelist << new_tag
-                else
-                  # end parsing if we reach an unknown tag and let the caller decide
-                  # determine how to proceed
-                  return yield tag_name, markup
-                end
-              else
-                raise_missing_tag_terminator(token, options)
-              end
-            when token.start_with?(VARSTART)
-              new_var = create_variable(token, options)
-              new_var.line_number = token.line_number if token.is_a?(Token)
-              @nodelist << new_var
-              @blank = false
-            else
-              @nodelist << token
-              @blank &&= !!(token =~ /\A\s*\z/)
-            end
-          end
-        rescue SyntaxError => e
-          e.set_line_number_from_token(token)
-          raise
-        end
-      end
-
-      yield nil, nil
-    end
-
-    def blank?
-      @blank
-    end
-
-    def warnings
-      all_warnings = []
-      nodelist.each do |node|
-        all_warnings.concat(node.warnings || []) if node.respond_to?(:warnings)
-      end
-      all_warnings
-    end
-
-    def render(context)
-      @output ||= []
-      @output.clear
-      context.resource_limits.render_score += @nodelist.length
-
-      @nodelist.each do |token|
-        # Break out if we have any unhanded interrupts.
-        break if context.has_interrupt?
-
-        begin
-          # If we get an Interrupt that means the block must stop processing. An
-          # Interrupt is any command that stops block execution such as {% break %}
-          # or {% continue %}
-          if token.is_a?(Continue) or token.is_a?(Break)
-            context.push_interrupt(token.interrupt)
-            break
-          end
-
-          token_output = render_token(token, context)
-
-          unless token.is_a?(Block) && token.blank?
-            @output << token_output
-          end
-        rescue MemoryError => e
-          raise e
-        rescue ::StandardError => e
-          @output << context.handle_error(e, token)
-        end
-      end
-
-      @output.join
-    end
-
-    private
-
-    def render_token(token, context)
-      token_output = (token.respond_to?(:render) ? token.render(context) : token)
-      token_str = token_output.is_a?(Array) ? token_output.join : token_output.to_s
-
-      context.resource_limits.render_length += token_str.length
-      if context.resource_limits.reached?
-        raise MemoryError.new("Memory limits exceeded".freeze)
-      end
-      token_str
-    end
-
-    def create_variable(token, options)
-      token.scan(ContentOfVariable) do |content|
-        markup = token.is_a?(Token) ? token.child(content.first) : content.first
-        return Variable.new(markup, options)
-      end
-      raise_missing_variable_terminator(token, options)
-    end
-
-    def raise_missing_tag_terminator(token, options)
-      raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination".freeze, :token => token, :tag_end => TagEnd.inspect))
-    end
-
-    def raise_missing_variable_terminator(token, options)
-      raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination".freeze, :token => token, :tag_end => VariableEnd.inspect))
-    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,9 +15,7 @@ module Liquid
       '>'.freeze  => :>,
       '>='.freeze => :>=,
       '<='.freeze => :<=,
-      'contains'.freeze => lambda { |cond, left, right|
-        left && right && left.respond_to?(:include?) ? left.include?(right) : false
-      }
+      'contains'.freeze => lambda { |cond, left, right| left && right ? left.include?(right) : false }
     }
 
     def self.operators
@@ -28,9 +26,7 @@ module Liquid
     attr_accessor :left, :operator, :right
 
     def initialize(left = nil, operator = nil, right = nil)
-      @left = left
-      @operator = operator
-      @right = right
+      @left, @operator, @right = left, operator, right
       @child_relation  = nil
       @child_condition = nil
     end
@@ -49,13 +45,11 @@ module Liquid
     end
 
     def or(condition)
-      @child_relation = :or
-      @child_condition = condition
+      @child_relation, @child_condition = :or, condition
     end
 
     def and(condition)
-      @child_relation = :and
-      @child_condition = condition
+      @child_relation, @child_condition = :and, condition
     end
 
     def attach(attachment)
@@ -96,10 +90,9 @@ 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.evaluate(left) if op == nil
+      return context[left] if op == nil
 
-      left = context.evaluate(left)
-      right = context.evaluate(right)
+      left, right = context[left], context[right]
 
       operation = self.class.operators[op] || raise(Liquid::ArgumentError.new("Unknown operator #{op}"))
 

lib/liquid/context.rb

@@ -13,14 +13,16 @@ module Liquid
   #
   #   context['bob']  #=> nil  class Context
   class Context
-    attr_reader :scopes, :registers, :environments, :resource_limits
+    attr_reader :scopes, :errors, :registers, :environments, :resource_limits
     attr_accessor :exception_handler
 
-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = {})
       @environments     = [environments].flatten
       @scopes           = [(outer_scope || {})]
       @registers        = registers
-      @resource_limits  = resource_limits || ResourceLimits.new(Template.default_resource_limits)
+      @errors           = []
+      @resource_limits  = (resource_limits || {}).merge!({ :render_score_current => 0, :assign_score_current => 0 })
+      @parsed_expression = Hash.new{ |cache, markup| cache[markup] = Expression.parse(markup) }
       squash_instance_assigns_with_environments
 
       @this_stack_used = false
@@ -29,12 +31,22 @@ module Liquid
         self.exception_handler = ->(e) { true }
       end
 
-      @interrupts = nil
+      @interrupts = []
       @filters = []
     end
 
-    def errors
-      @errors ||= []
+    def increment_used_resources(key, obj)
+      @resource_limits[key] += if obj.kind_of?(String) || obj.kind_of?(Array) || obj.kind_of?(Hash)
+        obj.length
+      else
+        1
+      end
+    end
+
+    def resource_limits_reached?
+      (@resource_limits[:render_length_limit] && @resource_limits[:render_length_current] > @resource_limits[:render_length_limit]) ||
+      (@resource_limits[:render_score_limit]  && @resource_limits[:render_score_current]  > @resource_limits[:render_score_limit] ) ||
+      (@resource_limits[:assign_score_limit]  && @resource_limits[:assign_score_current]  > @resource_limits[:assign_score_limit] )
     end
 
     def strainer
@@ -47,31 +59,41 @@ module Liquid
     # for that
     def add_filters(filters)
       filters = [filters].flatten.compact
-      @filters += filters
-      @strainer = nil
+      filters.each do |f|
+        raise ArgumentError, "Expected module but got: #{f.class}" unless f.is_a?(Module)
+        Strainer.add_known_filter(f)
+      end
+
+      # If strainer is already setup then there's no choice but to use a runtime
+      # extend call. If strainer is not yet created, we can utilize strainers
+      # cached class based API, which avoids busting the method cache.
+      if @strainer
+        filters.each do |f|
+          strainer.extend(f)
+        end
+      else
+        @filters.concat filters
+      end
     end
 
     # are there any not handled interrupts?
     def has_interrupt?
-      @interrupts && !@interrupts.empty?
+      !@interrupts.empty?
     end
 
     # push an interrupt to the stack. this interrupt is considered not handled.
     def push_interrupt(e)
-      (@interrupts ||= []).push(e)
+      @interrupts.push(e)
     end
 
     # pop an interrupt from the stack
     def pop_interrupt
-      @interrupts.pop if @interrupts
+      @interrupts.pop
     end
 
 
-    def handle_error(e, token=nil)
-      if e.is_a?(Liquid::Error)
-        e.set_line_number_from_token(token)
-      end
-
+    def handle_error(e, token)
+      e = Liquid::Error.error_with_line_number(e, token)
       errors.push(e)
       raise if exception_handler && exception_handler.call(e)
       Liquid::Error.render(e)
@@ -143,7 +165,7 @@ module Liquid
     # Example:
     #   products == empty #=> products.empty?
     def [](expression)
-      evaluate(Expression.parse(expression))
+      evaluate(@parsed_expression[expression])
     end
 
     def has_key?(key)

lib/liquid/document.rb

@@ -1,24 +1,17 @@
 module Liquid
-  class Document < BlockBody
-    def self.parse(tokens, options)
-      doc = new
-      doc.parse(tokens, options)
-      doc
+  class Document < Block
+    def self.parse(tokens, options={})
+      # we don't need markup to open this block
+      super(nil, nil, tokens, options)
     end
 
-    def parse(tokens, options)
-      super do |end_tag_name, end_tag_params|
-        unknown_tag(end_tag_name, options) if end_tag_name
-      end
+    # There isn't a real delimiter
+    def block_delimiter
+      []
     end
 
-    def unknown_tag(tag, options)
-      case tag
-      when 'else'.freeze, 'end'.freeze
-        raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_outer_tag".freeze, :tag => tag))
-      else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag".freeze, :tag => tag))
-      end
+    # Document blocks don't need to be terminated since they are not actually opened
+    def assert_missing_delimitation!
     end
   end
 end

lib/liquid/drop.rb

@@ -62,10 +62,6 @@ module Liquid
 
     # Check for method existence without invoking respond_to?, which creates symbols
     def self.invokable?(method_name)
-      self.invokable_methods.include?(method_name.to_s)
-    end
-
-    def self.invokable_methods
       unless @invokable_methods
         blacklist = Liquid::Drop.public_instance_methods + [:each]
         if include?(Enumerable)
@@ -75,7 +71,7 @@ module Liquid
         whitelist = [:to_liquid] + (public_instance_methods - blacklist)
         @invokable_methods = Set.new(whitelist.map(&:to_s))
       end
-      @invokable_methods
+      @invokable_methods.include?(method_name.to_s)
     end
   end
 end

lib/liquid/errors.rb

@@ -1,60 +1,42 @@
 module Liquid
   class Error < ::StandardError
     attr_accessor :line_number
-    attr_accessor :markup_context
 
-    def to_s(with_prefix=true)
-      str = ""
-      str << message_prefix if with_prefix
-      str << super()
-
-      if markup_context
-        str << " "
-        str << markup_context
+    def self.render(e)
+      msg = if e.is_a?(Liquid::Error) && e.line_number
+        "#{e.line_number}: #{e.message}"
+      else
+        e.message
       end
 
-      str
+      case e
+      when SyntaxError
+        "Liquid syntax error: #{msg}"
+      else
+        "Liquid error: #{msg}"
+      end
+    end
+
+    def self.error_with_line_number(e, token)
+      if e.is_a?(Liquid::Error)
+        e.set_line_number_from_token(token)
+      end
+
+      e
     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/file_system.rb

@@ -14,7 +14,7 @@ module Liquid
   # This will parse the template with a LocalFileSystem implementation rooted at 'template_path'.
   class BlankFileSystem
     # Called by Liquid to retrieve a template file
-    def read_template_file(template_path)
+    def read_template_file(template_path, context)
       raise FileSystemError, "This liquid context does not allow includes."
     end
   end
@@ -49,7 +49,7 @@ module Liquid
       @pattern = pattern
     end
 
-    def read_template_file(template_path)
+    def read_template_file(template_path, context)
       full_path = full_path(template_path)
       raise FileSystemError, "No such template '#{template_path}'" unless File.exists?(full_path)
 

lib/liquid/lexer.rb

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

lib/liquid/locales/en.yml

@@ -14,8 +14,7 @@
       include: "Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]"
       unknown_tag: "Unknown tag '%{tag}'"
       invalid_delimiter: "'end' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
-      unexpected_else: "%{block_name} tag does not expect 'else' tag"
-      unexpected_outer_tag: "Unexpected outer '%{tag}' tag"
+      unexpected_else: "%{block_name} tag does not expect else tag"
       tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
       variable_termination: "Variable '%{token}' was not properly terminated with regexp: %{tag_end}"
       tag_never_closed: "'%{block_name}' tag was never closed"

lib/liquid/module_ex.rb

@@ -7,17 +7,16 @@
 # to the allowed method passed with the liquid_methods call
 # Example:
 #
-#   class SomeClass
-#     liquid_methods :an_allowed_method
+# class SomeClass
+#   liquid_methods :an_allowed_method
 #
-#     def an_allowed_method
-#       'this comes from an allowed method'
-#     end
-#
-#     def unallowed_method
-#       'this will never be an output'
-#     end
+#   def an_allowed_method
+#     'this comes from an allowed method'
 #   end
+#   def unallowed_method
+#     'this will never be an output'
+#   end
+# end
 #
 # if you want to extend the drop to other methods you can defines more methods
 # in the class <YourClass>::LiquidDropClass
@@ -27,33 +26,31 @@
 #       'and this from another allowed method'
 #     end
 #   end
-#
+# end
 #
 # usage:
-#   @something = SomeClass.new
+# @something = SomeClass.new
 #
 # template:
-#   {{something.an_allowed_method}}{{something.unallowed_method}} {{something.another_allowed_method}}
+# {{something.an_allowed_method}}{{something.unallowed_method}} {{something.another_allowed_method}}
 #
 # output:
-#   'this comes from an allowed method and this from another allowed method'
+# 'this comes from an allowed method and this from another allowed method'
 #
 # You can also chain associations, by adding the liquid_method call in the
 # association models.
 #
 class Module
+
   def liquid_methods(*allowed_methods)
     drop_class = eval "class #{self.to_s}::LiquidDropClass < Liquid::Drop; self; end"
-    
     define_method :to_liquid do
       drop_class.new(self)
     end
-    
     drop_class.class_eval do
       def initialize(object)
         @object = object
       end
-      
       allowed_methods.each do |sym|
         define_method sym do
           @object.send sym
@@ -61,4 +58,5 @@ class Module
       end
     end
   end
+
 end

lib/liquid/parser_switching.rb

@@ -8,7 +8,7 @@ module Liquid
         begin
           return strict_parse_with_error_context(markup)
         rescue SyntaxError => e
-          e.set_line_number_from_token(markup)
+          e.line_number = markup.line_number if markup.is_a?(Token)
           @warnings ||= []
           @warnings << e
           return lax_parse(markup)
@@ -20,12 +20,12 @@ module Liquid
     def strict_parse_with_error_context(markup)
       strict_parse(markup)
     rescue SyntaxError => e
-      e.markup_context = markup_context(markup)
+      e.message << markup_context(markup)
       raise e
     end
 
     def markup_context(markup)
-      "in \"#{markup.strip}\""
+      " in \"#{markup.strip}\"" 
     end
   end
-end
+end

lib/liquid/profiler.rb

@@ -1,12 +1,9 @@
-require 'liquid/profiler/hooks'
-
 module Liquid
 
   # Profiler enables support for profiling template rendering to help track down performance issues.
   #
-  # To enable profiling, first require 'liquid/profiler'.
-  # Then, to profile a parse/render cycle, pass the <tt>profile: true</tt> option to <tt>Liquid::Template.parse</tt>.
-  # After <tt>Liquid::Template#render</tt> is called, the template object makes available an instance of this
+  # 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)

lib/liquid/profiler/hooks.rb

@@ -1,5 +1,5 @@
 module Liquid
-  class BlockBody
+  class Block < Tag
     def render_token_with_profiling(token, context)
       Profiler.profile_token_render(token) do
         render_token_without_profiling(token, context)
@@ -12,7 +12,7 @@ module Liquid
 
   class Include < Tag
     def render_with_profiling(context)
-      Profiler.profile_children(context.evaluate(@template_name).to_s) do
+      Profiler.profile_children(@template_name) do
         render_without_profiling(context)
       end
     end

lib/liquid/resource_limits.rb

@@ -1,23 +0,0 @@
-module Liquid
-  class ResourceLimits
-    attr_accessor :render_length, :render_score, :assign_score,
-                  :render_length_limit, :render_score_limit, :assign_score_limit
-
-    def initialize(limits)
-      @render_length_limit = limits[:render_length_limit]
-      @render_score_limit = limits[:render_score_limit]
-      @assign_score_limit = limits[:assign_score_limit]
-      reset
-    end
-
-    def reached?
-      (@render_length_limit && @render_length > @render_length_limit) ||
-      (@render_score_limit  && @render_score  > @render_score_limit ) ||
-      (@assign_score_limit  && @assign_score  > @assign_score_limit )
-    end
-
-    def reset
-      @render_length = @render_score = @assign_score = 0
-    end
-  end
-end

lib/liquid/standardfilters.rb

@@ -34,7 +34,7 @@ module Liquid
     end
 
     def escape(input)
-      CGI.escapeHTML(input).untaint rescue input
+      CGI.escapeHTML(input) rescue input
     end
     alias_method :h, :escape
 
@@ -42,10 +42,6 @@ module Liquid
       input.to_s.gsub(HTML_ESCAPE_ONCE_REGEXP, HTML_ESCAPE)
     end
 
-    def url_encode(input)
-      CGI.escape(input) rescue input
-    end
-
     def slice(input, offset, length=nil)
       offset = Integer(offset)
       length = length ? Integer(length) : 1
@@ -177,10 +173,6 @@ module Liquid
       input.to_s + string.to_s
     end
 
-    def concat(input, array)
-      InputIterator.new(input).concat(array)
-    end
-
     # prepend a string to another
     def prepend(input, string)
       string.to_s + input.to_s
@@ -310,8 +302,6 @@ module Liquid
     def to_date(obj)
       return obj if obj.respond_to?(:strftime)
 
-      obj = obj.downcase if obj.is_a?(String)
-
       case obj
       when 'now'.freeze, 'today'.freeze
         Time.now
@@ -350,10 +340,6 @@ module Liquid
         to_a.join(glue)
       end
 
-      def concat(args)
-        to_a.concat args
-      end
-
       def reverse
         reverse_each.to_a
       end

lib/liquid/strainer.rb

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

lib/liquid/tags/assign.rb

@@ -25,10 +25,7 @@ module Liquid
     def render(context)
       val = @from.render(context)
       context.scopes.last[@to] = val
-
-      inc = val.instance_of?(String) || val.instance_of?(Array) || val.instance_of?(Hash) ? val.length : 1
-      context.resource_limits.assign_score += inc
-
+      context.increment_used_resources(:assign_score_current, val)
       ''.freeze
     end
 

lib/liquid/tags/capture.rb

@@ -11,7 +11,7 @@ module Liquid
   # in a sidebar or footer.
   #
   class Capture < Block
-    Syntax = /(#{VariableSignature}+)/o
+    Syntax = /(\w+)/
 
     def initialize(tag_name, markup, options)
       super
@@ -25,7 +25,7 @@ module Liquid
     def render(context)
       output = super
       context.scopes.last[@to] = output
-      context.resource_limits.assign_score += output.length
+      context.increment_used_resources(:assign_score_current, output)
       ''.freeze
     end
 

lib/liquid/tags/case.rb

@@ -8,24 +8,18 @@ module Liquid
       @blocks = []
 
       if markup =~ Syntax
-        @left = Expression.parse($1)
+        @left = $1
       else
         raise SyntaxError.new(options[:locale].t("errors.syntax.case".freeze))
       end
     end
 
-    def parse(tokens)
-      body = BlockBody.new
-      while more = parse_body(body, tokens)
-        body = @blocks.last.attachment
-      end
-    end
-
     def nodelist
-      @blocks.map(&:attachment)
+      @blocks.map(&:attachment).flatten
     end
 
     def unknown_tag(tag, markup, tokens)
+      @nodelist = []
       case tag
       when 'when'.freeze
         record_when_condition(markup)
@@ -43,10 +37,10 @@ module Liquid
         output = ''
         @blocks.each do |block|
           if block.else?
-            return block.attachment.render(context) if execute_else_block
+            return render_all(block.attachment, context) if execute_else_block
           elsif block.evaluate(context)
             execute_else_block = false
-            output << block.attachment.render(context)
+            output << render_all(block.attachment, context)
           end
         end
         output
@@ -56,18 +50,17 @@ module Liquid
     private
 
     def record_when_condition(markup)
-      body = BlockBody.new
-
       while markup
+        # Create a new nodelist and assign it to the new block
         if not markup =~ WhenSyntax
           raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when".freeze))
         end
 
         markup = $2
 
-        block = Condition.new(@left, '=='.freeze, Expression.parse($1))
-        block.attach(body)
-        @blocks << block
+        block = Condition.new(@left, '=='.freeze, $1)
+        block.attach(@nodelist)
+        @blocks.push(block)
       end
     end
 
@@ -77,7 +70,7 @@ module Liquid
       end
 
       block = ElseCondition.new
-      block.attach(BlockBody.new)
+      block.attach(@nodelist)
       @blocks << block
     end
   end

lib/liquid/tags/cycle.rb

@@ -20,10 +20,10 @@ module Liquid
       case markup
       when NamedSyntax
         @variables = variables_from_string($2)
-        @name = Expression.parse($1)
+        @name = $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.evaluate(@name)
+        key = context[@name]
         iteration = context.registers[:cycle][key]
-        result = context.evaluate(@variables[iteration])
+        result = context[@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 ? Expression.parse($1) : nil
+        $1 ? $1 : nil
       end.compact
     end
   end

lib/liquid/tags/for.rb

@@ -42,7 +42,6 @@ module Liquid
   #                   where 0 is the last item.
   # forloop.first:: Returns true if the item is the first item.
   # forloop.last:: Returns true if the item is the last item.
-  # forloop.parentloop:: Provides access to the parent loop, if present.
   #
   class For < Block
     Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
@@ -50,40 +49,38 @@ module Liquid
     def initialize(tag_name, markup, options)
       super
       parse_with_selected_parser(markup)
-      @for_block = BlockBody.new
-    end
-
-    def parse(tokens)
-      if more = parse_body(@for_block, tokens)
-        parse_body(@else_block, tokens)
-      end
+      @nodelist = @for_block = []
     end
 
     def nodelist
-      @else_block ? [@for_block, @else_block] : [@for_block]
+      if @else_block
+        @for_block + @else_block
+      else
+        @for_block
+      end
     end
 
     def unknown_tag(tag, markup, tokens)
       return super unless tag == 'else'.freeze
-      @else_block = BlockBody.new
+      @nodelist = @else_block = []
     end
 
     def render(context)
       context.registers[:for] ||= Hash.new(0)
 
-      collection = context.evaluate(@collection_name)
+      collection = context[@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 @from == :continue
+      from = if @attributes['offset'.freeze] == 'continue'.freeze
         context.registers[:for][@name].to_i
       else
-        context.evaluate(@from).to_i
+        context[@attributes['offset'.freeze]].to_i
       end
 
-      limit = context.evaluate(@limit)
+      limit = context[@attributes['limit'.freeze]]
       to    = limit ? limit.to_i + from : nil
 
       segment = Utils.slice_collection(collection, from, to)
@@ -99,24 +96,21 @@ module Liquid
       # Store our progress through the collection for the continue flag
       context.registers[:for][@name] = from + segment.length
 
-      parent_loop = context['forloop'.freeze]
-
       context.stack do
         segment.each_with_index do |item, index|
           context[@variable_name] = item
           context['forloop'.freeze] = {
-            'name'.freeze       => @name,
-            'length'.freeze     => length,
-            'index'.freeze      => index + 1,
-            'index0'.freeze     => index,
-            'rindex'.freeze     => length - index,
-            'rindex0'.freeze    => length - index - 1,
-            'first'.freeze      => (index == 0),
-            'last'.freeze       => (index == length - 1),
-            'parentloop'.freeze => parent_loop
+            'name'.freeze    => @name,
+            'length'.freeze  => length,
+            'index'.freeze   => index + 1,
+            'index0'.freeze  => index,
+            'rindex'.freeze  => length - index,
+            'rindex0'.freeze => length - index - 1,
+            'first'.freeze   => (index == 0),
+            'last'.freeze    => (index == length - 1)
           }
 
-          result << @for_block.render(context)
+          result << render_all(@for_block, context)
 
           # Handle any interrupts if they exist.
           if context.has_interrupt?
@@ -134,12 +128,12 @@ module Liquid
     def lax_parse(markup)
       if markup =~ Syntax
         @variable_name = $1
-        collection_name = $2
+        @collection_name = $2
+        @name = "#{$1}-#{$2}"
         @reversed = $3
-        @name = "#{@variable_name}-#{collection_name}"
-        @collection_name = Expression.parse(collection_name)
+        @attributes = {}
         markup.scan(TagAttributes) do |key, value|
-          set_attribute(key, value)
+          @attributes[key] = value
         end
       else
         raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze))
@@ -150,38 +144,26 @@ 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 = Expression.parse(collection_name)
+      @collection_name = p.expression
+      @name = "#{@variable_name}-#{@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
-        set_attribute(attribute, p.expression)
+        val = p.expression
+        @attributes[attribute] = val
       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)
-      @else_block ? @else_block.render(context) : ''.freeze
+      return @else_block ? [render_all(@else_block, context)] : ''.freeze
     end
 
     def iterable?(collection)

lib/liquid/tags/if.rb

@@ -20,13 +20,8 @@ module Liquid
       push_block('if'.freeze, markup)
     end
 
-    def parse(tokens)
-      while more = parse_body(@blocks.last.attachment, tokens)
-      end
-    end
-
     def nodelist
-      @blocks.map(&:attachment)
+      @blocks.map(&:attachment).flatten
     end
 
     def unknown_tag(tag, markup, tokens)
@@ -41,7 +36,7 @@ module Liquid
       context.stack do
         @blocks.each do |block|
           if block.evaluate(context)
-            return block.attachment.render(context)
+            return render_all(block.attachment, context)
           end
         end
         ''.freeze
@@ -58,21 +53,21 @@ module Liquid
         end
 
         @blocks.push(block)
-        block.attach(BlockBody.new)
+        @nodelist = block.attach(Array.new)
       end
 
       def lax_parse(markup)
-        expressions = markup.scan(ExpressionsAndOperators)
-        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax
+        expressions = markup.scan(ExpressionsAndOperators).reverse
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.shift =~ Syntax
 
-        condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
+        condition = Condition.new($1, $2, $3)
 
         while not expressions.empty?
-          operator = expressions.pop.to_s.strip
+          operator = (expressions.shift).to_s.strip
 
-          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax
+          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.shift.to_s =~ Syntax
 
-          new_condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
+          new_condition = Condition.new($1, $2, $3)
           raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
           new_condition.send(operator, condition)
           condition = new_condition
@@ -97,9 +92,9 @@ module Liquid
       end
 
       def parse_comparison(p)
-        a = Expression.parse(p.expression)
+        a = p.expression
         if op = p.consume?(:comparison)
-          b = Expression.parse(p.expression)
+          b = 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 = super
+        output = render_all(@nodelist, context)
 
         if output != context.registers[:ifchanged]
           context.registers[:ifchanged] = output

lib/liquid/tags/include.rb

@@ -22,16 +22,12 @@ module Liquid
 
       if markup =~ Syntax
 
-        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)
+        @template_name = $1
+        @variable_name = $3
         @attributes    = {}
 
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = Expression.parse(value)
+          @attributes[key] = value
         end
 
       else
@@ -44,20 +40,21 @@ module Liquid
 
     def render(context)
       partial = load_cached_partial(context)
-      variable = context.evaluate(@variable_name)
+      variable = context[@variable_name || @template_name[1..-2]]
 
       context.stack do
         @attributes.each do |key, value|
-          context[key] = context.evaluate(value)
+          context[key] = context[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
@@ -66,13 +63,13 @@ module Liquid
     private
       def load_cached_partial(context)
         cached_partials = context.registers[:cached_partials] || {}
-        template_name = context.evaluate(@template_name)
+        template_name = context[@template_name]
 
         if cached = cached_partials[template_name]
           return cached
         end
         source = read_template_from_file_system(context)
-        partial = Liquid::Template.parse(source, pass_options)
+        partial = Liquid::Template.parse(source)
         cached_partials[template_name] = partial
         context.registers[:cached_partials] = cached_partials
         partial
@@ -81,17 +78,15 @@ module Liquid
       def read_template_from_file_system(context)
         file_system = context.registers[:file_system] || Liquid::Template.file_system
 
-        file_system.read_template_file(context.evaluate(@template_name))
-      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)}
+        # 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])
+        when 2
+          file_system.read_template_file(context[@template_name], context)
+        else
+          raise ArgumentError, "file_system.read_template_file expects two parameters: (template_name, context)"
         end
-        opts
       end
   end
 

lib/liquid/tags/raw.rb

@@ -3,27 +3,19 @@ module Liquid
     FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
 
     def parse(tokens)
-      @body = ''
+      @nodelist ||= []
+      @nodelist.clear
       while token = tokens.shift
         if token =~ FullTokenPossiblyInvalid
-          @body << $1 if $1 != "".freeze
-          return if block_delimiter == $2
+          @nodelist << $1 if $1 != "".freeze
+          if block_delimiter == $2
+            end_tag
+            return
+          end
         end
-        @body << token if not token.empty?
+        @nodelist << token if not token.empty?
       end
     end
-
-    def render(context)
-      @body
-    end
-
-    def nodelist
-      [@body]
-    end
-
-    def blank?
-      @body.empty?
-    end
   end
 
   Template.register_tag('raw'.freeze, Raw)

lib/liquid/tags/table_row.rb

@@ -6,10 +6,10 @@ module Liquid
       super
       if markup =~ Syntax
         @variable_name = $1
-        @collection_name = Expression.parse($2)
+        @collection_name = $2
         @attributes = {}
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = Expression.parse(value)
+          @attributes[key] = 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.evaluate(@collection_name) or return ''.freeze
+      collection = context[@collection_name] or return ''.freeze
 
-      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
+      from = @attributes['offset'.freeze] ? context[@attributes['offset'.freeze]].to_i : 0
+      to = @attributes['limit'.freeze] ? from + context[@attributes['limit'.freeze]].to_i : nil
 
       collection = Utils.slice_collection(collection, from, to)
 
       length = collection.length
 
-      cols = context.evaluate(@attributes['cols'.freeze]).to_i
+      cols = context[@attributes['cols'.freeze]].to_i
 
       row = 1
       col = 0
@@ -42,6 +42,7 @@ module Liquid
             'index0'.freeze    => index,
             'col'.freeze       => col + 1,
             'col0'.freeze      => col,
+            'index0'.freeze    => index,
             'rindex'.freeze    => length - index,
             'rindex0'.freeze   => length - index - 1,
             'first'.freeze     => (index == 0),
@@ -53,7 +54,7 @@ module Liquid
 
           col += 1
 
-          result << "<td class=\"col#{col}\">" << super << '</td>'
+          result << "<td class=\"col#{col}\">" << render_all(@nodelist, context) << '</td>'
 
           if col == cols and (index != length - 1)
             col  = 0

lib/liquid/tags/unless.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/if'
 module Liquid
   # Unless is a conditional just like 'if' but works on the inverse logic.
   #
-  #   {% unless x < 0 %} x is greater than zero {% endunless %}
+  #   {% unless x < 0 %} x is greater than zero {% end %}
   #
   class Unless < If
     def render(context)
@@ -12,13 +12,13 @@ module Liquid
         # First condition is interpreted backwards ( if not )
         first_block = @blocks.first
         unless first_block.evaluate(context)
-          return first_block.attachment.render(context)
+          return render_all(first_block.attachment, context)
         end
 
         # After the first condition unless works just like if
         @blocks[1..-1].each do |block|
           if block.evaluate(context)
-            return block.attachment.render(context)
+            return render_all(block.attachment, context)
           end
         end
 

lib/liquid/template.rb

@@ -18,9 +18,7 @@ module Liquid
       :locale => I18n.new
     }
 
-    attr_accessor :root
-    attr_reader :resource_limits
-
+    attr_accessor :root, :resource_limits
     @@file_system = BlankFileSystem.new
 
     class TagRegistry
@@ -62,12 +60,6 @@ module Liquid
       # :strict will enforce correct syntax.
       attr_writer :error_mode
 
-      # Sets how strict the taint checker should be.
-      # :lax is the default, and ignores the taint flag completely
-      # :warn adds a warning, but does not interrupt the rendering
-      # :error raises an error when tainted output is used
-      attr_writer :taint_mode
-
       def file_system
         @@file_system
       end
@@ -88,20 +80,12 @@ 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
@@ -111,16 +95,16 @@ module Liquid
       end
     end
 
+    # creates a new <tt>Template</tt> from an array of tokens. Use <tt>Template.parse</tt> instead
     def initialize
-      @resource_limits = ResourceLimits.new(self.class.default_resource_limits)
+      @resource_limits = {}
     end
 
     # Parse source code.
     # Returns self for easy chaining
     def parse(source, options = {})
-      @options = options
-      @profiling = options[:profile]
-      @line_numbers = options[:line_numbers] || @profiling
+      @profiling = options.delete(:profile)
+      @line_numbers = options.delete(:line_numbers) || @profiling
       @root = Document.parse(tokenize(source), DEFAULT_OPTIONS.merge(options))
       @warnings = nil
       self
@@ -205,9 +189,6 @@ module Liquid
         context.add_filters(args.pop)
       end
 
-      # Retrying a render resets resource usage
-      context.resource_limits.reset
-
       begin
         # render the nodelist.
         # for performance reasons we get an array back here. join will make a string out of it.
@@ -216,7 +197,7 @@ module Liquid
         end
         result.respond_to?(:join) ? result.join : result
       rescue Liquid::MemoryError => e
-        context.handle_error(e)
+        context.handle_error(e, nil)
       ensure
         @errors = context.errors
       end
@@ -254,9 +235,7 @@ module Liquid
     end
 
     def with_profiling
-      if @profiling && !@options[:included]
-        raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)
-
+      if @profiling
         @profiler = Profiler.new
         @profiler.start
 

lib/liquid/variable.rb

@@ -12,6 +12,7 @@ module Liquid
   #
   class Variable
     FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
+    EasyParse = /\A *(\w+(?:\.\w+)*) *\z/
     attr_accessor :filters, :name, :warnings
     attr_accessor :line_number
     include ParserSwitching
@@ -29,23 +30,20 @@ module Liquid
     end
 
     def markup_context(markup)
-      "in \"{{#{markup}}}\""
+      " in \"{{#{markup}}}\""
     end
 
     def lax_parse(markup)
-      @filters ||= []
-      @filters.clear
-      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 = []
+      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)
           filters.each do |f|
             if f =~ /\w+/
               filtername = Regexp.last_match(0)
               filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
-              @filters << parse_filter_expressions(filtername, filterargs)
+              @filters << [filtername, filterargs]
             end
           end
         end
@@ -53,15 +51,21 @@ module Liquid
     end
 
     def strict_parse(markup)
-      @filters ||= []
-      @filters.clear
-      p = Parser.new(markup)
+      # Very simple valid cases
+      if markup =~ EasyParse
+        @name = $1
+        @filters = []
+        return
+      end
 
-      @name = Expression.parse(p.expression)
+      @filters = []
+      p = Parser.new(markup)
+      # Could be just filters with no input
+      @name = p.look(:pipe) ? ''.freeze : p.expression
       while p.consume?(:pipe)
         filtername = p.consume(:id)
         filterargs = p.consume?(:colon) ? parse_filterargs(p) : []
-        @filters << parse_filter_expressions(filtername, filterargs)
+        @filters << [filtername, filterargs]
       end
       p.consume(:end_of_string)
     end
@@ -77,51 +81,22 @@ module Liquid
     end
 
     def render(context)
-      @filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
-        filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
-        output = context.invoke(filter_name, output, *filter_args)
-      end.tap{ |obj| taint_check(obj) }
-    end
-
-    private
-
-    def parse_filter_expressions(filter_name, unparsed_args)
-      filter_args = []
-      keyword_args = {}
-      unparsed_args.each do |a|
-        if matches = a.match(/\A#{TagAttributes}\z/o)
-          keyword_args[matches[1]] = Expression.parse(matches[2])
-        else
-          filter_args << Expression.parse(a)
+      return ''.freeze if @name.nil?
+      @filters.inject(context[@name]) do |output, filter|
+        filterargs = []
+        keyword_args = {}
+        filter[1].to_a.each do |a|
+          if matches = a.match(/\A#{TagAttributes}\z/o)
+            keyword_args[matches[1]] = context[matches[2]]
+          else
+            filterargs << context[a]
+          end
         end
-      end
-      result = [filter_name, filter_args]
-      result << keyword_args unless keyword_args.empty?
-      result
-    end
-
-    def evaluate_filter_expressions(context, filter_args, filter_kwargs)
-      parsed_args = filter_args.map{ |expr| context.evaluate(expr) }
-      if filter_kwargs
-        parsed_kwargs = {}
-        filter_kwargs.each do |key, expr|
-          parsed_kwargs[key] = context.evaluate(expr)
-        end
-        parsed_args << parsed_kwargs
-      end
-      parsed_args
-    end
-
-    def taint_check(obj)
-      if obj.tainted?
-        @markup =~ QuotedFragment
-        name = Regexp.last_match(0)
-        case Template.taint_mode
-        when :warn
-          @warnings ||= []
-          @warnings << "variable '#{name}' is tainted and was not escaped"
-        when :error
-          raise TaintedError, "Error - variable '#{name}' is tainted and was not escaped"
+        filterargs << keyword_args unless keyword_args.empty?
+        begin
+          output = context.invoke(filter[0], output, *filterargs)
+        rescue FilterNotFound
+          raise FilterNotFound, "Error - filter '#{filter[0]}' in '#{@markup.strip}' could not be found."
         end
       end
     end

lib/liquid/variable_lookup.rb

@@ -3,27 +3,26 @@ module Liquid
     SQUARE_BRACKETED = /\A\[(.*)\]\z/m
     COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze]
 
-    attr_reader :name, :lookups
-
     def self.parse(markup)
       new(markup)
     end
 
     def initialize(markup)
-      @lookups = markup.scan(VariableParser)
+      lookups = markup.scan(VariableParser)
 
-      name = @lookups.shift
+      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]
+        lookup = lookups[i]
         if lookup =~ SQUARE_BRACKETED
-          @lookups[i] = Expression.parse($1)
+          lookups[i] = Expression.parse($1)
         elsif COMMAND_METHODS.include?(lookup)
           @command_flags |= 1 << i
         end
@@ -65,15 +64,5 @@ module Liquid
 
       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 = "4.0.0.alpha"
+  VERSION = "3.0.0"
 end

liquid.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.version     = Liquid::VERSION
   s.platform    = Gem::Platform::RUBY
   s.summary     = "A secure, non-evaling end user template engine with aesthetic markup."
-  s.authors     = ["Tobias Lütke"]
+  s.authors     = ["Tobias Luetke"]
   s.email       = ["tobi@leetsoft.com"]
   s.homepage    = "http://www.liquidmarkup.org"
   s.license     = "MIT"

performance/memory.rb

@@ -1,19 +0,0 @@
-at_exit do
-  p 'Objects distribution:'
-  require 'pp'
-  pp ObjectSpace.count_objects
-end
-
-require 'allocation_tracer' rescue fail("install allocation_tracer extension/gem")
-require File.dirname(__FILE__) + '/theme_runner'
-
-Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
-profiler = ThemeRunner.new
-
-require 'allocation_tracer/trace'
-
-puts "Profiling memory usage..."
-
-200.times do
-  profiler.run
-end

performance/profile.rb

@@ -8,17 +8,10 @@ profiler.run
 [:cpu, :object].each do |profile_type|
   puts "Profiling in #{profile_type.to_s} mode..."
   results = StackProf.run(mode: profile_type) do
-    200.times do
+    100.times do
       profiler.run
     end
   end
-
-  if profile_type == :cpu && graph_filename = ENV['GRAPH_FILENAME']
-    File.open(graph_filename, 'w') do |f|
-      StackProf::Report.new(results).print_graphviz(nil, f)
-    end
-  end
-
   StackProf::Report.new(results).print_text(false, 20)
   File.write(ENV['FILENAME'] + "." + profile_type.to_s, Marshal.dump(results)) if ENV['FILENAME']
 end

performance/shopify/paginate.rb

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

performance/theme_runner.rb

@@ -17,7 +17,7 @@ class ThemeRunner
     end
 
     # Called by Liquid to retrieve a template file
-    def read_template_file(template_path)
+    def read_template_file(template_path, context)
       File.read(@path + '/' + template_path + '.liquid')
     end
   end

test/integration/assign_test.rb

@@ -3,16 +3,6 @@ require 'test_helper'
 class AssignTest < Minitest::Test
   include Liquid
 
-  def test_assign_with_hyphen_in_variable_name
-    template_source = <<-END_TEMPLATE
-    {% assign this-thing = 'Print this-thing' %}
-    {{ this-thing }}
-    END_TEMPLATE
-    template = Template.parse(template_source)
-    rendered = template.render!
-    assert_equal "Print this-thing", rendered.strip
-  end
-
   def test_assigned_variable
     assert_template_result('.foo.',
                            '{% assign foo = values %}.{{ foo[0] }}.',

test/integration/blank_test.rb

@@ -9,7 +9,7 @@ class FoobarTag < Liquid::Tag
 end
 
 class BlankTestFileSystem
-  def read_template_file(template_path)
+  def read_template_file(template_path, context)
     template_path
   end
 end

test/integration/capture_test.rb

@@ -7,16 +7,6 @@ class CaptureTest < Minitest::Test
     assert_template_result("test string", "{% capture 'var' %}test string{% endcapture %}{{var}}", {})
   end
 
-  def test_capture_with_hyphen_in_variable_name
-    template_source = <<-END_TEMPLATE
-    {% capture this-thing %}Print this-thing{% endcapture %}
-    {{ this-thing }}
-    END_TEMPLATE
-    template = Template.parse(template_source)
-    rendered = template.render!
-    assert_equal "Print this-thing", rendered.strip
-  end
-
   def test_capture_to_variable_from_outer_scope_if_existing
     template_source = <<-END_TEMPLATE
     {% assign var = '' %}

test/integration/context_test.rb

@@ -23,10 +23,12 @@ class ContextTest < Minitest::Test
   end
 
   def test_has_key_will_not_add_an_error_for_missing_keys
-    with_error_mode :strict do
-      context = Context.new
-      context.has_key?('unknown')
-      assert_empty context.errors
-    end
+    Template.error_mode = :strict
+
+    context = Context.new
+
+    context.has_key?('unknown')
+
+    assert_empty context.errors
   end
 end

test/integration/document_test.rb

@@ -1,19 +0,0 @@
-require 'test_helper'
-
-class DocumentTest < Minitest::Test
-  include Liquid
-
-  def test_unexpected_outer_tag
-    exc = assert_raises(SyntaxError) do
-      Template.parse("{% else %}")
-    end
-    assert_equal exc.message, "Liquid syntax error: Unexpected outer 'else' tag"
-  end
-
-  def test_unknown_tag
-    exc = assert_raises(SyntaxError) do
-      Template.parse("{% foo %}")
-    end
-    assert_equal exc.message, "Liquid syntax error: Unknown tag 'foo'"
-  end
-end

test/integration/drop_test.rb

@@ -48,10 +48,6 @@ class ProductDrop < Liquid::Drop
     ContextDrop.new
   end
 
-  def user_input
-    "foo".taint
-  end
-
   protected
     def callmenot
       "protected"
@@ -112,30 +108,6 @@ class DropsTest < Minitest::Test
     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
-
   def test_drop_does_only_respond_to_whitelisted_methods
     assert_equal "", Liquid::Template.parse("{{ product.inspect }}").render!('product' => ProductDrop.new)
     assert_equal "", Liquid::Template.parse("{{ product.pretty_inspect }}").render!('product' => ProductDrop.new)

test/integration/error_handling_test.rb

@@ -40,13 +40,13 @@ class ErrorHandlingTest < Minitest::Test
     expected = <<-TEXT
       Hello,
 
-      Liquid error (line 3): standard error will raise a standard error.
+      Liquid error: 3: standard error will raise a standard error.
 
       Bla bla test.
 
-      Liquid syntax error (line 7): syntax error will raise a syntax error.
+      Liquid syntax error: 7: syntax error will raise a syntax error.
 
-      This is an argument error: Liquid error (line 9): argument error
+      This is an argument error: Liquid error: 9: argument error
 
       Bla.
     TEXT
@@ -100,99 +100,29 @@ class ErrorHandlingTest < Minitest::Test
     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_raises(SyntaxError) do
       Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :strict)
     end
-    assert_equal 'Liquid syntax error: Unexpected character = in "1 =! 2"', err.message
+    assert_equal 'Unexpected character = in "1 =! 2"', err.message
 
     err = assert_raises(SyntaxError) do
       Liquid::Template.parse('{{%%%}}', :error_mode => :strict)
     end
-    assert_equal 'Liquid syntax error: Unexpected character % in "{{%%%}}"', err.message
+    assert_equal 'Unexpected character % in "{{%%%}}"', err.message
   end
 
   def test_warnings
     template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', :error_mode => :warn)
     assert_equal 3, template.warnings.size
-    assert_equal 'Unexpected character ~ in "~~~"', template.warnings[0].to_s(false)
-    assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false)
-    assert_equal 'Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false)
+    assert_equal 'Unexpected character ~ in "~~~"', template.warnings[0].message
+    assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].message
+    assert_equal 'Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message
     assert_equal '', template.render
   end
 
   def test_warning_line_numbers
     template = Liquid::Template.parse("{% if ~~~ %}\n{{%%%}}{% else %}\n{{ hello. }}{% endif %}", :error_mode => :warn, :line_numbers => true)
-    assert_equal 'Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message
-    assert_equal 'Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message
-    assert_equal 'Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message
     assert_equal 3, template.warnings.size
     assert_equal [1,2,3], template.warnings.map(&:line_number)
   end

test/integration/filter_test.rb

@@ -25,12 +25,6 @@ end
 class FiltersTest < Minitest::Test
   include Liquid
 
-  module OverrideObjectMethodFilter
-    def tap(input)
-      "tap overridden"
-    end
-  end
-
   def setup
     @context = Context.new
   end
@@ -111,13 +105,6 @@ class FiltersTest < Minitest::Test
     output = Variable.new(%! 'hello %{first_name}, %{last_name}' | substitute: first_name: surname, last_name: 'doe' !).render(@context)
     assert_equal 'hello john, doe', output
   end
-
-  def test_override_object_method_in_filter
-    assert_equal "tap overridden", Template.parse("{{var | tap}}").render!({ 'var' => 1000 }, :filters => [OverrideObjectMethodFilter])
-
-    # tap still treated as a non-existent filter
-    assert_equal "1000", Template.parse("{{var | tap}}").render!({ 'var' => 1000 })
-  end
 end
 
 class FiltersInTemplate < Minitest::Test

test/integration/parsing_quirks_test.rb

@@ -28,14 +28,11 @@ class ParsingQuirksTest < Minitest::Test
 
   def test_error_on_empty_filter
     assert Template.parse("{{test}}")
-
-    with_error_mode(:lax) do
-      assert Template.parse("{{|test}}")
-    end
-
+    assert Template.parse("{{|test}}")
     with_error_mode(:strict) do
-      assert_raises(SyntaxError) { Template.parse("{{|test}}") }
-      assert_raises(SyntaxError) { Template.parse("{{test |a|b|}}") }
+      assert_raises(SyntaxError) do
+        Template.parse("{{test |a|b|}}")
+      end
     end
   end
 
@@ -103,17 +100,4 @@ class ParsingQuirksTest < Minitest::Test
     end
   end
 
-  def test_invalid_variables_work
-    with_error_mode(:lax) do
-      assert_template_result('bar', "{% assign 123foo = 'bar' %}{{ 123foo }}")
-      assert_template_result('123', "{% assign 123 = 'bar' %}{{ 123 }}")
-    end
-  end
-
-  def test_extra_dots_in_ranges
-    with_error_mode(:lax) do
-      assert_template_result('12345', "{% for i in (1...5) %}{{ i }}{% endfor %}")
-    end
-  end
-
 end # ParsingQuirksTest

test/integration/render_profiling_test.rb

@@ -4,7 +4,7 @@ class RenderProfilingTest < Minitest::Test
   include Liquid
 
   class ProfilingFileSystem
-    def read_template_file(template_path)
+    def read_template_file(template_path, context)
       "Rendering template {% assign template_name = '#{template_path}'%}\n{{ template_name }}"
     end
   end
@@ -48,18 +48,6 @@ class RenderProfilingTest < Minitest::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!
@@ -72,7 +60,7 @@ class RenderProfilingTest < Minitest::Test
     t = Template.parse("{% include 'a_template' %}", :profile => true)
     t.render!
 
-    assert t.profiler.total_render_time >= 0, "Total render time was not calculated"
+    assert t.profiler.total_render_time > 0, "Total render time was not calculated"
   end
 
   def test_profiling_uses_include_to_mark_children
@@ -89,7 +77,7 @@ class RenderProfilingTest < Minitest::Test
 
     include_node = t.profiler[1]
     include_node.children.each do |child|
-      assert_equal "a_template", child.partial
+      assert_equal "'a_template'", child.partial
     end
   end
 
@@ -99,12 +87,12 @@ class RenderProfilingTest < Minitest::Test
 
     a_template = t.profiler[1]
     a_template.children.each do |child|
-      assert_equal "a_template", child.partial
+      assert_equal "'a_template'", child.partial
     end
 
     b_template = t.profiler[2]
     b_template.children.each do |child|
-      assert_equal "b_template", child.partial
+      assert_equal "'b_template'", child.partial
     end
   end
 
@@ -114,12 +102,12 @@ class RenderProfilingTest < Minitest::Test
 
     a_template1 = t.profiler[1]
     a_template1.children.each do |child|
-      assert_equal "a_template", child.partial
+      assert_equal "'a_template'", child.partial
     end
 
     a_template2 = t.profiler[2]
     a_template2.children.each do |child|
-      assert_equal "a_template", child.partial
+      assert_equal "'a_template'", child.partial
     end
   end
 

test/integration/standard_filter_test.rb

@@ -118,11 +118,6 @@ class StandardFiltersTest < Minitest::Test
     assert_equal '&lt;strong&gt;Hulk&lt;/strong&gt;', @filters.escape_once('&lt;strong&gt;Hulk</strong>')
   end
 
-  def test_url_encode
-    assert_equal 'foo%2B1%40example.com', @filters.url_encode('foo+1@example.com')
-    assert_equal nil, @filters.url_encode(nil)
-  end
-
   def test_truncatewords
     assert_equal 'one two three', @filters.truncatewords('one two three', 4)
     assert_equal 'one two...', @filters.truncatewords('one two three', 2)
@@ -249,7 +244,6 @@ class StandardFiltersTest < Minitest::Test
     assert_equal "07/16/2004", @filters.date("Fri Jul 16 01:00:00 2004", "%m/%d/%Y")
     assert_equal "#{Date.today.year}", @filters.date('now', '%Y')
     assert_equal "#{Date.today.year}", @filters.date('today', '%Y')
-    assert_equal "#{Date.today.year}", @filters.date('Today', '%Y')
 
     assert_equal nil, @filters.date(nil, "%B")
 
@@ -359,17 +353,6 @@ class StandardFiltersTest < Minitest::Test
     assert_template_result('bcd',"{{ a | append: b}}",assigns)
   end
 
-  def test_concat
-    assert_equal [1, 2, 3, 4], @filters.concat([1, 2], [3, 4])
-    assert_equal [1, 2, 'a'],  @filters.concat([1, 2], ['a'])
-    assert_equal [1, 2, 10],   @filters.concat([1, 2], [10])
-
-    assert_raises(TypeError) do
-      # no implicit conversion of Fixnum into Array
-      @filters.concat([1, 2], 10)
-    end
-  end
-
   def test_prepend
     assigns = {'a' => 'bc', 'b' => 'a' }
     assert_template_result('abc',"{{ a | prepend: 'a'}}",assigns)

test/integration/tags/for_tag_test.rb

@@ -298,22 +298,6 @@ HERE
                 'string' => "test string")
   end
 
-  def test_for_parentloop_references_parent_loop
-    assert_template_result('1.1 1.2 1.3 2.1 2.2 2.3 ',
-                           '{% for inner in outer %}{% for k in inner %}' +
-                           '{{ forloop.parentloop.index }}.{{ forloop.index }} ' +
-                           '{% endfor %}{% endfor %}',
-                           'outer' => [[1, 1, 1], [1, 1, 1]])
-  end
-
-  def test_for_parentloop_nil_when_not_present
-    assert_template_result('.1 .2 ',
-                           '{% for inner in outer %}' +
-                           '{{ forloop.parentloop.index }}.{{ forloop.index }} ' +
-                           '{% endfor %}',
-                           'outer' => [[1, 1, 1], [1, 1, 1]])
-  end
-
   def test_blank_string_not_iterable
     assert_template_result('', "{% for char in characters %}I WILL NOT BE OUTPUT{% endfor %}", 'characters' => '')
   end

test/integration/tags/if_else_tag_test.rb

@@ -10,11 +10,6 @@ class IfElseTagTest < Minitest::Test
     assert_template_result('  you rock ?','{% if false %} you suck {% endif %} {% if true %} you rock {% endif %}?')
   end
 
-  def test_literal_comparisons
-    assert_template_result(' NO ','{% assign v = false %}{% if v %} YES {% else %} NO {% endif %}')
-    assert_template_result(' YES ','{% assign v = nil %}{% if v == nil %} YES {% else %} NO {% endif %}')
-  end
-
   def test_if_else
     assert_template_result(' YES ','{% if false %} NO {% else %} YES {% endif %}')
     assert_template_result(' YES ','{% if true %} YES {% else %} NO {% endif %}')

test/integration/tags/include_tag_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 class TestFileSystem
-  def read_template_file(template_path)
+  def read_template_file(template_path, context)
     case template_path
     when "product"
       "Product: {{ product.title }} "
@@ -27,9 +27,6 @@ class TestFileSystem
     when "pick_a_source"
       "from TestFileSystem"
 
-    when 'assignments'
-      "{% assign foo = 'bar' %}"
-
     else
       template_path
     end
@@ -37,14 +34,14 @@ class TestFileSystem
 end
 
 class OtherFileSystem
-  def read_template_file(template_path)
+  def read_template_file(template_path, context)
     'from OtherFileSystem'
   end
 end
 
 class CountingFileSystem
   attr_reader :count
-  def read_template_file(template_path)
+  def read_template_file(template_path, context)
     @count ||= 0
     @count += 1
     'from CountingFileSystem'
@@ -111,10 +108,6 @@ class IncludeTagTest < Minitest::Test
       'echo1' => 'test123', 'more_echos' => { "echo2" => 'test321'}
   end
 
-  def test_included_templates_assigns_variables
-    assert_template_result "bar", "{% include 'assignments' %}{{ foo }}"
-  end
-
   def test_nested_include_tag
     assert_template_result "body body_detail", "{% include 'body' %}"
 
@@ -132,19 +125,31 @@ class IncludeTagTest < Minitest::Test
   def test_recursively_included_template_does_not_produce_endless_loop
 
     infinite_file_system = Class.new do
-      def read_template_file(template_path)
+      def read_template_file(template_path, context)
         "-{% include 'loop' %}"
       end
     end
 
     Liquid::Template.file_system = infinite_file_system.new
 
-    assert_raises(Liquid::StackLevelError, SystemStackError) do
+    assert_raises(Liquid::StackLevelError) do
       Template.parse("{% include 'loop' %}").render!
     end
 
   end
 
+  def test_backwards_compatability_support_for_overridden_read_template_file
+    infinite_file_system = Class.new do
+      def read_template_file(template_path) # testing only one argument here.
+        "- hi mom"
+      end
+    end
+
+    Liquid::Template.file_system = infinite_file_system.new
+
+    Template.parse("{% include 'hi_mom' %}").render!
+  end
+
   def test_dynamically_choosen_template
     assert_template_result "Test123", "{% include template %}", "template" => 'Test123'
     assert_template_result "Test321", "{% include template %}", "template" => 'Test321'
@@ -204,19 +209,4 @@ class IncludeTagTest < Minitest::Test
     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/template_test.rb

@@ -1,5 +1,4 @@
 require 'test_helper'
-require 'timeout'
 
 class TemplateContextDrop < Liquid::Drop
   def before_method(method)
@@ -38,16 +37,6 @@ class TemplateTest < Minitest::Test
     assert_equal 'from instance assigns', t.parse("{{ foo }}").render!
   end
 
-  def test_warnings_is_not_exponential_time
-    str = "false"
-    100.times do
-      str = "{% if true %}true{% else %}#{str}{% endif %}"
-    end
-
-    t = Template.parse(str)
-    assert_equal [], Timeout::timeout(1) { t.warnings }
-  end
-
   def test_instance_assigns_persist_on_same_template_parsing_between_renders
     t = Template.new.parse("{{ foo }}{% assign foo = 'foo' %}{{ foo }}")
     assert_equal 'foo', t.render!
@@ -93,92 +82,57 @@ class TemplateTest < Minitest::Test
 
   def test_resource_limits_works_with_custom_length_method
     t = Template.parse("{% assign foo = bar %}")
-    t.resource_limits.render_length_limit = 42
+    t.resource_limits = { :render_length_limit => 42 }
     assert_equal "", t.render!("bar" => SomethingWithLength.new)
   end
 
   def test_resource_limits_render_length
     t = Template.parse("0123456789")
-    t.resource_limits.render_length_limit = 5
+    t.resource_limits = { :render_length_limit => 5 }
     assert_equal "Liquid error: Memory limits exceeded", t.render()
-    assert t.resource_limits.reached?
-
-    t.resource_limits.render_length_limit = 10
+    assert t.resource_limits[:reached]
+    t.resource_limits = { :render_length_limit => 10 }
     assert_equal "0123456789", t.render!()
-    refute_nil t.resource_limits.render_length
+    refute_nil t.resource_limits[:render_length_current]
   end
 
   def test_resource_limits_render_score
     t = Template.parse("{% for a in (1..10) %} {% for a in (1..10) %} foo {% endfor %} {% endfor %}")
-    t.resource_limits.render_score_limit = 50
+    t.resource_limits = { :render_score_limit => 50 }
     assert_equal "Liquid error: Memory limits exceeded", t.render()
-    assert t.resource_limits.reached?
-
+    assert t.resource_limits[:reached]
     t = Template.parse("{% for a in (1..100) %} foo {% endfor %}")
-    t.resource_limits.render_score_limit = 50
+    t.resource_limits = { :render_score_limit => 50 }
     assert_equal "Liquid error: Memory limits exceeded", t.render()
-    assert t.resource_limits.reached?
-
-    t.resource_limits.render_score_limit = 200
+    assert t.resource_limits[:reached]
+    t.resource_limits = { :render_score_limit => 200 }
     assert_equal (" foo " * 100), t.render!()
-    refute_nil t.resource_limits.render_score
+    refute_nil t.resource_limits[:render_score_current]
   end
 
   def test_resource_limits_assign_score
     t = Template.parse("{% assign foo = 42 %}{% assign bar = 23 %}")
-    t.resource_limits.assign_score_limit = 1
+    t.resource_limits = { :assign_score_limit => 1 }
     assert_equal "Liquid error: Memory limits exceeded", t.render()
-    assert t.resource_limits.reached?
-
-    t.resource_limits.assign_score_limit = 2
+    assert t.resource_limits[:reached]
+    t.resource_limits = { :assign_score_limit => 2 }
     assert_equal "", t.render!()
-    refute_nil t.resource_limits.assign_score
+    refute_nil t.resource_limits[:assign_score_current]
   end
 
   def test_resource_limits_aborts_rendering_after_first_error
     t = Template.parse("{% for a in (1..100) %} foo1 {% endfor %} bar {% for a in (1..100) %} foo2 {% endfor %}")
-    t.resource_limits.render_score_limit = 50
+    t.resource_limits = { :render_score_limit => 50 }
     assert_equal "Liquid error: Memory limits exceeded", t.render()
-    assert t.resource_limits.reached?
+    assert t.resource_limits[:reached]
   end
 
   def test_resource_limits_hash_in_template_gets_updated_even_if_no_limits_are_set
     t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
     t.render!()
-    assert t.resource_limits.assign_score > 0
-    assert t.resource_limits.render_score > 0
-    assert t.resource_limits.render_length > 0
-  end
-
-  def test_render_length_persists_between_blocks
-    t = Template.parse("{% if true %}aaaa{% endif %}")
-    t.resource_limits.render_length_limit = 7
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
-    t.resource_limits.render_length_limit = 8
-    assert_equal "aaaa", t.render()
-
-    t = Template.parse("{% if true %}aaaa{% endif %}{% if true %}bbb{% endif %}")
-    t.resource_limits.render_length_limit = 13
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
-    t.resource_limits.render_length_limit = 14
-    assert_equal "aaaabbb", t.render()
-
-    t = Template.parse("{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}")
-    t.resource_limits.render_length_limit = 5
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
-    t.resource_limits.render_length_limit = 11
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
-    t.resource_limits.render_length_limit = 12
-    assert_equal "ababab", t.render()
-  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 > 0
-    assert context.resource_limits.render_score > 0
-    assert context.resource_limits.render_length > 0
+    assert t.resource_limits[:assign_score_current] > 0
+    assert t.resource_limits[:render_score_current] > 0
+    assert t.resource_limits[:render_length_current] > 0
   end
 
   def test_can_use_drop_as_context

test/integration/variable_test.rb

@@ -31,12 +31,6 @@ class VariableTest < Minitest::Test
 
   def test_false_renders_as_false
     assert_equal 'false', Template.parse("{{ foo }}").render!('foo' => false)
-    assert_equal 'false', Template.parse("{{ false }}").render!
-  end
-
-  def test_nil_renders_as_empty_string
-    assert_equal '', Template.parse("{{ nil }}").render!
-    assert_equal 'cat', Template.parse("{{ nil | append: 'cat' }}").render!
   end
 
   def test_preset_assigns

test/test_helper.rb

@@ -1,12 +1,10 @@
 #!/usr/bin/env ruby
 
-ENV["MT_NO_EXPECTATIONS"] = "1"
 require 'minitest/autorun'
 require 'spy/integration'
 
 $:.unshift(File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib'))
 require 'liquid.rb'
-require 'liquid/profiler'
 
 mode = :strict
 if env_mode = ENV['LIQUID_PARSER_MODE']
@@ -50,27 +48,13 @@ module Minitest
     end
 
     def with_global_filter(*globals)
-      original_global_strainer = Liquid::Strainer.class_variable_get(:@@global_strainer)
-      Liquid::Strainer.class_variable_set(:@@global_strainer, Class.new(Liquid::Strainer) do
-        @filter_methods = Set.new
-      end)
-      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
-
+      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_get(:@@strainer_class_cache).clear
-      Liquid::Strainer.class_variable_set(:@@global_strainer, original_global_strainer)
-    end
-
-    def with_taint_mode(mode)
-      old_mode = Liquid::Template.taint_mode
-      Liquid::Template.taint_mode = mode
-      yield
-    ensure
-      Liquid::Template.taint_mode = old_mode
+      Liquid::Strainer.class_variable_set(:@@filters, original_filters)
     end
 
     def with_error_mode(mode)

test/unit/condition_unit_test.rb

@@ -4,111 +4,106 @@ 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_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"
+    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"'
   end
 
   def test_contains_returns_false_for_nil_operands
     @context = Liquid::Context.new
-    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
+    assert_evalutes_false "not_assigned", 'contains', '0'
+    assert_evalutes_false "0", 'contains', 'not_assigned'
   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
@@ -116,17 +111,18 @@ class ConditionUnitTest < Minitest::Test
   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 VariableLookup.new("one"), '==', VariableLookup.new("another")
+    assert_evalutes_true "one", '==', "another"
   end
 
   private

test/unit/context_unit_test.rb

@@ -465,11 +465,20 @@ class ContextUnitTest < Minitest::Test
     mock_empty = Spy.on_instance_method(Array, :empty?)
     mock_has_interrupt = Spy.on(@context, :has_interrupt?).and_call_through
 
-    @context.push_interrupt(StandardError.new)
     @context.has_interrupt?
 
     refute mock_any.has_been_called?
     assert mock_empty.has_been_called?
+  end 
+
+  def test_variable_lookup_caches_markup
+    mock_scan = Spy.on_instance_method(String, :scan).and_return(["string"])
+
+    @context['string'] = 'string'
+    @context['string']
+    @context['string']
+
+    assert_equal 1, mock_scan.calls.size
   end
 
   def test_context_initialization_with_a_proc_in_environment

test/unit/file_system_unit_test.rb

@@ -5,7 +5,7 @@ class FileSystemUnitTest < Minitest::Test
 
   def test_default
     assert_raises(FileSystemError) do
-      BlankFileSystem.new.read_template_file("dummy")
+      BlankFileSystem.new.read_template_file("dummy", {'dummy'=>'smarty'})
     end
   end
 

test/unit/lexer_unit_test.rb

@@ -31,11 +31,8 @@ class LexerUnitTest < Minitest::Test
   end
 
   def test_fancy_identifiers
-    tokens = Lexer.new('hi five?').tokenize
-    assert_equal [[:id, 'hi'], [:id, 'five?'], [:end_of_string]], tokens
-
-    tokens = Lexer.new('2foo').tokenize
-    assert_equal [[:number, '2'], [:id, 'foo'], [:end_of_string]], tokens
+    tokens = Lexer.new('hi! five?').tokenize
+    assert_equal [[:id,'hi!'], [:id, 'five?'], [:end_of_string]], tokens
   end
 
   def test_whitespace

test/unit/parser_unit_test.rb

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

test/unit/strainer_unit_test.rb

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

test/unit/tags/case_tag_unit_test.rb

@@ -5,6 +5,6 @@ class CaseTagUnitTest < Minitest::Test
 
   def test_case_nodelist
     template = Liquid::Template.parse('{% case var %}{% when true %}WHEN{% else %}ELSE{% endcase %}')
-    assert_equal ['WHEN', 'ELSE'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten
+    assert_equal ['WHEN', 'ELSE'], template.root.nodelist[0].nodelist
   end
 end

test/unit/tags/for_tag_unit_test.rb

@@ -3,11 +3,11 @@ require 'test_helper'
 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.map(&:nodelist).flatten
+    assert_equal ['FOR'], template.root.nodelist[0].nodelist
   end
 
   def test_for_else_nodelist
     template = Liquid::Template.parse('{% for item in items %}FOR{% else %}ELSE{% endfor %}')
-    assert_equal ['FOR', 'ELSE'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten
+    assert_equal ['FOR', 'ELSE'], template.root.nodelist[0].nodelist
   end
 end

test/unit/tags/if_tag_unit_test.rb

@@ -3,6 +3,6 @@ require 'test_helper'
 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.map(&:nodelist).flatten
+    assert_equal ['IF', 'ELSE'], template.root.nodelist[0].nodelist
   end
 end

test/unit/template_unit_test.rb

@@ -5,17 +5,16 @@ class TemplateUnitTest < Minitest::Test
 
   def test_sets_default_localization_in_document
     t = Template.new
-    t.parse('{%comment%}{%endcomment%}')
-    assert_instance_of I18n, t.root.nodelist[0].options[:locale]
+    t.parse('')
+    assert_instance_of I18n, t.root.options[:locale]
   end
 
   def test_sets_default_localization_in_context_with_quick_initialization
     t = Template.new
-    t.parse('{%comment%}{%endcomment%}', :locale => I18n.new(fixture("en_locale.yml")))
+    t.parse('{{foo}}', :locale => I18n.new(fixture("en_locale.yml")))
 
-    locale = t.root.nodelist[0].options[:locale]
-    assert_instance_of I18n, locale
-    assert_equal fixture("en_locale.yml"), locale.path
+    assert_instance_of I18n, t.root.options[:locale]
+    assert_equal fixture("en_locale.yml"), t.root.options[:locale].path
   end
 
   def test_with_cache_classes_tags_returns_the_same_class

test/unit/variable_unit_test.rb

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