locomotivecms-liquid 2.6.0

data/lib/liquid/locales/en.yml

@@ -0,0 +1,25 @@
+---
+  errors:
+    syntax:
+      assign: "Syntax Error in 'assign' - Valid syntax: assign [var] = [source]"
+      capture: "Syntax Error in 'capture' - Valid syntax: capture [var]"
+      case: "Syntax Error in 'case' - Valid syntax: case [condition]"
+      case_invalid_when: "Syntax Error in tag 'case' - Valid when condition: {% when [condition] [or condition2...] %}"
+      case_invalid_else: "Syntax Error in tag 'case' - Valid else condition: {% else %} (no parameters) "
+      cycle: "Syntax Error in 'cycle' - Valid syntax: cycle [name :] var [, var2, var3 ...]"
+      for: "Syntax Error in 'for loop' - Valid syntax: for [item] in [collection]"
+      for_invalid_in: "For loops require an 'in' clause"
+      for_invalid_attribute: "Invalid attribute in for loop. Valid attributes are limit and offset"
+      if: "Syntax Error in tag 'if' - Valid syntax: if [expression]"
+      include: "Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]"
+      unknown_tag: "Unknown tag '%{tag}'"
+      invalid_delimiter: "'end' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
+      unexpected_else: "%{block_name} tag does not expect else tag"
+      tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
+      variable_termination: "Variable '%{token}' was not properly terminated with regexp: %{tag_end}"
+      tag_never_closed: "'%{block_name}' tag was never closed"
+      meta_syntax_error: "Liquid syntax error: #{e.message}"
+      table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
+
+      extends: "Syntax Error in 'extends' - Valid syntax: extends [template]"
+      block: "Syntax Error in 'block' - Valid syntax: block [name]"

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 used 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/parser.rb

@@ -0,0 +1,89 @@
+module Liquid
+  class Parser
+    def initialize(input)
+      l = Lexer.new(input)
+      @tokens = l.tokenize
+      @p = 0 # pointer to current location
+    end
+
+    def jump(point)
+      @p = point
+    end
+
+    def consume(type = nil)
+      token = @tokens[@p]
+      if type && token[0] != type
+        raise SyntaxError, "Expected #{type} but found #{@tokens[@p].first}"
+      end
+      @p += 1
+      token[1]
+    end
+
+    # Only consumes the token if it matches the type
+    # Returns the token's contents if it was consumed
+    # or false otherwise.
+    def consume?(type)
+      token = @tokens[@p]
+      return false unless token && token[0] == type
+      @p += 1
+      token[1]
+    end
+
+    # Like consume? Except for an :id token of a certain name
+    def id?(str)
+      token = @tokens[@p]
+      return false unless token && token[0] == :id
+      return false unless token[1] == str
+      @p += 1
+      token[1]
+    end
+
+    def look(type, ahead = 0)
+      tok = @tokens[@p + ahead]
+      return false unless tok
+      tok[0] == type
+    end
+
+    def expression
+      token = @tokens[@p]
+      if token[0] == :id
+        variable_signature
+      elsif [:string, :number].include? token[0]
+        consume
+      elsif token.first == :open_round
+        consume
+        first = expression
+        consume(:dotdot)
+        last = expression
+        consume(:close_round)
+        "(#{first}..#{last})"
+      else
+        raise SyntaxError, "#{token} is not a valid expression"
+      end
+    end
+
+    def argument
+      str = ""
+      # might be a keyword argument (identifier: expression)
+      if look(:id) && look(:colon, 1)
+        str << consume << consume << ' '
+      end
+
+      str << expression
+    end
+
+    def variable_signature
+      str = consume(:id)
+      if look(:open_square)
+        str << consume
+        str << expression
+        str << consume(:close_square)
+      end
+      if look(:dot)
+        str << consume
+        str << variable_signature
+      end
+      str
+    end
+  end
+end

data/lib/liquid/standardfilters.rb

