spinto-liquid 2.3.0.1

data/lib/liquid/document.rb

@@ -0,0 +1,17 @@
+module Liquid
+  class Document < Block
+    # we don't need markup to open this block
+    def initialize(tokens)
+      parse(tokens)
+    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

data/lib/liquid/drop.rb

@@ -0,0 +1,49 @@
+module Liquid
+
+  # A drop in liquid is a class which allows you 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
+  # a drop is a great way to do that
+  #
+  # Example:
+  #
+  #   class ProductDrop < Liquid::Drop
+  #     def top_sales
+  #       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.
+  #
+  # 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
+    def before_method(method)
+      nil
+    end
+
+    # called by liquid to invoke a drop
+    def invoke_drop(method_or_key)
+      if method_or_key && method_or_key != '' && self.class.public_method_defined?(method_or_key.to_s.to_sym)
+        send(method_or_key.to_s.to_sym)
+      else
+        before_method(method_or_key)
+      end
+    end
+
+    def has_key?(name)
+      true
+    end
+
+    def to_liquid
+      self
+    end
+
+    alias :[] :invoke_drop
+  end
+end

data/lib/liquid/errors.rb

@@ -0,0 +1,11 @@
+module Liquid
+  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
+  class StackLevelError < Error; end
+end

data/lib/liquid/extensions.rb

@@ -0,0 +1,62 @@
+require 'time'
+require 'date'
+
+class String # :nodoc:
+  def to_liquid
+    self
+  end
+end
+
+class Array  # :nodoc:
+  def to_liquid
+    self
+  end
+end
+
+class Hash  # :nodoc:
+  def to_liquid
+    self
+  end
+end
+
+class Numeric  # :nodoc:
+  def to_liquid
+    self
+  end
+end
+
+class Time  # :nodoc:
+  def to_liquid
+    self
+  end
+end
+
+class DateTime < Date  # :nodoc:
+  def to_liquid
+    self
+  end
+end
+
+class Date  # :nodoc:
+  def to_liquid
+    self
+  end
+end
+
+class TrueClass
+  def to_liquid  # :nodoc:
+    self
+  end
+end
+
+class FalseClass
+  def to_liquid # :nodoc:
+    self
+  end
+end
+
+class NilClass
+  def to_liquid # :nodoc:
+    self
+  end
+end

data/lib/liquid/file_system.rb

@@ -0,0 +1,62 @@
+module Liquid
+  # A Liquid file system is way to let your templates retrieve other templates for use with the include tag.
+  #
+  # You can implement subclasses that retrieve templates from the database, from the file system using a different 
+  # path structure, you can provide them as hard-coded inline strings, or any manner that you see fit.
+  #
+  # You can add additional instance variables, arguments, or methods as needed.
+  #
+  # Example:
+  #
+  # Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
+  # liquid = Liquid::Template.parse(template)
+  #
+  # This will parse the template with a LocalFileSystem implementation rooted at 'template_path'.
+  class BlankFileSystem
+    # Called by Liquid to retrieve a template file
+    def read_template_file(template_path, context)
+      raise FileSystemError, "This liquid context does not allow includes."
+    end
+  end
+  
+  # This implements an abstract file system which retrieves template files named in a manner similar to Rails partials,
+  # ie. with the template name prefixed with an underscore. The extension ".liquid" is also added.
+  #
+  # For security reasons, template paths are only allowed to contain letters, numbers, and underscore.
+  #
+  # Example:
+  #
+  # file_system = Liquid::LocalFileSystem.new("/some/path")
+  # 
+  # file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquid"
+  # file_system.full_path("dir/mypartial")   # => "/some/path/dir/_mypartial.liquid"
+  #
+  class LocalFileSystem
+    attr_accessor :root
+    
+    def initialize(root)
+      @root = root
+    end
+    
+    def read_template_file(template_path, context)
+      full_path = full_path(template_path)
+      raise FileSystemError, "No such template '#{template_path}'" unless File.exists?(full_path)
+      
+      File.read(full_path)
+    end
+    
+    def full_path(template_path)
+      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /^[^.\/][a-zA-Z0-9_\/]+$/
+      
+      full_path = if template_path.include?('/')
+        File.join(root, File.dirname(template_path), "_#{File.basename(template_path)}.liquid")
+      else
+        File.join(root, "_#{template_path}.liquid")
+      end
+      
+      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path) =~ /^#{File.expand_path(root)}/
+      
+      full_path
+    end
+  end
+end

data/lib/liquid/htmltags.rb

@@ -0,0 +1,75 @@
+module Liquid
+  class TableRow < Block
+    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/
+
+    def initialize(tag_name, markup, tokens)
+      if markup =~ Syntax
+        @variable_name = $1
+        @collection_name = $2
+        @attributes = {}
+        markup.scan(TagAttributes) do |key, value|
+          @attributes[key] = value
+        end
+      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)
+      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
+
+        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,
+            '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)
+            col  = 0
+            row += 1
+            result << "</tr>\n<tr class=\"row#{row}\">"
+          end
+
+        end
+      end
+      result << "</tr>\n"
+      result
+    end
+  end
+
+  Template.register_tag('tablerow', TableRow)
+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

@@ -0,0 +1,241 @@
+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
+
+    def escape_once(input)
+      ActionView::Helpers::TagHelper.escape_once(input)
+    rescue NameError
+      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
+
+    # Split input string into an array of substrings separated by given pattern.
+    def split(input, pattern)
+      input.split(pattern)
+    end
+
+    def strip_html(input)
+      input.to_s.gsub(/<script.*?<\/script>/, '').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
+
+      if ((input.is_a?(String) && !/^\d+$/.match(input.to_s).nil?) || input.is_a?(Integer)) && input.to_i > 0
+        input = Time.at(input.to_i)
+      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)
+      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
+
+    def modulo(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
+        end
+      end
+
+  end
+
+  Template.register_filter(StandardFilters)
+end