liquid 2.6.1 → 4.0.3

data/lib/liquid/tags/ifchanged.rb

@@ -1,20 +1,18 @@
 module Liquid
   class Ifchanged < Block
-
     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)
+  Template.register_tag('ifchanged'.freeze, Ifchanged)
 end

data/lib/liquid/tags/include.rb

@@ -1,5 +1,4 @@
 module Liquid
-
   # Include allows templates to relate with other templates
   #
   # Simply include another template:
@@ -17,77 +16,109 @@ module Liquid
   class Include < Tag
     Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o
 
-    def initialize(tag_name, markup, tokens)
+    attr_reader :template_name_expr, :variable_name_expr, :attributes
+
+    def initialize(tag_name, markup, options)
+      super
+
       if markup =~ Syntax
 
-        @template_name = $1
-        @variable_name = $3
-        @attributes    = {}
+        template_name = $1
+        variable_name = $3
+
+        @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
+        @template_name_expr = Expression.parse(template_name)
+        @attributes = {}
 
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = value
+          @attributes[key] = Expression.parse(value)
         end
 
       else
-        raise SyntaxError.new("Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.include".freeze))
       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]]
+      template_name = context.evaluate(@template_name_expr)
+      raise ArgumentError.new(options[:locale].t("errors.argument.include")) unless template_name
 
-      context.stack do
-        @attributes.each do |key, value|
-          context[key] = context[value]
-        end
+      partial = load_cached_partial(template_name, context)
+      context_variable_name = template_name.split('/'.freeze).last
+
+      variable = if @variable_name_expr
+        context.evaluate(@variable_name_expr)
+      else
+        context.find_variable(template_name, raise_on_not_found: false)
+      end
 
-        if variable.is_a?(Array)
-          variable.collect do |var|
-            context[@template_name[1..-2]] = var
+      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 variable.is_a?(Array)
+            variable.collect do |var|
+              context[context_variable_name] = var
+              partial.render(context)
+            end
+          else
+            context[context_variable_name] = variable
             partial.render(context)
           end
-        else
-          context[@template_name[1..-2]] = variable
-          partial.render(context)
         end
+      ensure
+        context.template_name = old_template_name
+        context.partial = old_partial
       end
     end
 
     private
-      def load_cached_partial(context)
-        cached_partials = context.registers[:cached_partials] || {}
-        template_name = context[@template_name]
 
-        if cached = cached_partials[template_name]
-          return cached
-        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
+    alias_method :parse_context, :options
+    private :parse_context
+
+    def load_cached_partial(template_name, context)
+      cached_partials = context.registers[:cached_partials] || {}
+
+      if cached = cached_partials[template_name]
+        return cached
+      end
+      source = read_template_from_file_system(context)
+      begin
+        parse_context.partial = true
+        partial = Liquid::Template.parse(source, parse_context)
+      ensure
+        parse_context.partial = false
       end
+      cached_partials[template_name] = partial
+      context.registers[:cached_partials] = cached_partials
+      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
+    def read_template_from_file_system(context)
+      file_system = context.registers[:file_system] || Liquid::Template.file_system
+
+      file_system.read_template_file(context.evaluate(@template_name_expr))
+    end
+
+    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)
+  Template.register_tag('include'.freeze, Include)
 end

data/lib/liquid/tags/increment.rb

@@ -1,12 +1,11 @@
 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.
-
+  #
   #   Hello: {% increment variable %}
   #
   # gives you:
@@ -16,10 +15,9 @@ module Liquid
   #    Hello: 2
   #
   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)
@@ -27,9 +25,7 @@ module Liquid
       context.environments.first[@variable] = value + 1
       value.to_s
     end
-
-    private
   end
 
-  Template.register_tag('increment', Increment)
+  Template.register_tag('increment'.freeze, Increment)
 end

data/lib/liquid/tags/raw.rb

@@ -1,22 +1,47 @@
 module Liquid
   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
+      @body = ''
       while token = tokens.shift
         if token =~ FullTokenPossiblyInvalid