@@ -0,0 +1,285 @@
+require 'cgi'
+require 'bigdecimal'
+
+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 an input string to DOWNCASE
+    def downcase(input)
+      input.to_s.downcase
+    end
+
+    # convert an 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
+      truncated = RUBY_VERSION[0,3] == "1.8" ? input.scan(/./mu)[0...l].to_s : input[0...l]
+      input.length > length.to_i ? truncated + 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.
+    #
+    # Example:
+    #   <div class="summary">{{ post | split '//' | first }}</div>
+    #
+    def split(input, pattern)
+      input.split(pattern)
+    end
+
+    def strip_html(input)
+      input.to_s.gsub(/<script.*?<\/script>/m, '').gsub(/<!--.*?-->/m, '').gsub(/<style.*?<\/style>/m, '').gsub(/<.*?>/m, '')
+    end
+
+    # Remove all newlines from the string
+    def strip_newlines(input)
+      input.to_s.gsub(/\r?\n/, '')
+    end
+
+    # Join elements of the array with certain character between them
+    def join(input, array_glue = ' ', hash_glue = nil)
+      hash_glue ||= array_glue
+
+      # translate from hash to array if needed
+      input = input.map{|k,v| "#{k}#{hash_glue}#{v}" } if input.is_a?(Hash)
+
+      [input].flatten.join(array_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 = flatten_if_necessary(input)
+      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
+
+    # Reverse the elements of an array
+    def reverse(input)
+      ary = [input].flatten
+      ary.reverse
+    end
+
+    # map/collect on a given property
+    def map(input, property)
+      flatten_if_necessary(input).map do |e|
+        e = e.call if e.is_a?(Proc)
+
+        if property == "to_liquid"
+          e
+        elsif e.respond_to?(:[])
+          e[property]
+        end
+      end
+    end
+
+    # Replace occurrences of a string with another
+    def replace(input, string, replacement = '')
+      input.to_s.gsub(string, replacement.to_s)
+    end
+
+    # Replace the first occurrences of a string with another
+    def replace_first(input, string, replacement = '')
+      input.to_s.sub(string, replacement.to_s)
+    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 = if input.is_a?(String)
+        case input.downcase
+        when 'now', 'today'
+          Time.now
+        else
+          Time.parse(input)
+        end
+      else
+        input
+      end
+
+      if date.respond_to?(:strftime)
+        date.strftime(format.to_s)
+      else
+        input
+      end
+    rescue
+      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)
+      apply_operation(input, operand, :+)
+    end
+
+    # subtraction
+    def minus(input, operand)
+      apply_operation(input, operand, :-)
+    end
+
+    # multiplication
+    def times(input, operand)
+      apply_operation(input, operand, :*)
+    end
+
+    # division
+    def divided_by(input, operand)
+      apply_operation(input, operand, :/)
+    end
+
+    def modulo(input, operand)
+      apply_operation(input, operand, :%)
+    end
+
+    private
+
+    def flatten_if_necessary(input)
+      ary = if input.is_a?(Array)
+        input.flatten
+      elsif input.kind_of?(Enumerable)
+        input
+      else
+        [input].flatten
+      end
+      ary.map{ |e| e.respond_to?(:to_liquid) ? e.to_liquid : e }
+    end
+
+    def to_number(obj)
+      case obj
+      when Float
+        BigDecimal.new(obj.to_s)
+      when Numeric
+        obj
+      when String
+        (obj.strip =~ /^\d+\.\d+$/) ? BigDecimal.new(obj) : obj.to_i
+      else
+        0
+      end
+    end
+
+    def apply_operation(input, operand, operation)
+      result = to_number(input).send(operation, to_number(operand))
+      result.is_a?(BigDecimal) ? result.to_f : result
+    end
+  end
+
+  Template.register_filter(StandardFilters)
+end

data/lib/liquid/strainer.rb

@@ -0,0 +1,53 @@
+require 'set'
+
+module Liquid
+
+  # Strainer is the parent class for the filters system.
+  # New filters are mixed into the strainer class which is then instantiated for each liquid template render run.
+  #
+  # The Strainer only allows method calls defined in filters given to it via Strainer.global_filter,
+  # Context#add_filters or Template.register_filter
+  class Strainer #:nodoc:
+    @@filters = []
+    @@known_filters = Set.new
+    @@known_methods = Set.new
+
+    def initialize(context)
+      @context = context
+    end
+
+    def self.global_filter(filter)
+      raise ArgumentError, "Passed filter is not a module" unless filter.is_a?(Module)
+      add_known_filter(filter)
+      @@filters << filter unless @@filters.include?(filter)
+    end
+
+    def self.add_known_filter(filter)
+      unless @@known_filters.include?(filter)
+        @@method_blacklist ||= Set.new(Strainer.instance_methods.map(&:to_s))
+        new_methods = filter.instance_methods.map(&:to_s)
+        new_methods.reject!{ |m| @@method_blacklist.include?(m) }
+        @@known_methods.merge(new_methods)
+        @@known_filters.add(filter)
+      end
+    end
+
+    def self.create(context)
+      strainer = Strainer.new(context)
+      @@filters.each { |m| strainer.extend(m) }
+      strainer
+    end
+
+    def invoke(method, *args)
+      if invokable?(method)
+        send(method, *args)
+      else
+        args.first
+      end
+    end
+
+    def invokable?(method)
+      @@known_methods.include?(method.to_s) && respond_to?(method)
+    end
+  end
+end

