liquid 2.6.3 → 5.4.0

data/lib/liquid/tags/if.rb

@@ -1,78 +1,139 @@
-module Liquid
+# frozen_string_literal: true
 
-  # If is the conditional block
-  #
-  #   {% if user.admin %}
-  #     Admin user!
-  #   {% else %}
-  #     Not admin user
+module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category conditional
+  # @liquid_name if
+  # @liquid_summary
+  #   Renders an expression if a specific condition is `true`.
+  # @liquid_syntax
+  #   {% if condition %}
+  #     expression
   #   {% endif %}
-  #
-  #    There are {% if count < 5 %} less {% else %} more {% endif %} items than you need.
-  #
-  #
+  # @liquid_syntax_keyword condition The condition to evaluate.
+  # @liquid_syntax_keyword expression The expression to render if the condition is met.
   class If < Block
-    SyntaxHelp = "Syntax Error in tag 'if' - Valid syntax: if [expression]"
-    Syntax = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
+    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)
-      @blocks = []
+    attr_reader :blocks
 
+    def initialize(tag_name, markup, options)
+      super
+      @blocks = []
       push_block('if', markup)
+    end
 
-      super
+    def nodelist
+      @blocks.map(&:attachment)
     end
 
+    def parse(tokens)
+      while parse_body(@blocks.last.attachment, tokens)
+      end
+      @blocks.reverse_each do |block|
+        block.attachment.remove_blank_strings if blank?
+        block.attachment.freeze
+      end
+    end
+
+    ELSE_TAG_NAMES = ['elsif', 'else'].freeze
+    private_constant :ELSE_TAG_NAMES
+
     def unknown_tag(tag, markup, tokens)
-      if ['elsif', 'else'].include?(tag)
+      if ELSE_TAG_NAMES.include?(tag)
         push_block(tag, markup)
       else
         super
       end
     end
 
-    def render(context)
-      context.stack do
-        @blocks.each do |block|
-          if block.evaluate(context)
-            return render_all(block.attachment, context)
-          end
+    def render_to_output_buffer(context, output)
+      @blocks.each do |block|
+        result = Liquid::Utils.to_liquid_value(
+          block.evaluate(context)
+        )
+
+        if result
+          return block.attachment.render_to_output_buffer(context, output)
         end
-        ''
       end
+
+      output
     end
 
     private
 
-      def push_block(tag, markup)
-        block = if tag == 'else'
-          ElseCondition.new
-        else
+    def push_block(tag, markup)
+      block = if tag == 'else'
+        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(new_body)
+    end
 
-          condition = Condition.new($1, $2, $3)
+    def parse_expression(markup)
+      Condition.parse_expression(parse_context, markup)
+    end
 
-          while not expressions.empty?
-            operator = (expressions.shift).to_s.strip
+    def lax_parse(markup)
+      expressions = markup.scan(ExpressionsAndOperators)
+      raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop =~ Syntax
 
-            raise(SyntaxError, SyntaxHelp) unless expressions.shift.to_s =~ Syntax
+      condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))
 
-            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
+      until expressions.empty?
+        operator = expressions.pop.to_s.strip
 
-          condition
-        end
+        raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop.to_s =~ Syntax
+
+        new_condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))
+        raise SyntaxError, options[:locale].t("errors.syntax.if") unless BOOLEAN_OPERATORS.include?(operator)
+        new_condition.send(operator, condition)
+        condition = new_condition
+      end
+
+      condition
+    end
+
+    def strict_parse(markup)
+      p = Parser.new(markup)
+      condition = parse_binary_comparisons(p)
+      p.consume(:end_of_string)
+      condition
+    end
 
-        @blocks.push(block)
-        @nodelist = block.attach(Array.new)
+    def parse_binary_comparisons(p)
+      condition = parse_comparison(p)
+      first_condition = condition
+      while (op = (p.id?('and') || p.id?('or')))
+        child_condition = parse_comparison(p)
+        condition.send(op, child_condition)
+        condition = child_condition
       end
+      first_condition
+    end
+
+    def parse_comparison(p)
+      a = parse_expression(p.expression)
+      if (op = p.consume?(:comparison))
+        b = parse_expression(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)

data/lib/liquid/tags/ifchanged.rb

@@ -1,18 +1,17 @@
+# frozen_string_literal: true
+
 module Liquid
   class Ifchanged < Block
+    def render_to_output_buffer(context, output)
+      block_output = +''
+      super(context, block_output)
 
