liquid 2.6.1 → 4.0.3

data/lib/liquid/tags/comment.rb

@@ -1,9 +1,16 @@
 module Liquid
   class Comment < Block
-    def render(context)
-      ''
+    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,32 +12,34 @@ 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
+
+    attr_reader :variables
 
-    def initialize(tag_name, markup, tokens)
+    def initialize(tag_name, markup, options)
+      super
       case markup
       when NamedSyntax
         @variables = variables_from_string($2)
-        @name = $1
+        @name = Expression.parse($1)
       when SimpleSyntax
         @variables = variables_from_string(markup)
-        @name = "'#{@variables.to_s}'"
+        @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)
-      context.registers[:cycle] ||= Hash.new(0)
+      context.registers[:cycle] ||= {}
 
       context.stack do
-        key = context[@name]
-        iteration = context.registers[:cycle][key]
-        result = context[@variables[iteration]]
+        key = context.evaluate(@name)
+        iteration = context.registers[:cycle][key].to_i
+        result = context.evaluate(@variables[iteration])
         iteration += 1
-        iteration  = 0  if iteration >= @variables.size
+        iteration  = 0 if iteration >= @variables.size
         context.registers[:cycle][key] = iteration
         result
       end
@@ -49,10 +50,15 @@ module Liquid
     def variables_from_string(markup)
       markup.split(',').collect do |var|
         var =~ /\s*(#{QuotedFragment})\s*/o
-        $1 ? $1 : nil
+        $1 ? Expression.parse($1) : nil
       end.compact
     end
 
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        Array(@node.variables)
+      end
+    end
   end
 
   Template.register_tag('cycle', Cycle)

data/lib/liquid/tags/decrement.rb

@@ -1,5 +1,4 @@
 module Liquid
-
   # decrement is used in a place where one needs to insert a counter
   #     into a template, and needs the counter to survive across
   #     multiple instantiations of the template.
@@ -19,21 +18,18 @@ 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)
       value = context.environments.first[@variable] ||= 0
-      value = value - 1
+      value -= 1
       context.environments.first[@variable] = value
       value.to_s
     end
-
-    private
   end
 
-  Template.register_tag('decrement', Decrement)
+  Template.register_tag('decrement'.freeze, Decrement)
 end

data/lib/liquid/tags/for.rb

@@ -1,5 +1,4 @@
 module Liquid
-
   # "For" iterates over an array or collection.
   # Several useful variables are available to you within the loop.
   #
@@ -24,7 +23,7 @@ module Liquid
   #      {{ item.name }}
   #    {% end %}
   #
-  #  To reverse the for loop simply use {% for item in collection reversed %}
+  #  To reverse the for loop simply use {% for item in collection reversed %} (note that the flag's spelling is different to the filter `reverse`)
   #
   # == Available variables:
   #
@@ -42,101 +41,163 @@ module Liquid
   #                   where 0 is the last item.
   # forloop.first:: Returns true if the item is the first item.
   # forloop.last:: Returns true if the item is the last item.
+  # forloop.parentloop:: Provides access to the parent loop, if present.
   #
   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
-      else
-        raise SyntaxError.new("Syntax Error in 'for loop' - Valid syntax: for [item] in [collection]")
-      end
+    attr_reader :collection_name, :variable_name, :limit, :from
 
-      @nodelist = @for_block = []
+    def initialize(tag_name, markup, options)
       super
+      @from = @limit = nil
+      parse_with_selected_parser(markup)
+      @for_block = BlockBody.new
+      @else_block = nil
+    end
+
+    def parse(tokens)
+      return unless parse_body(@for_block, tokens)
+      parse_body(@else_block, tokens)
+    end
+
+    def nodelist
+      @else_block ? [@for_block, @else_block] : [@for_block]
     end
 
     def unknown_tag(tag, markup, tokens)
-      return super unless tag == 'else'
-      @nodelist = @else_block = []
+      return super unless tag == 'else'.freeze
+      @else_block = BlockBody.new
     end
 
     def render(context)
