liquid 2.0.0 → 2.1.0

data/CHANGELOG

@@ -1,9 +1,13 @@
+* Ruby 1.9.1 bugfixes
+
+* Fix LiquidView for Rails 2.2. Fix local assigns for all versions of Rails
+
 * Fixed gem install rake task
 * Improve Error encapsulation in liquid by maintaining a own set of exceptions instead of relying on ruby build ins
 
 * Added If with or / and expressions
 
-* Implemented .to_liquid for all objects which can be passed to liquid like Strings Arrays Hashes Numerics and Booleans. To export new objects to liquid just implement .to_liquid on them and return objects which themselves have .to_liquid methods. 
+* Implemented .to_liquid for all objects which can be passed to liquid like Strings Arrays Hashes Numerics and Booleans. To export new objects to liquid just implement .to_liquid on them and return objects which themselves have .to_liquid methods.
 
 * Added more tags to standard library
 
@@ -22,17 +26,17 @@
 * Fixed bug with string filter parameters failing to tolerate commas in strings. [Paul Hammond]
 
 * Improved filter parameters. Filter parameters are now context sensitive; Types are resolved according to the rules of the context. Multiple parameters are now separated by the Liquid::ArgumentSeparator: , by default [Paul Hammond]
-	
-	{{ 'Typo' | link_to: 'http://typo.leetsoft.com', 'Typo - a modern weblog engine' }}
-	
 
-* Added Liquid::Drop. A base class which you can use for exporting proxy objects to liquid which can acquire more data when used in liquid. [Tobias Luetke] 
+  {{ 'Typo' | link_to: 'http://typo.leetsoft.com', 'Typo - a modern weblog engine' }}
+
+
+* Added Liquid::Drop. A base class which you can use for exporting proxy objects to liquid which can acquire more data when used in liquid. [Tobias Luetke]
 
   class ProductDrop < Liquid::Drop
     def top_sales
        Shop.current.products.find(:all, :order => 'sales', :limit => 10 )
     end
-  end   
+  end
   t = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {% endfor %} '  )
   t.render('product' => ProductDrop.new )
 

data/Rakefile

@@ -1,11 +1,10 @@
 #!/usr/bin/env ruby
 require 'rubygems'
 require 'rake'
-require 'hoe'
+require 'rake/testtask'
+require 'rake/gempackagetask'
 
-PKG_VERSION = "2.0.0"
-PKG_NAME    = "liquid"
-PKG_DESC    = "A secure non evaling end user template engine with aesthetic markup."
+task :default => 'test'
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "lib"
@@ -14,11 +13,27 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = false
 end
 
-Hoe.new(PKG_NAME, PKG_VERSION) do |p|
-  p.rubyforge_name = PKG_NAME
-  p.summary        = PKG_DESC
-  p.description    = PKG_DESC
-  p.author         = "Tobias Luetke"
-  p.email          = "tobi@leetsoft.com"
-  p.url            = "http://www.liquidmarkup.org"    
-end
+gemspec = eval(File.read('liquid.gemspec'))
+Rake::GemPackageTask.new(gemspec) do |pkg|
+  pkg.gem_spec = gemspec
+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" 
+  task :grind => :run  do
+    system "kcachegrind /tmp/liquid.rubyprof_calltreeprinter.txt"
+  end
+end
+  
+  

data/lib/extras/liquid_view.rb

@@ -5,32 +5,43 @@
 # 
 #   ActionView::Base::register_template_handler :liquid, LiquidView
 class LiquidView
+  PROTECTED_ASSIGNS = %w( template_root response _session template_class action_name request_origin session template
+                          _response url _request _cookies variables_added _flash params _headers request cookies
+                          ignore_missing_templates flash _params logger before_filter_chain_aborted headers )
+  PROTECTED_INSTANCE_VARIABLES = %w( @_request @controller @_first_render @_memoized__pick_template @view_paths 
+                                     @helpers @assigns_added @template @_render_stack @template_format @assigns )
+  
+  def self.call(template)
+    "LiquidView.new(self).render(template, local_assigns)"
+  end
 