-    def render(context)
-      context.stack do
-
-        output = render_all(@nodelist, context)
-
-        if output != context.registers[:ifchanged]
-          context.registers[:ifchanged] = output
-          output
-        else
-          ''
-        end
+      if block_output != context.registers[:ifchanged]
+        context.registers[:ifchanged] = block_output
+        output << block_output
       end
+
+      output
     end
   end
 

data/lib/liquid/tags/include.rb

@@ -1,92 +1,112 @@
-module Liquid
+# frozen_string_literal: true
 
-  # Include allows templates to relate with other templates
-  #
-  # Simply include another template:
-  #
-  #   {% include 'product' %}
-  #
-  # Include a template with a local variable:
-  #
-  #   {% include 'product' with products[0] %}
-  #
-  # Include a template for a collection:
-  #
-  #   {% include 'product' for products %}
+module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category theme
+  # @liquid_name include
+  # @liquid_summary
+  #   Renders a [snippet](/themes/architecture#snippets).
+  # @liquid_description
+  #   Inside the snippet, you can access and alter variables that are [created](/api/liquid/tags#variable-tags) outside of the
+  #   snippet.
+  # @liquid_syntax
+  #   {% include 'filename' %}
+  # @liquid_syntax_keyword filename The name of the snippet to render, without the `.liquid` extension.
+  # @liquid_deprecated
+  #   Deprecated because the way that variables are handled reduces performance and makes code harder to both read and maintain.
   #
+  #   The `include` tag has been replaced by [`render`](/api/liquid/tags#render).
   class Include < Tag
-    Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o
+    prepend Tag::Disableable
+
+    SYNTAX = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
+    Syntax = SYNTAX
 
-    def initialize(tag_name, markup, tokens)
-      if markup =~ Syntax
+    attr_reader :template_name_expr, :variable_name_expr, :attributes
+
+    def initialize(tag_name, markup, options)
+      super
 
-        @template_name = $1
-        @variable_name = $3
-        @attributes    = {}
+      if markup =~ SYNTAX
+
+        template_name = Regexp.last_match(1)
+        variable_name = Regexp.last_match(3)
+
+        @alias_name         = Regexp.last_match(5)
+        @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
+        @template_name_expr = parse_expression(template_name)
+        @attributes         = {}
 
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = value
+          @attributes[key] = parse_expression(value)
         end
 
       else
-        raise SyntaxError.new("Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]")
+        raise SyntaxError, options[:locale].t("errors.syntax.include")
       end
-
-      super
     end
 
-    def parse(tokens)
+    def parse(_tokens)
     end
 
-    def render(context)
-      partial = load_cached_partial(context)
-      variable = context[@variable_name || @template_name[1..-2]]
+    def render_to_output_buffer(context, output)
+      template_name = context.evaluate(@template_name_expr)
+      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name
 
-      context.stack do
-        @attributes.each do |key, value|
-          context[key] = context[value]
-        end
+      partial = PartialCache.load(
+        template_name,
+        context: context,
+        parse_context: parse_context
+      )
 
-        if variable.is_a?(Array)
-          variable.collect do |var|
-            context[@template_name[1..-2]] = var
-            partial.render(context)
-          end
-        else
-          context[@template_name[1..-2]] = variable
-          partial.render(context)
-        end
+      context_variable_name = @alias_name || template_name.split('/').last
+
+      variable = if @variable_name_expr
+        context.evaluate(@variable_name_expr)
+      else
+        context.find_variable(template_name, raise_on_not_found: false)
       end
-    end
 
-    private
-      def load_cached_partial(context)
-        cached_partials = context.registers[:cached_partials] || {}
-        template_name = context[@template_name]
+      old_template_name = context.template_name
+      old_partial       = context.partial
+      begin
+        context.template_name = template_name
+        context.partial       = true
+        context.stack do
+          @attributes.each do |key, value|
+            context[key] = context.evaluate(value)
+          end
 
-        if cached = cached_partials[template_name]
-          return cached
+          if variable.is_a?(Array)
+            variable.each do |var|
+              context[context_variable_name] = var
+              partial.render_to_output_buffer(context, output)
+            end
+          else
+            context[context_variable_name] = variable
+            partial.render_to_output_buffer(context, output)
+          end
         end
-        source = read_template_from_file_system(context)
-        partial = Liquid::Template.parse(source)
-        cached_partials[template_name] = partial
-        context.registers[:cached_partials] = cached_partials
-        partial
+      ensure
+        context.template_name = old_template_name
+        context.partial       = old_partial
       end
 