-      context.registers[:for] ||= Hash.new(0)
+      segment = collection_segment(context)
 
-      collection = context[@collection_name]
-      collection = collection.to_a if collection.is_a?(Range)
+      if segment.empty?
+        render_else(context)
+      else
+        render_segment(context, segment)
+      end
+    end
 
-      # Maintains Ruby 1.8.7 String#each behaviour on 1.9
-      return render_else(context) unless iterable?(collection)
+    protected
 
-      from = if @attributes['offset'] == 'continue'
-        context.registers[:for][@name].to_i
+    def lax_parse(markup)
+      if markup =~ Syntax
+        @variable_name = $1
+        collection_name = $2
+        @reversed = !!$3
+        @name = "#{@variable_name}-#{collection_name}"
+        @collection_name = Expression.parse(collection_name)
+        markup.scan(TagAttributes) do |key, value|
+          set_attribute(key, value)
+        end
       else
-        context[@attributes['offset']].to_i
+        raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze))
       end
+    end
 
-      limit = context[@attributes['limit']]
-      to    = limit ? limit.to_i + from : nil
+    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}"
+      @collection_name = Expression.parse(collection_name)
+      @reversed = p.id?('reversed'.freeze)
+
+      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
+        set_attribute(attribute, p.expression)
+      end
+      p.consume(:end_of_string)
+    end
 
+    private
+
+    def collection_segment(context)
+      offsets = context.registers[:for] ||= {}
+
+      from = if @from == :continue
+        offsets[@name].to_i
+      else
+        context.evaluate(@from).to_i
+      end
 
-      segment = Utils.slice_collection_using_each(collection, from, to)
+      collection = context.evaluate(@collection_name)
+      collection = collection.to_a if collection.is_a?(Range)
 
-      return render_else(context) if segment.empty?
+      limit = context.evaluate(@limit)
+      to = limit ? limit.to_i + from : nil
 
+      segment = Utils.slice_collection(collection, from, to)
       segment.reverse! if @reversed
 
-      result = ''
+      offsets[@name] = from + segment.length
+
+      segment
+    end
 
+    def render_segment(context, segment)
+      for_stack = context.registers[:for_stack] ||= []
       length = segment.length
 
-      # Store our progress through the collection for the continue flag
-      context.registers[:for][@name] = from + segment.length
+      result = ''
 
       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) }
-
-          result << render_all(@for_block, context)
-
-          # Handle any interrupts if they exist.
-          if context.has_interrupt?
-            interrupt = context.pop_interrupt
-            break if interrupt.is_a? BreakInterrupt
-            next if interrupt.is_a? ContinueInterrupt
+        loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])
+
+        for_stack.push(loop_vars)
+
+        begin
+          context['forloop'.freeze] = loop_vars
+
+          segment.each do |item|
+            context[@variable_name] = item
+            result << @for_block.render(context)
+            loop_vars.send(:increment!)
+
+            # Handle any interrupts if they exist.
+            if context.interrupt?
+              interrupt = context.pop_interrupt
+              break if interrupt.is_a? BreakInterrupt
+              next if interrupt.is_a? ContinueInterrupt
+            end
           end
+        ensure
+          for_stack.pop
         end
       end
+
       result
     end
 
-    private
-
-      def render_else(context)
-        return @else_block ? [render_all(@else_block, context)] : ''
+    def set_attribute(key, expr)
+      case key
+      when 'offset'.freeze
+        @from = if expr == 'continue'.freeze
+          :continue
+        else
+          Expression.parse(expr)
+        end
+      when 'limit'.freeze
+        @limit = Expression.parse(expr)
       end
+    end
 
-      def iterable?(collection)
-        collection.respond_to?(:each) || Utils.non_blank_string?(collection)
+    def render_else(context)
+      @else_block ? @else_block.render(context) : ''.freeze
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        (super + [@node.limit, @node.from, @node.collection_name]).compact
       end
+    end
   end
 
-  Template.register_tag('for', For)
+  Template.register_tag('for'.freeze, For)
 end

