tobi-liquid 2.0.1

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

@@ -0,0 +1,209 @@
+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         
+    
+    # convert a input string to DOWNCASE
+    def downcase(input)
+      input.to_s.downcase
+    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
+    
+    alias_method :h, :escape
+    
+    # Truncate a string down to x characters
+    def truncate(input, length = 50, truncate_string = "...")
+      if input.nil? then return end
+      l = length.to_i - truncate_string.length
+      l = 0 if l < 0
+      input.length > length.to_i ? input[0...l] + truncate_string : input
+    end
+
+    def truncatewords(input, words = 15, truncate_string = "...")
+      if input.nil? then return end
+      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 
+    end
+    
+    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)
+    end
+
+    # Sort elements of the array
+    # provide optional property with which to sort an array of hashes or drops
+    def sort(input, property = nil)
+      ary = [input].flatten
+      if property.nil?
+        ary.sort
+      elsif ary.first.respond_to?('[]') and !ary.first[property].nil?
+        ary.sort {|a,b| a[property] <=> b[property] }
+      elsif ary.first.respond_to?(property)
+        ary.sort {|a,b| a.send(property) <=> b.send(property) }
+      end
+    end               
+    
+    # map/collect on a given property
+    def map(input, property)
+      ary = [input].flatten
+      if ary.first.respond_to?('[]') and !ary.first[property].nil?
+        ary.map {|e| e[property] }
+      elsif ary.first.respond_to?(property)
+        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              
+                                                           
+    # 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 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")      
+    end
+    
+    # Reformat a date
+    #
+    #   %a - The abbreviated weekday name (``Sun'')
+    #   %A - The  full  weekday  name (``Sunday'')
+    #   %b - The abbreviated month name (``Jan'')
+    #   %B - The  full  month  name (``January'')
+    #   %c - The preferred local date and time representation
+    #   %d - Day of the month (01..31)
+    #   %H - Hour of the day, 24-hour clock (00..23)
+    #   %I - Hour of the day, 12-hour clock (01..12)
+    #   %j - Day of the year (001..366)
+    #   %m - Month of the year (01..12)
+    #   %M - Minute of the hour (00..59)
+    #   %p - Meridian indicator (``AM''  or  ``PM'')
+    #   %S - Second of the minute (00..60)
+    #   %U - Week  number  of the current year,
+    #           starting with the first Sunday as the first
+    #           day of the first week (00..53)
+    #   %W - Week  number  of the current year,
+    #           starting with the first Monday as the first
+    #           day of the first week (00..53)
+    #   %w - Day of the week (Sunday is 0, 0..6)
+    #   %x - Preferred representation for the date alone, no time
+    #   %X - Preferred representation for the time alone, no date
+    #   %y - Year without a century (00..99)
+    #   %Y - Year with century
+    #   %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 
+      input
+    end
+    
+    # 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 
+    # 
+    # Example:
+    #    {{ product.images | last | to_img }}
+    #  
+    def last(array)
+      array.last if array.respond_to?(:last)
+    end
+    
+    # addition
+    def plus(input, operand)
+      input + operand if input.respond_to?('+')
+    end
+    
+    # subtraction
+    def minus(input, operand)
+      input - operand if input.respond_to?('-')
+    end
+    
+    # multiplication
+    def times(input, operand)
+      input * operand if input.respond_to?('*')
+    end
+    
+    # division
+    def divided_by(input, operand)
+      input / operand if input.respond_to?('/')
+    end
+    
+  end
+   
+  Template.register_filter(StandardFilters)
+end

data/lib/liquid/strainer.rb

@@ -0,0 +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.
+  #
+  # One of the strainer's responsibilities is to keep malicious method calls out
+  class Strainer < parent_object #:nodoc:
+    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)
+        undef_method m
+      end
+    end
+  end
+end

data/lib/liquid/tag.rb

@@ -0,0 +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
+

data/lib/liquid/tags/assign.rb

@@ -0,0 +1,33 @@
+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 = /(#{VariableSignature}+)\s*=\s*(#{QuotedFragment}+)/   
+  
+    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.scopes.last[@to.to_s] = context[@from]
+       ''
+    end 
+  
+  end  
+  
+  Template.register_tag('assign', Assign)  
+end

data/lib/liquid/tags/capture.rb

@@ -0,0 +1,35 @@
+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(tag_name, markup, tokens)
+      if markup =~ Syntax
+        @to = $1
+      else
+        raise SyntaxError.new("Syntax Error in 'capture' - Valid syntax: capture [var]")
+      end
+
+      super
+    end
+
+    def render(context)
+      output = super
+      context[@to] = output.join
+      ''
+    end
+  end
+
+  Template.register_tag('capture', Capture)
+end

data/lib/liquid/tags/case.rb

@@ -0,0 +1,83 @@
+module Liquid
+  class Case < Block
+    Syntax     = /(#{QuotedFragment})/
+    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/
+
+    def initialize(tag_name, markup, tokens)      
+      @blocks = []
+      
+      if markup =~ Syntax
+        @left = $1
+      else
+        raise SyntaxError.new("Syntax Error in tag 'case' - Valid syntax: case [condition]")
+      end
+            
+      super
+    end
+
+    def unknown_tag(tag, markup, tokens)
+      @nodelist = []
+      case tag
+      when 'when'
+        record_when_condition(markup)
+      when 'else'
+        record_else_condition(markup)
+      else
+        super
+      end
+    end
+
+    def render(context)      
+      context.stack do          
+        execute_else_block = true
+        
+        @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 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
+    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