liquid 2.6.3 → 3.0.0.rc1

data/lib/liquid/document.rb

@@ -1,8 +1,8 @@
 module Liquid
   class Document < Block
-    # we don't need markup to open this block
-    def initialize(tokens)
-      parse(tokens)
+    def self.parse(tokens, options={})
+      # we don't need markup to open this block
+      super(nil, nil, tokens, options)
     end
 
     # There isn't a real delimiter

data/lib/liquid/drop.rb

@@ -44,17 +44,33 @@ module Liquid
       true
     end
 
+    def inspect
+      self.class.to_s
+    end
+
     def to_liquid
       self
     end
 
+    def to_s
+      self.class.name
+    end
+
     alias :[] :invoke_drop
 
     private
 
     # Check for method existence without invoking respond_to?, which creates symbols
     def self.invokable?(method_name)
-      @invokable_methods ||= Set.new(["to_liquid"] + (public_instance_methods - Liquid::Drop.public_instance_methods).map(&:to_s))
+      unless @invokable_methods
+        blacklist = Liquid::Drop.public_instance_methods + [:each]
+        if include?(Enumerable)
+          blacklist += Enumerable.public_instance_methods
+          blacklist -= [:sort, :count, :first, :min, :max, :include?]
+        end
+        whitelist = [:to_liquid] + (public_instance_methods - blacklist)
+        @invokable_methods = Set.new(whitelist.map(&:to_s))
+      end
       @invokable_methods.include?(method_name.to_s)
     end
   end

data/lib/liquid/file_system.rb

@@ -31,11 +31,22 @@ module Liquid
   # file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquid"
   # file_system.full_path("dir/mypartial")   # => "/some/path/dir/_mypartial.liquid"
   #
+  # Optionally in the second argument you can specify a custom pattern for template filenames.
+  # The Kernel::sprintf format specification is used.
+  # Default pattern is "_%s.liquid".
+  #
+  # Example:
+  #
+  # file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
+  #
+  # file_system.full_path("index") # => "/some/path/index.html"
+  #
   class LocalFileSystem
     attr_accessor :root
 
-    def initialize(root)
+    def initialize(root, pattern = "_%s.liquid".freeze)
       @root = root
+      @pattern = pattern
     end
 
     def read_template_file(template_path, context)
@@ -46,15 +57,15 @@ module Liquid
     end
 
     def full_path(template_path)
-      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /^[^.\/][a-zA-Z0-9_\/]+$/
+      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /\A[^.\/][a-zA-Z0-9_\/]+\z/
 
-      full_path = if template_path.include?('/')
-        File.join(root, File.dirname(template_path), "_#{File.basename(template_path)}.liquid")
+      full_path = if template_path.include?('/'.freeze)
+        File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))
       else
-        File.join(root, "_#{template_path}.liquid")
+        File.join(root, @pattern % template_path)
       end
 
-      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path) =~ /^#{File.expand_path(root)}/
+      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path) =~ /\A#{File.expand_path(root)}/
 
       full_path
     end

data/lib/liquid/i18n.rb

@@ -0,0 +1,39 @@
+require 'yaml'
+
+module Liquid
+  class I18n
+    DEFAULT_LOCALE = File.join(File.expand_path(File.dirname(__FILE__)), "locales", "en.yml")
+
+    class TranslationError < StandardError
+    end
+
+    attr_reader :path
+
+    def initialize(path = DEFAULT_LOCALE)
+      @path = path
+    end
+
+    def translate(name, vars = {})
+      interpolate(deep_fetch_translation(name), vars)
+    end
+    alias_method :t, :translate
+
+    def locale
+      @locale ||= YAML.load_file(@path)
+    end
+
+    private
+    def interpolate(name, vars)
+      name.gsub(/%\{(\w+)\}/) {
+        # raise TranslationError, "Undefined key #{$1} for interpolation in translation #{name}"  unless vars[$1.to_sym]
+        "#{vars[$1.to_sym]}"
+      }
+    end
+
+    def deep_fetch_translation(name)
+      name.split('.'.freeze).reduce(locale) do |level, cur|
+        level[cur] or raise TranslationError, "Translation for #{name} does not exist in locale #{path}"
+      end
+    end
+  end
+end

data/lib/liquid/interrupts.rb

@@ -5,7 +5,7 @@ module Liquid
     attr_reader :message
 
     def initialize(message=nil)
-      @message = message || "interrupt"
+      @message = message || "interrupt".freeze
     end
   end
 

data/lib/liquid/lexer.rb