data/lib/liquid/tag.rb

@@ -0,0 +1,61 @@
+module Liquid
+  class Tag
+    attr_accessor :nodelist, :options, :line
+    attr_reader :warnings
+
+    def self.new_with_options(tag_name, markup, tokens, options)
+      # Forgive me Matz for I have sinned. I know this code is weird
+      # but it was necessary to maintain API compatibility.
+      new_tag = self.allocate
+      new_tag.options = options
+      new_tag.send(:initialize, tag_name, markup, tokens, options)
+      new_tag
+    end
+
+    def initialize(tag_name, markup, tokens, options)
+      @tag_name   = tag_name
+      @markup     = markup
+      @options    = options || {}
+      @line       = @options[:line] || 1
+      parse(tokens)
+    end
+
+    def parse(tokens)
+    end
+
+    def name
+      self.class.name.downcase
+    end
+
+    def render(context)
+      ''
+    end
+
+    def blank?
+      @blank || true
+    end
+
+    def parse_with_selected_parser(markup)
+      case @options[:error_mode] || Template.error_mode
+      when :strict then strict_parse_with_error_context(markup)
+      when :lax    then lax_parse(markup)
+      when :warn
+        begin
+          return strict_parse_with_error_context(markup)
+        rescue SyntaxError => e
+          @warnings ||= []
+          @warnings << e
+          return lax_parse(markup)
+        end
+      end
+    end
+
+    private
+    def strict_parse_with_error_context(markup)
+      strict_parse(markup)
+    rescue SyntaxError => e
+      e.message << " in \"#{markup.strip}\""
+      raise e
+    end
+  end # Tag
+end # Liquid

data/lib/liquid/tags/assign.rb

@@ -0,0 +1,36 @@
+module Liquid
+
+  # Assign sets a variable in your template.
+  #
+  #   {% assign foo = 'monkey' %}
+  #
+  # You can then use the variable later in the page.
+  #
+  #  {{ foo }}
+  #
+  class Assign < Tag
+    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/o
+
+
+    def initialize(tag_name, markup, tokens, options)
+      if markup =~ Syntax
+        @to = $1
+        @from = Variable.new($2)
+      else
+        raise SyntaxError.new options[:locale].t("errors.syntax.assign")
+      end
+
+      super
+    end
+
+    def render(context)
+      val = @from.render(context)
+      context.scopes.last[@to] = val
+      context.resource_limits[:assign_score_current] += (val.respond_to?(:length) ? val.length : 1)
+      ''
+    end
+
+  end
+
+  Template.register_tag('assign', Assign)
+end

data/lib/liquid/tags/break.rb

@@ -0,0 +1,21 @@
+module Liquid
+
+  # Break tag to be used to break out of a for loop.
+  #
+  # == Basic Usage:
+  #    {% for item in collection %}
+  #      {% if item.condition %}
+  #        {% break %}
+  #      {% endif %}
+  #    {% endfor %}
+  #
+  class Break < Tag
+
+    def interrupt
+      BreakInterrupt.new
+    end
+
+  end
+
+  Template.register_tag('break', Break)
+end

data/lib/liquid/tags/capture.rb

@@ -0,0 +1,40 @@
+module Liquid
+
+  # Capture stores the result of a block into a variable without rendering it inplace.
+  #
+  #   {% capture heading %}
+  #     Monkeys!
+  #   {% endcapture %}
+  #   ...
+  #   <h1>{{ heading }}</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, options)
+      if markup =~ Syntax
+        @to = $1
+      else
+        raise SyntaxError.new(options[:locale].t("errors.syntax.capture"), options[:line])
+      end
+
+      super
+    end
+
+    def render(context)
+      output = super
+      context.scopes.last[@to] = output
+      context.resource_limits[:assign_score_current] += (output.respond_to?(:length) ? output.length : 1)
+      ''
+    end
+
+    def blank?
+      true
+    end
+  end
+
+  Template.register_tag('capture', Capture)
+end