-  def initialize(action_view)
-    @action_view = action_view
+  def initialize(view)
+    @view = view
   end
   
-
-  def render(template, local_assigns_for_rails_less_than_2_1_0 = nil)
-    @action_view.controller.headers["Content-Type"] ||= 'text/html; charset=utf-8'
-    assigns = @action_view.assigns.dup
+  def render(template, local_assigns = nil)
+    @view.controller.headers["Content-Type"] ||= 'text/html; charset=utf-8'
     
-    # template is a Template object in Rails >=2.1.0, a source string previously.
-    if template.respond_to? :source
-      source = template.source
-      local_assigns = template.locals
+    # Rails 2.2 Template has source, but not locals
+    if template.respond_to?(:source) && !template.respond_to?(:locals)
+      assigns = (@view.instance_variables - PROTECTED_INSTANCE_VARIABLES).inject({}) do |hash, ivar|
+                  hash[ivar[1..-1]] = @view.instance_variable_get(ivar)
+                  hash
+                end
     else
-      source = template
-      local_assigns = local_assigns_for_rails_less_than_2_1_0
+      assigns = @view.assigns.reject{ |k,v| PROTECTED_ASSIGNS.include?(k) }
     end
-
-    if content_for_layout = @action_view.instance_variable_get("@content_for_layout")
+    
+    source = template.respond_to?(:source) ? template.source : template
+    local_assigns = (template.respond_to?(:locals) ? template.locals : local_assigns) || {}
+    
+    if content_for_layout = @view.instance_variable_get("@content_for_layout")
       assigns['content_for_layout'] = content_for_layout
     end
-    assigns.merge!(local_assigns)
+    assigns.merge!(local_assigns.stringify_keys)
     
     liquid = Liquid::Template.parse(source)
-    liquid.render(assigns, :filters => [@action_view.controller.master_helper_module], :registers => {:action_view => @action_view, :controller => @action_view.controller})
+    liquid.render(assigns, :filters => [@view.controller.master_helper_module], :registers => {:action_view => @view, :controller => @view.controller})
   end
 
   def compilable?

data/lib/liquid.rb

@@ -29,11 +29,11 @@ module Liquid
   TagStart                    = /\{\%/
   TagEnd                      = /\%\}/
   VariableSignature           = /\(?[\w\-\.\[\]]\)?/
-  VariableSegment             = /[\w\-]\??/
+  VariableSegment             = /[\w\-]/
   VariableStart               = /\{\{/
   VariableEnd                 = /\}\}/
   VariableIncompleteEnd       = /\}\}?/
-  QuotedString                = /"[^"]+"|'[^']+'/
+  QuotedString                = /"[^"]*"|'[^']*'/
   QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/
   StrictQuotedFragment        = /"[^"]+"|'[^']+'|[^\s,\|,\:,\,]+/
   FirstFilterArgument         = /#{FilterArgumentSeparator}(?:#{StrictQuotedFragment})/
