liquid 2.1.3 → 2.2.0

data/Rakefile

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+$:.unshift File.join(File.dirname(__FILE__), 'test') unless $:.include? File.join(File.dirname(__FILE__), 'test')
+
 require 'rubygems'
 require 'rake'
 require 'rake/testtask'
@@ -7,9 +9,8 @@ require 'rake/gempackagetask'
 task :default => 'test'
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << "lib"
-  t.libs << "test"
-  t.pattern = 'test/*_test.rb'
+  t.libs << '.' << 'lib' << 'test'
+  t.pattern = 'test/lib/**/*_test.rb'
   t.verbose = false
 end
 
@@ -25,20 +26,18 @@ end
 
 namespace :profile do
 
-  
   task :default => [:run]
-  
+
   desc "Run the liquid profile/perforamce coverage"
   task :run do
-  
+
     ruby "performance/shopify.rb"
-  
+
   end
-  
-  desc "Run KCacheGrind" 
+
+  desc "Run KCacheGrind"
   task :grind => :run  do
     system "kcachegrind /tmp/liquid.rubyprof_calltreeprinter.txt"
   end
+
 end
-  
-  

data/lib/liquid.rb

@@ -38,7 +38,7 @@ module Liquid
   StrictQuotedFragment        = /"[^"]+"|'[^']+'|[^\s,\|,\:,\,]+/
   FirstFilterArgument         = /#{FilterArgumentSeparator}(?:#{StrictQuotedFragment})/
   OtherFilterArgument         = /#{ArgumentSeparator}(?:#{StrictQuotedFragment})/
