liquid 5.1.0 → 5.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d033978c659ebc86ff6ae3a36adaa1a90b8f69580e0cd033eb9c2c669ff6d66d
-  data.tar.gz: 5c440b450df6ac2c673b0a23091d97e497ccb8207a443b0b6011f2b1a9b6529b
+  metadata.gz: c8408df245a1cc22ee1154fe5387e3e41eb3c740f7277e7d3736c1863d387e47
+  data.tar.gz: 64549a58828fd7e9e0eb7310cb4371e75e64a7c3249fe9ebd021039e3334bba1
 SHA512:
-  metadata.gz: 114697a0375800b4f67d7c216f9c56f823bb4468203632d45bda92bc597e0677acd0c4151c60f92fc121c2cd1b8d0d1c18d2482f1265acb62dbf190f12773d5c
-  data.tar.gz: 3c013aef59a531829e202b73c4ce33d63ad5f58d763b7f2c610a3ff96fdab13fe2fdcf7e9401b63e09bb136fb1518ad69300b41114ebc1f076565c7d2953de78
+  metadata.gz: 29aaff16e3bc464712cdcac3aa205df943132198ef9568d46f4a123d327849f7ead7bd669a095eae0425581eb59ea08874ac38664bf9d8df00b0aa99917c7768
+  data.tar.gz: 9f6070c39733b7f4064f70676b1f886fc61070f3ba8921360b9c5fcdb09c217b3e58c3d59d8293b24b6c18e55899ed17552a2f867ea8eb95e7dee9a7deb29ae5

data/History.md

@@ -1,5 +1,40 @@
 # Liquid Change Log
 
