liquid 2.6.3 → 3.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 556c422717dbe398a9c414ac93d2d7fa6cf824d9
-  data.tar.gz: 1b63c67741c2e9c1bb0fa61c0e84856ecd17a6a7
+  metadata.gz: f98aa57f8713db177b94a4cd217b6c5f40234bc5
+  data.tar.gz: 50a9905b550fcedf21315f4764360f104d0964bb
 SHA512:
-  metadata.gz: fefb1fb53e150321193372e6f75dac1b860454a214a16a3cdb526e13d524b00761d50450b986b0ddab7297d253e2db46025e3a23144362b188a974834adfd08d
-  data.tar.gz: 8e1449c8d9923df9ca9ea64c52848725106d84b39e16311fee5c7a8e006f9b8c78f663efa2574f15d1f32c6bfe7acb1001ac79881fe87435dbd273f5ea7eb213
+  metadata.gz: 7c9c6d8d006ef94568651f21dba6d4619cef50c575510e74159602140263a10f20148b4c278c17aa77221690e7dedb547aedf4af5fc866b1c3ab4644243b8d68
+  data.tar.gz: ff19880456ff443065ed50371ad4223fedcf350494564ba69e51c9c2c4e06281ffc54773e9f0cbae60fbee95a60be4514f13924b0d831db43a41fcabadab1a8c

data/History.md

@@ -1,17 +1,38 @@
 # Liquid Version History
 
-IMPORTANT: Liquid 2.6 is going to be the last version of Liquid which maintains explicit Ruby 1.8 compatability.
-The following releases will only be tested against Ruby 1.9 and Ruby 2.0 and are likely to break on Ruby 1.8.
-
-## 2.6.3 / 2015-07-23 / branch "2-6-stable"
-
-* Fix test failure under certain timezones [Dylan Thacker-Smith]
-
-## 2.6.2 / 2015-01-23
+## 3.0.0 / not yet released / branch "master"
 
-* Remove duplicate hash key [Parker Moore]
-
-## 2.6.1 / 2014-01-10
+* ...
+* Add exception_handler feature, see #397 and #254 [Bogdan Gusiev, bogdan and Florian Weingarten, fw42]
+* Optimize variable parsing to avoid repeated regex evaluation during template rendering #383 [Jason Hiltz-Laforge, jasonhl]
+* Optimize checking for block interrupts to reduce object allocation #380 [Jason Hiltz-Laforge, jasonhl] 
+* Properly set context rethrow_errors on render! #349 [Thierry Joyal, tjoyal]
+* Fix broken rendering of variables which are equal to false, see #345 [Florian Weingarten, fw42]
+* Remove ActionView template handler [Dylan Thacker-Smith, dylanahsmith]
+* 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, 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, 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, see #273 [Bouke van der Bijl, bouk]
@@ -19,7 +40,9 @@ Security fix, cherry-picked from master (4e14a65):
 
 ## 2.6.0 / 2013-11-25
 
-* ...
+IMPORTANT: Liquid 2.6 is going to be the last version of Liquid which maintains explicit Ruby 1.8 compatability.
+The following releases will only be tested against Ruby 1.9 and Ruby 2.0 and are likely to break on Ruby 1.8.
+
 * Bugfix for #106: fix example servlet [gnowoel]
 * Bugfix for #97: strip_html filter supports multi-line tags [Jo Liss, joliss]
 * Bugfix for #114: strip_html filter supports style tags [James Allardice, jamesallardice]
