liquid 5.9.0 → 5.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 112da43191fdf32af9afb1ad6322ff2fab8b22b6d658073980ba236aa1834213
-  data.tar.gz: b7ab5c91bc2f65b91a782027eedd8374f1f46629c791d6b2c07a8ba2c07d7314
+  metadata.gz: 88705bb2e645a541fb76afe0a59c727429aaae33824103fb94178b5edbbda54e
+  data.tar.gz: 5982801da2e3431575b2e32edfd0f46a3371b1c74060dc8936470df75c27c630
 SHA512:
-  metadata.gz: c941dc92d57cf97c30a6db6eb206e7f00b780070b8dc790def3a8be06a3714562813b0ca8da34d5745be4432c839cf2f5946557d103ae0e56ffe5822b4ebf1e6
-  data.tar.gz: 9491a34a69273c3cebe65208f935007e68dbd81a8b32913ebc7d0056863c9f3a30b6dff9d1da3b37af66e472aedf60c6979e22d5f500ba6d24bd4f8637449a3f
+  metadata.gz: 9c8ddeba605175a534a658c96dc749624ce78171f3df420011b3ac0f525301b29dac63b452e07081a8355f231e4643ee49a087daf0bcf0bb550bf07726c17228
+  data.tar.gz: 150dce06c67bc6aa2efddf094e6b2b745b58503436fcfa8784f0f1d88f2d8447f2b8a025915745a5b0b31109b3a8e0887b552e7a7279ff3cb123182ae4188543

data/History.md

@@ -1,5 +1,12 @@
 # Liquid Change Log
 