-      def read_template_from_file_system(context)
-        file_system = context.registers[:file_system] || Liquid::Template.file_system
-
-        # 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])
-        when 2
-          file_system.read_template_file(context[@template_name], context)
-        else
-          raise ArgumentError, "file_system.read_template_file expects two parameters: (template_name, context)"
-        end
+      output
+    end
+
+    alias_method :parse_context, :options
+    private :parse_context
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [
+          @node.template_name_expr,
+          @node.variable_name_expr,
+        ] + @node.attributes.values
       end
+    end
   end
 
   Template.register_tag('include', Include)

data/lib/liquid/tags/increment.rb

@@ -1,34 +1,36 @@
-module Liquid
-
-  # increment 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.
-  #     (To achieve the survival, the application must keep the context)
-  #
-  #     if the variable does not exist, it is created with value 0.
+# frozen_string_literal: true
 
-  #   Hello: {% increment variable %}
-  #
-  # gives you:
-  #
-  #    Hello: 0
-  #    Hello: 1
-  #    Hello: 2
+module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category variable
+  # @liquid_name increment
+  # @liquid_summary
+  #   Creates a new variable, with a default value of 0, that's increased by 1 with each subsequent call.
+  # @liquid_description
+  #   Variables that are declared with `increment` are unique to the [layout](/themes/architecture/layouts), [template](/themes/architecture/templates),
+  #   or [section](/themes/architecture/sections) file that they're created in. However, the variable is shared across
+  #   [snippets](/themes/architecture#snippets) included in the file.
   #
+  #   Similarly, variables that are created with `increment` are independent from those created with [`assign`](/api/liquid/tags#assign)
+  #   and [`capture`](/api/liquid/tags#capture). However, `increment` and [`decrement`](/api/liquid/tags#decrement) share
+  #   variables.
+  # @liquid_syntax
+  #   {% increment variable_name %}
+  # @liquid_syntax_keyword variable_name The name of the variable being incremented.
   class Increment < Tag
-    def initialize(tag_name, markup, tokens)
-      @variable = markup.strip
-
+    def initialize(tag_name, markup, options)
       super
+      @variable = markup.strip
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
       value = context.environments.first[@variable] ||= 0
       context.environments.first[@variable] = value + 1
-      value.to_s
-    end
 
-    private
+      output << value.to_s
+      output
+    end
   end
 
   Template.register_tag('increment', Increment)

