avoid new regex allocation in util functions

lib/liquid/parser_switching.rb

@@ -2,17 +2,10 @@
 
 module Liquid
   module ParserSwitching
-    # We want "rigid" which is like strict but more strict only in some cases.
-    # We want to make it so strict behaves as is
-    # We want "rigid" to be stricter (prob beta flag)
-    # It shouldn't be slower to run rigid than strict, it's not rigid -> strict -> lax
-    # It's rigid -> lax or it's strict -> lax
     def strict_parse_with_error_mode_fallback(markup)
-      rigid_parse_with_error_context(markup)
+      strict_parse_with_error_context(markup)
     rescue SyntaxError => e
       case parse_context.error_mode
-      when :rigid
-        raise
       when :strict
         raise
       when :warn
@@ -23,7 +16,6 @@ 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 :warn
@@ -38,14 +30,6 @@ module Liquid
 
     private
 
-    def rigid_parse_with_error_context(markup)
-      respond_to?(:rigid_parse) ? rigid_parse(markup) : strict_parse(markup)
-    rescue SyntaxError => e
-      e.line_number    = line_number
-      e.markup_context = markup_context(markup)
-      raise e
-    end
-
     def strict_parse_with_error_context(markup)
       strict_parse(markup)
     rescue SyntaxError => e

lib/liquid/tags/cycle.rb

@@ -22,7 +22,18 @@ module Liquid
 
     def initialize(tag_name, markup, options)
       super
-      parse_with_selected_parser(markup)
+      case markup
+      when NamedSyntax
+        @variables = variables_from_string(Regexp.last_match(2))
+        @name      = parse_expression(Regexp.last_match(1))
+        @is_named = true
+      when SimpleSyntax
+        @variables = variables_from_string(markup)
+        @name      = @variables.to_s
+        @is_named = !@name.match?(/\w+:0x\h{8}/)
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.cycle")
+      end
     end
 
     def named?
@@ -54,47 +65,6 @@ module Liquid
 
     private
 
-    # cycle [name:] expression(, expression)*
-    def rigid_parse(markup)
-      $stderr.puts "using rigid"
-      p = @parse_context.new_parser(markup)
-
-      if p.look(:id) && p.peek(1) == :colon
-        @name = p.consume(:id)
-        @is_named = true
-        p.consume(:colon)
-      end
-
-      @variables = []
-      while (var = p.expression)
-        @variables << var
-        break unless p.consume?(:comma)
-      end
-
-      raise_syntax_error(options) if @variables.empty?
-    end
-
-    # Temporarily until we migrate
-    def strict_parse(markup)
-      $stderr.puts "using rigid"
-      lax_parse(markup)
-    end
-
-    def lax_parse(markup)
-      case markup
-      when NamedSyntax
-        @variables = variables_from_string(Regexp.last_match(2))
-        @name      = parse_expression(Regexp.last_match(1))
-        @is_named = true
-      when SimpleSyntax
-        @variables = variables_from_string(markup)
-        @name      = @variables.to_s
-        @is_named = !@name.match?(/\w+:0x\h{8}/)
-      else
-        raise SyntaxError, options[:locale].t("errors.syntax.cycle")
-      end
-    end
-
     def variables_from_string(markup)
       markup.split(',').collect do |var|
         var =~ /\s*(#{QuotedFragment})\s*/o

lib/liquid/tags/for.rb

@@ -20,8 +20,8 @@ module Liquid
   # @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 for each iteration.
-  # @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 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.
   # @liquid_optional_param reversed [untyped] Iterate in reverse order.
   class For < Block

lib/liquid/tags/table_row.rb

@@ -19,9 +19,9 @@ module Liquid
   # @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 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

lib/liquid/template.rb

@@ -2,7 +2,7 @@
 
 module Liquid
   # Templates are central to liquid.
-  # Interpreting templates is a two step process. First you compile the
+  # Interpretating templates is a two step process. First you compile the
   # source code you got. During compile time some extensive error checking is performed.
   # your code should expect to get some SyntaxErrors.
   #
@@ -25,7 +25,6 @@ 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.
-      # :rigid will is stricter even.
       def error_mode=(mode)
         Deprecations.warn("Template.error_mode=", "Environment#error_mode=")
         Environment.default.error_mode = mode

lib/liquid/utils.rb

@@ -2,6 +2,9 @@
 
 module Liquid
   module Utils
+    DECIMAL_REGEX = /\A-?\d+\.\d+\z/
+    UNIX_TIMESTAMP_REGEX = /\A\d+\z/
+
     def self.slice_collection(collection, from, to)
       if (from != 0 || !to.nil?) && collection.respond_to?(:load_slice)
         collection.load_slice(from, to)
@@ -52,7 +55,7 @@ module Liquid
       when Numeric
         obj
       when String
-        /\A-?\d+\.\d+\z/.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
+        DECIMAL_REGEX.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
       else
         if obj.respond_to?(:to_number)
           obj.to_number
@@ -73,7 +76,7 @@ module Liquid
       case obj
       when 'now', 'today'
         Time.now
-      when /\A\d+\z/, Integer
+      when UNIX_TIMESTAMP_REGEX, Integer
         Time.at(obj.to_i)
       when String
         Time.parse(obj)

test/integration/tags/cycle_tag_test.rb

@@ -45,19 +45,4 @@ class CycleTagTest < Minitest::Test
 
     assert_template_result("11", template)
   end
-
-  def test_cycle_tag_with_error_mode
-    # QuotedFragment is more permissive than what Parser#expression allows.
-    [:lax, :strict].each do |mode|
-      with_error_mode(mode) do
-        assert_template_result("a", "{% cycle .5: 'a', 'b' %}")
-        assert_template_result("b", "{% assign 5 = 'b' %}{% cycle .5, .4 %}")
-      end
-    end
-
-    with_error_mode(:rigid) do
-      assert_raises(Liquid::SyntaxError) { Template.parse("{% cycle .5: 'a', 'b' %}") }
-      assert_raises(Liquid::SyntaxError) { Template.parse("{% cycle .5, .4 %}") }
-    end
-  end
 end