locomotivecms-liquid 2.6.0 → 4.0.0.alpha

data/lib/liquid/tag.rb

@@ -1,61 +1,42 @@
 module Liquid
   class Tag
-    attr_accessor :nodelist, :options, :line
-    attr_reader :warnings
-
-    def self.new_with_options(tag_name, markup, tokens, options)
-      # Forgive me Matz for I have sinned. I know this code is weird
-      # but it was necessary to maintain API compatibility.
-      new_tag = self.allocate
-      new_tag.options = options
-      new_tag.send(:initialize, tag_name, markup, tokens, options)
-      new_tag
+    attr_accessor :options, :line_number
+    attr_reader :nodelist, :warnings
+    include ParserSwitching
+
+    class << self
+      def parse(tag_name, markup, tokens, options)
+        tag = new(tag_name, markup, options)
+        tag.parse(tokens)
+        tag
+      end
+
+      private :new
     end
 
-    def initialize(tag_name, markup, tokens, options)
+    def initialize(tag_name, markup, options)
       @tag_name   = tag_name
       @markup     = markup
-      @options    = options || {}
-      @line       = @options[:line] || 1
-      parse(tokens)
+      @options    = options
     end
 
     def parse(tokens)
     end
 
+    def raw
+      "#{@tag_name} #{@markup}"
+    end
+
     def name
       self.class.name.downcase
     end
 
     def render(context)
-      ''
+      ''.freeze
     end
 
     def blank?
-      @blank || true
-    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
-
-    private
-    def strict_parse_with_error_context(markup)
-      strict_parse(markup)
-    rescue SyntaxError => e
-      e.message << " in \"#{markup.strip}\""
-      raise e
+      false
     end
-  end # Tag
-end # Liquid
+  end
+end

data/lib/liquid/tags/assign.rb

@@ -9,28 +9,33 @@ module Liquid
   #  {{ foo }}
   #
   class Assign < Tag
-    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/o
+    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
 
-
-    def initialize(tag_name, markup, tokens, options)
+    def initialize(tag_name, markup, options)
+      super
       if markup =~ Syntax
         @to = $1
-        @from = Variable.new($2)
+        @from = Variable.new($2,options)
+        @from.line_number = line_number
       else
-        raise SyntaxError.new options[:locale].t("errors.syntax.assign")
+        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)
-      ''
+
+      inc = val.instance_of?(String) || val.instance_of?(Array) || val.instance_of?(Hash) ? val.length : 1
+      context.resource_limits.assign_score += inc
+
+      ''.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 %}
@@ -12,23 +11,22 @@ module Liquid
   # in a sidebar or footer.
   #
   class Capture < Block
-    Syntax = /(\w+)/
+    Syntax = /(#{VariableSignature}+)/o
 
-    def initialize(tag_name, markup, tokens, options)
+    def initialize(tag_name, markup, options)
+      super
       if markup =~ Syntax
         @to = $1
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.capture"), options[:line])
+        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.resource_limits.assign_score += output.length
+      ''.freeze
     end
 
     def blank?
@@ -36,5 +34,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('capture', Capture)
+  Template.register_tag('capture'.freeze, Capture)
 end

data/lib/liquid/tags/case.rb

@@ -1,27 +1,35 @@
 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, options)
+    def initialize(tag_name, markup, options)
+      super
       @blocks = []
 
       if markup =~ Syntax
-        @left = $1
+        @left = Expression.parse($1)
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.case"), options[:line])
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case".freeze))
       end
+    end
 
-      super
+    def parse(tokens)
+      body = BlockBody.new
+      while more = parse_body(body, tokens)
+        body = @blocks.last.attachment
+      end
+    end
+
+    def nodelist
+      @blocks.map(&:attachment)
     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
@@ -35,10 +43,10 @@ module Liquid
         output = ''
         @blocks.each do |block|
           if block.else?
-            return render_all(block.attachment, context) if execute_else_block
+            return block.attachment.render(context) if execute_else_block
           elsif block.evaluate(context)
             execute_else_block = false
-            output << render_all(block.attachment, context)
+            output << block.attachment.render(context)
           end
         end
         output
@@ -48,30 +56,31 @@ module Liquid
     private
 
     def record_when_condition(markup)
+      body = BlockBody.new
+
       while markup
-        # Create a new nodelist and assign it to the new block
         if not markup =~ WhenSyntax
-          raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when"), line)
+          raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when".freeze))
         end
 
         markup = $2
 
-        block = Condition.new(@left, '==', $1)
-        block.attach(@nodelist)
-        @blocks.push(block)
+        block = Condition.new(@left, '=='.freeze, Expression.parse($1))
+        block.attach(body)
+        @blocks << block
       end
     end
 
     def record_else_condition(markup)
       if not markup.strip.empty?