data/lib/liquid/tags/inline_comment.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category syntax
+  # @liquid_name inline_comment
+  # @liquid_summary
+  #   Prevents an expression from being rendered or output.
+  # @liquid_description
+  #   Any text inside an `inline_comment` tag won't be rendered or output.
+  #
+  #   You can create multi-line inline comments. However, each line must begin with a `#`.
+  # @liquid_syntax
+  #   {% # content %}
+  # @liquid_syntax_keyword content The content of the comment.
+  class InlineComment < Tag
+    def initialize(tag_name, markup, options)
+      super
+
+      # Semantically, a comment should only ignore everything after it on the line.
+      # Currently, this implementation doesn't support mixing a comment with another tag
+      # but we need to reserve future support for this and prevent the introduction
+      # of inline comments from being backward incompatible change.
+      #
+      # As such, we're forcing users to put a # symbol on every line otherwise this
+      # tag will throw an error.
+      if markup.match?(/\n\s*[^#\s]/)
+        raise SyntaxError, options[:locale].t("errors.syntax.inline_comment_invalid")
+      end
+    end
+
+    def render_to_output_buffer(_context, output)
+      output
+    end
+
+    def blank?
+      true
+    end
+  end
+
+  Template.register_tag('#', InlineComment)
+end

data/lib/liquid/tags/raw.rb

@@ -1,19 +1,58 @@
+# frozen_string_literal: true
+
 module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category syntax
+  # @liquid_name raw
+  # @liquid_summary
+  #   Outputs any Liquid code as text instead of rendering it.
+  # @liquid_syntax
+  #   {% raw %}
+  #     expression
+  #   {% endraw %}
+  # @liquid_syntax_keyword expression The expression to be output without being rendered.
   class Raw < Block
-    FullTokenPossiblyInvalid = /^(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}$/o
+    Syntax = /\A\s*\z/
+    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
+
+    def initialize(tag_name, markup, parse_context)
+      super
+
+      ensure_valid_markup(tag_name, markup, parse_context)
+    end
 
     def parse(tokens)
-      @nodelist ||= []
-      @nodelist.clear
-      while token = tokens.shift
-        if token =~ FullTokenPossiblyInvalid
-          @nodelist << $1 if $1 != ""
-          if block_delimiter == $2
-            end_tag
-            return
-          end
+      @body = +''
+      while (token = tokens.shift)
+        if token =~ FullTokenPossiblyInvalid && block_delimiter == Regexp.last_match(2)
+          @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
+          return
         end
-        @nodelist << token if not token.empty?
+        @body << token unless token.empty?
+      end
+
+      raise_tag_never_closed(block_name)
+    end
+
+    def render_to_output_buffer(_context, output)
+      output << @body
+      output
+    end
+
+    def nodelist
+      [@body]
+    end
+
+    def blank?
+      @body.empty?
+    end
+
+    protected
+
+    def ensure_valid_markup(tag_name, markup, parse_context)
+      unless Syntax.match?(markup)
+        raise SyntaxError, parse_context.locale.t("errors.syntax.tag_unexpected_args", tag: tag_name)
       end
     end
   end

data/lib/liquid/tags/render.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category theme
+  # @liquid_name render
+  # @liquid_summary
+  #   Renders a [snippet](/themes/architecture#snippets) or [app block](/themes/architecture/sections/section-schema#render-app-blocks).
+  # @liquid_description
+  #   Inside snippets and app blocks, you can't directly access variables that are [created](/api/liquid/tags#variable-tags) outside
+  #   of the snippet or app block. However, you can [specify variables as parameters](/api/liquid/tags#render-passing-variables-to-snippets)
+  #   to pass outside variables to snippets.
+  #
+  #   While you can't directly access created variables, you can access global objects, as well as any objects that are
+  #   directly accessible outside the snippet or app block. For example, a snippet or app block inside the [product template](/themes/architecture/templates/product)
+  #   can access the [`product` object](/api/liquid/objects#product), and a snippet or app block inside a [section](/themes/architecture/sections)
+  #   can access the [`section` object](/api/liquid/objects#section).
+  #
+  #   Outside a snippet or app block, you can't access variables created inside the snippet or app block.
+  #
+  #   > Note:
+  #   > When you render a snippet using the `render` tag, you can't use the [`include` tag](/api/liquid/tags#include)
+  #   > inside the snippet.
+  # @liquid_syntax
+  #   {% render 'filename' %}
+  # @liquid_syntax_keyword filename The name of the snippet to render, without the `.liquid` extension.
+  class Render < Tag
+    FOR = 'for'
+    SYNTAX = /(#{QuotedString}+)(\s+(with|#{FOR})\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
+
+    disable_tags "include"
+
+    attr_reader :template_name_expr, :variable_name_expr, :attributes
+
+    def initialize(tag_name, markup, options)
+      super
+
+      raise SyntaxError, options[:locale].t("errors.syntax.render") unless markup =~ SYNTAX
+
+      template_name = Regexp.last_match(1)
+      with_or_for = Regexp.last_match(3)
+      variable_name = Regexp.last_match(4)
+
+      @alias_name = Regexp.last_match(6)
+      @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
+      @template_name_expr = parse_expression(template_name)
+      @for = (with_or_for == FOR)
+
+      @attributes = {}
+      markup.scan(TagAttributes) do |key, value|
+        @attributes[key] = parse_expression(value)
+      end
+    end
+
+    def render_to_output_buffer(context, output)
+      render_tag(context, output)
+    end
+
+    def render_tag(context, output)
+      # The expression should be a String literal, which parses to a String object
+      template_name = @template_name_expr
+      raise ::ArgumentError unless template_name.is_a?(String)
+
+      partial = PartialCache.load(
+        template_name,
+        context: context,
+        parse_context: parse_context
+      )
+
+      context_variable_name = @alias_name || template_name.split('/').last
+
+      render_partial_func = ->(var, forloop) {
+        inner_context               = context.new_isolated_subcontext
+        inner_context.template_name = template_name
+        inner_context.partial       = true
+        inner_context['forloop']    = forloop if forloop
+
+        @attributes.each do |key, value|
+          inner_context[key] = context.evaluate(value)
+        end
+        inner_context[context_variable_name] = var unless var.nil?
+        partial.render_to_output_buffer(inner_context, output)
+        forloop&.send(:increment!)
+      }
+
+      variable = @variable_name_expr ? context.evaluate(@variable_name_expr) : nil
+      if @for && variable.respond_to?(:each) && variable.respond_to?(:count)
+        forloop = Liquid::ForloopDrop.new(template_name, variable.count, nil)
+        variable.each { |var| render_partial_func.call(var, forloop) }
+      else
+        render_partial_func.call(variable, nil)
+      end
+
+      output
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [
+          @node.template_name_expr,
+          @node.variable_name_expr,
+        ] + @node.attributes.values
+      end
+    end
+  end
+
+  Template.register_tag('render', Render)
+end