liquid 2.6.3 → 3.0.0.rc1

data/lib/liquid/strainer.rb

@@ -11,6 +11,11 @@ module Liquid
     @@filters = []
     @@known_filters = Set.new
     @@known_methods = Set.new
+    @@strainer_class_cache = Hash.new do |hash, filters|
+      hash[filters] = Class.new(Strainer) do
+        filters.each { |f| include f }
+      end
+    end
 
     def initialize(context)
       @context = context
@@ -32,10 +37,13 @@ module Liquid
       end
     end
 
-    def self.create(context)
-      strainer = Strainer.new(context)
-      @@filters.each { |m| strainer.extend(m) }
-      strainer
+    def self.strainer_class_cache
+      @@strainer_class_cache
+    end
+
+    def self.create(context, filters = [])
+      filters = @@filters + filters
+      strainer_class_cache[filters].new(context)
     end
 
     def invoke(method, *args)
@@ -44,6 +52,8 @@ module Liquid
       else
         args.first
       end
+    rescue ::ArgumentError => e
+      raise Liquid::ArgumentError.new(e.message)
     end
 
     def invokable?(method)

data/lib/liquid/tag.rb

@@ -1,13 +1,22 @@
 module Liquid
-
   class Tag
+    attr_accessor :options
+    attr_reader :nodelist, :warnings
+
+    class << self
+      def parse(tag_name, markup, tokens, options)
+        tag = new(tag_name, markup, options)
+        tag.parse(tokens)
+        tag
+      end
 
-    attr_accessor :nodelist
+      private :new
+    end
 
-    def initialize(tag_name, markup, tokens)
+    def initialize(tag_name, markup, options)
       @tag_name   = tag_name
       @markup     = markup
-      parse(tokens)
+      @options    = options
     end
 
     def parse(tokens)
@@ -18,9 +27,35 @@ module Liquid
     end
 
     def render(context)
-      ''
+      ''.freeze
+    end
+
+    def blank?
+      false
+    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
 
-  end # Tag
+    private
 
-end # Liquid
+    def strict_parse_with_error_context(markup)
+      strict_parse(markup)
+    rescue SyntaxError => e
+      e.message << " in \"#{markup.strip}\"" 
+      raise e
+    end
+  end
+end

data/lib/liquid/tags/assign.rb

@@ -9,27 +9,29 @@ module Liquid
   #  {{ foo }}
   #
   class Assign < Tag
-    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/o
+    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
 
-    def initialize(tag_name, markup, tokens)
+    def initialize(tag_name, markup, options)
+      super
       if markup =~ Syntax
         @to = $1
         @from = Variable.new($2)
       else
-        raise SyntaxError.new("Syntax Error in 'assign' - Valid syntax: assign [var] = [source]")
+        raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
       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)
-      ''
+      context.increment_used_resources(:assign_score_current, val)
+      ''.freeze
     end
 
+    def blank?
+      true
+    end
   end
 
-  Template.register_tag('assign', Assign)
+  Template.register_tag('assign'.freeze, Assign)
 end

data/lib/liquid/tags/break.rb

@@ -17,5 +17,5 @@ module Liquid
 
   end
 
-  Template.register_tag('break', Break)
+  Template.register_tag('break'.freeze, Break)
 end

data/lib/liquid/tags/capture.rb

@@ -1,5 +1,4 @@
 module Liquid
-
   # Capture stores the result of a block into a variable without rendering it inplace.
   #
   #   {% capture heading %}
@@ -14,23 +13,26 @@ module Liquid
   class Capture < Block
     Syntax = /(\w+)/
 
-    def initialize(tag_name, markup, tokens)
+    def initialize(tag_name, markup, options)
+      super
       if markup =~ Syntax
         @to = $1
       else
-        raise SyntaxError.new("Syntax Error in 'capture' - Valid syntax: capture [var]")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.capture"))
       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)
-      ''
+      context.increment_used_resources(:assign_score_current, output)
+      ''.freeze
+    end
+
+    def blank?
+      true
     end
   end
 
-  Template.register_tag('capture', Capture)
+  Template.register_tag('capture'.freeze, Capture)
 end

data/lib/liquid/tags/case.rb

