liquid 2.0.0 → 2.1.0

data/lib/liquid/document.rb

@@ -1,17 +1,17 @@
 module Liquid
-  class Document < Block                                                             
+  class Document < Block
     # we don't need markup to open this block
     def initialize(tokens)
       parse(tokens)
-    end                                                                        
-  
-    # There isn't a real delimter   
+    end
+
+    # There isn't a real delimter
     def block_delimiter
       []
     end
-  
+
     # Document blocks don't need to be terminated since they are not actually opened
     def assert_missing_delimitation!
-    end    
+    end
   end
-end
+end

data/lib/liquid/drop.rb

@@ -1,9 +1,9 @@
 module Liquid
-  
+
   # A drop in liquid is a class which allows you to to export DOM like things to liquid
-  # Methods of drops are callable. 
-  # The main use for liquid drops is the implement lazy loaded objects. 
-  # If you would like to make data available to the web designers which you don't want loaded unless needed then 
+  # Methods of drops are callable.
+  # The main use for liquid drops is the implement lazy loaded objects.
+  # If you would like to make data available to the web designers which you don't want loaded unless needed then
   # a drop is a great way to do that
   #
   # Example:
@@ -13,38 +13,39 @@ module Liquid
   #      Shop.current.products.find(:all, :order => 'sales', :limit => 10 )
   #   end
   # end
-  #  
+  #
   # tmpl = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {%endfor%} '  )
-  # tmpl.render('product' => ProductDrop.new ) # will invoke top_sales query. 
+  # tmpl.render('product' => ProductDrop.new ) # will invoke top_sales query.
   #
-  # Your drop can either implement the methods sans any parameters or implement the before_method(name) method which is a 
+  # Your drop can either implement the methods sans any parameters or implement the before_method(name) method which is a
   # catch all
   class Drop
     attr_writer :context
 
-    # Catch all for the method 
+    # Catch all for the method
     def before_method(method)
       nil
     end
-    
+
     # called by liquid to invoke a drop
-    def invoke_drop(method)          
-      if self.class.public_instance_methods.include?(method.to_s)
-        send(method.to_sym) 
-      else        
+    def invoke_drop(method)
+      # for backward compatibility with Ruby 1.8
+      methods = self.class.public_instance_methods.map { |m| m.to_s }
+      if methods.include?(method.to_s)
+        send(method.to_sym)
+      else
         before_method(method)
       end
     end
-    
+
     def has_key?(name)
       true
     end
-    
+
     def to_liquid
       self
     end
 
     alias :[] :invoke_drop
   end
-  
 end

data/lib/liquid/htmltags.rb

@@ -1,7 +1,7 @@
 module Liquid
