liquid 3.0.6 → 5.4.0

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

data/lib/liquid/tags/table_row.rb

@@ -1,72 +1,88 @@
+# frozen_string_literal: true
+
 module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category iteration
+  # @liquid_name tablerow
+  # @liquid_summary
+  #   Generates HTML table rows for every item in an array.
+  # @liquid_description
+  #   The `tablerow` tag must be wrapped in HTML `<table>` and `</table>` tags.
+  #
+  #   > Tip:
+  #   > Every `tablerow` loop has an associated [`tablerowloop` object](/api/liquid/objects#tablerowloop) with information about the loop.
+  # @liquid_syntax
+  #   {% tablerow variable in array %}
+  #     expression
+  #   {% endtablerow %}
+  # @liquid_syntax_keyword variable The current item in the array.
+  # @liquid_syntax_keyword array The array to iterate over.
+  # @liquid_syntax_keyword expression The expression to render.
+  # @liquid_optional_param cols [number] The number of columns that the table should have.
+  # @liquid_optional_param limit [number] The number of iterations to perform.
+  # @liquid_optional_param offset [number] The 1-based index to start iterating at.
+  # @liquid_optional_param range [untyped] A custom numeric range to iterate over.
   class TableRow < Block
     Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o
 
+    attr_reader :variable_name, :collection_name, :attributes
+
     def initialize(tag_name, markup, options)
       super
       if markup =~ Syntax
-        @variable_name = $1
-        @collection_name = $2
-        @attributes = {}
+        @variable_name   = Regexp.last_match(1)
+        @collection_name = parse_expression(Regexp.last_match(2))
+        @attributes      = {}
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = value
+          @attributes[key] = parse_expression(value)
         end
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.table_row".freeze))
+        raise SyntaxError, options[:locale].t("errors.syntax.table_row")
       end
     end
 
-    def render(context)
-      collection = context[@collection_name] or return ''.freeze
+    def render_to_output_buffer(context, output)
+      (collection = context.evaluate(@collection_name)) || (return '')
 
-      from = @attributes['offset'.freeze] ? context[@attributes['offset'.freeze]].to_i : 0
-      to = @attributes['limit'.freeze] ? from + context[@attributes['limit'.freeze]].to_i : nil
+      from = @attributes.key?('offset') ? context.evaluate(@attributes['offset']).to_i : 0
+      to   = @attributes.key?('limit')  ? from + context.evaluate(@attributes['limit']).to_i : nil
 
       collection = Utils.slice_collection(collection, from, to)
+      length     = collection.length
 
-      length = collection.length
-
-      cols = context[@attributes['cols'.freeze]].to_i
+      cols = context.evaluate(@attributes['cols']).to_i
 
-      row = 1
-      col = 0
-
-      result = "<tr class=\"row1\">\n"
+      output << "<tr class=\"row1\">\n"
       context.stack do
+        tablerowloop = Liquid::TablerowloopDrop.new(length, cols)
+        context['tablerowloop'] = tablerowloop
 
-        collection.each_with_index do |item, index|
+        collection.each do |item|
           context[@variable_name] = item
-          context['tablerowloop'.freeze] = {
-            'length'.freeze    => length,
-            'index'.freeze     => index + 1,
-            'index0'.freeze    => index,
-            'col'.freeze       => col + 1,
-            'col0'.freeze      => col,
-            'rindex'.freeze    => length - index,
-            'rindex0'.freeze   => length - index - 1,
-            'first'.freeze     => (index == 0),
-            'last'.freeze      => (index == length - 1),
-            'col_first'.freeze => (col == 0),
-            'col_last'.freeze  => (col == cols - 1)
-          }
-
 
-          col += 1
+          output << "<td class=\"col#{tablerowloop.col}\">"
+          super
+          output << '</td>'
 
-          result << "<td class=\"col#{col}\">" << super << '</td>'
-
-          if col == cols and (index != length - 1)
-            col  = 0
-            row += 1
-            result << "</tr>\n<tr class=\"row#{row}\">"
+          if tablerowloop.col_last && !tablerowloop.last
+            output << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">"
           end
 
