liquid 1.7.0 → 1.9.0

data/lib/liquid/errors.rb

@@ -1,7 +1,10 @@
 module Liquid
-  class FilterNotFound < StandardError
-  end
-
-  class FileSystemError < StandardError
-  end
+  class Error < ::StandardError; 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
 end

data/lib/liquid/htmltags.rb

@@ -2,9 +2,7 @@ module Liquid
   class TableRow < Block                                             
     Syntax = /(\w+)\s+in\s+(#{VariableSignature}+)/   
     
-    def initialize(markup, tokens)
-      super
-
+    def initialize(tag_name, markup, tokens)
       if markup =~ Syntax
         @variable_name = $1
         @collection_name = $2
@@ -15,6 +13,8 @@ module Liquid
       else
         raise SyntaxError.new("Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3")
       end
+      
+      super      
     end
     
     def render(context)        
@@ -42,16 +42,26 @@ module Liquid
             'length'  => length,
             '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) }
+            'last'    => (index == length - 1),
+            'col_first' => (col == 0),
+            'col_last'  => (col == cols - 1)
+          }  
+          
+            
+          col += 1
                                 
-          result << ["<td class=\"col#{col += 1}\">"] + render_all(@nodelist, context) + ['</td>']
+          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
-            result << ["</tr>\n<tr class=\"row#{row += 1}\">"] 
+            row += 1
+            result << ["</tr>\n<tr class=\"row#{row}\">"] 
           end
           
         end

data/lib/liquid/module_ex.rb

@@ -0,0 +1,62 @@
+# Copyright 2007 by Domizio Demichelis
+# This library is free software. It may be used, redistributed and/or modified
+# under the same terms as Ruby itself
+#
+# This extension is usesd in order to expose the object of the implementing class
+# to liquid as it were a Drop. It also limits the liquid-callable methods of the instance
+# to the allowed method passed with the liquid_methods call
+# Example:
+#
+# 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
+# end
+#
+# if you want to extend the drop to other methods you can defines more methods 
+# in the class <YourClass>::LiquidDropClass
+#
+#   class SomeClass::LiquidDropClass
+#     def another_allowed_method
+#       'and this from another allowed method'
+#     end
+#   end
+# end
+#
+# usage:
+# @something = SomeClass.new
+#
+# template:
+# {{something.an_allowed_method}}{{something.unallowed_method}} {{something.another_allowed_method}}
+#
+# 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 
+# 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
+        end
+      end
+    end
+  end
+  
+end

data/lib/liquid/standardfilters.rb

@@ -1,3 +1,5 @@
+require 'cgi'
+
 module Liquid
   
   module StandardFilters
@@ -22,6 +24,12 @@ module Liquid
     def capitalize(input)
       input.to_s.capitalize
     end
+        
+    def escape(input)
+      CGI.escapeHTML(input) rescue input
+    end
+    
+    alias_method :h, :escape
     
     # Truncate a string down to x characters
     def truncate(input, length = 50, truncate_string = "...")
@@ -41,8 +49,14 @@ module Liquid
     
     def strip_html(input)
       input.to_s.gsub(/<.*?>/, '')
+    end       
+    
+    # Remove all newlines from the string
+    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)
@@ -51,6 +65,31 @@ module Liquid
     # Sort elements of the array
     def sort(input)
       [input].flatten.sort