-          @nodelist << $1 if $1 != ""
-          if block_delimiter == $2
-            end_tag
-            return
-          end
+          @body << $1 if $1 != "".freeze
+          return if block_delimiter == $2
         end
-        @nodelist << token if not token.empty?
+        @body << token unless token.empty?
+      end
+
+      raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name))
+    end
+
+    def render(_context)
+      @body
+    end
+
+    def nodelist
+      [@body]
+    end
+
+    def blank?
+      @body.empty?
+    end
+
+    protected
+
+    def ensure_valid_markup(tag_name, markup, parse_context)
+      unless markup =~ Syntax
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_unexpected_args".freeze, tag: tag_name))
       end
     end
   end
 
-  Template.register_tag('raw', Raw)
+  Template.register_tag('raw'.freeze, Raw)
 end

data/lib/liquid/tags/table_row.rb

@@ -0,0 +1,62 @@
+module Liquid
+  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 = Expression.parse($2)
+        @attributes = {}
+        markup.scan(TagAttributes) do |key, value|
+          @attributes[key] = Expression.parse(value)
+        end
+      else
+        raise SyntaxError.new(options[:locale].t("errors.syntax.table_row".freeze))
+      end
+    end
+
+    def render(context)
+      collection = context.evaluate(@collection_name) or return ''.freeze
+
+      from = @attributes.key?('offset'.freeze) ? context.evaluate(@attributes['offset'.freeze]).to_i : 0
+      to = @attributes.key?('limit'.freeze) ? from + context.evaluate(@attributes['limit'.freeze]).to_i : nil
+
+      collection = Utils.slice_collection(collection, from, to)
+
+      length = collection.length
+
+      cols = context.evaluate(@attributes['cols'.freeze]).to_i
+
+      result = "<tr class=\"row1\">\n"
+      context.stack do
+        tablerowloop = Liquid::TablerowloopDrop.new(length, cols)
+        context['tablerowloop'.freeze] = tablerowloop
+
+        collection.each do |item|
+          context[@variable_name] = item
+
+          result << "<td class=\"col#{tablerowloop.col}\">" << super << '</td>'
+
+          if tablerowloop.col_last && !tablerowloop.last
+            result << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">"
+          end
+
+          tablerowloop.send(:increment!)
+        end
+      end
+      result << "</tr>\n"
+      result
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        super + @node.attributes.values + [@node.collection_name]
+      end
+    end
+  end
+
+  Template.register_tag('tablerow'.freeze, TableRow)
+end

data/lib/liquid/tags/unless.rb

@@ -1,33 +1,30 @@
-require File.dirname(__FILE__) + '/if'
+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 {% end %}
+  #   {% unless x < 0 %} x is greater than zero {% endunless %}
   #
   class Unless < If
     def render(context)
       context.stack do
-
         # First condition is interpreted backwards ( if not )
         first_block = @blocks.first
         unless first_block.evaluate(context)
-          return render_all(first_block.attachment, context)
+          return first_block.attachment.render(context)
         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)
+            return block.attachment.render(context)
           end
         end
 
-        ''
+        ''.freeze
       end
     end
   end
 
-
-  Template.register_tag('unless', Unless)
+  Template.register_tag('unless'.freeze, Unless)
 end

data/lib/liquid/template.rb

@@ -1,5 +1,4 @@
 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,10 +13,67 @@ module Liquid
   #   template.render('user_name' => 'bob')
   #
   class Template
-    attr_accessor :root, :resource_limits
+    attr_accessor :root
+    attr_reader :resource_limits, :warnings
+
     @@file_system = BlankFileSystem.new
 
+    class TagRegistry
+      include Enumerable
+
+      def initialize
+        @tags = {}
+        @cache = {}
+      end
+
+      def [](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 }
+      end
+
+      def []=(tag_name, klass)
+        @tags[tag_name]  = klass.name
+        @cache[tag_name] = klass
+      end
+
+      def delete(tag_name)
+        @tags.delete(tag_name)
+        @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) }
+      end
+    end
+
+    attr_reader :profiler
+
     class << self