@@ -1,26 +1,29 @@
 module Liquid
   class Case < Block
     Syntax     = /(#{QuotedFragment})/o
-    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/o
+    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/om
 
-    def initialize(tag_name, markup, tokens)
+    def initialize(tag_name, markup, options)
+      super
       @blocks = []
 
       if markup =~ Syntax
         @left = $1
       else
-        raise SyntaxError.new("Syntax Error in tag 'case' - Valid syntax: case [condition]")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case".freeze))
       end
+    end
 
-      super
+    def nodelist
+      @blocks.map(&:attachment).flatten
     end
 
     def unknown_tag(tag, markup, tokens)
       @nodelist = []
       case tag
-      when 'when'
+      when 'when'.freeze
         record_when_condition(markup)
-      when 'else'
+      when 'else'.freeze
         record_else_condition(markup)
       else
         super
@@ -50,30 +53,27 @@ module Liquid
       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...] %} ")
+          raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when".freeze))
         end
 
         markup = $2
 
-        block = Condition.new(@left, '==', $1)
+        block = Condition.new(@left, '=='.freeze, $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) ")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_else".freeze))
       end
 
       block = ElseCondition.new
       block.attach(@nodelist)
       @blocks << block
     end
-
-
   end
 
-  Template.register_tag('case', Case)
+  Template.register_tag('case'.freeze, Case)
 end

data/lib/liquid/tags/comment.rb

@@ -1,9 +1,16 @@
 module Liquid
   class Comment < Block
     def render(context)
-      ''
+      ''.freeze
+    end
+
+    def unknown_tag(tag, markup, tokens)
+    end
+
+    def blank?
+      true
     end
   end
 
-  Template.register_tag('comment', Comment)
+  Template.register_tag('comment'.freeze, Comment)
 end

data/lib/liquid/tags/continue.rb

@@ -1,5 +1,4 @@
 module Liquid
-
   # Continue tag to be used to break out of a for loop.
   #
   # == Basic Usage:
@@ -10,12 +9,10 @@ module Liquid
   #    {% endfor %}
   #
   class Continue < Tag
-
     def interrupt
       ContinueInterrupt.new
     end
-
   end
 
-  Template.register_tag('continue', Continue)
+  Template.register_tag('continue'.freeze, Continue)
 end

data/lib/liquid/tags/cycle.rb

@@ -1,5 +1,4 @@
 module Liquid
-
   # Cycle is usually used within a loop to alternate between values, like colors or DOM classes.
   #
   #   {% for item in items %}
@@ -13,10 +12,11 @@ module Liquid
   #    <div class="green"> Item five</div>
   #
   class Cycle < Tag
-    SimpleSyntax = /^#{QuotedFragment}+/o
-    NamedSyntax  = /^(#{QuotedFragment})\s*\:\s*(.*)/o
+    SimpleSyntax = /\A#{QuotedFragment}+/o
+    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
 
-    def initialize(tag_name, markup, tokens)
+    def initialize(tag_name, markup, options)
+      super
       case markup
       when NamedSyntax
         @variables = variables_from_string($2)
@@ -25,9 +25,8 @@ module Liquid
         @variables = variables_from_string(markup)
         @name = "'#{@variables.to_s}'"
       else
-        raise SyntaxError.new("Syntax Error in 'cycle' - Valid syntax: cycle [name :] var [, var2, var3 ...]")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze))
       end
-      super
     end
 
     def render(context)
@@ -52,7 +51,6 @@ module Liquid
         $1 ? $1 : nil
       end.compact
     end
-
   end
 
   Template.register_tag('cycle', Cycle)

data/lib/liquid/tags/decrement.rb

@@ -19,10 +19,9 @@ module Liquid
   #    Hello: -3
   #
   class Decrement < Tag
-    def initialize(tag_name, markup, tokens)
-      @variable = markup.strip
-
+    def initialize(tag_name, markup, options)
       super
+      @variable = markup.strip
     end
 
     def render(context)
@@ -35,5 +34,5 @@ module Liquid
     private
   end
 
-  Template.register_tag('decrement', Decrement)
+  Template.register_tag('decrement'.freeze, Decrement)
 end

data/lib/liquid/tags/for.rb

@@ -44,28 +44,24 @@ module Liquid
   # forloop.last:: Returns true if the item is the last item.
   #
   class For < Block