-  class TableRow < Block                                             
-    Syntax = /(\w+)\s+in\s+(#{VariableSignature}+)/   
-    
+  class TableRow < Block
+    Syntax = /(\w+)\s+in\s+(#{VariableSignature}+)/
+
     def initialize(tag_name, markup, tokens)
       if markup =~ Syntax
         @variable_name = $1
@@ -13,62 +13,62 @@ module Liquid
       else
         raise SyntaxError.new("Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3")
       end
-      
-      super      
+
+      super
     end
-    
-    def render(context)        
+
+    def render(context)
       collection = context[@collection_name] or return ''
-      
+
       if @attributes['limit'] or @attributes['offset']
         limit = context[@attributes['limit']] || -1
         offset = context[@attributes['offset']] || 0
         collection = collection[offset.to_i..(limit.to_i + offset.to_i - 1)]
       end
-            
+
       length = collection.length
-      
+
       cols = context[@attributes['cols']].to_i
 
       row = 1
       col = 0
 
       result = ["<tr class=\"row1\">\n"]
-      context.stack do 
+      context.stack do
 
         collection.each_with_index do |item, index|
           context[@variable_name] = item
           context['tablerowloop'] = {
             'length'  => length,
-            'index'   => index + 1, 
-            'index0'  => index, 
-            'col'     => col + 1, 
-            'col0'    => col, 
-            'index0'  => index, 
+            'index'   => index + 1,
+            'index0'  => index,
+            'col'     => col + 1,
+            'col0'    => col,
+            'index0'  => index,
             'rindex'  => length - index,
             'rindex0' => length - index -1,
             'first'   => (index == 0),
             'last'    => (index == length - 1),
             'col_first' => (col == 0),
             'col_last'  => (col == cols - 1)
-          }  
-          
-            
+          }
+
+
           col += 1
-                                
+
           result << ["<td class=\"col#{col}\">"] + render_all(@nodelist, context) + ['</td>']
 
-          if col == cols and not (index == length - 1)                        
+          if col == cols and not (index == length - 1)
             col  = 0
             row += 1
-            result << ["</tr>\n<tr class=\"row#{row}\">"] 
+            result << ["</tr>\n<tr class=\"row#{row}\">"]
           end
-          
+
         end
       end
       result + ["</tr>\n"]
-    end    
+    end
   end
-  
-  Template.register_tag('tablerow', TableRow)  
-end
+
+  Template.register_tag('tablerow', TableRow)
+end

data/lib/liquid/module_ex.rb

@@ -18,7 +18,7 @@
 #   end
 # end
 #
-# if you want to extend the drop to other methods you can defines more methods 
+# if you want to extend the drop to other methods you can defines more methods
 # in the class <YourClass>::LiquidDropClass
 #
 #   class SomeClass::LiquidDropClass
@@ -37,11 +37,11 @@
 # output:
 # '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 
+# 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
@@ -58,5 +58,5 @@ class Module
       end
     end
   end
-  
+
 end

data/lib/liquid/standardfilters.rb

@@ -48,7 +48,7 @@ module Liquid
     end
     
     def strip_html(input)
-      input.to_s.gsub(/<.*?>/, '')
+      input.to_s.gsub(/<script.*?<\/script>/, '').gsub(/<.*?>/, '')
     end       
     
     # Remove all newlines from the string
@@ -185,22 +185,35 @@ module Liquid
     
     # addition
     def plus(input, operand)
-      input + operand if input.respond_to?('+')
+      to_number(input) + to_number(operand)
     end
     
     # subtraction
     def minus(input, operand)
-      input - operand if input.respond_to?('-')
+      to_number(input) - to_number(operand)
     end
     
     # multiplication
     def times(input, operand)
-      input * operand if input.respond_to?('*')
+      to_number(input) * to_number(operand)
     end
     
     # division
     def divided_by(input, operand)
-      input / operand if input.respond_to?('/')
+      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
+      end
     end
     
   end

data/lib/liquid/strainer.rb

@@ -1,52 +1,51 @@
 require 'set'
 
 module Liquid
-  
-  
+
   parent_object = if defined? BlankObject
     BlankObject
   else
     Object
   end
 
-  # Strainer is the parent class for the filters system. 
-  # New filters are mixed into the strainer class which is then instanciated for each liquid template render run. 
+  # Strainer is the parent class for the filters system.
+  # New filters are mixed into the strainer class which is then instanciated for each liquid template render run.
   #
-  # One of the strainer's responsibilities is to keep malicious method calls out 
+  # One of the strainer's responsibilities is to keep malicious method calls out
   class Strainer < parent_object #:nodoc:
-    INTERNAL_METHOD = /^__/ 
-    @@required_methods = Set.new([:__send__, :__id__, :respond_to?, :extend, :methods, :class])
-    
+    INTERNAL_METHOD = /^__/
+    @@required_methods = Set.new([:__id__, :__send__, :respond_to?, :extend, :methods, :class, :object_id])
+
     @@filters = {}
-    
+
     def initialize(context)
       @context = context
     end
-              
+
     def self.global_filter(filter)
       raise ArgumentError, "Passed filter is not a module" unless filter.is_a?(Module)
       @@filters[filter.name] = filter
     end
-    
+
     def self.create(context)
       strainer = Strainer.new(context)
       @@filters.each { |k,m| strainer.extend(m) }
       strainer
     end
-    
+
     def respond_to?(method, include_private = false)
       method_name = method.to_s
       return false if method_name =~ INTERNAL_METHOD
       return false if @@required_methods.include?(method_name)
       super
     end
-    
-    # remove all standard methods from the bucket so circumvent security 
-    # problems 
-    instance_methods.each do |m| 
-      unless @@required_methods.include?(m.to_sym) 
+
+    # remove all standard methods from the bucket so circumvent security
+    # problems
+    instance_methods.each do |m|
+      unless @@required_methods.include?(m.to_sym)
         undef_method m
       end
-    end    
+    end
   end
 end

data/lib/liquid/tag.rb

@@ -1,26 +1,26 @@
 module Liquid
-  
+
   class Tag
     attr_accessor :nodelist
-    
+
     def initialize(tag_name, markup, tokens)
       @tag_name   = tag_name
       @markup     = markup
       parse(tokens)
     end
-    
+
     def parse(tokens)
     end
-    
+
     def name
       self.class.name.downcase
     end
-        
+
     def render(context)
       ''
-    end    
+    end
   end
-   
+
 
 end
-   
+

data/lib/liquid/tags/assign.rb

@@ -9,7 +9,7 @@ module Liquid
   #  {{ monkey }}
   #
   class Assign < Tag
-    Syntax = /(#{VariableSignature}+)\s*=\s*(#{Expression}+)/   
+    Syntax = /(#{VariableSignature}+)\s*=\s*(#{QuotedFragment}+)/   
   
     def initialize(tag_name, markup, tokens)          
       if markup =~ Syntax

data/lib/liquid/tags/capture.rb

@@ -1,5 +1,5 @@
 module Liquid
-  
+
   # Capture stores the result of a block into a variable without rendering it inplace.
   #
   #   {% capture heading %}
@@ -8,28 +8,28 @@ module Liquid
   #   ...
   #   <h1>{{ monkeys }}</h1>
   #
-  # Capture is useful for saving content for use later in your template, such as 
+  # Capture is useful for saving content for use later in your template, such as
   # in a sidebar or footer.
   #
   class Capture < Block
     Syntax = /(\w+)/
 
-    def initialize(tag_name, markup, tokens)      
+    def initialize(tag_name, markup, tokens)
       if markup =~ Syntax
         @to = $1
       else
         raise SyntaxError.new("Syntax Error in 'capture' - Valid syntax: capture [var]")
       end
-      
-      super       
+
+      super
     end
 
     def render(context)
       output = super
-      context[@to] = output.to_s
+      context[@to] = output.join
       ''
     end
-  end  
-  
+  end
+
   Template.register_tag('capture', Capture)
-end
+end

data/lib/liquid/tags/case.rb

@@ -1,7 +1,7 @@
 module Liquid
   class Case < Block
-    Syntax     = /(#{Expression})/
-    WhenSyntax = /(#{Expression})(?:(?:\s+or\s+|\s*\,\s*)(#{Expression}.*))?/
+    Syntax     = /(#{QuotedFragment})/
+    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/
 
     def initialize(tag_name, markup, tokens)      
       @blocks = []

data/lib/liquid/tags/cycle.rb

@@ -13,8 +13,8 @@ module Liquid
   #    <div class="green"> Item five</div>
   #
   class Cycle < Tag
-    SimpleSyntax = /^#{Expression}/        
-    NamedSyntax  = /^(#{Expression})\s*\:\s*(.*)/
+    SimpleSyntax = /^#{QuotedFragment}+/        
+    NamedSyntax  = /^(#{QuotedFragment})\s*\:\s*(.*)/
   
     def initialize(tag_name, markup, tokens)      
       case markup
@@ -48,7 +48,7 @@ module Liquid
   
     def variables_from_string(markup)
       markup.split(',').collect do |var|
-    	  var =~ /\s*(#{Expression})\s*/
+    	  var =~ /\s*(#{QuotedFragment})\s*/
     	  $1 ? $1 : nil
     	end.compact
     end