liquid-4-0-2 4.0.2

data/lib/liquid/strainer.rb

@@ -0,0 +1,66 @@
+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.
+  #
+  # The Strainer only allows method calls defined in filters given to it via Strainer.global_filter,
+  # Context#add_filters or Template.register_filter
+  class Strainer #:nodoc:
+    @@global_strainer = Class.new(Strainer) do
+      @filter_methods = Set.new
+    end
+    @@strainer_class_cache = Hash.new do |hash, filters|
+      hash[filters] = Class.new(@@global_strainer) do
+        @filter_methods = @@global_strainer.filter_methods.dup
+        filters.each { |f| add_filter(f) }
+      end
+    end
+
+    def initialize(context)
+      @context = context
+    end
+
+    class << self
+      attr_reader :filter_methods
+    end
+
+    def self.add_filter(filter)
+      raise ArgumentError, "Expected module but got: #{filter.class}" unless filter.is_a?(Module)
+      unless self.include?(filter)
+        invokable_non_public_methods = (filter.private_instance_methods + filter.protected_instance_methods).select { |m| invokable?(m) }
+        if invokable_non_public_methods.any?
+          raise MethodOverrideError, "Filter overrides registered public methods as non public: #{invokable_non_public_methods.join(', ')}"
+        else
+          send(:include, filter)
+          @filter_methods.merge(filter.public_instance_methods.map(&:to_s))
+        end
+      end
+    end
+
+    def self.global_filter(filter)
+      @@strainer_class_cache.clear
+      @@global_strainer.add_filter(filter)
+    end
+
+    def self.invokable?(method)
+      @filter_methods.include?(method.to_s)
+    end
+
+    def self.create(context, filters = [])
+      @@strainer_class_cache[filters].new(context)
+    end
+
+    def invoke(method, *args)
+      if self.class.invokable?(method)
+        send(method, *args)
+      elsif @context && @context.strict_filters
+        raise Liquid::UndefinedFilter, "undefined filter #{method}"
+      else
+        args.first
+      end
+    rescue ::ArgumentError => e
+      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

@@ -0,0 +1,43 @@
+module Liquid
+  class Tag
+    attr_reader :nodelist, :tag_name, :line_number, :parse_context
+    alias_method :options, :parse_context
+    include ParserSwitching
+
+    class << self
+      def parse(tag_name, markup, tokenizer, options)
+        tag = new(tag_name, markup, options)
+        tag.parse(tokenizer)
+        tag
+      end
+
+      private :new
+    end
+
+    def initialize(tag_name, markup, parse_context)
+      @tag_name   = tag_name
+      @markup     = markup
+      @parse_context = parse_context
+      @line_number = parse_context.line_number
+    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?
+      false
+    end
+  end
+end

data/lib/liquid/tags/assign.rb

@@ -0,0 +1,59 @@
+module Liquid
+  # Assign sets a variable in your template.
+  #
+  #   {% assign foo = 'monkey' %}
+  #
+  # You can then use the variable later in the page.
+  #
+  #  {{ foo }}
+  #
+  class Assign < Tag
+    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
+
+    attr_reader :to, :from
+
+    def initialize(tag_name, markup, options)
+      super
+      if markup =~ Syntax
+        @to = $1
+        @from = Variable.new($2, options)
+      else
+        raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
+      end
+    end
+
+    def render(context)
+      val = @from.render(context)
+      context.scopes.last[@to] = val
+      context.resource_limits.assign_score += assign_score_of(val)
+      ''.freeze
+    end
+
+    def blank?
+      true
+    end
+
+    private
+
+    def assign_score_of(val)
+      if val.instance_of?(String)
+        val.length
+      elsif val.instance_of?(Array) || val.instance_of?(Hash)
+        sum = 1
+        # Uses #each to avoid extra allocations.
+        val.each { |child| sum += assign_score_of(child) }
+        sum
+      else
+        1
+      end
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [@node.from]
+      end
+    end
+  end
+
+  Template.register_tag('assign'.freeze, Assign)
+end

data/lib/liquid/tags/break.rb

@@ -0,0 +1,18 @@
+module Liquid
+  # Break tag to be used to break out of a for loop.
+  #
+  # == Basic Usage:
+  #    {% for item in collection %}
+  #      {% if item.condition %}
+  #        {% break %}
+  #      {% endif %}
+  #    {% endfor %}
+  #
+  class Break < Tag
+    def interrupt
+      BreakInterrupt.new
+    end
+  end
+
+  Template.register_tag('break'.freeze, Break)
+end

data/lib/liquid/tags/capture.rb

