locomotivecms-liquid 2.6.0 → 4.0.0.alpha

data/lib/liquid/tags/for.rb

@@ -46,37 +46,46 @@ module Liquid
   class For < Block
     Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
 
-    def initialize(tag_name, markup, tokens, options)
-      parse_with_selected_parser(markup)
-      @nodelist = @for_block = []
+    def initialize(tag_name, markup, options)
       super
+      parse_with_selected_parser(markup)
+      @for_block = BlockBody.new
+    end
+
+    def parse(tokens)
+      if more = parse_body(@for_block, tokens)
+        parse_body(@else_block, tokens)
+      end
+    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)
 
-      collection = context[@collection_name]
+      collection = context.evaluate(@collection_name)
       collection = collection.to_a if collection.is_a?(Range)
 
       # 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 @from == :continue
         context.registers[:for][@name].to_i
       else
-        context[@attributes['offset']].to_i
+        context.evaluate(@from).to_i
       end
 
-      limit = context[@attributes['limit']]
+      limit = context.evaluate(@limit)
       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?
 
@@ -92,17 +101,18 @@ 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) }
-
-          result << render_all(@for_block, context)
+          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 << @for_block.render(context)
 
           # Handle any interrupts if they exist.
           if context.has_interrupt?
@@ -120,48 +130,60 @@ module Liquid
     def lax_parse(markup)
       if markup =~ Syntax
         @variable_name = $1
-        @collection_name = $2
-        @name = "#{$1}-#{$2}"
+        collection_name = $2
         @reversed = $3
-        @attributes = {}
+        @name = "#{@variable_name}-#{collection_name}"
+        @collection_name = Expression.parse(collection_name)
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = value
+          set_attribute(key, value)
         end
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.for"), line)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze))
       end
     end
 
     def strict_parse(markup)
       p = Parser.new(markup)
       @variable_name = p.consume(:id)
-      raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_in"), line)  unless p.id?('in')
-      @collection_name = p.expression
-      @name = "#{@variable_name}-#{@collection_name}"
-      @reversed = p.id?('reversed')
+      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)
 
-      @attributes = {}
       while p.look(:id) && p.look(:colon, 1)
-        unless attribute = p.id?('limit') || p.id?('offset')
-          raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute"), line)
+        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
+        set_attribute(attribute, p.expression)
       end
       p.consume(:end_of_string)
     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)
-      end
+    def render_else(context)
+      @else_block ? @else_block.render(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

data/lib/liquid/tags/if.rb

@@ -12,15 +12,25 @@ module Liquid
   class If < Block
     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)
 
-    def initialize(tag_name, markup, tokens, options)
-      @blocks = []
-      push_block('if', markup)
+    def initialize(tag_name, markup, options)
       super
+      @blocks = []
+      push_block('if'.freeze, markup)
+    end
+
+    def parse(tokens)
+      while more = parse_body(@blocks.last.attachment, tokens)
+      end
+    end
+
+    def nodelist
+      @blocks.map(&:attachment)
     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
@@ -31,39 +41,40 @@ 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'
+        block = if tag == 'else'.freeze
           ElseCondition.new
         else
           parse_with_selected_parser(markup)
         end
 
         @blocks.push(block)
-        @nodelist = block.attach(Array.new)
+        block.attach(BlockBody.new)
       end
 
       def lax_parse(markup)
-        expressions = markup.scan(ExpressionsAndOperators).reverse
-        raise(SyntaxError.new(options[:locale].t("errors.syntax.if")), line) unless expressions.shift =~ Syntax
+        expressions = markup.scan(ExpressionsAndOperators)
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax
 
-        condition = Condition.new($1, $2, $3)
+        condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
 
         while not expressions.empty?
-          operator = (expressions.shift).to_s.strip
+          operator = expressions.pop.to_s.strip
 
-          raise(SyntaxError.new(options[:locale].t("errors.syntax.if")), line) unless expressions.shift.to_s =~ Syntax
+          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax
 
-          new_condition = Condition.new($1, $2, $3)
-          new_condition.send(operator.to_sym, condition)
+          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
 
@@ -75,7 +86,7 @@ module Liquid
 
         condition = parse_comparison(p)
 
-        while op = (p.id?('and') || p.id?('or'))
+        while op = (p.id?('and'.freeze) || p.id?('or'.freeze))
           new_cond = parse_comparison(p)
           new_cond.send(op, condition)
           condition = new_cond