@@ -44,7 +44,7 @@ module Liquid
   AnyStartingTag              = /\{\{|\{\%/
   PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/
   TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/
-  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+/
+  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/
 end
 
 require 'liquid/drop'

data/lib/liquid/block.rb

@@ -1,19 +1,23 @@
 module Liquid
-  
+
   class Block < Tag
+    IsTag             = /^#{TagStart}/
+    IsVariable        = /^#{VariableStart}/
+    FullToken         = /^#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}$/
+    ContentOfVariable = /^#{VariableStart}(.*)#{VariableEnd}$/
 
     def parse(tokens)
       @nodelist ||= []
       @nodelist.clear
 
-      while token = tokens.shift 
+      while token = tokens.shift
 
         case token
-        when /^#{TagStart}/                   
-          if token =~ /^#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}$/
+        when IsTag
+          if token =~ FullToken
 
             # if we found the proper block delimitor just end parsing here and let the outer block
-            # proceed                               
+            # proceed
             if block_delimiter == $1
               end_tag
               return
@@ -23,33 +27,33 @@ module Liquid
             if tag = Template.tags[$1]
               @nodelist << tag.new($1, $2, tokens)
             else
-              # this tag is not registered with the system 
+              # 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              
+            end
           else
             raise SyntaxError, "Tag '#{token}' was not properly terminated with regexp: #{TagEnd.inspect} "
           end
-        when /^#{VariableStart}/
+        when IsVariable
           @nodelist << create_variable(token)
         when ''
           # pass
         else
           @nodelist << token
         end
-      end       
-      
-      # Make sure that its ok to end parsing in the current block. 
-      # Effectively this method will throw and exception unless the current block is 
-      # of type Document 
+      end
+
+      # Make sure that its ok to end parsing in the current block.
+      # Effectively this method will throw and exception unless the current block is
+      # of type Document
       assert_missing_delimitation!
-    end                     
-    
-    def end_tag      
+    end
+
+    def end_tag
     end
 
     def unknown_tag(tag, params, tokens)
-      case tag 
+      case tag
       when 'else'
         raise SyntaxError, "#{block_name} tag does not expect else tag"
       when 'end'
@@ -61,14 +65,14 @@ module Liquid
 
     def block_delimiter
       "end#{block_name}"
-    end                           
+    end
 
     def block_name
       @tag_name
     end
 
     def create_variable(token)
-      token.scan(/^#{VariableStart}(.*)#{VariableEnd}$/) do |content|
+      token.scan(ContentOfVariable) do |content|
         return Variable.new(content.first)
       end
       raise SyntaxError.new("Variable '#{token}' was not properly terminated with regexp: #{VariableEnd.inspect} ")
@@ -77,7 +81,7 @@ module Liquid
     def render(context)
       render_all(@nodelist, context)
     end
-    
+
     protected
 
     def assert_missing_delimitation!
@@ -86,12 +90,12 @@ module Liquid
 
     def render_all(list, context)
       list.collect do |token|
-        begin        
+        begin
           token.respond_to?(:render) ? token.render(context) : token
-        rescue Exception => e          
+        rescue Exception => e
           context.handle_error(e)
-        end          
-      end      
+        end
+      end
     end
-  end  
-end
+  end
+end

data/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,35 +15,35 @@ module Liquid
       '>'  => :>,
       '>=' => :>=,
       '<=' => :<=,
-      'contains' => lambda { |cond, left, right| left.include?(right) },
+      'contains' => lambda { |cond, left, right| left && right ? left.include?(right) : false }
     }
-    
+
     def self.operators
       @@operators
     end
 
     attr_reader :attachment
     attr_accessor :left, :operator, :right
-  
+
     def initialize(left = nil, operator = nil, right = nil)
       @left, @operator, @right = left, operator, right
       @child_relation  = nil
       @child_condition = nil
     end
-    
+
     def evaluate(context = Context.new)
-      result = interpret_condition(left, right, operator, context)        
-      
+      result = interpret_condition(left, right, operator, context)
+
       case @child_relation
-      when :or 
+      when :or
         result || @child_condition.evaluate(context)
-      when :and 
+      when :and
         result && @child_condition.evaluate(context)
       else
         result
-      end      
-    end                    
-    
+      end
+    end
+
     def or(condition)
       @child_relation, @child_condition = :or, condition
     end
@@ -51,25 +51,25 @@ module Liquid
     def and(condition)
       @child_relation, @child_condition = :and, condition
     end
-  
+
     def attach(attachment)
       @attachment = attachment
     end
-  
+
     def else?
       false
-    end                          
-    
+    end
+
     def inspect
       "#<Condition #{[@left, @operator, @right].compact.join(' ')}>"
     end
-    
+
     private
-  
+
     def equal_variables(left, right)
       if left.is_a?(Symbol)
         if right.respond_to?(left)
-          return right.send(left.to_s) 
+          return right.send(left.to_s)
         else
           return nil
         end
@@ -77,47 +77,44 @@ module Liquid
 
       if right.is_a?(Symbol)
         if left.respond_to?(right)
-          return left.send(right.to_s) 
+          return left.send(right.to_s)
         else
           return nil
         end
       end
 
-      left == right      
-    end    
+      left == right
+    end
 
     def interpret_condition(left, right, op, context)
-
-      # 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 
+      # If the operator is empty this means that the decision statement is just
+      # a single variable. We can just poll this variable from the context and
       # return this as the result.
-      return context[left] if op == nil      
+      return context[left] if op == nil
 
       left, right = context[left], context[right]
-            
 
       operation = self.class.operators[op] || raise(ArgumentError.new("Unknown operator #{op}"))
 
       if operation.respond_to?(:call)
         operation.call(self, left, right)
-      elsif left.respond_to?(operation) and right.respond_to?(operation)        
+      elsif left.respond_to?(operation) and right.respond_to?(operation)
         left.send(operation, right)
       else
         nil
       end
-    end    
-  end           
+    end
+  end
 
 
   class ElseCondition < Condition
-      
-    def else? 
+    def else?
       true
     end
-  
+
     def evaluate(context)
       true
     end
   end
 
-end
+end

data/lib/liquid/context.rb

@@ -13,14 +13,15 @@ module Liquid
   #
   #   context['bob']  #=> nil  class Context
   class Context
-    attr_reader :scopes
-    attr_reader :errors, :registers
+    attr_reader :scopes, :errors, :registers, :environments
 
-    def initialize(assigns = {}, registers = {}, rethrow_errors = false)
-      @scopes     = [(assigns || {})]
-      @registers  = registers
-      @errors     = []
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false)
+      @environments   = [environments].flatten
+      @scopes         = [(outer_scope || {})]
+      @registers      = registers
+      @errors         = []
       @rethrow_errors = rethrow_errors
+      squash_instance_assigns_with_environments
     end
 
     def strainer
@@ -61,9 +62,9 @@ module Liquid
     end
 
     # push new local scope on the stack. use <tt>Context#stack</tt> instead
-    def push
+    def push(new_scope={})
       raise StackLevelError, "Nesting too deep" if @scopes.length > 100
-      @scopes.unshift({})
+      @scopes.unshift(new_scope)
     end
 
     # merge a hash of variables in the current local scope
@@ -86,9 +87,9 @@ module Liquid
     #   end
     #   context['var]  #=> nil
     #
-    def stack(&block)
+    def stack(new_scope={},&block)
       result = nil
-      push
+      push(new_scope)
       begin
         result = yield
       ensure
@@ -96,6 +97,10 @@ module Liquid
       end
       result
     end
+    
+    def clear_instance_assigns
+      @scopes[0] = {}
+    end
 
     # Only allow String, Numeric, Hash, Array, Proc, Boolean or <tt>Liquid::Drop</tt>
     def []=(key, value)
@@ -133,9 +138,6 @@ module Liquid
         :blank?
       when 'empty'
         :empty?
-      # filtered variables
-      when SpacelessFilter
-        filtered_variable(key)
       # Single quoted strings
       when /^'(.*)'$/
         $1.to_s
@@ -159,16 +161,21 @@ module Liquid
     # fetches an object starting at the local scope and then moving up
     # the hierachy
     def find_variable(key)
-      @scopes.each do |scope|
-        if scope.has_key?(key)
-          variable = scope[key]
-          variable = scope[key] = variable.call(self) if variable.is_a?(Proc)
-          variable = variable.to_liquid
-          variable.context = self if variable.respond_to?(:context=)
-          return variable
+      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
-      nil
+      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.
@@ -200,8 +207,7 @@ module Liquid
              (object.respond_to?(:fetch) and part.is_a?(Integer)))
 
             # if its a proc we will replace the entry with the proc
-            res = object[part]
-            res = object[part] = res.call(self) if res.is_a?(Proc) and object.respond_to?(:[]=)
+            res = lookup_and_evaluate(object, part)
             object = res.to_liquid
 
           # Some special cases. If the part wasn't in square brackets and
@@ -225,8 +231,24 @@ module Liquid
       object
     end
     
-    def filtered_variable(markup)
-      Variable.new(markup).render(self)
+    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
+          end
+        end
+      end
+    end
+    
   end
 end