+          tablerowloop.send(:increment!)
         end
       end
-      result << "</tr>\n"
-      result
+
+      output << "</tr>\n"
+      output
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        super + @node.attributes.values + [@node.collection_name]
+      end
     end
   end
 
-  Template.register_tag('tablerow'.freeze, TableRow)
+  Template.register_tag('tablerow', TableRow)
 end

data/lib/liquid/tags/unless.rb

@@ -1,31 +1,49 @@
-require File.dirname(__FILE__) + '/if'
+# frozen_string_literal: true
+
+require_relative 'if'
 
 module Liquid
-  # Unless is a conditional just like 'if' but works on the inverse logic.
-  #
-  #   {% unless x < 0 %} x is greater than zero {% endunless %}
-  #
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category conditional
+  # @liquid_name unless
+  # @liquid_summary
+  #   Renders an expression unless a specific condition is `true`.
+  # @liquid_description
+  #   > Tip:
+  #   > Similar to the [`if` tag](/api/liquid/tags#if), you can use `elsif` to add more conditions to an `unless` tag.
+  # @liquid_syntax
+  #   {% unless condition %}
+  #     expression
+  #   {% endunless %}
+  # @liquid_syntax_keyword condition The condition to evaluate.
+  # @liquid_syntax_keyword expression The expression to render unless the condition is met.
   class Unless < If
-    def render(context)
-      context.stack do
+    def render_to_output_buffer(context, output)
+      # First condition is interpreted backwards ( if not )
+      first_block = @blocks.first
+      result = Liquid::Utils.to_liquid_value(
+        first_block.evaluate(context)
+      )
 
-        # First condition is interpreted backwards ( if not )
-        first_block = @blocks.first
-        unless first_block.evaluate(context)
-          return render_all(first_block.attachment, context)
-        end
+      unless result
+        return first_block.attachment.render_to_output_buffer(context, output)
+      end
 
-        # After the first condition unless works just like if
-        @blocks[1..-1].each do |block|
-          if block.evaluate(context)
-            return render_all(block.attachment, context)
-          end
-        end
+      # After the first condition unless works just like if
+      @blocks[1..-1].each do |block|
+        result = Liquid::Utils.to_liquid_value(
+          block.evaluate(context)
+        )
 
-        ''.freeze
+        if result
+          return block.attachment.render_to_output_buffer(context, output)
+        end
       end
+
+      output
     end
   end
 
-  Template.register_tag('unless'.freeze, Unless)
+  Template.register_tag('unless', Unless)
 end

data/lib/liquid/template.rb

@@ -1,5 +1,6 @@
-module Liquid
+# frozen_string_literal: true
 
+module Liquid
   # Templates are central to liquid.
   # Interpretating templates is a two step process. First you compile the
   # source code you got. During compile time some extensive error checking is performed.
@@ -14,21 +15,19 @@ module Liquid
   #   template.render('user_name' => 'bob')
   #
   class Template
-    DEFAULT_OPTIONS = {
-      :locale => I18n.new
-    }
-
-    attr_accessor :root, :resource_limits
-    @@file_system = BlankFileSystem.new
+    attr_accessor :root
+    attr_reader :resource_limits, :warnings
 
     class TagRegistry
+      include Enumerable
+
       def initialize
         @tags  = {}
         @cache = {}
       end
 
       def [](tag_name)
-        return nil unless @tags.has_key?(tag_name)
+        return nil unless @tags.key?(tag_name)
         return @cache[tag_name] if Liquid.cache_classes
 
         lookup_class(@tags[tag_name]).tap { |o| @cache[tag_name] = o }
@@ -44,10 +43,14 @@ module Liquid
         @cache.delete(tag_name)
       end
 
+      def each(&block)
+        @tags.each(&block)
+      end
+
       private
 
       def lookup_class(name)
-        name.split("::").reject(&:empty?).reduce(Object) { |scope, const| scope.const_get(const) }
+        Object.const_get(name)
       end
     end
 