@@ -0,0 +1,51 @@
+require "strscan"
+module Liquid
+  class Lexer
+    SPECIALS = {
+      '|'.freeze => :pipe,
+      '.'.freeze => :dot,
+      ':'.freeze => :colon,
+      ','.freeze => :comma,
+      '['.freeze => :open_square,
+      ']'.freeze => :close_square,
+      '('.freeze => :open_round,
+      ')'.freeze => :close_round
+    }
+    IDENTIFIER = /[\w\-?!]+/
+    SINGLE_STRING_LITERAL = /'[^\']*'/
+    DOUBLE_STRING_LITERAL = /"[^\"]*"/
+    NUMBER_LITERAL = /-?\d+(\.\d+)?/
+    DOTDOT = /\.\./
+    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains/
+
+    def initialize(input)
+      @ss = StringScanner.new(input.rstrip)
+    end
+
+    def tokenize
+      @output = []
+
+      while !@ss.eos?
+        @ss.skip(/\s*/)
+        tok = case
+        when t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
+        when t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
+        when t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
+        when t = @ss.scan(NUMBER_LITERAL) then [:number, t]
+        when t = @ss.scan(IDENTIFIER) then [:id, t]
+        when t = @ss.scan(DOTDOT) then [:dotdot, t]
+        else
+          c = @ss.getch
+          if s = SPECIALS[c]
+            [s,c]
+          else
+            raise SyntaxError, "Unexpected character #{c}"
+          end
+        end
+        @output << tok
+      end
+
+      @output << [:end_of_string]
+    end
+  end
+end

data/lib/liquid/locales/en.yml

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

data/lib/liquid/parser.rb

@@ -0,0 +1,90 @@
+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 << ' '.freeze
+      end
+
+      str << expression
+      str
+    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

@@ -4,10 +4,17 @@ require 'bigdecimal'
 module Liquid
 
   module StandardFilters
+    HTML_ESCAPE = {
+      '&'.freeze => '&'.freeze,
+      '>'.freeze => '>'.freeze,
+      '<'.freeze => '&lt;'.freeze,
+      '"'.freeze => '&quot;'.freeze,
+      "'".freeze => '&#39;'.freeze
+    }
+    HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+));)/
 
     # Return the size of an array or of an string
     def size(input)
-
       input.respond_to?(:size) ? input.size : 0
     end
 
@@ -31,28 +38,25 @@ module Liquid
     end
 
     def escape_once(input)
-      ActionView::Helpers::TagHelper.escape_once(input)
-    rescue NameError
-      input
+      input.to_s.gsub(HTML_ESCAPE_ONCE_REGEXP, HTML_ESCAPE)
     end
 
     alias_method :h, :escape
 
     # Truncate a string down to x characters
-    def truncate(input, length = 50, truncate_string = "...")
+    def truncate(input, length = 50, truncate_string = "...".freeze)
       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
+      input.length > length.to_i ? input[0...l] + truncate_string : input
     end
 
-    def truncatewords(input, words = 15, truncate_string = "...")
+    def truncatewords(input, words = 15, truncate_string = "...".freeze)
       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
+      wordlist.length > l ? wordlist[0..l].join(" ".freeze) + truncate_string : input
     end
 
     # Split input string into an array of substrings separated by given pattern.
@@ -64,27 +68,40 @@ module Liquid
       input.split(pattern)
     end
 
+    def strip(input)
+      input.to_s.strip
+    end
+
+    def lstrip(input)
+      input.to_s.lstrip
+    end
+
+    def rstrip(input)
+      input.to_s.rstrip
+    end
+
     def strip_html(input)
-      input.to_s.gsub(/<script.*?<\/script>/m, '').gsub(/<!--.*?-->/m, '').gsub(/<style.*?<\/style>/m, '').gsub(/<.*?>/m, '')
+      empty = ''.freeze
+      input.to_s.gsub(/<script.*?<\/script>/m, empty).gsub(/<!--.*?-->/m, empty).gsub(/<style.*?<\/style>/m, empty).gsub(/<.*?>/m, empty)
     end
 
     # Remove all newlines from the string
     def strip_newlines(input)
-      input.to_s.gsub(/\r?\n/, '')
+      input.to_s.gsub(/\r?\n/, ''.freeze)
     end
 
     # Join elements of the array with certain character between them
-    def join(input, glue = ' ')
-      [input].flatten.join(glue)
+    def join(input, glue = ' '.freeze)
+      InputIterator.new(input).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
+      ary = InputIterator.new(input)
       if property.nil?
         ary.sort
-      elsif ary.first.respond_to?('[]') and !ary.first[property].nil?
+      elsif ary.first.respond_to?('[]'.freeze) && !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) }
@@ -93,18 +110,16 @@ module Liquid
 
     # Reverse the elements of an array
     def reverse(input)
-      ary = [input].flatten
+      ary = InputIterator.new(input)
       ary.reverse
     end
 
     # map/collect on a given property
     def map(input, property)
