liquid 3.0.6 → 4.0.0.rc1

data/lib/liquid/standardfilters.rb

@@ -2,7 +2,6 @@ require 'cgi'
 require 'bigdecimal'
 
 module Liquid
-
   module StandardFilters
     HTML_ESCAPE = {
       '&'.freeze => '&'.freeze,
@@ -34,7 +33,7 @@ module Liquid
     end
 
     def escape(input)
-      CGI.escapeHTML(input).untaint rescue input
+      CGI.escapeHTML(input).untaint unless input.nil?
     end
     alias_method :h, :escape
 
@@ -43,12 +42,16 @@ module Liquid
     end
 
     def url_encode(input)
-      CGI.escape(input) rescue input
+      CGI.escape(input) unless input.nil?
+    end
+
+    def url_decode(input)
+      CGI.unescape(input) unless input.nil?
     end
 
-    def slice(input, offset, length=nil)
-      offset = Integer(offset)
-      length = length ? Integer(length) : 1
+    def slice(input, offset, length = nil)
+      offset = Utils.to_integer(offset)
+      length = length ? Utils.to_integer(length) : 1
 
       if input.is_a?(Array)
         input.slice(offset, length) || []
@@ -59,16 +62,19 @@ module Liquid
 
     # Truncate a string down to x characters
     def truncate(input, length = 50, truncate_string = "...".freeze)
-      if input.nil? then return end
-      l = length.to_i - truncate_string.length
+      return if input.nil?
+      input_str = input.to_s
+      length = Utils.to_integer(length)
+      l = length - truncate_string.length
       l = 0 if l < 0
-      input.length > length.to_i ? input[0...l] + truncate_string : input
+      input_str.length > length ? input_str[0...l] + truncate_string : input_str
     end
 
     def truncatewords(input, words = 15, truncate_string = "...".freeze)
-      if input.nil? then return end
+      return if input.nil?
       wordlist = input.to_s.split
-      l = words.to_i - 1
+      words = Utils.to_integer(words)
+      l = words - 1
       l = 0 if l < 0
       wordlist.length > l ? wordlist[0..l].join(" ".freeze) + truncate_string : input
     end
@@ -115,10 +121,28 @@ module Liquid
       ary = InputIterator.new(input)
       if property.nil?
         ary.sort
+      elsif ary.empty? # The next two cases assume a non-empty array.
+        []
+      elsif ary.first.respond_to?(:[]) && !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
+
+    # Sort elements of an array ignoring case if strings
+    # provide optional property with which to sort an array of hashes or drops
+    def sort_natural(input, property = nil)
+      ary = InputIterator.new(input)
+
+      if property.nil?
+        ary.sort { |a, b| a.casecmp(b) }
+      elsif ary.empty? # The next two cases assume a non-empty array.
+        []
       elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
-        ary.sort {|a,b| a[property] <=> b[property] }
+        ary.sort { |a, b| a[property].casecmp(b[property]) }
       elsif ary.first.respond_to?(property)
-        ary.sort {|a,b| a.send(property) <=> b.send(property) }
+        ary.sort { |a, b| a.send(property).casecmp(b.send(property)) }
       end
     end
 
@@ -126,10 +150,13 @@ module Liquid
     # provide optional property with which to determine uniqueness
     def uniq(input, property = nil)
       ary = InputIterator.new(input)
+
       if property.nil?
-        input.uniq
-      elsif input.first.respond_to?(:[])
-        input.uniq{ |a| a[property] }
+        ary.uniq
+      elsif ary.empty? # The next two cases assume a non-empty array.
+        []
+      elsif ary.first.respond_to?(:[])
+        ary.uniq{ |a| a[property] }
       end
     end
 
@@ -147,29 +174,46 @@ module Liquid
         if property == "to_liquid".freeze
           e
         elsif e.respond_to?(:[])
-          e[property]
+          r = e[property]
+          r.is_a?(Proc) ? r.call : r
         end
       end
     end
 
+    # Remove nils within an array
+    # provide optional property with which to check for nil
+    def compact(input, property = nil)
+      ary = InputIterator.new(input)
+
+      if property.nil?
+        ary.compact
+      elsif ary.empty? # The next two cases assume a non-empty array.
+        []
+      elsif ary.first.respond_to?(:[])
+        ary.reject{ |a| a[property].nil? }
+      elsif ary.first.respond_to?(property)
+        ary.reject { |a| a.send(property).nil? }
+      end
+    end
+
     # Replace occurrences of a string with another
     def replace(input, string, replacement = ''.freeze)
-      input.to_s.gsub(string, replacement.to_s)
+      input.to_s.gsub(string.to_s, replacement.to_s)
     end
 
     # Replace the first occurrences of a string with another
     def replace_first(input, string, replacement = ''.freeze)
-      input.to_s.sub(string, replacement.to_s)
+      input.to_s.sub(string.to_s, replacement.to_s)
     end
 
     # remove a substring
     def remove(input, string)
-      input.to_s.gsub(string, ''.freeze)
+      input.to_s.gsub(string.to_s, ''.freeze)
     end
 
     # remove the first occurrences of a substring
     def remove_first(input, string)
-      input.to_s.sub(string, ''.freeze)
+      input.to_s.sub(string.to_s, ''.freeze)
     end
 
     # add one string to another
@@ -177,6 +221,10 @@ module Liquid
       input.to_s + string.to_s
     end
 
+    def concat(input, array)
+      InputIterator.new(input).concat(array)
+    end
+
     # prepend a string to another
     def prepend(input, string)
       string.to_s + input.to_s
@@ -221,7 +269,7 @@ module Liquid
     def date(input, format)
       return input if format.to_s.empty?
 
-      return input unless date = to_date(input)
+      return input unless date = Utils.to_date(input)
 
       date.strftime(format.to_s)
     end
@@ -262,25 +310,35 @@ module Liquid
     # division
     def divided_by(input, operand)
       apply_operation(input, operand, :/)
+    rescue ::ZeroDivisionError => e
+      raise Liquid::ZeroDivisionError, e.message
     end
 
     def modulo(input, operand)
       apply_operation(input, operand, :%)
+    rescue ::ZeroDivisionError => e
+      raise Liquid::ZeroDivisionError, e.message
     end
 
     def round(input, n = 0)
-      result = to_number(input).round(to_number(n))
+      result = Utils.to_number(input).round(Utils.to_number(n))
       result = result.to_f if result.is_a?(BigDecimal)
       result = result.to_i if n == 0
       result
+    rescue ::FloatDomainError => e
+      raise Liquid::FloatDomainError, e.message
     end
 
     def ceil(input)
-      to_number(input).ceil.to_i
+      Utils.to_number(input).ceil.to_i
+    rescue ::FloatDomainError => e
+      raise Liquid::FloatDomainError, e.message
     end
 
     def floor(input)
-      to_number(input).floor.to_i
+      Utils.to_number(input).floor.to_i
+    rescue ::FloatDomainError => e
+      raise Liquid::FloatDomainError, e.message
     end
 
     def default(input, default_value = "".freeze)
@@ -290,38 +348,8 @@ module Liquid
 
     private
 
-    def to_number(obj)
-      case obj
-      when Float
-        BigDecimal.new(obj.to_s)
-      when Numeric
-        obj
-      when String
-        (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 = Utils.to_number(input).send(operation, Utils.to_number(operand))
       result.is_a?(BigDecimal) ? result.to_f : result
     end
 
@@ -344,10 +372,27 @@ module Liquid
         to_a.join(glue)
       end
 
+      def concat(args)
+        to_a.concat args
+      end
+
       def reverse
         reverse_each.to_a
       end
 
+      def uniq(&block)
+        to_a.uniq(&block)
+      end
+
+      def compact
+        to_a.compact
+      end
+
+      def empty?
+        @input.each { return false }
+        true
+      end
+
       def each
         @input.each do |e|
           yield(e.respond_to?(:to_liquid) ? e.to_liquid : e)

data/lib/liquid/strainer.rb

@@ -1,7 +1,6 @@
 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.
   #
@@ -22,14 +21,14 @@ module Liquid
       @context = context
     end
 
-    def self.filter_methods
-      @filter_methods
+    class << self
+      attr_reader :filter_methods
     end
 
     def self.add_filter(filter)
       raise ArgumentError, "Expected module but got: #{f.class}" unless filter.is_a?(Module)
       unless self.class.include?(filter)
-        self.send(:include, filter)
+        send(:include, filter)
         @filter_methods.merge(filter.public_instance_methods.map(&:to_s))
       end
     end
@@ -53,7 +52,7 @@ module Liquid
         args.first
       end
     rescue ::ArgumentError => e
-      raise Liquid::ArgumentError.new(e.message)
+      raise Liquid::ArgumentError, e.message, e.backtrace
     end
   end
 end

data/lib/liquid/tablerowloop_drop.rb

@@ -0,0 +1,62 @@
+module Liquid
+  class TablerowloopDrop < Drop
+    def initialize(length, cols)
+      @length = length
+      @row = 1
+      @col = 1
+      @cols = cols
+      @index = 0
+    end
+
+    attr_reader :length, :col, :row
+
+    def index
+      @index + 1
+    end
+
+    def index0
+      @index
+    end
+
+    def col0
+      @col - 1
+    end
+
+    def rindex
+      @length - @index
+    end
+
+    def rindex0
+      @length - @index - 1
+    end
+
+    def first
+      @index == 0
+    end
+
+    def last
+      @index == @length - 1
+    end
+
+    def col_first
+      @col == 1
+    end
+
+    def col_last
+      @col == @cols
+    end
+
+    protected
+
+    def increment!
+      @index += 1
+
+      if @col == @cols
+        @col = 1
+        @row += 1
+      else
+        @col += 1
+      end
+    end
+  end
+end

data/lib/liquid/tag.rb

@@ -1,26 +1,27 @@
 module Liquid
   class Tag
-    attr_accessor :options, :line_number
-    attr_reader :nodelist, :warnings
+    attr_reader :nodelist, :tag_name, :line_number, :parse_context
+    alias_method :options, :parse_context
     include ParserSwitching
 
     class << self
-      def parse(tag_name, markup, tokens, options)
+      def parse(tag_name, markup, tokenizer, options)
         tag = new(tag_name, markup, options)
-        tag.parse(tokens)
+        tag.parse(tokenizer)
         tag
       end
 
       private :new
     end
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, parse_context)
       @tag_name   = tag_name
       @markup     = markup
-      @options    = options
+      @parse_context = parse_context
+      @line_number = parse_context.line_number
     end
 
-    def parse(tokens)
+    def parse(_tokens)
     end
 
     def raw
@@ -31,7 +32,7 @@ module Liquid
       self.class.name.downcase
     end
 
-    def render(context)
+    def render(_context)
       ''.freeze
     end
 

data/lib/liquid/tags/assign.rb

@@ -1,5 +1,4 @@
 module Liquid
-
   # Assign sets a variable in your template.
   #
   #   {% assign foo = 'monkey' %}
@@ -15,8 +14,7 @@ module Liquid
       super
       if markup =~ Syntax
         @to = $1
-        @from = Variable.new($2,options)
-        @from.line_number = line_number
+        @from = Variable.new($2, options)
       else
         raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
       end
@@ -25,7 +23,10 @@ module Liquid
     def render(context)
       val = @from.render(context)
       context.scopes.last[@to] = val
-      context.increment_used_resources(:assign_score_current, val)
+
+      inc = val.instance_of?(String) || val.instance_of?(Array) || val.instance_of?(Hash) ? val.length : 1
+      context.resource_limits.assign_score += inc
+
       ''.freeze
     end