@@ -58,77 +61,57 @@ module Liquid
       # :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
       # :warn is the default and will give deprecation warnings when invalid syntax is used.
       # :strict will enforce correct syntax.
-      attr_writer :error_mode
+      attr_accessor :error_mode
+      Template.error_mode = :lax
 
-      # Sets how strict the taint checker should be.
-      # :lax is the default, and ignores the taint flag completely
-      # :warn adds a warning, but does not interrupt the rendering
-      # :error raises an error when tainted output is used
-      attr_writer :taint_mode
-
-      def file_system
-        @@file_system
+      attr_accessor :default_exception_renderer
+      Template.default_exception_renderer = lambda do |exception|
+        exception
       end
 
-      def file_system=(obj)
-        @@file_system = obj
-      end
+      attr_accessor :file_system
+      Template.file_system = BlankFileSystem.new
+
+      attr_accessor :tags
+      Template.tags = TagRegistry.new
+      private :tags=
 
       def register_tag(name, klass)
         tags[name.to_s] = klass
       end
 
-      def tags
-        @tags ||= TagRegistry.new
-      end
-
-      def error_mode
-        @error_mode || :lax
-      end
-
-      def taint_mode
-        @taint_mode || :lax
-      end
-
       # Pass a module with filter methods which should be available
       # to all liquid views. Good for registering the standard library
       def register_filter(mod)
-        Strainer.global_filter(mod)
+        StrainerFactory.add_global_filter(mod)
       end
 
-      def default_resource_limits
-        @default_resource_limits ||= {}
-      end
+      attr_accessor :default_resource_limits
+      Template.default_resource_limits = {}
+      private :default_resource_limits=
 
       # creates a new <tt>Template</tt> object from liquid source code
       # To enable profiling, pass in <tt>profile: true</tt> as an option.
       # See Liquid::Profiler for more information
       def parse(source, options = {})
-        template = Template.new
-        template.parse(source, options)
+        new.parse(source, options)
       end
     end
 
     def initialize
-      @resource_limits = self.class.default_resource_limits.dup
+      @rethrow_errors  = false
+      @resource_limits = ResourceLimits.new(Template.default_resource_limits)
     end
 
     # Parse source code.
     # Returns self for easy chaining
     def parse(source, options = {})
-      @options = options
-      @profiling = options[:profile]
-      @line_numbers = options[:line_numbers] || @profiling
-      @root = Document.parse(tokenize(source), DEFAULT_OPTIONS.merge(options))
-      @warnings = nil
+      parse_context = configure_options(options)
+      tokenizer     = parse_context.new_tokenizer(source, start_line_number: @line_numbers && 1)
+      @root         = Document.parse(tokenizer, parse_context)
       self
     end
 
-    def warnings
-      return [] unless @root
-      @warnings ||= @root.warnings
-    end
-
     def registers
       @registers ||= {}
     end
@@ -160,19 +143,19 @@ module Liquid
     #    filters and tags and might be useful to integrate liquid more with its host application
     #
     def render(*args)
-      return ''.freeze if @root.nil?
+      return '' if @root.nil?
 
       context = case args.first
       when Liquid::Context
         c = args.shift
 
         if @rethrow_errors
-          c.exception_handler = ->(e) { true }
+          c.exception_renderer = Liquid::RAISE_EXCEPTION_LAMBDA
         end
 
         c
       when Liquid::Drop
-        drop = args.shift
+        drop         = args.shift
         drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
       when Hash
         Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
@@ -182,34 +165,33 @@ module Liquid
         raise ArgumentError, "Expected Hash or Liquid::Context as parameter"
       end
 
+      output = nil
+
       case args.last
       when Hash
         options = args.pop
+        output  = options[:output] if options[:output]
+        static_registers = context.registers.static
 
-        if options[:registers].is_a?(Hash)
-          self.registers.merge!(options[:registers])
+        options[:registers]&.each do |key, register|
+          static_registers[key] = register
         end
 
