liquid-render-tag 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8dba018c056179fd88c9210a4c0b310cd6dc90034be347b47e1c450e65b724c3
+  data.tar.gz: ce4dbcf7a26834241ce06402a69ddc9e5b2d3c12dbd202e9acc9dac2c13be373
+SHA512:
+  metadata.gz: edb9790d7028931a5b0511f117cd21e6e59a9aa8af5d126dede1dc0c4679523d8d0f52dd7e53d1bf1bfa270f55003d6a628083bb378258b766ee4bcfa5c3c383
+  data.tar.gz: e5e51c721402926535d167cb29345011e64419450b8cc4ca8196fdf980f260ca05093671f0f19c9f4d8a17084821a788da0867eb6ae2d10aafd569c5ed3673fa

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in liquid-render-tag.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2005, 2006 Tobias Luetke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,23 @@
+# Liquid::Render
+
+This gem is simply a backport of code from the master branch of the [Liquid gem](https://github.com/shopify/liquid) to bring
+support for the `render` tag to Liquid v4.0.3 (the current version released on
+Rubygems).
+
+## Installation
+
+```ruby
+# Gemfile
+gem 'liquid'
+gem 'liquid-render-tag'
+```
+
+Then require `liquid-render-tag` right after you require `liquid`.
+
+## Usage
+
+Information about the `render` tag can be found in [Shopify's Liquid Reference](https://shopify.dev/docs/themes/liquid/reference/tags/theme-tags#render).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/lib/liquid-render-tag.rb

@@ -0,0 +1,20 @@
+require "liquid"
+
+p "Liquid!"
+
+unless defined?(Liquid::Render)
+  tags = Liquid::Template.tags.instance_variable_get(:@cache)
+
+  original_verbosity = $VERBOSE
+  $VERBOSE = nil
+  Dir["#{__dir__}/liquid-render-tag/*.rb"].each { |f| require f }
+  Dir["#{__dir__}/liquid-render-tag/registers/*.rb"].each { |f| require f }
+  Dir["#{__dir__}/liquid-render-tag/tags/*.rb"].each { |f| require f }
+  $VERBOSE = original_verbosity
+
+  Liquid::Template.register_filter(Liquid::StandardFilters)
+
+  tags.each do |name, klass|
+    Liquid::Template.register_tag(name, klass)
+  end
+end

data/lib/liquid-render-tag/block_body.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require 'English'
+
+module Liquid
+  class BlockBody
+    LiquidTagToken      = /\A\s*(\w+)\s*(.*?)\z/o
+    FullToken           = /\A#{TagStart}#{WhitespaceControl}?(\s*)(\w+)(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
+    ContentOfVariable   = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
+    WhitespaceOrNothing = /\A\s*\z/
+    TAGSTART            = "{%"
+    VARSTART            = "{{"
+
+    attr_reader :nodelist
+
+    def initialize
+      @nodelist = []
+      @blank    = true
+    end
+
+    def parse(tokenizer, parse_context, &block)
+      parse_context.line_number = tokenizer.line_number
+
+      if tokenizer.for_liquid_tag
+        parse_for_liquid_tag(tokenizer, parse_context, &block)
+      else
+        parse_for_document(tokenizer, parse_context, &block)
+      end
+    end
+
+    private def parse_for_liquid_tag(tokenizer, parse_context)
+      while (token = tokenizer.shift)
+        unless token.empty? || token =~ WhitespaceOrNothing
+          unless token =~ LiquidTagToken
+            # line isn't empty but didn't match tag syntax, yield and let the
+            # caller raise a syntax error
+            return yield token, token
+          end
+          tag_name = Regexp.last_match(1)
+          markup   = Regexp.last_match(2)
+          unless (tag = registered_tags[tag_name])
+            # end parsing if we reach an unknown tag and let the caller decide
+            # determine how to proceed
+            return yield tag_name, markup
+          end
+          new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
+          @blank &&= new_tag.blank?
+          @nodelist << new_tag
+        end
+        parse_context.line_number = tokenizer.line_number
+      end
+
+      yield nil, nil
+    end
+
+    # @api private
+    def self.unknown_tag_in_liquid_tag(end_tag_name, end_tag_markup)
+      yield end_tag_name, end_tag_markup
+    ensure
+      Usage.increment("liquid_tag_contains_outer_tag") unless $ERROR_INFO.is_a?(SyntaxError)
+    end
+
+    private def parse_liquid_tag(markup, parse_context, &block)
+      liquid_tag_tokenizer = Tokenizer.new(markup, line_number: parse_context.line_number, for_liquid_tag: true)
+      parse_for_liquid_tag(liquid_tag_tokenizer, parse_context) do |end_tag_name, end_tag_markup|
+        next unless end_tag_name
+        self.class.unknown_tag_in_liquid_tag(end_tag_name, end_tag_markup, &block)
+      end
+    end
+
+    private def parse_for_document(tokenizer, parse_context, &block)
+      while (token = tokenizer.shift)
+        next if token.empty?
+        case
+        when token.start_with?(TAGSTART)
+          whitespace_handler(token, parse_context)
+          unless token =~ FullToken
+            raise_missing_tag_terminator(token, parse_context)
+          end
+          tag_name = Regexp.last_match(2)
+          markup   = Regexp.last_match(4)
+
+          if parse_context.line_number
+            # newlines inside the tag should increase the line number,
+            # particularly important for multiline {% liquid %} tags
+            parse_context.line_number += Regexp.last_match(1).count("\n") + Regexp.last_match(3).count("\n")
+          end
+
+          if tag_name == 'liquid'
+            parse_liquid_tag(markup, parse_context, &block)
+            next
+          end
+
+          unless (tag = registered_tags[tag_name])
+            # end parsing if we reach an unknown tag and let the caller decide
+            # determine how to proceed
+            return yield tag_name, markup
+          end
+          new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
+          @blank &&= new_tag.blank?
+          @nodelist << new_tag
+        when token.start_with?(VARSTART)
+          whitespace_handler(token, parse_context)
+          @nodelist << create_variable(token, parse_context)
+          @blank = false
+        else
+          if parse_context.trim_whitespace
+            token.lstrip!
+          end
+          parse_context.trim_whitespace = false
+          @nodelist << token
+          @blank &&= !!(token =~ WhitespaceOrNothing)
+        end
+        parse_context.line_number = tokenizer.line_number
+      end
+
+      yield nil, nil
+    end
+
+    def whitespace_handler(token, parse_context)
+      if token[2] == WhitespaceControl
+        previous_token = @nodelist.last
+        if previous_token.is_a?(String)
+          previous_token.rstrip!
+        end
+      end
+      parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
+    end
+
+    def blank?
+      @blank
+    end
+
+    def render(context)
+      render_to_output_buffer(context, +'')
+    end
+
+    def render_to_output_buffer(context, output)
+      context.resource_limits.render_score += @nodelist.length
+
+      idx = 0
+      while (node = @nodelist[idx])
+        previous_output_size = output.bytesize
+
+        case node
+        when String
+          output << node
+        when Variable
+          render_node(context, output, node)
+        when Block
+          render_node(context, node.blank? ? +'' : output, node)
+          break if context.interrupt? # might have happened in a for-block
+        when Continue, Break
+          # If we get an Interrupt that means the block must stop processing. An
+          # Interrupt is any command that stops block execution such as {% break %}
+          # or {% continue %}
+          context.push_interrupt(node.interrupt)
+          break
+        else # Other non-Block tags
+          render_node(context, output, node)
+          break if context.interrupt? # might have happened through an include
+        end
+        idx += 1
+
+        raise_if_resource_limits_reached(context, output.bytesize - previous_output_size)
+      end
+
+      output
+    end
+
+    private
+
+    def render_node(context, output, node)
+      if node.disabled?(context)
+        output << node.disabled_error_message
+        return
+      end
+      disable_tags(context, node.disabled_tags) do
+        node.render_to_output_buffer(context, output)
+      end
+    rescue UndefinedVariable, UndefinedDropMethod, UndefinedFilter => e
+      context.handle_error(e, node.line_number)
+    rescue ::StandardError => e
+      line_number = node.is_a?(String) ? nil : node.line_number
+      output << context.handle_error(e, line_number)
+    end
+
+    def disable_tags(context, tags, &block)
+      return yield if tags.empty?
+      context.registers[:disabled_tags].disable(tags, &block)
+    end
+
+    def raise_if_resource_limits_reached(context, length)
+      context.resource_limits.render_length += length
+      return unless context.resource_limits.reached?
+      raise MemoryError, "Memory limits exceeded"
+    end
+
+    def create_variable(token, parse_context)
+      token.scan(ContentOfVariable) do |content|
+        markup = content.first
+        return Variable.new(markup, parse_context)
+      end
+      raise_missing_variable_terminator(token, parse_context)
+    end
+
+    def raise_missing_tag_terminator(token, parse_context)
+      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_termination", token: token, tag_end: TagEnd.inspect)
+    end
+
+    def raise_missing_variable_terminator(token, parse_context)
+      raise SyntaxError, parse_context.locale.t("errors.syntax.variable_termination", token: token, tag_end: VariableEnd.inspect)
+    end
+
+    def registered_tags
+      Template.tags
+    end
+  end
+end

data/lib/liquid-render-tag/context.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+module Liquid
+  # Context keeps the variable stack and resolves variables, as well as keywords
+  #
+  #   context['variable'] = 'testing'
+  #   context['variable'] #=> 'testing'
+  #   context['true']     #=> true
+  #   context['10.2232']  #=> 10.2232
+  #
+  #   context.stack do
+  #      context['bob'] = 'bobsen'
+  #   end
+  #
+  #   context['bob']  #=> nil  class Context
+  class Context
+    attr_reader :scopes, :errors, :registers, :environments, :resource_limits, :static_registers, :static_environments
+    attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters
+
+    # rubocop:disable Metrics/ParameterLists
+    def self.build(environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_environments: {})
+      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_environments)
+    end
+
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_environments = {})
+      @environments = [environments]
+      @environments.flatten!
+
+      @static_environments = [static_environments].flat_map(&:freeze).freeze
+      @scopes              = [(outer_scope || {})]
+      @registers           = registers
+      @errors              = []
+      @partial             = false
+      @strict_variables    = false
+      @resource_limits     = resource_limits || ResourceLimits.new(Template.default_resource_limits)
+      @base_scope_depth    = 0
+      squash_instance_assigns_with_environments
+
+      self.exception_renderer = Template.default_exception_renderer
+      if rethrow_errors
+        self.exception_renderer = ->(_e) { raise }
+      end
+
+      @interrupts    = []
+      @filters       = []
+      @global_filter = nil
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    def warnings
+      @warnings ||= []
+    end
+
+    def strainer
+      @strainer ||= StrainerFactory.create(self, @filters)
+    end
+
+    # Adds filters to this context.
+    #
+    # Note that this does not register the filters with the main Template object. see <tt>Template.register_filter</tt>
+    # for that
+    def add_filters(filters)
+      filters = [filters].flatten.compact
+      @filters += filters
+      @strainer = nil
+    end
+
+    def apply_global_filter(obj)
+      global_filter.nil? ? obj : global_filter.call(obj)
+    end
+
+    # are there any not handled interrupts?
+    def interrupt?
+      !@interrupts.empty?
+    end
+
+    # push an interrupt to the stack. this interrupt is considered not handled.
+    def push_interrupt(e)
+      @interrupts.push(e)
+    end
+
+    # pop an interrupt from the stack
+    def pop_interrupt
+      @interrupts.pop
+    end
+
+    def handle_error(e, line_number = nil)
+      e = internal_error unless e.is_a?(Liquid::Error)
+      e.template_name ||= template_name
+      e.line_number   ||= line_number
+      errors.push(e)
+      exception_renderer.call(e).to_s
+    end
+
+    def invoke(method, *args)
+      strainer.invoke(method, *args).to_liquid
+    end
+
+    # Push new local scope on the stack. use <tt>Context#stack</tt> instead
+    def push(new_scope = {})
+      @scopes.unshift(new_scope)
+      check_overflow
+    end
+
+    # Merge a hash of variables in the current local scope
+    def merge(new_scopes)
+      @scopes[0].merge!(new_scopes)
+    end
+
+    # Pop from the stack. use <tt>Context#stack</tt> instead
+    def pop
+      raise ContextError if @scopes.size == 1
+      @scopes.shift
+    end
+
+    # Pushes a new local scope on the stack, pops it at the end of the block
+    #
+    # Example:
+    #   context.stack do
+    #      context['var'] = 'hi'
+    #   end
+    #
+    #   context['var]  #=> nil
+    def stack(new_scope = {})
+      push(new_scope)
+      yield
+    ensure
+      pop
+    end
+
+    # Creates a new context inheriting resource limits, filters, environment etc.,
+    # but with an isolated scope.
+    def new_isolated_subcontext
+      check_overflow
+
+      Context.build(
+        resource_limits: resource_limits,
+        static_environments: static_environments,
+        registers: StaticRegisters.new(registers)
+      ).tap do |subcontext|
+        subcontext.base_scope_depth   = base_scope_depth + 1
+        subcontext.exception_renderer = exception_renderer
+        subcontext.filters  = @filters
+        subcontext.strainer = nil
+        subcontext.errors   = errors
+        subcontext.warnings = warnings
+      end
+    end
+
+    def clear_instance_assigns
+      @scopes[0] = {}
+    end
+
+    # Only allow String, Numeric, Hash, Array, Proc, Boolean or <tt>Liquid::Drop</tt>
+    def []=(key, value)
+      @scopes[0][key] = value
+    end
+
+    # Look up variable, either resolve directly after considering the name. We can directly handle
+    # Strings, digits, floats and booleans (true,false).
+    # If no match is made we lookup the variable in the current scope and
+    # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
+    # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
+    #
+    # Example:
+    #   products == empty #=> products.empty?
+    def [](expression)
+      evaluate(Expression.parse(expression))
+    end
+
+    def key?(key)
+      self[key] != nil
+    end
+
+    def evaluate(object)
+      object.respond_to?(:evaluate) ? object.evaluate(self) : object
+    end
+
+    # Fetches an object starting at the local scope and then moving up the hierachy
+    def find_variable(key, raise_on_not_found: true)
+      # This was changed from find() to find_index() because this is a very hot
+      # path and find_index() is optimized in MRI to reduce object allocation
+      index = @scopes.find_index { |s| s.key?(key) }
+
+      variable = if index
+        lookup_and_evaluate(@scopes[index], key, raise_on_not_found: raise_on_not_found)
+      else
+        try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
+      end
+
+      variable         = variable.to_liquid
+      variable.context = self if variable.respond_to?(:context=)
+
+      variable
+    end
+
+    def lookup_and_evaluate(obj, key, raise_on_not_found: true)
+      if @strict_variables && raise_on_not_found && obj.respond_to?(:key?) && !obj.key?(key)
+        raise Liquid::UndefinedVariable, "undefined variable #{key}"
+      end
+
+      value = obj[key]
+
+      if value.is_a?(Proc) && obj.respond_to?(:[]=)
+        obj[key] = value.arity == 0 ? value.call : value.call(self)
+      else
+        value
+      end
+    end
+
+    protected
+
+    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters
+
+    private
+
+    attr_reader :base_scope_depth
+
+    def try_variable_find_in_environments(key, raise_on_not_found:)
+      @environments.each do |environment|
+        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
+        if !found_variable.nil? || @strict_variables && raise_on_not_found
+          return found_variable
+        end
+      end
+      @static_environments.each do |environment|
+        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
+        if !found_variable.nil? || @strict_variables && raise_on_not_found
+          return found_variable
+        end
+      end
+      nil
+    end
+
+    def check_overflow
+      raise StackLevelError, "Nesting too deep" if overflow?
+    end
+
+    def overflow?
+      base_scope_depth + @scopes.length > Block::MAX_DEPTH
+    end
+
+    def internal_error
+      # raise and catch to set backtrace and cause on exception
+      raise Liquid::InternalError, 'internal'
+    rescue Liquid::InternalError => exc
+      exc
+    end
+
+    def squash_instance_assigns_with_environments
+      @scopes.last.each_key do |k|
+        @environments.each do |env|
+          if env.key?(k)
+            scopes.last[k] = lookup_and_evaluate(env, k)
+            break
+          end
+        end
+      end
+    end # squash_instance_assigns_with_environments
+  end # Context
+end # Liquid