-      ary = [input].flatten
-      ary.map do |e|
+      InputIterator.new(input).map do |e|
         e = e.call if e.is_a?(Proc)
-        e = e.to_liquid if e.respond_to?(:to_liquid)
 
-        if property == "to_liquid"
+        if property == "to_liquid".freeze
           e
         elsif e.respond_to?(:[])
           e[property]
@@ -113,23 +128,23 @@ module Liquid
     end
 
     # Replace occurrences of a string with another
-    def replace(input, string, replacement = '')
+    def replace(input, string, replacement = ''.freeze)
       input.to_s.gsub(string, replacement.to_s)
     end
 
     # Replace the first occurrences of a string with another
-    def replace_first(input, string, replacement = '')
+    def replace_first(input, string, replacement = ''.freeze)
       input.to_s.sub(string, replacement.to_s)
     end
 
     # remove a substring
     def remove(input, string)
-      input.to_s.gsub(string, '')
+      input.to_s.gsub(string, ''.freeze)
     end
 
     # remove the first occurrences of a substring
     def remove_first(input, string)
-      input.to_s.sub(string, '')
+      input.to_s.sub(string, ''.freeze)
     end
 
     # add one string to another
@@ -144,10 +159,10 @@ module Liquid
 
     # Add <br /> tags in front of all newlines in input string
     def newline_to_br(input)
-      input.to_s.gsub(/\n/, "<br />\n")
+      input.to_s.gsub(/\n/, "<br />\n".freeze)
     end
 
-    # Reformat a date
+    # Reformat a date using Ruby's core Time#strftime( string ) -> string
     #
     #   %a - The abbreviated weekday name (``Sun'')
     #   %A - The  full  weekday  name (``Sunday'')
@@ -161,6 +176,7 @@ module Liquid
     #   %m - Month of the year (01..12)
     #   %M - Minute of the hour (00..59)
     #   %p - Meridian indicator (``AM''  or  ``PM'')
+    #   %s - Number of seconds since 1970-01-01 00:00:00 UTC.
     #   %S - Second of the minute (00..60)
     #   %U - Week  number  of the current year,
     #           starting with the first Sunday as the first
@@ -175,34 +191,14 @@ module Liquid
     #   %Y - Year with century
     #   %Z - Time zone name
     #   %% - Literal ``%'' character
+    #
+    #   See also: http://www.ruby-doc.org/core/Time.html#method-i-strftime
     def date(input, format)
+      return input if format.to_s.empty?
 
-      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
+      return input unless date = to_date(input)
 
-      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
+      date.strftime(format.to_s)
     end
 
     # Get the first element of the passed in array
@@ -247,6 +243,26 @@ module Liquid
       apply_operation(input, operand, :%)
     end
 
+    def round(input, n = 0)
+      result = to_number(input).round(to_number(n))
+      result = result.to_f if result.is_a?(BigDecimal)
+      result = result.to_i if n == 0
+      result
+    end
+
+    def ceil(input)
+      to_number(input).ceil.to_i
+    end
+
+    def floor(input)
+      to_number(input).floor.to_i
+    end
+
+    def default(input, default_value = "".freeze)
+      is_blank = input.respond_to?(:empty?) ? input.empty? : !input
+      is_blank ? default_value : input
+    end
+
     private
 
     def to_number(obj)
@@ -256,16 +272,63 @@ module Liquid
       when Numeric
         obj
       when String
-        (obj.strip =~ /^\d+\.\d+$/) ? BigDecimal.new(obj) : obj.to_i
+        (obj.strip =~ /\A\d+\.\d+\z/) ? BigDecimal.new(obj) : obj.to_i
       else
         0
       end
     end
 
+    def to_date(obj)
+      return obj if obj.respond_to?(:strftime)
+
+      case obj
+      when 'now'.freeze, 'today'.freeze
+        Time.now
+      when /\A\d+\z/, Integer
+        Time.at(obj.to_i)
+      when String
+        Time.parse(obj)
+      else
+        nil
+      end
+    rescue ArgumentError
+      nil
+    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
+
+    class InputIterator
+      include Enumerable
+
+      def initialize(input)
+        @input = if input.is_a?(Array)
+          input.flatten
+        elsif input.is_a?(Hash)
+          [input]
+        elsif input.is_a?(Enumerable)
+          input
+        else
+          Array(input)
+        end
+      end
+
+      def join(glue)
+        to_a.join(glue)
+      end
+
+      def reverse
+        reverse_each.to_a
+      end
+
+      def each
+        @input.each do |e|
+          yield(e.respond_to?(:to_liquid) ? e.to_liquid : e)
+        end
+      end
+    end
   end
 
   Template.register_filter(StandardFilters)