-        raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_else"), line)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_else".freeze))
       end
 
       block = ElseCondition.new
-      block.attach(@nodelist)
+      block.attach(BlockBody.new)
       @blocks << block
     end
   end
 
-  Template.register_tag('case', Case)
+  Template.register_tag('case'.freeze, Case)
 end

data/lib/liquid/tags/comment.rb

@@ -1,7 +1,7 @@
 module Liquid
   class Comment < Block
     def render(context)
-      ''
+      ''.freeze
     end
 
     def unknown_tag(tag, markup, tokens)
@@ -12,5 +12,5 @@ module Liquid
     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

@@ -12,30 +12,30 @@ 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, options)
+    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(options[:locale].t("errors.syntax.cycle"), options[:line])
+        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze))
       end
-      super
     end
 
     def render(context)
       context.registers[:cycle] ||= Hash.new(0)
 
       context.stack do
-        key = context[@name]
+        key = context.evaluate(@name)
         iteration = context.registers[:cycle][key]
-        result = context[@variables[iteration]]
+        result = context.evaluate(@variables[iteration])
         iteration += 1
         iteration  = 0  if iteration >= @variables.size
         context.registers[:cycle][key] = iteration
@@ -43,16 +43,12 @@ module Liquid
       end
     end
 
-    def blank?
-      false
-    end
-
     private
 
     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
   end

data/lib/liquid/tags/decrement.rb

@@ -19,10 +19,9 @@ module Liquid
   #    Hello: -3
   #
   class Decrement < 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)
@@ -35,5 +34,5 @@ module Liquid
     private
   end
 
-  Template.register_tag('decrement', Decrement)
+  Template.register_tag('decrement'.freeze, Decrement)
 end

data/lib/liquid/tags/extends.rb

@@ -1,40 +1,38 @@
 module Liquid
 
-  # Extends allows designer to use template inheritance
+  # Extends allows designer to use template inheritance.
   #
   #   {% extends home %}
   #   {% block content }Hello world{% endblock %}
   #
   class Extends < Block
-    Syntax = /(#{QuotedFragment}+)/
+    Syntax = /(#{QuotedFragment}+)/o
+
+    def initialize(tag_name, markup, options)
+      super
 
-    def initialize(tag_name, markup, tokens, options)
       if markup =~ Syntax
         @template_name = $1.gsub(/["']/o, '').strip
       else
-        raise(SyntaxError.new(options[:locale].t("errors.syntax.extends")), options[:line])
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.extends".freeze)))
       end
 
-      @options = options
-
-      @parent_template = parse_parent_template
-
-      prepare_parsing
-
-      super
-
-      end_tag
+      # variables needed by the inheritance mechanism during the parsing
+      options[:inherited_blocks] ||= {
+        nested:   [], # used to get the full name of the blocks if nested (stack mechanism)
+        all:      {}  # keep track of the blocks by their full name
+      }
     end
 
-    def prepare_parsing
-      @options.merge!(:blocks => self.find_blocks(@parent_template.root.nodelist))
-    end
+    def parse(tokens)
+      super
 
-    def end_tag
-      # replace the nodelist by the new one
-      @nodelist = @parent_template.root.nodelist.clone
+      parent_template = parse_parent_template
 
-      @parent_template = nil # no need to keep it
+      # replace the nodes of the current template by those from the parent
+      # which itself may have have done the same operation if it includes
+      # the extends tag.
+      nodelist.replace(parent_template.root.nodelist)
     end
 
     def blank?
@@ -43,37 +41,23 @@ module Liquid
 
     protected
 
-    def find_blocks(nodelist, blocks = {})
-      if nodelist && nodelist.any?
-        0.upto(nodelist.size - 1).each do |index|
-          node = nodelist[index]
-
-          if node.respond_to?(:call_super) # inherited block !
-            new_node = node.class.clone_block(node)
-
-            nodelist.insert(index, new_node)
-            nodelist.delete_at(index + 1)
+    def parse_body(body, tokens)
+      body.parse(tokens, options) do |end_tag_name, end_tag_params|
+        @blank &&= body.blank?
 
-            blocks[node.name] = new_node
-          end
-          if node.respond_to?(:nodelist)
-            self.find_blocks(node.nodelist, blocks) # FIXME: find nested blocks too
-          end
-        end
+        # Note: extends does not require the "end tag".
+        return false if end_tag_name.nil?
       end
-      blocks
-    end
 
-    private
+      true
+    end
 
     def parse_parent_template
-      source = Template.file_system.read_template_file(@template_name)
-      Template.parse(source)
+      source = Template.file_system.read_template_file(@template_name, {})
+      Template.parse(source, options)
     end
 
-    def assert_missing_delimitation!
-    end
   end
 
   Template.register_tag('extends', Extends)
-end
+end