-        if options[:filters]
-          context.add_filters(options[:filters])
-        end
-
-        if options[:exception_handler]
-          context.exception_handler = options[:exception_handler]
-        end
-      when Module
-        context.add_filters(args.pop)
-      when Array
+        apply_options_to_context(context, options)
+      when Module, Array
         context.add_filters(args.pop)
       end
 
+      # Retrying a render resets resource usage
+      context.resource_limits.reset
+
+      if @profiling && context.profiler.nil?
+        @profiler = context.profiler = Liquid::Profiler.new
+      end
+
       begin
         # render the nodelist.
-        # for performance reasons we get an array back here. join will make a string out of it.
-        result = with_profiling do
-          @root.render(context)
-        end
-        result.respond_to?(:join) ? result.join : result
+        @root.render_to_output_buffer(context, output || +'')
       rescue Liquid::MemoryError => e
         context.handle_error(e)
       ensure
@@ -222,45 +204,31 @@ module Liquid
       render(*args)
     end
 
-    private
-
-    # Uses the <tt>Liquid::TemplateParser</tt> regexp to tokenize the passed source
-    def tokenize(source)
-      source = source.source if source.respond_to?(:source)
-      return [] if source.to_s.empty?
-
-      tokens = calculate_line_numbers(source.split(TemplateParser))
-
-      # removes the rogue empty element at the beginning of the array
-      tokens.shift if tokens[0] and tokens[0].empty?
-
-      tokens
+    def render_to_output_buffer(context, output)
+      render(context, output: output)
     end
 
-    def calculate_line_numbers(raw_tokens)
-      return raw_tokens unless @line_numbers
+    private
 
-      current_line = 1
-      raw_tokens.map do |token|
-        Token.new(token, current_line).tap do
-          current_line += token.count("\n")
-        end
+    def configure_options(options)
+      if (profiling = options[:profile])
+        raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)
       end
-    end
 
-    def with_profiling
-      if @profiling && !@options[:included]
-        @profiler = Profiler.new
-        @profiler.start
+      @options      = options
+      @profiling    = profiling
+      @line_numbers = options[:line_numbers] || @profiling
+      parse_context = options.is_a?(ParseContext) ? options : ParseContext.new(options)
+      @warnings     = parse_context.warnings
+      parse_context
+    end
 
-        begin
-          yield
-        ensure
-          @profiler.stop
-        end
-      else
-        yield
-      end
+    def apply_options_to_context(context, options)
+      context.add_filters(options[:filters]) if options[:filters]
+      context.global_filter      = options[:global_filter] if options[:global_filter]
+      context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
+      context.strict_variables   = options[:strict_variables] if options[:strict_variables]
+      context.strict_filters     = options[:strict_filters] if options[:strict_filters]
     end
   end
 end

data/lib/liquid/template_factory.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Liquid
+  class TemplateFactory
+    def for(_template_name)
+      Liquid::Template.new
+    end
+  end
+end

data/lib/liquid/tokenizer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Liquid
+  class Tokenizer
+    attr_reader :line_number, :for_liquid_tag
+
+    def initialize(source, line_numbers = false, line_number: nil, for_liquid_tag: false)
+      @source         = source.to_s.to_str
+      @line_number    = line_number || (line_numbers ? 1 : nil)
+      @for_liquid_tag = for_liquid_tag
+      @tokens         = tokenize
+    end
+
+    def shift
+      (token = @tokens.shift) || return
+
+      if @line_number
+        @line_number += @for_liquid_tag ? 1 : token.count("\n")
+      end
+
+      token
+    end
+
+    private
+
+    def tokenize
+      return [] if @source.empty?
+
+      return @source.split("\n") if @for_liquid_tag
+
+      tokens = @source.split(TemplateParser)
+
+      # removes the rogue empty element at the beginning of the array
+      tokens.shift if tokens[0]&.empty?
+
+      tokens
+    end
+  end
+end

data/lib/liquid/usage.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Liquid
+  module Usage
+    def self.increment(name)
+    end
+  end
+end