@@ -86,9 +97,9 @@ module Liquid
       end
 
       def parse_comparison(p)
-        a = p.expression
+        a = Expression.parse(p.expression)
         if op = p.consume?(:comparison)
-          b = p.expression
+          b = Expression.parse(p.expression)
           Condition.new(a, op, b)
         else
           Condition.new(a)
@@ -96,5 +107,5 @@ module Liquid
       end
   end
 
-  Template.register_tag('if', If)
+  Template.register_tag('if'.freeze, If)
 end

data/lib/liquid/tags/ifchanged.rb

@@ -4,17 +4,17 @@ module Liquid
     def render(context)
       context.stack do
 
-        output = render_all(@nodelist, context)
+        output = super
 
         if output != context.registers[:ifchanged]
           context.registers[:ifchanged] = output
           output
         else
-          ''
+          ''.freeze
         end
       end
     end
   end
 
-  Template.register_tag('ifchanged', Ifchanged)
-end
+  Template.register_tag('ifchanged'.freeze, Ifchanged)
+end

data/lib/liquid/tags/include.rb

@@ -17,47 +17,47 @@ module Liquid
   class Include < Tag
     Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o
 
-    def initialize(tag_name, markup, tokens, options)
+    def initialize(tag_name, markup, options)
+      super
+
       if markup =~ Syntax
 
-        @template_name = $1
-        @variable_name = $3
+        template_name = $1
+        variable_name = $3
+
+        @variable_name = Expression.parse(variable_name || template_name[1..-2])
+        @context_variable_name = template_name[1..-2].split('/'.freeze).last
+        @template_name = Expression.parse(template_name)
         @attributes    = {}
 
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = value
+          @attributes[key] = Expression.parse(value)
         end
 
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.include"), options[:line])
+        raise SyntaxError.new(options[:locale].t("errors.syntax.include".freeze))
       end
-
-      super
     end
 
     def parse(tokens)
     end
 
-    def blank?
-      false
-    end
-
     def render(context)
       partial = load_cached_partial(context)
-      variable = context[@variable_name || @template_name[1..-2]]
+      variable = context.evaluate(@variable_name)
 
       context.stack do
         @attributes.each do |key, value|
-          context[key] = context[value]
+          context[key] = context.evaluate(value)
         end
 
         if variable.is_a?(Array)
           variable.collect do |var|
-            context[@template_name[1..-2]] = var
+            context[@context_variable_name] = var
             partial.render(context)
           end
         else
-          context[@template_name[1..-2]] = variable
+          context[@context_variable_name] = variable
           partial.render(context)
         end
       end
@@ -66,13 +66,13 @@ module Liquid
     private
       def load_cached_partial(context)
         cached_partials = context.registers[:cached_partials] || {}
-        template_name = context[@template_name]
+        template_name = context.evaluate(@template_name)
 
         if cached = cached_partials[template_name]
           return cached
         end
         source = read_template_from_file_system(context)
-        partial = Liquid::Template.parse(source)
+        partial = Liquid::Template.parse(source, pass_options)
         cached_partials[template_name] = partial
         context.registers[:cached_partials] = cached_partials
         partial
@@ -84,14 +84,24 @@ module Liquid
         # make read_template_file call backwards-compatible.
         case file_system.method(:read_template_file).arity
         when 1
-          file_system.read_template_file(context[@template_name])
+          file_system.read_template_file(context.evaluate(@template_name))
         when 2
-          file_system.read_template_file(context[@template_name], context)
+          file_system.read_template_file(context.evaluate(@template_name), context)
         else
           raise ArgumentError, "file_system.read_template_file expects two parameters: (template_name, context)"
         end
       end
+
+      def pass_options
+        dont_pass = @options[:include_options_blacklist]
+        return {locale: @options[:locale]} if dont_pass == true
+        opts = @options.merge(included: true, include_options_blacklist: false)
+        if dont_pass.is_a?(Array)
+          dont_pass.each {|o| opts.delete(o)}
+        end
+        opts
+      end
   end
 
-  Template.register_tag('include', Include)
+  Template.register_tag('include'.freeze, Include)
 end

data/lib/liquid/tags/increment.rb

@@ -15,9 +15,9 @@ module Liquid
   #    Hello: 2
   #
   class Increment < Tag
-    def initialize(tag_name, markup, tokens, options)
-      @variable = markup.strip
+    def initialize(tag_name, markup, options)
       super