@@ -0,0 +1,38 @@
+module Liquid
+  # Capture stores the result of a block into a variable without rendering it inplace.
+  #
+  #   {% capture heading %}
+  #     Monkeys!
+  #   {% endcapture %}
+  #   ...
+  #   <h1>{{ heading }}</h1>
+  #
+  # Capture is useful for saving content for use later in your template, such as
+  # in a sidebar or footer.
+  #
+  class Capture < Block
+    Syntax = /(#{VariableSignature}+)/o
+
+    def initialize(tag_name, markup, options)
+      super
+      if markup =~ Syntax
+        @to = $1
+      else
+        raise SyntaxError.new(options[:locale].t("errors.syntax.capture"))
+      end
+    end
+
+    def render(context)
+      output = super
+      context.scopes.last[@to] = output
+      context.resource_limits.assign_score += output.length
+      ''.freeze
+    end
+
+    def blank?
+      true
+    end
+  end
+
+  Template.register_tag('capture'.freeze, Capture)
+end

data/lib/liquid/tags/case.rb

@@ -0,0 +1,94 @@
+module Liquid
+  class Case < Block
+    Syntax     = /(#{QuotedFragment})/o
+    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/om
+
+    attr_reader :blocks, :left
+
+    def initialize(tag_name, markup, options)
+      super
+      @blocks = []
+
+      if markup =~ Syntax
+        @left = Expression.parse($1)
+      else
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case".freeze))
+      end
+    end
+
+    def parse(tokens)
+      body = BlockBody.new
+      while parse_body(body, tokens)
+        body = @blocks.last.attachment
+      end
+    end
+
+    def nodelist
+      @blocks.map(&:attachment)
+    end
+
+    def unknown_tag(tag, markup, tokens)
+      case tag
+      when 'when'.freeze
+        record_when_condition(markup)
+      when 'else'.freeze
+        record_else_condition(markup)
+      else
+        super
+      end
+    end
+
+    def render(context)
+      context.stack do
+        execute_else_block = true
+
+        output = ''
+        @blocks.each do |block|
+          if block.else?
+            return block.attachment.render(context) if execute_else_block
+          elsif block.evaluate(context)
+            execute_else_block = false
+            output << block.attachment.render(context)
+          end
+        end
+        output
+      end
+    end
+
+    private
+
+    def record_when_condition(markup)
+      body = BlockBody.new
+
+      while markup
+        unless markup =~ WhenSyntax
+          raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when".freeze))
+        end
+
+        markup = $2
+
+        block = Condition.new(@left, '=='.freeze, Expression.parse($1))
+        block.attach(body)
+        @blocks << block
+      end
+    end
+
+    def record_else_condition(markup)
+      unless markup.strip.empty?
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_else".freeze))
+      end
+
+      block = ElseCondition.new
+      block.attach(BlockBody.new)
+      @blocks << block
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [@node.left] + @node.blocks
+      end
+    end
+  end
+
+  Template.register_tag('case'.freeze, Case)
+end

data/lib/liquid/tags/comment.rb

@@ -0,0 +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'.freeze, Comment)
+end

data/lib/liquid/tags/continue.rb

@@ -0,0 +1,18 @@
+module Liquid
+  # Continue tag to be used to break out of a for loop.
+  #
+  # == Basic Usage:
+  #    {% for item in collection %}
+  #      {% if item.condition %}
+  #        {% continue %}
+  #      {% endif %}
+  #    {% endfor %}
+  #
+  class Continue < Tag
+    def interrupt
+      ContinueInterrupt.new
+    end
+  end
+
+  Template.register_tag('continue'.freeze, Continue)
+end

data/lib/liquid/tags/cycle.rb

@@ -0,0 +1,65 @@
+module Liquid
+  # Cycle is usually used within a loop to alternate between values, like colors or DOM classes.
+  #
+  #   {% for item in items %}
+  #     <div class="{% cycle 'red', 'green', 'blue' %}"> {{ item }} </div>
+  #   {% end %}
+  #
+  #    <div class="red"> Item one </div>
+  #    <div class="green"> Item two </div>
+  #    <div class="blue"> Item three </div>
+  #    <div class="red"> Item four </div>
+  #    <div class="green"> Item five</div>
+  #
+  class Cycle < Tag
+    SimpleSyntax = /\A#{QuotedFragment}+/o
+    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
+
+    attr_reader :variables
+
+    def initialize(tag_name, markup, options)
+      super
+      case markup
+      when NamedSyntax
+        @variables = variables_from_string($2)
+        @name = Expression.parse($1)
+      when SimpleSyntax
+        @variables = variables_from_string(markup)
+        @name = @variables.to_s
+      else
+        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze))
+      end
+    end
+
+    def render(context)
+      context.registers[:cycle] ||= {}
+
+      context.stack do
+        key = context.evaluate(@name)
+        iteration = context.registers[:cycle][key].to_i
+        result = context.evaluate(@variables[iteration])
+        iteration += 1
+        iteration  = 0 if iteration >= @variables.size
+        context.registers[:cycle][key] = iteration
+        result
+      end
+    end
+
+    private
+
+    def variables_from_string(markup)
+      markup.split(',').collect do |var|
+        var =~ /\s*(#{QuotedFragment})\s*/o
+        $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)
+end