-  SpacelessFilter             = /#{FilterSeparator}(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?/
+  SpacelessFilter             = /^(?:'[^']+'|"[^"]+"|[^'"])*#{FilterSeparator}(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?/
   Expression                  = /(?:#{QuotedFragment}(?:#{SpacelessFilter})*)/
   TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/
   AnyStartingTag              = /\{\{|\{\%/

data/lib/liquid/context.rb

@@ -28,8 +28,9 @@ module Liquid
       @strainer ||= Strainer.create(self)
     end
 
-    # adds filters to this context.
-    # this does not register the filters with the main Template object. see <tt>Template.register_filter</tt>
+    # Adds filters to this context.
+    #
+    # Note that this does not register the filters with the main Template object. see <tt>Template.register_filter</tt>
     # for that
     def add_filters(filters)
       filters = [filters].flatten.compact
@@ -52,7 +53,6 @@ module Liquid
       end
     end
 
-
     def invoke(method, *args)
       if strainer.respond_to?(method)
         strainer.__send__(method, *args)
@@ -61,43 +61,44 @@ module Liquid
       end
     end
 
-    # push new local scope on the stack. use <tt>Context#stack</tt> instead
+    # Push new local scope on the stack. use <tt>Context#stack</tt> instead
     def push(new_scope={})
       raise StackLevelError, "Nesting too deep" if @scopes.length > 100
       @scopes.unshift(new_scope)
     end
 
-    # merge a hash of variables in the current local scope
+    # Merge a hash of variables in the current local scope
     def merge(new_scopes)
       @scopes[0].merge!(new_scopes)
     end
 
-    # pop from the stack. use <tt>Context#stack</tt> instead
+    # Pop from the stack. use <tt>Context#stack</tt> instead
     def pop
       raise ContextError if @scopes.size == 1
       @scopes.shift
     end
 
-    # pushes a new local scope on the stack, pops it at the end of the block
+    # Pushes a new local scope on the stack, pops it at the end of the block
     #
     # Example:
-    #
     #   context.stack do
     #      context['var'] = 'hi'
     #   end
-    #   context['var]  #=> nil
     #
+    #   context['var]  #=> nil
     def stack(new_scope={},&block)
       result = nil
       push(new_scope)
+
       begin
         result = yield
       ensure
         pop
       end
+
       result
     end
-    
+
     def clear_instance_assigns
       @scopes[0] = {}
     end
@@ -116,139 +117,133 @@ module Liquid
     end
 
     private
-
-    # Look up variable, either resolve directly after considering the name. We can directly handle
-    # Strings, digits, floats and booleans (true,false). If no match is made we lookup the variable in the current scope and
-    # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
-    # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
-    #
-    # Example:
-    #
-    #   products == empty #=> products.empty?
-    #
-    def resolve(key)
-      case key
-      when nil, 'nil', 'null', ''
-        nil
-      when 'true'
-        true
-      when 'false'
-        false
-      when 'blank'
-        :blank?
-      when 'empty'
-        :empty?
-      # Single quoted strings
-      when /^'(.*)'$/
-        $1.to_s
-      # Double quoted strings
-      when /^"(.*)"$/
-        $1.to_s
-      # Integer and floats
-      when /^(\d+)$/
-        $1.to_i
-      # Ranges
-      when /^\((\S+)\.\.(\S+)\)$/
-        (resolve($1).to_i..resolve($2).to_i)
-      # Floats
-      when /^(\d[\d\.]+)$/
-        $1.to_f
-      else
-        variable(key)
+      # Look up variable, either resolve directly after considering the name. We can directly handle
+      # Strings, digits, floats and booleans (true,false).
+      # If no match is made we lookup the variable in the current scope and
+      # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
+      # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
+      #
+      # Example:
+      #   products == empty #=> products.empty?
+      def resolve(key)
+        case key
+        when nil, 'nil', 'null', ''
+          nil
+        when 'true'
+          true
+        when 'false'
+          false
+        when 'blank'
+          :blank?
+        when 'empty' # Single quoted strings
+          :empty?
+        when /^'(.*)'$/ # Double quoted strings
+          $1.to_s
+        when /^"(.*)"$/ # Integer and floats
+          $1.to_s
+        when /^(\d+)$/ # Ranges
+          $1.to_i
+        when /^\((\S+)\.\.(\S+)\)$/ # Floats
+          (resolve($1).to_i..resolve($2).to_i)
+        when /^(\d[\d\.]+)$/
+          $1.to_f
+        else
+          variable(key)
+        end
       end
-    end
 
-    # fetches an object starting at the local scope and then moving up
-    # the hierachy
-    def find_variable(key)
-      scope = @scopes.find { |s| s.has_key?(key) }
-      if scope.nil?
-        @environments.each do |e|
-          if variable = lookup_and_evaluate(e, key)
-            scope = e
-            break
+      # 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) }
+
+        if scope.nil?
+          @environments.each do |e|
+            if variable = lookup_and_evaluate(e, key)
+              scope = e
+              break
+            end
           end
         end
-      end
-      scope     ||= @environments.last || @scopes.last
-      variable  ||= lookup_and_evaluate(scope, key)
-      
-      variable = variable.to_liquid
-      variable.context = self if variable.respond_to?(:context=)
-      return variable
-    end
 
-    # resolves namespaced queries gracefully.
-    #
-    # Example
-    #
-    #  @context['hash'] = {"name" => 'tobi'}
-    #  assert_equal 'tobi', @context['hash.name']
-    #  assert_equal 'tobi', @context['hash["name"]']
-    #
-    def variable(markup)
-      parts = markup.scan(VariableParser)
-      square_bracketed = /^\[(.*)\]$/
+        scope     ||= @environments.last || @scopes.last
+        variable  ||= lookup_and_evaluate(scope, key)
+
+        variable = variable.to_liquid
+        variable.context = self if variable.respond_to?(:context=)
 
-      first_part = parts.shift
-      if first_part =~ square_bracketed
-        first_part = resolve($1)
+        return variable
       end
 
-      if object = find_variable(first_part)
+      # Resolves namespaced queries gracefully.
+      #
+      # Example
+      #  @context['hash'] = {"name" => 'tobi'}
+      #  assert_equal 'tobi', @context['hash.name']
+      #  assert_equal 'tobi', @context['hash["name"]']
+      def variable(markup)
+        parts = markup.scan(VariableParser)
+        square_bracketed = /^\[(.*)\]$/
 
-        parts.each do |part|
-          part = resolve($1) if part_resolved = (part =~ square_bracketed)
+        first_part = parts.shift
 
-          # If object is a hash- or array-like object we look for the
-          # presence of the key and if its available we return it
-          if object.respond_to?(:[]) and
-            ((object.respond_to?(:has_key?) and object.has_key?(part)) or
-             (object.respond_to?(:fetch) and part.is_a?(Integer)))
+        if first_part =~ square_bracketed
+          first_part = resolve($1)
+        end
 
-            # if its a proc we will replace the entry with the proc
-            res = lookup_and_evaluate(object, part)
-            object = res.to_liquid
+        if object = find_variable(first_part)
 
-          # 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)
+          parts.each do |part|
+            part = resolve($1) if part_resolved = (part =~ square_bracketed)
 
-            object = object.send(part.intern).to_liquid
+            # If object is a hash- or array-like object we look for the
+            # presence of the key and if its available we return it
+            if object.respond_to?(:[]) and
+              ((object.respond_to?(:has_key?) and object.has_key?(part)) or
+               (object.respond_to?(:fetch) and part.is_a?(Integer)))
 
-          # No key was present with the desired value and it wasn't one of the directly supported
-          # keywords either. The only thing we got left is to return nil
-          else
-            return nil
-          end
+              # if its a proc we will replace the entry with the proc
+              res = lookup_and_evaluate(object, part)
+              object = res.to_liquid
 
-          # If we are dealing with a drop here we have to
-          object.context = self if object.respond_to?(:context=)
+              # 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)
+
+              object = object.send(part.intern).to_liquid
+
+              # No key was present with the desired value and it wasn't one of the directly supported
+              # keywords either. The only thing we got left is to return nil
+            else
+              return nil
+            end
+
+            # If we are dealing with a drop here we have to
+            object.context = self if object.respond_to?(:context=)
+          end
         end
-      end
 
-      object
-    end
-    
-    def lookup_and_evaluate(obj, key)
-      if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
-        obj[key] = value.call(self)
-      else
-        value
-      end
-    end
-    
-    def squash_instance_assigns_with_environments
-      @scopes.last.each_key do |k|
-        @environments.each do |env|
-          if env.has_key?(k)
-            scopes.last[k] = lookup_and_evaluate(env, k)
-            break
+        object
+      end # variable
+
+      def lookup_and_evaluate(obj, key)
+        if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
+          obj[key] = (value.arity == 0) ? value.call : value.call(self)
+        else
+          value
+        end
+      end # lookup_and_evaluate
+
+      def squash_instance_assigns_with_environments
+        @scopes.last.each_key do |k|
+          @environments.each do |env|
+            if env.has_key?(k)
+              scopes.last[k] = lookup_and_evaluate(env, k)
+              break
+            end
           end
         end
-      end
-    end
-    
-  end
-end
+      end # squash_instance_assigns_with_environments
+  end # Context
+
+end # Liquid

data/lib/liquid/standardfilters.rb

@@ -1,36 +1,40 @@
 require 'cgi'
 
 module Liquid
-  
+
   module StandardFilters
-    
+
     # Return the size of an array or of an string
     def size(input)
-      
+
       input.respond_to?(:size) ? input.size : 0
-    end         
-    
+    end
+
     # convert a input string to DOWNCASE
     def downcase(input)
       input.to_s.downcase
-    end         
+    end
 
     # convert a input string to UPCASE
     def upcase(input)
       input.to_s.upcase
     end
-    
+
     # capitalize words in the input centence
     def capitalize(input)
       input.to_s.capitalize
     end
-        
+
     def escape(input)
       CGI.escapeHTML(input) rescue input
     end
-    
+
+    def escape_once(input)
+      ActionView::Helpers::TagHelper.escape_once(input) rescue input
+    end
+
     alias_method :h, :escape
-    
+
     # Truncate a string down to x characters
     def truncate(input, length = 50, truncate_string = "...")
       if input.nil? then return end
@@ -44,19 +48,19 @@ module Liquid
       wordlist = input.to_s.split
       l = words.to_i - 1
       l = 0 if l < 0
-      wordlist.length > l ? wordlist[0..l].join(" ") + truncate_string : input 
+      wordlist.length > l ? wordlist[0..l].join(" ") + truncate_string : input
     end
-    
+
     def strip_html(input)
       input.to_s.gsub(/<script.*?<\/script>/, '').gsub(/<.*?>/, '')
-    end       
-    
+    end
+
     # Remove all newlines from the string
-    def strip_newlines(input)        
-      input.to_s.gsub(/\n/, '')      
+    def strip_newlines(input)
+      input.to_s.gsub(/\n/, '')
     end
-    
-    
+
+
     # Join elements of the array with certain character between them
     def join(input, glue = ' ')
       [input].flatten.join(glue)
@@ -73,8 +77,8 @@ module Liquid
       elsif ary.first.respond_to?(property)
         ary.sort {|a,b| a.send(property) <=> b.send(property) }
       end
-    end               
-    
+    end
+
     # map/collect on a given property
     def map(input, property)
       ary = [input].flatten
@@ -84,42 +88,42 @@ module Liquid
         ary.map {|e| e.send(property) }
       end
     end
-            
+
     # Replace occurrences of a string with another
     def replace(input, string, replacement = '')
       input.to_s.gsub(string, replacement)
     end
-                                                 
+
     # Replace the first occurrences of a string with another
     def replace_first(input, string, replacement = '')
       input.to_s.sub(string, replacement)
-    end              
-                                                           
+    end
+
     # remove a substring
     def remove(input, string)
-      input.to_s.gsub(string, '')      
+      input.to_s.gsub(string, '')
     end
-                        
+
     # remove the first occurrences of a substring
     def remove_first(input, string)
-      input.to_s.sub(string, '')      
-    end             
-                              
+      input.to_s.sub(string, '')
+    end
+
     # add one string to another
     def append(input, string)
       input.to_s + string.to_s
     end
-                                
+
     # prepend a string to another
     def prepend(input, string)
       string.to_s + input.to_s
     end
-                                             
+
     # Add <br /> tags in front of all newlines in input string
-    def newline_to_br(input)        
-      input.to_s.gsub(/\n/, "<br />\n")      
+    def newline_to_br(input)
+      input.to_s.gsub(/\n/, "<br />\n")
     end
-    
+
     # Reformat a date
     #
     #   %a - The abbreviated weekday name (``Sun'')
@@ -149,74 +153,74 @@ module Liquid
     #   %Z - Time zone name
     #   %% - Literal ``%'' character
     def date(input, format)
-      
+
       if format.to_s.empty?
         return input.to_s
       end
-      
+
       date = input.is_a?(String) ? Time.parse(input) : input
-      
+
       if date.respond_to?(:strftime)
         date.strftime(format.to_s)
       else
         input
       end
-    rescue => e 
+    rescue => e
       input
     end
-    
-    # Get the first element of the passed in array 
-    # 
+
+    # Get the first element of the passed in array
+    #
     # Example:
     #    {{ product.images | first | to_img }}
-    #  
+    #
     def first(array)
       array.first if array.respond_to?(:first)
     end
 
-    # Get the last element of the passed in array 
-    # 
+    # Get the last element of the passed in array
+    #
     # Example:
     #    {{ product.images | last | to_img }}
-    #  
+    #
     def last(array)
       array.last if array.respond_to?(:last)
     end
-    
+
     # addition
     def plus(input, operand)
       to_number(input) + to_number(operand)
     end
-    
+
     # subtraction
     def minus(input, operand)
       to_number(input) - to_number(operand)
     end
-    
+
     # multiplication
     def times(input, operand)
       to_number(input) * to_number(operand)
     end
-    
+
     # division
     def divided_by(input, operand)
       to_number(input) / to_number(operand)
     end
-    
+
     private
-    
-    def to_number(obj)
-      case obj
-      when Numeric
-        obj
-      when String
-        (obj.strip =~ /^\d+\.\d+$/) ? obj.to_f : obj.to_i
-      else
-        0
+
+      def to_number(obj)
+        case obj
+        when Numeric
+          obj
+        when String
+          (obj.strip =~ /^\d+\.\d+$/) ? obj.to_f : obj.to_i
+        else
+          0
+        end
       end
-    end
-    
+
   end
-   
+
   Template.register_filter(StandardFilters)
 end

data/lib/liquid/strainer.rb

@@ -16,6 +16,9 @@ module Liquid
     INTERNAL_METHOD = /^__/
     @@required_methods = Set.new([:__id__, :__send__, :respond_to?, :extend, :methods, :class, :object_id])
 
+    # Ruby 1.9.2 introduces Object#respond_to_missing?, which is invoked by Object#respond_to?
+    @@required_methods << :respond_to_missing? if Object.respond_to? :respond_to_missing?
+
     @@filters = {}
 
     def initialize(context)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: liquid
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 7
   prerelease: false
   segments: 
   - 2
-  - 1
-  - 3
-  version: 2.1.3
+  - 2
+  - 0
+  version: 2.2.0
 platform: ruby
 authors: 
 - Tobias Luetke
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-05 00:00:00 -04:00
+date: 2010-08-22 00:00:00 -04:00
 default_executable: 
 dependencies: []