-    Syntax = /\A(\w+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
+    Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
 
-    def initialize(tag_name, markup, tokens)
-      if markup =~ Syntax
-        @variable_name = $1
-        @collection_name = $2
-        @name = "#{$1}-#{$2}"
-        @reversed = $3
-        @attributes = {}
-        markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = value
-        end
+    def initialize(tag_name, markup, options)
+      super
+      parse_with_selected_parser(markup)
+      @nodelist = @for_block = []
+    end
+
+    def nodelist
+      if @else_block
+        @for_block + @else_block
       else
-        raise SyntaxError.new("Syntax Error in 'for loop' - Valid syntax: for [item] in [collection]")
+        @for_block
       end
-
-      @nodelist = @for_block = []
-      super
     end
 
     def unknown_tag(tag, markup, tokens)
-      return super unless tag == 'else'
+      return super unless tag == 'else'.freeze
       @nodelist = @else_block = []
     end
 
@@ -78,17 +74,16 @@ module Liquid
       # Maintains Ruby 1.8.7 String#each behaviour on 1.9
       return render_else(context) unless iterable?(collection)
 
-      from = if @attributes['offset'] == 'continue'
+      from = if @attributes['offset'.freeze] == 'continue'.freeze
         context.registers[:for][@name].to_i
       else
-        context[@attributes['offset']].to_i
+        context[@attributes['offset'.freeze]].to_i
       end
 
-      limit = context[@attributes['limit']]
+      limit = context[@attributes['limit'.freeze]]
       to    = limit ? limit.to_i + from : nil
 
-
-      segment = Utils.slice_collection_using_each(collection, from, to)
+      segment = Utils.slice_collection(collection, from, to)
 
       return render_else(context) if segment.empty?
 
@@ -104,15 +99,16 @@ module Liquid
       context.stack do
         segment.each_with_index do |item, index|
           context[@variable_name] = item
-          context['forloop'] = {
-            'name'    => @name,
-            'length'  => length,
-            'index'   => index + 1,
-            'index0'  => index,
-            'rindex'  => length - index,
-            'rindex0' => length - index - 1,
-            'first'   => (index == 0),
-          'last'    => (index == length - 1) }
+          context['forloop'.freeze] = {
+            'name'.freeze    => @name,
+            'length'.freeze  => length,
+            'index'.freeze   => index + 1,
+            'index0'.freeze  => index,
+            'rindex'.freeze  => length - index,
+            'rindex0'.freeze => length - index - 1,
+            'first'.freeze   => (index == 0),
+            'last'.freeze    => (index == length - 1)
+          }
 
           result << render_all(@for_block, context)
 
@@ -127,16 +123,53 @@ module Liquid
       result
     end
 
-    private
+    protected
 
-      def render_else(context)
-        return @else_block ? [render_all(@else_block, context)] : ''
+    def lax_parse(markup)
+      if markup =~ Syntax
+        @variable_name = $1
+        @collection_name = $2
+        @name = "#{$1}-#{$2}"
+        @reversed = $3
+        @attributes = {}
+        markup.scan(TagAttributes) do |key, value|
+          @attributes[key] = value
+        end
+      else
+        raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze))
       end
+    end
 
-      def iterable?(collection)
-        collection.respond_to?(:each) || Utils.non_blank_string?(collection)
+    def strict_parse(markup)
+      p = Parser.new(markup)
+      @variable_name = p.consume(:id)
+      raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_in".freeze))  unless p.id?('in'.freeze)
+      @collection_name = p.expression
+      @name = "#{@variable_name}-#{@collection_name}"
+      @reversed = p.id?('reversed'.freeze)
+
+      @attributes = {}
+      while p.look(:id) && p.look(:colon, 1)
+        unless attribute = p.id?('limit'.freeze) || p.id?('offset'.freeze)
+          raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute".freeze))
+        end
+        p.consume
+        val = p.expression
+        @attributes[attribute] = val
       end
+      p.consume(:end_of_string)
+    end
+
+    private
+
+    def render_else(context)
+      return @else_block ? [render_all(@else_block, context)] : ''.freeze
+    end
+
+    def iterable?(collection)
+      collection.respond_to?(:each) || Utils.non_blank_string?(collection)
+    end
   end
 
-  Template.register_tag('for', For)
+  Template.register_tag('for'.freeze, For)
 end