+      # Sets how strict the parser should be.
+      # :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
+
+      # 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
+
+      attr_accessor :default_exception_renderer
+      Template.default_exception_renderer = lambda do |exception|
+        exception
+      end
+
       def file_system
         @@file_system
       end
@@ -31,7 +87,15 @@ module Liquid
       end
 
       def tags
-        @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
@@ -40,23 +104,33 @@ module Liquid
         Strainer.global_filter(mod)
       end
 
+      def default_resource_limits
+        @default_resource_limits ||= {}
+      end
+
       # creates a new <tt>Template</tt> object from liquid source code
-      def parse(source)
+      # 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)
-        template
+        template.parse(source, options)
       end
     end
 
-    # creates a new <tt>Template</tt> from an array of tokens. Use <tt>Template.parse</tt> instead
     def initialize
-      @resource_limits = {}
+      @rethrow_errors = false
+      @resource_limits = ResourceLimits.new(self.class.default_resource_limits)
     end
 
     # Parse source code.
     # Returns self for easy chaining
-    def parse(source)
-      @root = Document.new(tokenize(source))
+    def parse(source, options = {})
+      @options = options
+      @profiling = options[:profile]
+      @line_numbers = options[:line_numbers] || @profiling
+      parse_context = options.is_a?(ParseContext) ? options : ParseContext.new(options)
+      @root = Document.parse(tokenize(source), parse_context)
+      @warnings = parse_context.warnings
       self
     end
 
@@ -81,6 +155,9 @@ module Liquid
     # if you use the same filters over and over again consider registering them globally
     # with <tt>Template.register_filter</tt>
     #
+    # if profiling was enabled in <tt>Template#parse</tt> then the resulting profiling information
+    # will be available via <tt>Template#profiler</tt>
+    #
     # Following options can be passed:
     #
     #  * <tt>filters</tt> : array with local filters
@@ -88,11 +165,17 @@ module Liquid
     #    filters and tags and might be useful to integrate liquid more with its host application
     #
     def render(*args)
-      return '' if @root.nil?
+      return ''.freeze if @root.nil?
 
       context = case args.first
       when Liquid::Context
-        args.shift
+        c = args.shift
+
+        if @rethrow_errors
+          c.exception_renderer = ->(e) { raise }
+        end
+
+        c
       when Liquid::Drop
         drop = args.shift
         drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
@@ -101,31 +184,29 @@ module Liquid
       when nil
         Context.new(assigns, instance_assigns, registers, @rethrow_errors, @resource_limits)
       else
-        raise ArgumentError, "Expect Hash or Liquid::Context as parameter"
+        raise ArgumentError, "Expected Hash or Liquid::Context as parameter"
       end
 
       case args.last
       when Hash
         options = args.pop
 
-        if options[:registers].is_a?(Hash)
-          self.registers.merge!(options[:registers])
-        end
+        registers.merge!(options[:registers]) if options[:registers].is_a?(Hash)
 
-        if options[:filters]
-          context.add_filters(options[:filters])
-        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
+
       begin
         # render the nodelist.
         # for performance reasons we get an array back here. join will make a string out of it.
-        result = @root.render(context)
+        result = with_profiling(context) do
+          @root.render(context)
+        end
         result.respond_to?(:join) ? result.join : result
       rescue Liquid::MemoryError => e
         context.handle_error(e)
@@ -135,22 +216,39 @@ module Liquid
     end
 
     def render!(*args)
-      @rethrow_errors = true; render(*args)
+      @rethrow_errors = true
+      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 = source.split(TemplateParser)
+      Tokenizer.new(source, @line_numbers)
+    end
 
-      # removes the rogue empty element at the beginning of the array
-      tokens.shift if tokens[0] and tokens[0].empty?
+    def with_profiling(context)
+      if @profiling && !context.partial
+        raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)
 
-      tokens
+        @profiler = Profiler.new
+        @profiler.start
+
+        begin
+          yield
+        ensure
+          @profiler.stop
+        end
+      else
+        yield
+      end
     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