+    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              
+                                                           
+    # remove a substring
+    def remove(input, 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            
+                                             
+    # Add <br /> tags in front of all newlines in input string
+    def newline_to_br(input)        
+      input.to_s.gsub(/\n/, "<br />\n")      
     end
     
     # Reformat a date

data/lib/liquid/strainer.rb

@@ -1,33 +1,42 @@
+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. 
   #
   # One of the strainer's responsibilities is to keep malicious method calls out 
-  class Strainer    
-  
-    @@required_methods = ["__send__", "__id__", "respond_to?", "extend", "methods"]
+  class Strainer < parent_object #:nodoc:
+    INTERNAL_METHOD = /^__/ 
+    @@required_methods = Set.new([:__send__, :__id__, :respond_to?, :extend, :methods, :class])
     
-    @@filters = []
+    @@filters = {}
     
     def initialize(context)
       @context = context
     end
               
     def self.global_filter(filter)
-      raise StandardError, "Passed filter is not a module" unless filter.is_a?(Module)      
-      @@filters << 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 { |m| strainer.extend(m) }
+      @@filters.each { |k,m| strainer.extend(m) }
       strainer
     end
     
     def respond_to?(method)
       method_name = method.to_s
-      return false if method_name =~ /^__/ 
+      return false if method_name =~ INTERNAL_METHOD
       return false if @@required_methods.include?(method_name)
       super
     end
@@ -35,9 +44,9 @@ module Liquid
     # remove all standard methods from the bucket so circumvent security 
     # problems 
     instance_methods.each do |m| 
-      unless @@required_methods.include?(m) 
-        undef_method m 
+      unless @@required_methods.include?(m.to_sym) 
+        undef_method m
       end
     end    
   end
-end
+end

data/lib/liquid/tag.rb

@@ -3,8 +3,9 @@ module Liquid
   class Tag
     attr_accessor :nodelist
     
-    def initialize(markup, tokens)
-      @markup = markup
+    def initialize(tag_name, markup, tokens)
+      @tag_name   = tag_name
+      @markup     = markup
       parse(tokens)
     end
     
@@ -14,7 +15,7 @@ module Liquid
     def name
       self.class.name.downcase
     end
-    
+        
     def render(context)
       ''
     end    

data/lib/liquid/tags/assign.rb

@@ -1,19 +1,30 @@
 module Liquid
+
+  # Assign sets a variable in your template.
+  #
+  #   {% assign foo = 'monkey' %}
+  #
+  # You can then use the variable later in the page.
+  #
+  #  {{ monkey }}
+  #
   class Assign < Tag
-    Syntax = /(\w+)\s*=\s*(#{QuotedFragment}+)/   
+    Syntax = /(#{VariableSignature}+)\s*=\s*(#{QuotedFragment}+)/   
   
-    def initialize(markup, tokens)
+    def initialize(tag_name, markup, tokens)          
       if markup =~ Syntax
         @to = $1
         @from = $2
       else
         raise SyntaxError.new("Syntax Error in 'assign' - Valid syntax: assign [var] = [source]")
       end
+      
+      super      
     end
   
     def render(context)
-       context[@to] = context[@from]
-       ''       
+       context.scopes.last[@to.to_s] = context[@from]
+       ''
     end 
   
   end  

data/lib/liquid/tags/capture.rb

@@ -1,14 +1,27 @@
 module Liquid
+  
+  # Capture stores the result of a block into a variable without rendering it inplace.
+  #
+  #   {% capture heading %}
+  #     Monkeys!
+  #   {% endcapture %}
+  #   ...
+  #   <h1>{{ monkeys }}</h1>
+  #
+  # 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(markup, tokens)
+    def initialize(tag_name, markup, tokens)      
       if markup =~ Syntax
         @to = $1
-        super 
       else
         raise SyntaxError.new("Syntax Error in 'capture' - Valid syntax: capture [var]")
       end
+      
+      super       
     end
 
     def render(context)

data/lib/liquid/tags/case.rb

@@ -1,9 +1,9 @@
 module Liquid
   class Case < Block
     Syntax     = /(#{QuotedFragment})/
-    WhenSyntax = /(#{QuotedFragment})/
+    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/
 
-    def initialize(markup, tokens)
+    def initialize(tag_name, markup, tokens)      
       @blocks = []
       
       if markup =~ Syntax
@@ -11,58 +11,73 @@ module Liquid
       else
         raise SyntaxError.new("Syntax Error in tag 'case' - Valid syntax: case [condition]")
       end
-
-      push_block('case', markup)
-      
+            
       super
     end
 
     def unknown_tag(tag, markup, tokens)
-      if ['when', 'else'].include?(tag)
-        push_block(tag, markup)
+      @nodelist = []
+      case tag
+      when 'when'
+        record_when_condition(markup)
+      when 'else'
+        record_else_condition(markup)
       else
         super
       end
     end
 
-    def render(context)
-      @blocks.inject([]) do |output, block|
-
-        if block.else?
-           return render_all(block.attachment, context) if output.empty? || output.join !~ /\S/
-        else
-          
-          if block.evaluate(context)
-            context.stack do          
-              output += render_all(block.attachment, context)
-            end          
-          end
-          
-        end
-              
+    def render(context)      
+      context.stack do          
+        execute_else_block = true
         
-        output
-      end.join
+        @blocks.inject([]) do |output, block|
+      
+          if block.else? 
+            
+            return render_all(block.attachment, context) if execute_else_block
+            
+          elsif block.evaluate(context)
+            
+            execute_else_block = false        
+            output += render_all(block.attachment, context)                    
+          end            
+      
+          output
+        end
+      end          
     end
     
     private
     
-    def push_block(tag, markup)            
-      
-      block = if tag == 'else'
-        ElseCondition.new
-      elsif markup =~ WhenSyntax
-        Condition.new(@left, '==', $1)        
-      else
-        raise SyntaxError.new("Syntax Error in tag 'case' - Valid when condition: when [condition] ")
+    def record_when_condition(markup)                
+      while markup
+      	# Create a new nodelist and assign it to the new block
+      	if not markup =~ WhenSyntax
+      	  raise SyntaxError.new("Syntax Error in tag 'case' - Valid when condition: {% when [condition] [or condition2...] %} ")
+      	end
+
+      	markup = $2
+
+      	block = Condition.new(@left, '==', $1)        
+      	block.attach(@nodelist)
+      	@blocks.push(block)
       end
-            
-      @blocks.push(block)      
-      @nodelist = block.attach(Array.new) 
+    end
+
+    def record_else_condition(markup)            
+
+      if not markup.strip.empty?
+        raise SyntaxError.new("Syntax Error in tag 'case' - Valid else condition: {% else %} (no parameters) ")
+      end
+         
+      block = ElseCondition.new            
+      block.attach(@nodelist)
+      @blocks << block
     end
     
         
   end    
   
   Template.register_tag('case', Case)
-end
+end