+      @variable = markup.strip
     end
 
     def render(context)
@@ -25,12 +25,7 @@ module Liquid
       context.environments.first[@variable] = value + 1
       value.to_s
     end
-
-
-    def blank?
-      false
-    end
   end
 
-  Template.register_tag('increment', Increment)
+  Template.register_tag('increment'.freeze, Increment)
 end

data/lib/liquid/tags/inherited_block.rb

@@ -7,95 +7,93 @@ module Liquid
   #   {% block content }Hello world{% endblock %}
   #
   class InheritedBlock < Block
-    Syntax = /(#{QuotedFragment}+)/
+    Syntax = /(#{QuotedFragment}+)/o
 
-    attr_accessor :parent
     attr_reader   :name
 
-    def initialize(tag_name, markup, tokens, options)
+    # linked chain of inherited blocks included
+    # in different templates if multiple extends
+    attr_accessor :parent, :descendant
+
+    def initialize(tag_name, markup, options)
+      super
+
       if markup =~ Syntax
         @name = $1.gsub(/["']/o, '').strip
       else
         raise(SyntaxError.new(options[:locale].t("errors.syntax.block")), options[:line])
       end
 
-      self.set_full_name!(options)
-
-      (options[:block_stack] ||= []).push(self)
-      options[:current_block] = self
-
-      super if tokens
+      prepare_for_inheritance
     end
 
-    def render(context)
-      context.stack do
-        context['block'] = InheritedBlockDrop.new(self)
-        render_all(@nodelist, context)
+    def prepare_for_inheritance
+      # give a different name if this is a nested block
+      if block = options[:inherited_blocks][:nested].last
+        @name = "#{block.name}/#{@name}"
       end
-    end
 
-    def end_tag
-      self.register_current_block
+      # append this block to the stack in order to
+      # get a name for the other nested inherited blocks
+      options[:inherited_blocks][:nested].push(self)
 
-      options[:block_stack].pop
-      options[:current_block] = options[:block_stack].last
-    end
+      # build the linked chain of inherited blocks
+      # make a link with the descendant and the parent (chained list)
+      if descendant = options[:inherited_blocks][:all][@name]
+        self.descendant   = descendant
+        descendant.parent = self
 
-    def call_super(context)
-      if parent
-        parent.render(context)
-      else
-        ''
+        # get the value of the blank property from the descendant
+        @blank = descendant.blank? #false
       end
-    end
 
-    def self.clone_block(block)
-      new_block = self.new(block.send(:instance_variable_get, :"@tag_name"), block.name, nil, {})
-      new_block.parent = block.parent
-      new_block.nodelist = block.nodelist
-      new_block
+      # become the descendant of the inherited block from the parent template
+      options[:inherited_blocks][:all][@name] = self
     end
 
-    protected
+    def parse(tokens)
+      super
 
-    def set_full_name!(options)
-      if options[:current_block]
-        @name = options[:current_block].name + '/' + @name
-      end
+      # when the parsing of the block is done, we can then remove it from the stack
+      options[:inherited_blocks][:nested].pop
     end
 
-    def register_current_block
-      options[:blocks] ||= {}
+    alias_method :render_without_inheritance, :render
 
-      block = options[:blocks][@name]
+    def render(context)
+      context.stack do
+        # look for the very first descendant
+        block = self_or_first_descendant
 
-      if block
-        # copy the existing block in order to make it a parent of the parsed block
-        new_block = self.class.clone_block(block)
+        if block != self
+          # the block drop is in charge of rendering "{{ block.super }}"
+          context['block'] = InheritedBlockDrop.new(block)
+        end
 
-        # replace the up-to-date version of the block in the parent template
-        block.parent = new_block
-        block.nodelist = @nodelist
+        block.render_without_inheritance(context)
       end
     end
 
-  end
-
-  class InheritedBlockDrop < Drop
-
-    def initialize(block)
-      @block = block
+    # when we render an inherited block, we need the version of the
+    # very first descendant.
+    def self_or_first_descendant
+      block = self
+      while block.descendant; block = block.descendant; end
+      block
     end
 
-    def name
-      @block.name
-    end
+    def call_super(context)
+      if parent
+        # remove the block from the linked chain
+        parent.descendant = nil
 
-    def super
-      @block.call_super(@context)
+        parent.render(context)
+      else
+        ''
+      end
     end
 
   end
 
   Template.register_tag('block', InheritedBlock)
-end
+end