@@ -39,7 +62,13 @@ Security fix, cherry-picked from master (4e14a65):
 * Better documentation for 'include' tag (closes #163) [Peter Schröder, phoet]
 * Use of BigDecimal on filters to have better precision (closes #155) [Arthur Nogueira Neves, arthurnn]
 
-## 2.5.4 / 2013-11-11 / branch "2.5-stable"
+## 2.5.5 / 2014-01-10 / branch "2-5-stable"
+
+Security fix, cherry-picked from master (4e14a65):
+* Don't call to_sym when creating conditions for security reasons, see #273 [Bouke van der Bijl, bouk]
+* Prevent arbitrary method invocation on condition objects, see #274 [Dylan Thacker-Smith, dylanahsmith]
+
+## 2.5.4 / 2013-11-11
 
 * Fix "can't convert Fixnum into String" for "replace", see #173, [wǒ_is神仙, jsw0528]
 

data/README.md

@@ -1,9 +1,12 @@
+[![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
 
 * [Contributing guidelines](CONTRIBUTING.md)
 * [Version history](History.md)
 * [Liquid documentation from Shopify](http://docs.shopify.com/themes/liquid-basics)
-* [Liquid Wiki from Shopify](http://wiki.shopify.com/Liquid)
+* [Liquid Wiki at GitHub](https://github.com/Shopify/liquid/wiki)
 * [Website](http://liquidmarkup.org/)
 
 ## Introduction
@@ -47,4 +50,26 @@ For standard use you can just pass it the content of a file and call render with
 @template.render('name' => 'tobi')                # => "hi tobi"
 ```
 
-[![Build Status](https://secure.travis-ci.org/Shopify/liquid.png)](http://travis-ci.org/Shopify/liquid)
+### Error Modes
+
+Setting the error mode of Liquid lets you specify how strictly you want your templates to be interpreted.
+Normally the parser is very lax and will accept almost anything without error. Unfortunately this can make
+it very hard to debug and can lead to unexpected behaviour. 
+
+Liquid also comes with a stricter parser that can be used when editing templates to give better error messages
+when templates are invalid. You can enable this new parser like this:
+
+```ruby
+Liquid::Template.error_mode = :strict # Raises a SyntaxError when invalid syntax is used
+Liquid::Template.error_mode = :warn # Adds errors to template.errors but continues as normal
+Liquid::Template.error_mode = :lax # The default mode, accepts almost anything.
+```
+
+If you want to set the error mode only on specific templates you can pass `:error_mode` as an option to `parse`:
+```ruby
+Liquid::Template.parse(source, :error_mode => :strict)
+```
+This is useful for doing things like enabling strict mode only in the theme editor.
+
+It is recommended that you enable `:strict` or `:warn` mode on new apps to stop invalid templates from being created.
+It is also recommended that you use it in the template editors of existing apps to give editors better error messages.

data/lib/liquid.rb

@@ -21,9 +21,9 @@
 
 module Liquid
   FilterSeparator             = /\|/
-  ArgumentSeparator           = ','
-  FilterArgumentSeparator     = ':'
-  VariableAttributeSeparator  = '.'
+  ArgumentSeparator           = ','.freeze
+  FilterArgumentSeparator     = ':'.freeze
+  VariableAttributeSeparator  = '.'.freeze
   TagStart                    = /\{\%/
   TagEnd                      = /\%\}/
   VariableSignature           = /\(?[\w\-\.\[\]]\)?/
@@ -33,19 +33,20 @@ module Liquid
   VariableIncompleteEnd       = /\}\}?/
   QuotedString                = /"[^"]*"|'[^']*'/
   QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
-  StrictQuotedFragment        = /"[^"]+"|'[^']+'|[^\s|:,]+/
-  FirstFilterArgument         = /#{FilterArgumentSeparator}(?:#{StrictQuotedFragment})/o
-  OtherFilterArgument         = /#{ArgumentSeparator}(?:#{StrictQuotedFragment})/o
-  SpacelessFilter             = /^(?:'[^']+'|"[^"]+"|[^'"])*#{FilterSeparator}(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?/o
-  Expression                  = /(?:#{QuotedFragment}(?:#{SpacelessFilter})*)/o
   TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
   AnyStartingTag              = /\{\{|\{\%/
-  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/o
-  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/o
+  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
+  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
   VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
+
+  singleton_class.send(:attr_accessor, :cache_classes)
+  self.cache_classes = true
 end
 
 require "liquid/version"
+require 'liquid/lexer'
+require 'liquid/parser'
+require 'liquid/i18n'
 require 'liquid/drop'
 require 'liquid/extensions'
 require 'liquid/errors'
@@ -58,7 +59,6 @@ require 'liquid/document'
 require 'liquid/variable'
 require 'liquid/file_system'
 require 'liquid/template'
-require 'liquid/htmltags'
 require 'liquid/standardfilters'
 require 'liquid/condition'
 require 'liquid/module_ex'

data/lib/liquid/block.rb

@@ -1,45 +1,58 @@
 module Liquid
-
   class Block < Tag
-    IsTag             = /^#{TagStart}/o
-    IsVariable        = /^#{VariableStart}/o
-    FullToken         = /^#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}$/o
-    ContentOfVariable = /^#{VariableStart}(.*)#{VariableEnd}$/o
+    FullToken         = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
+    ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
+    TAGSTART = "{%".freeze
+    VARSTART = "{{".freeze
+
+    def blank?
+      @blank
+    end
 
     def parse(tokens)
+      @blank = true
       @nodelist ||= []
       @nodelist.clear
 
-      while token = tokens.shift
-
-        case token
-        when IsTag
-          if token =~ FullToken
+      # All child tags of the current block.
+      @children = []
 
-            # 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]
-              @nodelist << tag.new($1, $2, tokens)
+      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]
+                new_tag = tag.parse($1, $2, tokens, @options)
+                @blank &&= new_tag.blank?
+                @nodelist << new_tag
+                @children << new_tag
+              else
+                # this tag is not registered with the system
+                # pass it to the current block for special handling or error reporting
+                unknown_tag($1, $2, tokens)
+              end
             else
-              # this tag is not registered with the system
-              # pass it to the current block for special handling or error reporting
-              unknown_tag($1, $2, tokens)
+              raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination".freeze, :token => token, :tag_end => TagEnd.inspect))
             end
+          when token.start_with?(VARSTART)
+            new_var = create_variable(token)
+            @nodelist << new_var
+            @children << new_var
+            @blank = false
           else
-            raise SyntaxError, "Tag '#{token}' was not properly terminated with regexp: #{TagEnd.inspect} "
+            @nodelist << token
+            @blank &&= (token =~ /\A\s*\z/)
           end
-        when IsVariable
-          @nodelist << create_variable(token)
-        when ''
-          # pass
-        else
-          @nodelist << token
         end
       end
 
@@ -49,33 +62,48 @@ module Liquid
       assert_missing_delimitation!
     end
 
+    # warnings of this block and all sub-tags
+    def warnings
+      all_warnings = []
+      all_warnings.concat(@warnings) if @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'
-        raise SyntaxError, "#{block_name} tag does not expect else tag"
-      when 'end'
-        raise SyntaxError, "'end' is not a valid delimiter for #{block_name} tags. use #{block_delimiter}"
+      when 'else'.freeze
+        raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_else".freeze,
+                                                 :block_name => block_name))
+      when 'end'.freeze
+        raise SyntaxError.new(options[:locale].t("errors.syntax.invalid_delimiter".freeze,
+                                                 :block_name => block_name,
+                                                 :block_delimiter => block_delimiter))
       else
-        raise SyntaxError, "Unknown tag '#{tag}'"
+        raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag".freeze, :tag => tag))
       end
     end
 
-    def block_delimiter
-      "end#{block_name}"
-    end
-
     def block_name
       @tag_name
     end
 
+    def block_delimiter
+      @block_delimiter ||= "end#{block_name}"
+    end
+
     def create_variable(token)
       token.scan(ContentOfVariable) do |content|
-        return Variable.new(content.first)
+        return Variable.new(content.first, @options)
       end
-      raise SyntaxError.new("Variable '#{token}' was not properly terminated with regexp: #{VariableEnd.inspect} ")
+      raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination".freeze, :token => token, :tag_end => VariableEnd.inspect))
     end
 
     def render(context)
@@ -85,7 +113,7 @@ module Liquid
     protected
 
     def assert_missing_delimitation!
-      raise SyntaxError.new("#{block_name} tag was never closed")
+      raise SyntaxError.new(options[:locale].t("errors.syntax.tag_never_closed".freeze, :block_name => block_name))
     end
 
     def render_all(list, context)
@@ -107,12 +135,14 @@ module Liquid
           end
 
           token_output = (token.respond_to?(:render) ? token.render(context) : token)
-          context.resource_limits[:render_length_current] += (token_output.respond_to?(:length) ? token_output.length : 1)
+          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")
+            raise MemoryError.new("Memory limits exceeded".freeze)
+          end
+          unless token.is_a?(Block) && token.blank?
+            output << token_output
           end
-          output << token_output
         rescue MemoryError => e
           raise e
         rescue ::StandardError => e

data/lib/liquid/condition.rb

@@ -8,14 +8,14 @@ module Liquid
   #
   class Condition #:nodoc:
     @@operators = {
-      '==' => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
-      '!=' => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<>' => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<'  => :<,
-      '>'  => :>,
-      '>=' => :>=,
-      '<=' => :<=,
-      'contains' => lambda { |cond, left, right| left && right ? left.include?(right) : false }
+      '=='.freeze => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
+      '!='.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
+      '<>'.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
+      '<'.freeze  => :<,
+      '>'.freeze  => :>,
+      '>='.freeze => :>=,
+      '<='.freeze => :<=,
+      'contains'.freeze => lambda { |cond, left, right| left && right ? left.include?(right) : false }
     }
 
     def self.operators
@@ -61,7 +61,7 @@ module Liquid
     end
 
     def inspect
-      "#<Condition #{[@left, @operator, @right].compact.join(' ')}>"
+      "#<Condition #{[@left, @operator, @right].compact.join(' '.freeze)}>"
     end
 
     private
@@ -94,12 +94,16 @@ module Liquid
 
       left, right = context[left], context[right]
 
-      operation = self.class.operators[op] || raise(ArgumentError.new("Unknown operator #{op}"))
+      operation = self.class.operators[op] || raise(Liquid::ArgumentError.new("Unknown operator #{op}"))
 
       if operation.respond_to?(:call)
         operation.call(self, left, right)
       elsif left.respond_to?(operation) and right.respond_to?(operation)
-        left.send(operation, right)
+        begin
+          left.send(operation, right)
+        rescue ::ArgumentError => e
+          raise Liquid::ArgumentError.new(e.message)
+        end
       else
         nil
       end

data/lib/liquid/context.rb

@@ -14,17 +14,33 @@ module Liquid
   #   context['bob']  #=> nil  class Context
   class Context
     attr_reader :scopes, :errors, :registers, :environments, :resource_limits
+    attr_accessor :exception_handler
+
+    SQUARE_BRACKETED = /\A\[(.*)\]\z/m
 
     def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = {})
       @environments    = [environments].flatten
       @scopes          = [(outer_scope || {})]
       @registers       = registers
       @errors          = []
-      @rethrow_errors  = rethrow_errors
       @resource_limits = (resource_limits || {}).merge!({ :render_score_current => 0, :assign_score_current => 0 })
       squash_instance_assigns_with_environments
 
+      if rethrow_errors
+        self.exception_handler = ->(e) { true }
+      end
+
       @interrupts = []
+      @filters = []
+      @parsed_variables = Hash.new{ |cache, markup| cache[markup] = variable_parse(markup) } 
+    end
+
+    def increment_used_resources(key, obj)
+      @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?
@@ -34,7 +50,7 @@ module Liquid
     end
 
     def strainer
-      @strainer ||= Strainer.create(self)
+      @strainer ||= Strainer.create(self, @filters)
     end
 
     # Adds filters to this context.
@@ -43,17 +59,26 @@ module Liquid
     # for that
     def add_filters(filters)
       filters = [filters].flatten.compact
-
       filters.each do |f|
         raise ArgumentError, "Expected module but got: #{f.class}" unless f.is_a?(Module)
         Strainer.add_known_filter(f)
-        strainer.extend(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.any?
+      !@interrupts.empty?
     end
 
     # push an interrupt to the stack. this interrupt is considered not handled.
@@ -68,7 +93,8 @@ module Liquid
 
     def handle_error(e)
       errors.push(e)
-      raise if @rethrow_errors
+
+      raise if exception_handler && exception_handler.call(e)
 
       case e
       when SyntaxError
@@ -85,7 +111,7 @@ module Liquid
     # Push new local scope on the stack. use <tt>Context#stack</tt> instead
     def push(new_scope={})
       @scopes.unshift(new_scope)
-      raise StackLevelError, "Nesting too deep" if @scopes.length > 100
+      raise StackLevelError, "Nesting too deep".freeze if @scopes.length > 100
     end
 
     # Merge a hash of variables in the current local scope
@@ -133,11 +159,11 @@ module Liquid
 
     private
       LITERALS = {
-        nil => nil, 'nil' => nil, 'null' => nil, '' => nil,
-        'true'  => true,
-        'false' => false,
-        'blank' => :blank?,
-        'empty' => :empty?
+        nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
+        'true'.freeze  => true,
+        'false'.freeze => false,
+        'blank'.freeze => :blank?,
+        'empty'.freeze => :empty?
       }
 
       # Look up variable, either resolve directly after considering the name. We can directly handle
@@ -153,15 +179,15 @@ module Liquid
           LITERALS[key]
         else
           case key
-          when /^'(.*)'$/ # Single quoted strings
+          when /\A'(.*)'\z/m # Single quoted strings
             $1
-          when /^"(.*)"$/ # Double quoted strings
+          when /\A"(.*)"\z/m # Double quoted strings
             $1
-          when /^(-?\d+)$/ # Integer and floats
+          when /\A(-?\d+)\z/ # Integer and floats
             $1.to_i
-          when /^\((\S+)\.\.(\S+)\)$/ # Ranges
+          when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
             (resolve($1).to_i..resolve($2).to_i)
-          when /^(-?\d[\d\.]+)$/ # Floats
+          when /\A(-?\d[\d\.]+)\z/ # Floats
             $1.to_f
           else
             variable(key)
@@ -171,12 +197,18 @@ module Liquid
 
       # Fetches an object starting at the local scope and then moving up the hierachy
       def find_variable(key)
-        scope = @scopes.find { |s| s.has_key?(key) }
+
+        # This was changed from find() to find_index() because this is a very hot
+        # path and find_index() is optimized in MRI to reduce object allocation
+        index = @scopes.find_index { |s| s.has_key?(key) }
+        scope = @scopes[index] if index
+
         variable = nil
 
         if scope.nil?
           @environments.each do |e|
-            if variable = lookup_and_evaluate(e, key)
+            variable = lookup_and_evaluate(e, key)
+            unless variable.nil?
               scope = e
               break
             end
@@ -192,6 +224,16 @@ module Liquid
         return variable
       end
 
+      def variable_parse(markup)
+        parts = markup.scan(VariableParser)
+        needs_resolution = false
+        if parts.first =~ SQUARE_BRACKETED 
+          needs_resolution = true
+          parts[0] = $1
+        end
+        {:first => parts.shift, :needs_resolution => needs_resolution, :rest => parts} 
+      end
+
       # Resolves namespaced queries gracefully.
       #
       # Example
@@ -199,19 +241,17 @@ module Liquid
       #  assert_equal 'tobi', @context['hash.name']
       #  assert_equal 'tobi', @context['hash["name"]']
       def variable(markup)
-        parts = markup.scan(VariableParser)
-        square_bracketed = /^\[(.*)\]$/
+        parts = @parsed_variables[markup]
 
-        first_part = parts.shift
-
-        if first_part =~ square_bracketed
-          first_part = resolve($1)
+        first_part = parts[:first] 
+        if parts[:needs_resolution]
+          first_part = resolve(parts[:first])
         end
 
         if object = find_variable(first_part)
 
-          parts.each do |part|
-            part = resolve($1) if part_resolved = (part =~ square_bracketed)
+          parts[:rest].each do |part|
+            part = resolve($1) if part_resolved = (part =~ SQUARE_BRACKETED)
 
             # If object is a hash- or array-like object we look for the
             # presence of the key and if its available we return it
@@ -226,7 +266,7 @@ module Liquid
               # Some special cases. If the part wasn't in square brackets and
               # no key with the same name was found we interpret following calls
               # as commands and call them on the current object
-            elsif !part_resolved and object.respond_to?(part) and ['size', 'first', 'last'].include?(part)
+            elsif !part_resolved and object.respond_to?(part) and ['size'.freeze, 'first'.freeze, 'last'.freeze].include?(part)
 
               object = object.send(part.intern).to_liquid
 
@@ -263,5 +303,4 @@ module Liquid
         end
       end # squash_instance_assigns_with_environments
   end # Context
-
 end # Liquid