+## 5.11.0
+* Revert the Inline Snippets tag (#2001), treat its inclusion in the latest Liquid release as a bug, and allow for feedback on RFC#1916 to better support Liquid developers [Guilherme Carreiro]
+* Rename the `:rigid` error mode to `:strict2` and display a warning when users attempt to use the `:rigid` mode [Guilherme Carreiro]
+
+## 5.10.0
+* Introduce support for Inline Snippets [Julia Boutin]
+
 ## 5.9.0
 * Introduce `:rigid` error mode for stricter, safer parsing of all tags [CP Clermont, Guilherme Carreiro]
 

data/README.md

@@ -103,10 +103,10 @@ Liquid also comes with different parsers that can be used when editing templates
 when templates are invalid. You can enable this new parser like this:
 
 ```ruby
-Liquid::Environment.default.error_mode = :rigid  # Raises a SyntaxError when invalid syntax is used in all tags
-Liquid::Environment.default.error_mode = :strict # Raises a SyntaxError when invalid syntax is used in some tags
-Liquid::Environment.default.error_mode = :warn   # Adds strict errors to template.errors but continues as normal
-Liquid::Environment.default.error_mode = :lax    # The default mode, accepts almost anything.
+Liquid::Environment.default.error_mode = :strict2 # Raises a SyntaxError when invalid syntax is used in all tags
+Liquid::Environment.default.error_mode = :strict  # Raises a SyntaxError when invalid syntax is used in some tags
+Liquid::Environment.default.error_mode = :warn    # Adds strict errors to template.errors but continues as normal
+Liquid::Environment.default.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`:

data/lib/liquid/context.rb

@@ -184,7 +184,7 @@ module Liquid
     end
 
     def key?(key)
-      self[key] != nil
+      find_variable(key, raise_on_not_found: false) != nil
     end
 
     def evaluate(object)

data/lib/liquid/environment.rb

@@ -34,7 +34,7 @@ module Liquid
       # @param file_system The default file system that is used
       #  to load templates from.
       # @param error_mode [Symbol] The default error mode for all templates
-      #  (either :rigid, :strict, :warn, or :lax).
+      #  (either :strict2, :strict, :warn, or :lax).
       # @param exception_renderer [Proc] The exception renderer that is used to
       #   render exceptions.
       # @yieldparam environment [Environment] The environment instance that is being built.

data/lib/liquid/parse_context.rb

@@ -55,15 +55,15 @@ module Liquid
     end
 
     def parse_expression(markup, safe: false)
-      if !safe && @error_mode == :rigid
+      if !safe && @error_mode == :strict2
         # parse_expression is a widely used API. To maintain backward
-        # compatibility while raising awareness about rigid parser standards,
+        # compatibility while raising awareness about strict2 parser standards,
         # the safe flag supports API users make a deliberate decision.
         #
-        # In rigid mode, markup MUST come from a string returned by the parser
+        # In strict2 mode, markup MUST come from a string returned by the parser
         # (e.g., parser.expression). We're not calling the parser here to
         # prevent redundant parser overhead.
-        raise Liquid::InternalError, "unsafe parse_expression cannot be used in rigid mode"
+        raise Liquid::InternalError, "unsafe parse_expression cannot be used in strict2 mode"
       end
 
       Expression.parse(markup, @string_scanner, @expression_cache)

data/lib/liquid/parser_switching.rb

@@ -7,16 +7,19 @@ module Liquid
     # It's basically doing the same thing the {#parse_with_selected_parser},
     # except this will try the strict parser regardless of the error mode,
     # and fall back to the lax parser if the error mode is lax or warn,
-    # except when in rigid mode where it uses the rigid parser.
+    # except when in strict2 mode where it uses the strict2 parser.
     #
     # @deprecated Use {#parse_with_selected_parser} instead.
     def strict_parse_with_error_mode_fallback(markup)
-      return rigid_parse_with_error_context(markup) if rigid_mode?
+      return strict2_parse_with_error_context(markup) if strict2_mode?
 
       strict_parse_with_error_context(markup)
     rescue SyntaxError => e
       case parse_context.error_mode
       when :rigid
+        rigid_warn
+        raise
+      when :strict2
         raise
       when :strict
         raise
@@ -28,12 +31,13 @@ module Liquid
 
     def parse_with_selected_parser(markup)
       case parse_context.error_mode
-      when :rigid  then rigid_parse_with_error_context(markup)
-      when :strict then strict_parse_with_error_context(markup)
-      when :lax    then lax_parse(markup)
+      when :rigid   then rigid_warn && strict2_parse_with_error_context(markup)
+      when :strict2 then strict2_parse_with_error_context(markup)
+      when :strict  then strict_parse_with_error_context(markup)
+      when :lax     then lax_parse(markup)
       when :warn
         begin
-          rigid_parse_with_error_context(markup)
+          strict2_parse_with_error_context(markup)
         rescue SyntaxError => e
           parse_context.warnings << e
           lax_parse(markup)
@@ -41,14 +45,18 @@ module Liquid
       end
     end
 
-    def rigid_mode?
-      parse_context.error_mode == :rigid
+    def strict2_mode?
+      parse_context.error_mode == :strict2 || parse_context.error_mode == :rigid
     end
 
     private
 
-    def rigid_parse_with_error_context(markup)
-      rigid_parse(markup)
+    def rigid_warn
+      Deprecations.warn(':rigid', ':strict2')
+    end
+
+    def strict2_parse_with_error_context(markup)
+      strict2_parse(markup)
     rescue SyntaxError => e
       e.line_number    = line_number
       e.markup_context = markup_context(markup)

data/lib/liquid/tags/case.rb

@@ -86,7 +86,7 @@ module Liquid
 
     private
 
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       parser = @parse_context.new_parser(markup)
       @left = safe_parse_expression(parser)
       parser.consume(:end_of_string)
@@ -107,14 +107,14 @@ module Liquid
     def record_when_condition(markup)
       body = new_body
 
-      if rigid_mode?
-        parse_rigid_when(markup, body)
+      if strict2_mode?
+        parse_strict2_when(markup, body)
       else
         parse_lax_when(markup, body)
       end
     end
 
-    def parse_rigid_when(markup, body)
+    def parse_strict2_when(markup, body)
       parser = @parse_context.new_parser(markup)
 
       loop do

data/lib/liquid/tags/cycle.rb

@@ -56,7 +56,7 @@ module Liquid
     private
 
     # cycle [name:] expression(, expression)*
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       p = @parse_context.new_parser(markup)
 
       @variables = []

data/lib/liquid/tags/for.rb

@@ -111,7 +111,7 @@ module Liquid
 
     private
 
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       strict_parse(markup)
     end
 

data/lib/liquid/tags/if.rb

@@ -66,7 +66,7 @@ module Liquid
 
     private
 
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       strict_parse(markup)
     end
 

data/lib/liquid/tags/include.rb

@@ -84,7 +84,7 @@ module Liquid
     alias_method :parse_context, :options
     private :parse_context
 
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       p = @parse_context.new_parser(markup)
 
       @template_name_expr = safe_parse_expression(p)

data/lib/liquid/tags/render.rb

@@ -85,10 +85,10 @@ module Liquid
     end
 
     # render (string) (with|for expression)? (as id)? (key: value)*
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       p = @parse_context.new_parser(markup)
 
-      @template_name_expr = parse_expression(rigid_template_name(p), safe: true)
+      @template_name_expr = parse_expression(strict2_template_name(p), safe: true)
       with_or_for         = p.id?("for") || p.id?("with")
       @variable_name_expr = safe_parse_expression(p) if with_or_for
       @alias_name         = p.consume(:id) if p.id?("as")
@@ -107,7 +107,7 @@ module Liquid
       p.consume(:end_of_string)
     end
 
-    def rigid_template_name(p)
+    def strict2_template_name(p)
       p.consume(:string)
     end
 

data/lib/liquid/tags/table_row.rb

@@ -34,7 +34,7 @@ module Liquid
       parse_with_selected_parser(markup)
     end
 
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       p = @parse_context.new_parser(markup)
 
       @variable_name = p.consume(:id)

data/lib/liquid/template.rb

@@ -25,7 +25,7 @@ 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 enforces correct syntax for most tags
-      # :rigid enforces correct syntax for all tags
+      # :strict2 enforces correct syntax for all tags
       def error_mode=(mode)
         Deprecations.warn("Template.error_mode=", "Environment#error_mode=")
         Environment.default.error_mode = mode

data/lib/liquid/variable.rb

@@ -74,14 +74,14 @@ module Liquid
       p.consume(:end_of_string)
     end
 
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       @filters = []
       p = @parse_context.new_parser(markup)
 
       return if p.look(:end_of_string)
 
       @name = parse_context.safe_parse_expression(p)
-      @filters << rigid_parse_filter_expressions(p) while p.consume?(:pipe)
+      @filters << strict2_parse_filter_expressions(p) while p.consume?(:pipe)
       p.consume(:end_of_string)
     end
 
@@ -156,7 +156,7 @@ module Liquid
     # argument = (positional_argument | keyword_argument)
     # positional_argument = expression
     # keyword_argument = id ":" expression
-    def rigid_parse_filter_expressions(p)
+    def strict2_parse_filter_expressions(p)
       filtername = p.consume(:id)
       filter_args = []
       keyword_args = {}

data/lib/liquid/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Liquid
-  VERSION = "5.9.0"
+  VERSION = "5.11.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: liquid
 version: !ruby/object:Gem::Version
-  version: 5.9.0
+  version: 5.11.0
 platform: ruby
 authors:
 - Tobias Lütke