data/lib/liquid/tags/if.rb

@@ -1,5 +1,4 @@
 module Liquid
-
   # If is the conditional block
   #
   #   {% if user.admin %}
@@ -10,23 +9,30 @@ module Liquid
   #
   #    There are {% if count < 5 %} less {% else %} more {% endif %} items than you need.
   #
-  #
   class If < Block
-    SyntaxHelp = "Syntax Error in tag 'if' - Valid syntax: if [expression]"
     Syntax = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
     ExpressionsAndOperators = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/o
-    BOOLEAN_OPERATORS = %w(and or)
+    BOOLEAN_OPERATORS = %w(and or).freeze
 
-    def initialize(tag_name, markup, tokens)
+    attr_reader :blocks
+
+    def initialize(tag_name, markup, options)
+      super
       @blocks = []
+      push_block('if'.freeze, markup)
+    end
 
-      push_block('if', markup)
+    def nodelist
+      @blocks.map(&:attachment)
+    end
 
-      super
+    def parse(tokens)
+      while parse_body(@blocks.last.attachment, tokens)
+      end
     end
 
     def unknown_tag(tag, markup, tokens)
-      if ['elsif', 'else'].include?(tag)
+      if ['elsif'.freeze, 'else'.freeze].include?(tag)
         push_block(tag, markup)
       else
         super
@@ -37,43 +43,80 @@ module Liquid
       context.stack do
         @blocks.each do |block|
           if block.evaluate(context)
-            return render_all(block.attachment, context)
+            return block.attachment.render(context)
           end
         end
-        ''
+        ''.freeze
       end
     end
 
     private
 
-      def push_block(tag, markup)
-        block = if tag == 'else'
-          ElseCondition.new
-        else
+    def push_block(tag, markup)
+      block = if tag == 'else'.freeze
+        ElseCondition.new
+      else
+        parse_with_selected_parser(markup)
+      end
 
-          expressions = markup.scan(ExpressionsAndOperators).reverse
-          raise(SyntaxError, SyntaxHelp) unless expressions.shift =~ Syntax
+      @blocks.push(block)
+      block.attach(BlockBody.new)
+    end
 
-          condition = Condition.new($1, $2, $3)
+    def lax_parse(markup)
+      expressions = markup.scan(ExpressionsAndOperators)
+      raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax
 
-          while not expressions.empty?
-            operator = (expressions.shift).to_s.strip
+      condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
 
-            raise(SyntaxError, SyntaxHelp) unless expressions.shift.to_s =~ Syntax
+      until expressions.empty?
+        operator = expressions.pop.to_s.strip
 
-            new_condition = Condition.new($1, $2, $3)
-            raise SyntaxError, "invalid boolean operator" unless BOOLEAN_OPERATORS.include?(operator)
-            new_condition.send(operator, condition)
-            condition = new_condition
-          end
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax
 
-          condition
-        end
+        new_condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
+        new_condition.send(operator, condition)
+        condition = new_condition
+      end
+
+      condition
+    end
 
-        @blocks.push(block)
-        @nodelist = block.attach(Array.new)
+    def strict_parse(markup)
+      p = Parser.new(markup)
+      condition = parse_binary_comparisons(p)
+      p.consume(:end_of_string)
+      condition
+    end
+
+    def parse_binary_comparisons(p)
+      condition = parse_comparison(p)
+      first_condition = condition
+      while op = (p.id?('and'.freeze) || p.id?('or'.freeze))
+        child_condition = parse_comparison(p)
+        condition.send(op, child_condition)
+        condition = child_condition
       end
+      first_condition
+    end
+
+    def parse_comparison(p)
+      a = Expression.parse(p.expression)
+      if op = p.consume?(:comparison)
+        b = Expression.parse(p.expression)
+        Condition.new(a, op, b)
+      else
+        Condition.new(a)
+      end
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        @node.blocks
+      end
+    end
   end
 
-  Template.register_tag('if', If)
+  Template.register_tag('if'.freeze, If)
 end