+## 5.4.0 2022-07-29
+
+### Breaking Changes
+* Drop support for end-of-life Ruby versions (2.5 and 2.6) (#1578) [Andy Waite]
+
+### Features
+* Allow `#` to be used as an inline comment tag (#1498) [CP Clermont]
+
+### Fixes
+* `PartialCache` now shares snippet cache with subcontexts by default (#1553) [Chris AtLee]
+* Hash registers no longer leak into subcontexts as static registers (#1564) [Chris AtLee]
+* Fix `ParseTreeVisitor` for `with` variable expressions in `Render` tag (#1596) [CP Clermont]
+
+### Changed
+* Liquid::Context#registers now always returns a Liquid::Registers object, though supports the most used Hash functions for compatibility (#1553)
+
+## 5.3.0 2022-03-22
+
+### Fixes
+* StandardFilter: Fix missing @context on iterations (#1525) [Thierry Joyal]
+* Fix warning about block and default value in `static_registers.rb` (#1531) [Peter Zhu]
+
+### Deprecation
+* Condition#evaluate to require mandatory context argument in Liquid 6.0.0 (#1527) [Thierry Joyal]
+
+## 5.2.0 2022-03-01
+
+### Features
+* Add `remove_last`, and `replace_last` filters (#1422) [Anders Hagbard]
+* Eagerly cache global filters (#1524) [Jean Boussier]
+
+### Fixes
+* Fix some internal errors in filters from invalid input (#1476) [Dylan Thacker-Smith]
+* Allow dash in filter kwarg name for consistency with Liquid::C (#1518) [CP Clermont]
+
 ## 5.1.0 / 2021-09-09
 
 ### Features

data/README.md

@@ -5,7 +5,7 @@
 
 * [Contributing guidelines](CONTRIBUTING.md)
 * [Version history](History.md)
-* [Liquid documentation from Shopify](http://docs.shopify.com/themes/liquid-basics)
+* [Liquid documentation from Shopify](https://shopify.dev/api/liquid)
 * [Liquid Wiki at GitHub](https://github.com/Shopify/liquid/wiki)
 * [Website](http://liquidmarkup.org/)
 
@@ -56,20 +56,20 @@ For standard use you can just pass it the content of a file and call render with
 
 Setting the error mode of Liquid lets you specify how strictly you want your templates to be interpreted.
 Normally the parser is very lax and will accept almost anything without error. Unfortunately this can make
-it very hard to debug and can lead to unexpected behaviour. 
+it very hard to debug and can lead to unexpected behaviour.
 
 Liquid also comes with a stricter parser that can be used when editing templates to give better error messages
 when templates are invalid. You can enable this new parser like this:
 
 ```ruby
 Liquid::Template.error_mode = :strict # Raises a SyntaxError when invalid syntax is used
-Liquid::Template.error_mode = :warn # Adds errors to template.errors but continues as normal
+Liquid::Template.error_mode = :warn # Adds strict errors to template.errors but continues as normal
 Liquid::Template.error_mode = :lax # The default mode, accepts almost anything.
 ```
 
 If you want to set the error mode only on specific templates you can pass `:error_mode` as an option to `parse`:
 ```ruby
-Liquid::Template.parse(source, :error_mode => :strict)
+Liquid::Template.parse(source, error_mode: :strict)
 ```
 This is useful for doing things like enabling strict mode only in the theme editor.
 

data/lib/liquid/block_body.rb

@@ -4,8 +4,8 @@ require 'English'
 
 module Liquid
   class BlockBody
-    LiquidTagToken      = /\A\s*(\w+)\s*(.*?)\z/o
-    FullToken           = /\A#{TagStart}#{WhitespaceControl}?(\s*)(\w+)(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
+    LiquidTagToken      = /\A\s*(#{TagName})\s*(.*?)\z/o
+    FullToken           = /\A#{TagStart}#{WhitespaceControl}?(\s*)(#{TagName})(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
     ContentOfVariable   = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
     WhitespaceOrNothing = /\A\s*\z/
     TAGSTART            = "{%"
@@ -37,7 +37,7 @@ module Liquid
 
     private def parse_for_liquid_tag(tokenizer, parse_context)
       while (token = tokenizer.shift)
-        unless token.empty? || token =~ WhitespaceOrNothing
+        unless token.empty? || token.match?(WhitespaceOrNothing)
           unless token =~ LiquidTagToken
             # line isn't empty but didn't match tag syntax, yield and let the
             # caller raise a syntax error
@@ -150,7 +150,7 @@ module Liquid
           end
           parse_context.trim_whitespace = false
           @nodelist << token
-          @blank &&= !!(token =~ WhitespaceOrNothing)
+          @blank &&= token.match?(WhitespaceOrNothing)
         end
         parse_context.line_number = tokenizer.line_number
       end
@@ -231,8 +231,8 @@ module Liquid
     end
 
     def create_variable(token, parse_context)
-      token.scan(ContentOfVariable) do |content|
-        markup = content.first
+      if token =~ ContentOfVariable
+        markup = Regexp.last_match(1)
         return Variable.new(markup, parse_context)
       end
       BlockBody.raise_missing_variable_terminator(token, parse_context)

data/lib/liquid/condition.rb

@@ -61,7 +61,7 @@ module Liquid
       @child_condition = nil
     end
 
-    def evaluate(context = Context.new)
+    def evaluate(context = deprecated_default_context)
       condition = self
       result = nil
       loop do
@@ -150,6 +150,12 @@ module Liquid
       end
     end
 
+    def deprecated_default_context
+      warn("DEPRECATION WARNING: Condition#evaluate without a context argument is deprecated" \
+        " and will be removed from Liquid 6.0.0.")
+      Context.new
+    end
+
     class ParseTreeVisitor < Liquid::ParseTreeVisitor
       def children
         [

data/lib/liquid/context.rb

@@ -28,7 +28,7 @@ module Liquid
 
       @static_environments = [static_environments].flat_map(&:freeze).freeze
       @scopes              = [(outer_scope || {})]
-      @registers           = registers
+      @registers           = registers.is_a?(Registers) ? registers : Registers.new(registers)
       @errors              = []
       @partial             = false
       @strict_variables    = false
@@ -39,6 +39,10 @@ module Liquid
       @global_filter       = nil
       @disabled_tags       = {}
 
+      @registers.static[:cached_partials] ||= {}
+      @registers.static[:file_system] ||= Liquid::Template.file_system
+      @registers.static[:template_factory] ||= Liquid::TemplateFactory.new
+
       self.exception_renderer = Template.default_exception_renderer
       if rethrow_errors
         self.exception_renderer = Liquid::RAISE_EXCEPTION_LAMBDA
@@ -140,7 +144,7 @@ module Liquid
       self.class.build(
         resource_limits: resource_limits,
         static_environments: static_environments,
-        registers: StaticRegisters.new(registers)
+        registers: Registers.new(registers)
       ).tap do |subcontext|
         subcontext.base_scope_depth   = base_scope_depth + 1
         subcontext.exception_renderer = exception_renderer

data/lib/liquid/expression.rb

@@ -10,21 +10,23 @@ module Liquid
       'empty' => ''
     }.freeze
 
-    SINGLE_QUOTED_STRING = /\A\s*'(.*)'\s*\z/m
-    DOUBLE_QUOTED_STRING = /\A\s*"(.*)"\s*\z/m
-    INTEGERS_REGEX       = /\A\s*(-?\d+)\s*\z/
-    FLOATS_REGEX         = /\A\s*(-?\d[\d\.]+)\s*\z/
+    INTEGERS_REGEX       = /\A(-?\d+)\z/
+    FLOATS_REGEX         = /\A(-?\d[\d\.]+)\z/
 
     # Use an atomic group (?>...) to avoid pathological backtracing from
     # malicious input as described in https://github.com/Shopify/liquid/issues/1357
-    RANGES_REGEX         = /\A\s*\(\s*(?>(\S+)\s*\.\.)\s*(\S+)\s*\)\s*\z/
+    RANGES_REGEX         = /\A\(\s*(?>(\S+)\s*\.\.)\s*(\S+)\s*\)\z/
 
     def self.parse(markup)
+      return nil unless markup
+
+      markup = markup.strip
+      if (markup.start_with?('"') && markup.end_with?('"')) ||
+         (markup.start_with?("'") && markup.end_with?("'"))
+        return markup[1..-2]
+      end
+
       case markup
-      when nil
-        nil
-      when SINGLE_QUOTED_STRING, DOUBLE_QUOTED_STRING
-        Regexp.last_match(1)
       when INTEGERS_REGEX
         Regexp.last_match(1).to_i
       when RANGES_REGEX
@@ -32,7 +34,6 @@ module Liquid
       when FLOATS_REGEX
         Regexp.last_match(1).to_f
       else
-        markup = markup.strip
         if LITERALS.key?(markup)
           LITERALS[markup]
         else

data/lib/liquid/forloop_drop.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
 module Liquid
+  # @liquid_public_docs
+  # @liquid_type object
+  # @liquid_name forloop
+  # @liquid_summary
+  #   Information about a parent [`for` loop](/api/liquid/tags#for).
   class ForloopDrop < Drop
     def initialize(name, length, parentloop)
       @name       = name
@@ -9,33 +14,71 @@ module Liquid
       @index      = 0
     end
 
-    attr_reader :length, :parentloop
+    # @liquid_public_docs
+    # @liquid_name length
+    # @liquid_summary
+    #   The total number of iterations in the loop.
+    # @liquid_return [number]
+    attr_reader :length
+
+    # @liquid_public_docs
+    # @liquid_name parentloop
+    # @liquid_summary
+    #   The parent `forloop` object.
+    # @liquid_description
+    #   If the current `for` loop isn't nested inside another `for` loop, then `nil` is returned.
+    # @liquid_return [forloop]
+    attr_reader :parentloop
 
     def name
       Usage.increment('forloop_drop_name')
       @name
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   The 1-based index of the current iteration.
+    # @liquid_return [number]
     def index
       @index + 1
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   The 0-based index of the current iteration.
+    # @liquid_return [number]
     def index0
       @index
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   The 1-based index of the current iteration, in reverse order.
+    # @liquid_return [number]
     def rindex
       @length - @index
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   The 0-based index of the current iteration, in reverse order.
+    # @liquid_return [number]
     def rindex0
       @length - @index - 1
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   Returns `true` if the current iteration is the first. Returns `false` if not.
+    # @liquid_return [boolean]
     def first
       @index == 0
     end
 
+    # @liquid_public_docs
+    # @liquid_summary
+    #   Returns `true` if the current iteration is the last. Returns `false` if not.
+    # @liquid_return [boolean]
     def last
       @index == @length - 1
     end

data/lib/liquid/locales/en.yml

@@ -13,15 +13,16 @@
       for_invalid_attribute: "Invalid attribute in for loop. Valid attributes are limit and offset"
       if: "Syntax Error in tag 'if' - Valid syntax: if [expression]"
       include: "Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]"
-      unknown_tag: "Unknown tag '%{tag}'"
+      inline_comment_invalid: "Syntax error in tag '#' - Each line of comments must be prefixed by the '#' character"
       invalid_delimiter: "'%{tag}' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
+      render: "Syntax error in tag 'render' - Template name must be a quoted string"
+      table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
+      tag_never_closed: "'%{block_name}' tag was never closed"
+      tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
       unexpected_else: "%{block_name} tag does not expect 'else' tag"
       unexpected_outer_tag: "Unexpected outer '%{tag}' tag"
-      tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
+      unknown_tag: "Unknown tag '%{tag}'"
       variable_termination: "Variable '%{token}' was not properly terminated with regexp: %{tag_end}"
-      tag_never_closed: "'%{block_name}' tag was never closed"
-      table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
-      render: "Syntax error in tag 'render' - Template name must be a quoted string"
     argument:
       include: "Argument error in tag 'include' - Illegal template name"
     disabled:

data/lib/liquid/partial_cache.rb

@@ -3,16 +3,16 @@
 module Liquid
   class PartialCache
     def self.load(template_name, context:, parse_context:)
-      cached_partials = (context.registers[:cached_partials] ||= {})
+      cached_partials = context.registers[:cached_partials]
       cached = cached_partials[template_name]
       return cached if cached
 
-      file_system = (context.registers[:file_system] ||= Liquid::Template.file_system)
+      file_system = context.registers[:file_system]
       source      = file_system.read_template_file(template_name)
 
       parse_context.partial = true
 
-      template_factory = (context.registers[:template_factory] ||= Liquid::TemplateFactory.new)
+      template_factory = context.registers[:template_factory]
       template = template_factory.for(template_name)
 
       partial = template.parse(source, parse_context)

data/lib/liquid/registers.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Liquid
+  class Registers
+    attr_reader :static
+
+    def initialize(registers = {})
+      @static = registers.is_a?(Registers) ? registers.static : registers
+      @changes = {}
+    end
+
+    def []=(key, value)
+      @changes[key] = value
+    end
+
+    def [](key)
+      if @changes.key?(key)
+        @changes[key]
+      else
+        @static[key]
+      end
+    end
+
+    def delete(key)
+      @changes.delete(key)
+    end
+
+    UNDEFINED = Object.new
+
+    def fetch(key, default = UNDEFINED, &block)
+      if @changes.key?(key)
+        @changes.fetch(key)
+      elsif default != UNDEFINED
+        if block_given?
+          @static.fetch(key, &block)
+        else
+          @static.fetch(key, default)
+        end
+      else
+        @static.fetch(key, &block)
+      end
+    end
+
+    def key?(key)
+      @changes.key?(key) || @static.key?(key)
+    end
+  end
+
+  # Alias for backwards compatibility
+  StaticRegisters = Registers
+end