honeybadger 5.3.0 → 5.4.0

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-cucumber-expressions-16.1.2 → cucumber-cucumber-expressions-17.0.1}/lib/cucumber/cucumber_expressions/parameter_type.rb

@@ -1,17 +1,17 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/errors'
 
 module Cucumber
   module CucumberExpressions
     class ParameterType
-      ILLEGAL_PARAMETER_NAME_PATTERN = /([\[\]()$.|?*+])/
-      UNESCAPE_PATTERN = /(\\([\[$.|?*+\]]))/
+      ILLEGAL_PARAMETER_NAME_PATTERN = /([\[\]()$.|?*+])/.freeze
+      UNESCAPE_PATTERN = /(\\([\[$.|?*+\]]))/.freeze
 
-      attr_reader :name, :type, :regexps
+      attr_reader :name, :type, :transformer, :use_for_snippets, :prefer_for_regexp_match, :regexps
 
       def self.check_parameter_type_name(type_name)
-        unless is_valid_parameter_type_name(type_name)
-          raise CucumberExpressionError.new("Illegal character in parameter name {#{type_name}}. Parameter names may not contain '[]()$.|?*+'")
-        end
+        raise CucumberExpressionError.new("Illegal character in parameter name {#{type_name}}. Parameter names may not contain '[]()$.|?*+'") unless is_valid_parameter_type_name(type_name)
       end
 
       def self.is_valid_parameter_type_name(type_name)
@@ -21,14 +21,6 @@ module Cucumber
         !(ILLEGAL_PARAMETER_NAME_PATTERN =~ unescaped_type_name)
       end
 
-      def prefer_for_regexp_match?
-        @prefer_for_regexp_match
-      end
-
-      def use_for_snippets?
-        @use_for_snippets
-      end
-
       # Create a new Parameter
       #
       # @param name the name of the parameter type
@@ -55,14 +47,14 @@ module Cucumber
       end
 
       def <=>(other)
-        return -1 if prefer_for_regexp_match? && !other.prefer_for_regexp_match?
-        return 1 if other.prefer_for_regexp_match? && !prefer_for_regexp_match?
+        return -1 if prefer_for_regexp_match && !other.prefer_for_regexp_match
+        return 1 if other.prefer_for_regexp_match && !prefer_for_regexp_match
+
         return name <=> other.name
       end
 
       private
 
-
       def string_array(regexps)
         array = regexps.is_a?(Array) ? regexps : [regexps]
         array.map { |regexp| regexp.is_a?(String) ? regexp : regexp_source(regexp) }
@@ -70,14 +62,12 @@ module Cucumber
 
       def regexp_source(regexp)
         [
-            'EXTENDED',
-            'IGNORECASE',
-            'MULTILINE'
+          'EXTENDED',
+          'IGNORECASE',
+          'MULTILINE'
         ].each do |option_name|
           option = Regexp.const_get(option_name)
-          if regexp.options & option != 0
-            raise CucumberExpressionError.new("ParameterType Regexps can't use option Regexp::#{option_name}")
-          end
+          raise CucumberExpressionError.new("ParameterType Regexps can't use option Regexp::#{option_name}") if regexp.options & option != 0
         end
         regexp.source
       end

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-cucumber-expressions-16.1.2 → cucumber-cucumber-expressions-17.0.1}/lib/cucumber/cucumber_expressions/parameter_type_matcher.rb

@@ -1,20 +1,20 @@
+# frozen_string_literal: true
+
 module Cucumber
   module CucumberExpressions
     class ParameterTypeMatcher
       attr_reader :parameter_type
 
-      def initialize(parameter_type, regexp, text, match_position=0)
+      def initialize(parameter_type, regexp, text, match_position = 0)
         @parameter_type, @regexp, @text = parameter_type, regexp, text
         @match = @regexp.match(@text, match_position)
       end
 
       def advance_to(new_match_position)
-        (new_match_position...@text.length).each {|advancedPos|
+        (new_match_position...@text.length).each do |advancedPos|
           matcher = self.class.new(parameter_type, @regexp, @text, advancedPos)
-          if matcher.find && matcher.full_word?
-            return matcher
-          end
-        }
+          return matcher if matcher.find && matcher.full_word?
+        end
 
         self.class.new(parameter_type, @regexp, @text, @text.length)
       end
@@ -38,8 +38,10 @@ module Cucumber
       def <=>(other)
         pos_comparison = start <=> other.start
         return pos_comparison if pos_comparison != 0
+
         length_comparison = other.group.length <=> group.length
         return length_comparison if length_comparison != 0
+
         0
       end
 

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-cucumber-expressions-16.1.2 → cucumber-cucumber-expressions-17.0.1}/lib/cucumber/cucumber_expressions/parameter_type_registry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/parameter_type'
 require 'cucumber/cucumber_expressions/errors'
 require 'cucumber/cucumber_expressions/cucumber_expression_generator'
@@ -6,27 +8,27 @@ require 'bigdecimal'
 module Cucumber
   module CucumberExpressions
     class ParameterTypeRegistry
-      INTEGER_REGEXPS = [/-?\d+/, /\d+/]
-      FLOAT_REGEXP = /(?=.*\d.*)[-+]?\d*(?:\.(?=\d.*))?\d*(?:\d+[E][-+]?\d+)?/
-      WORD_REGEXP = /[^\s]+/
-      STRING_REGEXP = /"([^"\\]*(\\.[^"\\]*)*)"|'([^'\\]*(\\.[^'\\]*)*)'/
-      ANONYMOUS_REGEXP = /.*/
+      INTEGER_REGEXPS = [/-?\d+/, /\d+/].freeze
+      FLOAT_REGEXP = /(?=.*\d.*)[-+]?\d*(?:\.(?=\d.*))?\d*(?:\d+[E][-+]?\d+)?/.freeze
+      WORD_REGEXP = /[^\s]+/.freeze
+      STRING_REGEXP = /"([^"\\]*(\\.[^"\\]*)*)"|'([^'\\]*(\\.[^'\\]*)*)'/.freeze
+      ANONYMOUS_REGEXP = /.*/.freeze
 
       def initialize
         @parameter_type_by_name = {}
-        @parameter_types_by_regexp = Hash.new {|hash, regexp| hash[regexp] = []}
+        @parameter_types_by_regexp = Hash.new { |hash, regexp| hash[regexp] = [] }
 
-        define_parameter_type(ParameterType.new('int', INTEGER_REGEXPS, Integer, lambda {|s = nil| s && s.to_i}, true, true))
-        define_parameter_type(ParameterType.new('float', FLOAT_REGEXP, Float, lambda {|s = nil| s && s.to_f}, true, false))
-        define_parameter_type(ParameterType.new('word', WORD_REGEXP, String, lambda {|s = nil| s}, false, false))
-        define_parameter_type(ParameterType.new('string', STRING_REGEXP, String, lambda { |s1, s2| arg = s1 != nil ? s1 : s2; arg.gsub(/\\"/, '"').gsub(/\\'/, "'")}, true, false))
-        define_parameter_type(ParameterType.new('', ANONYMOUS_REGEXP, String, lambda {|s = nil| s}, false, true))
-        define_parameter_type(ParameterType.new('bigdecimal', FLOAT_REGEXP, BigDecimal, lambda {|s = nil| BigDecimal(s)}, false, false))
-        define_parameter_type(ParameterType.new('biginteger', INTEGER_REGEXPS, Integer, lambda {|s = nil| s && s.to_i}, false, false))
-        define_parameter_type(ParameterType.new('byte', INTEGER_REGEXPS, Integer, lambda {|s = nil| s && s.to_i}, false, false))
-        define_parameter_type(ParameterType.new('short', INTEGER_REGEXPS, Integer, lambda {|s = nil| s && s.to_i}, false, false))
-        define_parameter_type(ParameterType.new('long', INTEGER_REGEXPS, Integer, lambda {|s = nil| s && s.to_i}, false, false))
-        define_parameter_type(ParameterType.new('double', FLOAT_REGEXP, Float, lambda {|s = nil| s && s.to_f}, false, false))
+        define_parameter_type(ParameterType.new('int', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i }, true, true))
+        define_parameter_type(ParameterType.new('float', FLOAT_REGEXP, Float, ->(s = nil) { s && s.to_f }, true, false))
+        define_parameter_type(ParameterType.new('word', WORD_REGEXP, String, ->(s = nil) { s }, false, false))
+        define_parameter_type(ParameterType.new('string', STRING_REGEXP, String, ->(s1, s2) { arg = s1 != nil ? s1 : s2; arg.gsub('\\"', '"').gsub("\\'", "'") }, true, false))
+        define_parameter_type(ParameterType.new('', ANONYMOUS_REGEXP, String, ->(s = nil) { s }, false, true))
+        define_parameter_type(ParameterType.new('bigdecimal', FLOAT_REGEXP, BigDecimal, ->(s = nil) { BigDecimal(s) }, false, false))
+        define_parameter_type(ParameterType.new('biginteger', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i }, false, false))
+        define_parameter_type(ParameterType.new('byte', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i }, false, false))
+        define_parameter_type(ParameterType.new('short', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i }, false, false))
+        define_parameter_type(ParameterType.new('long', INTEGER_REGEXPS, Integer, ->(s = nil) { s && s.to_i }, false, false))
+        define_parameter_type(ParameterType.new('double', FLOAT_REGEXP, Float, ->(s = nil) { s && s.to_f }, false, false))
       end
 
       def lookup_by_type_name(name)
@@ -36,7 +38,8 @@ module Cucumber
       def lookup_by_regexp(parameter_type_regexp, expression_regexp, text)
         parameter_types = @parameter_types_by_regexp[parameter_type_regexp]
         return nil if parameter_types.nil?
-        if parameter_types.length > 1 && !parameter_types[0].prefer_for_regexp_match?
+
+        if parameter_types.length > 1 && !parameter_types[0].prefer_for_regexp_match
           # We don't do this check on insertion because we only want to restrict
           # ambiguity when we look up by Regexp. Users of CucumberExpression should
           # not be restricted.
@@ -54,7 +57,7 @@ module Cucumber
         if parameter_type.name != nil
           if @parameter_type_by_name.has_key?(parameter_type.name)
             if parameter_type.name.length == 0
-              raise CucumberExpressionError.new("The anonymous parameter type has already been defined")
+              raise CucumberExpressionError.new('The anonymous parameter type has already been defined')
             else
               raise CucumberExpressionError.new("There is already a parameter with name #{parameter_type.name}")
             end
@@ -64,14 +67,16 @@ module Cucumber
 
         parameter_type.regexps.each do |parameter_type_regexp|
           parameter_types = @parameter_types_by_regexp[parameter_type_regexp]
-          if parameter_types.any? && parameter_types[0].prefer_for_regexp_match? && parameter_type.prefer_for_regexp_match?
-            raise CucumberExpressionError.new("There can only be one preferential parameter type per regexp. The regexp /#{parameter_type_regexp}/ is used for two preferential parameter types, {#{parameter_types[0].name}} and {#{parameter_type.name}}")
+          if parameter_types.any? && parameter_types[0].prefer_for_regexp_match && parameter_type.prefer_for_regexp_match
+            raise CucumberExpressionError.new(
+              "There can only be one preferential parameter type per regexp. The regexp /#{parameter_type_regexp}/ is used for two: {#{parameter_types[0].name}} and {#{parameter_type.name}}"
+            )
           end
+
           parameter_types.push(parameter_type)
           parameter_types.sort!
         end
       end
-
     end
   end
 end

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-cucumber-expressions-16.1.2 → cucumber-cucumber-expressions-17.0.1}/lib/cucumber/cucumber_expressions/regular_expression.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/argument'
 require 'cucumber/cucumber_expressions/parameter_type'
 require 'cucumber/cucumber_expressions/tree_regexp'
@@ -5,7 +7,6 @@ require 'cucumber/cucumber_expressions/tree_regexp'
 module Cucumber
   module CucumberExpressions
     class RegularExpression
-
       def initialize(expression_regexp, parameter_type_registry)
         @expression_regexp = expression_regexp
         @parameter_type_registry = parameter_type_registry
@@ -23,7 +24,7 @@ module Cucumber
             nil,
             parameter_type_regexp,
             String,
-            lambda {|*s| s[0]},
+            ->(*s) { s[0] },
             false,
             false
           )

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-cucumber-expressions-16.1.2 → cucumber-cucumber-expressions-17.0.1}/lib/cucumber/cucumber_expressions/tree_regexp.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/group_builder'
 require 'cucumber/cucumber_expressions/errors'
 
@@ -14,18 +16,19 @@ module Cucumber
       def match(s)
         match = @regexp.match(s)
         return nil if match.nil?
+
         group_indices = (0..match.length).to_a.to_enum
         @group_builder.build(match, group_indices)
       end
 
       private def is_non_capturing(source, i)
         # Regex is valid. Bounds check not required.
-        if source[i+1] != '?'
+        if source[i + 1] != '?'
           # (X)
           return false
         end
 
-        if source[i+2] != '<'
+        if source[i + 2] != '<'
           # (?:X)
           # (?idmsuxU-idmsuxU)
           # (?idmsux-idmsux:X)
@@ -35,14 +38,14 @@ module Cucumber
           return true
         end
 
-        if source[i+3] == '=' || source[i+3] == '!'
+        if source[i + 3] == '=' || source[i + 3] == '!'
           # (?<=X)
           # (?<!X)
           return true
         end
 
         # (?<name>X)
-        raise CucumberExpressionError.new("Named capture groups are not supported. See https://github.com/cucumber/cucumber/issues/329")
+        raise CucumberExpressionError.new('Named capture groups are not supported. See https://github.com/cucumber/cucumber/issues/329')
       end
 
       private def create_group_builder(regexp)
@@ -60,9 +63,7 @@ module Cucumber
             group_start_stack.push(i)
             group_builder = GroupBuilder.new
             non_capturing = is_non_capturing(source, i)
-            if non_capturing
-              group_builder.set_non_capturing!
-            end
+            group_builder.set_non_capturing! if non_capturing
             stack.push(group_builder)
           elsif c == ')' && !escaping && !char_class
             gb = stack.pop

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-cucumber-expressions-16.1.2 → cucumber-cucumber-expressions-17.0.1}/spec/cucumber/cucumber_expressions/argument_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/argument'
 require 'cucumber/cucumber_expressions/tree_regexp'
 require 'cucumber/cucumber_expressions/parameter_type_registry'
@@ -8,9 +10,9 @@ module Cucumber
       it 'exposes parameter_type' do
         tree_regexp = TreeRegexp.new(/three (.*) mice/)
         parameter_type_registry = ParameterTypeRegistry.new
-        arguments = Argument.build(tree_regexp, "three blind mice", [parameter_type_registry.lookup_by_type_name("string")])
+        arguments = Argument.build(tree_regexp, 'three blind mice', [parameter_type_registry.lookup_by_type_name('string')])
         argument = arguments[0]
-        expect(argument.parameter_type.name).to eq("string")
+        expect(argument.parameter_type.name).to eq('string')
       end
     end
   end

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-cucumber-expressions-16.1.2 → cucumber-cucumber-expressions-17.0.1}/spec/cucumber/cucumber_expressions/combinatorial_generated_expression_factory_test.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/parameter_type'
 require 'cucumber/cucumber_expressions/combinatorial_generated_expression_factory'
 
 module Cucumber
   module CucumberExpressions
-
     class Color; end
     class CssColor; end
     class Date; end
@@ -14,13 +15,13 @@ module Cucumber
       it 'generates multiple expressions' do
         parameter_type_combinations = [
           [
-            ParameterType.new('color', /red|blue|yellow/, Color, lambda {|s| Color.new}, true, false),
-            ParameterType.new('csscolor', /red|blue|yellow/, CssColor, lambda {|s| CssColor.new}, true, false)
+            ParameterType.new('color', /red|blue|yellow/, Color, ->(s) { Color.new }, true, false),
+            ParameterType.new('csscolor', /red|blue|yellow/, CssColor, ->(s) { CssColor.new }, true, false)
           ],
           [
-            ParameterType.new('date', /\d{4}-\d{2}-\d{2}/, Date, lambda {|s| Date.new}, true, false),
-            ParameterType.new('datetime', /\d{4}-\d{2}-\d{2}/, DateTime, lambda {|s| DateTime.new}, true, false),
-            ParameterType.new('timestamp', /\d{4}-\d{2}-\d{2}/, Timestamp, lambda {|s| Timestamp.new}, true, false)
+            ParameterType.new('date', /\d{4}-\d{2}-\d{2}/, Date, ->(s) { Date.new }, true, false),
+            ParameterType.new('datetime', /\d{4}-\d{2}-\d{2}/, DateTime, ->(s) { DateTime.new }, true, false),
+            ParameterType.new('timestamp', /\d{4}-\d{2}-\d{2}/, Timestamp, ->(s) { Timestamp.new }, true, false)
           ]
         ]
 
@@ -28,7 +29,7 @@ module Cucumber
           'I bought a {%s} ball on {%s}',
           parameter_type_combinations
         )
-        expressions = factory.generate_expressions.map {|ge| ge.source}
+        expressions = factory.generate_expressions.map { |ge| ge.source }
         expect(expressions).to eq([
             'I bought a {color} ball on {date}',
             'I bought a {color} ball on {datetime}',

data/vendor/bundle/ruby/3.2.0/gems/cucumber-cucumber-expressions-17.0.1/spec/cucumber/cucumber_expressions/cucumber_expression_generator_spec.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require 'cucumber/cucumber_expressions/cucumber_expression_generator'
+require 'cucumber/cucumber_expressions/cucumber_expression'
+require 'cucumber/cucumber_expressions/parameter_type'
+require 'cucumber/cucumber_expressions/parameter_type_registry'
+
+module Cucumber
+  module CucumberExpressions
+    describe CucumberExpressionGenerator do
+      class Currency
+      end
+
+      before do
+        @parameter_type_registry = ParameterTypeRegistry.new
+        @generator = CucumberExpressionGenerator.new(@parameter_type_registry)
+      end
+
+      it 'documents expression generation' do
+        parameter_registry = ParameterTypeRegistry.new
+        ### [generate-expression]
+        generator = CucumberExpressionGenerator.new(parameter_registry)
+        undefined_step_text = 'I have 2 cucumbers and 1.5 tomato'
+        generated_expression = generator.generate_expressions(undefined_step_text)[0]
+        expect(generated_expression.source).to eq('I have {int} cucumbers and {float} tomato')
+        expect(generated_expression.parameter_types[1].type).to eq(Float)
+        ### [generate-expression]
+      end
+
+      it 'generates expression for no args' do
+        assert_expression('hello', [], 'hello')
+      end
+
+      it 'generates expression with escaped left parenthesis' do
+        assert_expression('\\(iii)', [], '(iii)')
+      end
+
+      it 'generates expression with escaped left curly brace' do
+        assert_expression('\\{iii}', [], '{iii}')
+      end
+
+      it 'generates expression with escaped slashes' do
+        assert_expression('The {int}\\/{int}\\/{int} hey', ['int', 'int2', 'int3'], 'The 1814/05/17 hey')
+      end
+
+      it 'generates expression for int float arg' do
+        assert_expression('I have {int} cukes and {float} euro', ['int', 'float'], 'I have 2 cukes and 1.5 euro')
+      end
+
+      it 'generates expression for strings' do
+        assert_expression('I like {string} and {string}', ['string', 'string2'], 'I like "bangers" and \'mash\'')
+      end
+
+      it 'generates expression with % sign' do
+        assert_expression('I am {int}% foobar', ['int'], 'I am 20% foobar')
+      end
+
+      it 'generates expression for just int' do
+        assert_expression('{int}', ['int'], '99999')
+      end
+
+      it 'numbers only second argument when builtin type is not reserved keyword' do
+        assert_expression('I have {int} cukes and {int} euro', ['int', 'int2'], 'I have 2 cukes and 5 euro')
+      end
+
+      it 'numbers only second argument when type is not reserved keyword' do
+        @parameter_type_registry.define_parameter_type(
+          ParameterType.new(
+            'currency',
+            '[A-Z]{3}',
+            Currency,
+            ->(s) { Currency.new(s)},
+            true,
+            true
+          )
+        )
+
+        assert_expression('I have a {currency} account and a {currency} account', ['currency', 'currency2'], 'I have a EUR account and a GBP account')
+      end
+
+      it 'exposes parameters in a generated expression' do
+        expression = @generator.generate_expressions('I have 2 cukes and 1.5 euro')[0]
+        types = expression.parameter_types.map(&:type)
+
+        expect(types).to eq([Integer, Float])
+      end
+
+      it 'matches parameter types with optional capture groups' do
+        @parameter_type_registry.define_parameter_type(
+          ParameterType.new(
+            'optional-flight',
+            /(1st flight)?/,
+            String,
+            ->(s) { s},
+            true,
+            false
+          )
+        )
+        @parameter_type_registry.define_parameter_type(
+          ParameterType.new(
+            'optional-hotel',
+            /(1 hotel)?/,
+            String,
+            ->(s) { s},
+            true,
+            false
+          )
+        )
+
+        expression = @generator.generate_expressions('I reach Stage 4: 1st flight -1 hotel')[0]
+        # While you would expect this to be `I reach Stage {int}: {optional-flight} -{optional-hotel}`
+        # the `-1` causes {int} to match just before {optional-hotel}.
+
+        expect(expression.source).to eq('I reach Stage {int}: {optional-flight} {int} hotel')
+      end
+
+      it 'generates at most 256 expressions' do
+        for i in 0..3
+          @parameter_type_registry.define_parameter_type(
+            ParameterType.new(
+              "my-type-#{i}",
+              /([a-z] )*?[a-z]/,
+              String,
+              ->(s) { s},
+              true,
+              false
+            )
+          )
+        end
+        # This would otherwise generate 4^11=4194300 expressions and consume just shy of 1.5GB.
+        expressions = @generator.generate_expressions('a s i m p l e s t e p')
+
+        expect(expressions.length).to eq(256)
+      end
+
+      it 'prefers expression with longest non empty match' do
+        @parameter_type_registry.define_parameter_type(
+          ParameterType.new(
+            'zero-or-more',
+            /[a-z]*/,
+            String,
+            ->(s) { s},
+            true,
+            false
+          )
+        )
+        @parameter_type_registry.define_parameter_type(
+          ParameterType.new(
+            'exactly-one',
+            /[a-z]/,
+            String,
+            ->(s) { s},
+            true,
+            false
+          )
+        )
+        expressions = @generator.generate_expressions('a simple step')
+
+        expect(expressions.length).to eq(2)
+        expect(expressions[0].source).to eq('{exactly-one} {zero-or-more} {zero-or-more}')
+        expect(expressions[1].source).to eq('{zero-or-more} {zero-or-more} {zero-or-more}')
+      end
+
+      context 'does not suggest parameter when match is' do
+        before do
+          @parameter_type_registry.define_parameter_type(
+            ParameterType.new(
+              'direction',
+              /(up|down)/,
+              String,
+              ->(s) { s},
+              true,
+              false
+            )
+          )
+        end
+
+        it 'at the beginning of a word' do
+          expect(@generator.generate_expressions('When I download a picture')[0].source).not_to eq('When I {direction}load a picture')
+          expect(@generator.generate_expressions('When I download a picture')[0].source).to eq('When I download a picture')
+        end
+
+        it 'inside a word' do
+          expect(@generator.generate_expressions('When I watch the muppet show')[0].source).not_to eq('When I watch the m{direction}pet show')
+          expect(@generator.generate_expressions('When I watch the muppet show')[0].source).to eq('When I watch the muppet show')
+        end
+
+        it 'at the end of a word' do
+          expect(@generator.generate_expressions('When I create a group')[0].source).not_to eq('When I create a gro{direction}')
+          expect(@generator.generate_expressions('When I create a group')[0].source).to eq('When I create a group')
+        end
+      end
+
+      context 'does suggest parameter when match is' do
+        before do
+          @parameter_type_registry.define_parameter_type(
+            ParameterType.new(
+              'direction',
+              /(up|down)/,
+              String,
+              ->(s) { s},
+              true,
+              false
+            )
+          )
+        end
+
+        it 'a full word' do
+          expect(@generator.generate_expressions('When I go down the road')[0].source).to eq('When I go {direction} the road')
+          expect(@generator.generate_expressions('When I walk up the hill')[0].source).to eq('When I walk {direction} the hill')
+          expect(@generator.generate_expressions('up the hill, the road goes down')[0].source).to eq('{direction} the hill, the road goes {direction}')
+        end
+
+        it 'wrapped around punctuation characters' do
+          expect(@generator.generate_expressions('When direction is:down')[0].source).to eq('When direction is:{direction}')
+          expect(@generator.generate_expressions('Then direction is down.')[0].source).to eq('Then direction is {direction}.')
+        end
+      end
+
+      def assert_expression(expected_expression, expected_argument_names, text)
+        generated_expression = @generator.generate_expressions(text)[0]
+        expect(generated_expression.parameter_names).to eq(expected_argument_names)
+        expect(generated_expression.source).to eq(expected_expression)
+
+        cucumber_expression = CucumberExpression.new(generated_expression.source, @parameter_type_registry)
+        match = cucumber_expression.match(text)
+
+        raise "Expected text '#{text}' to match generated expression '#{generated_expression.source}'" if match.nil?
+
+        expect(match.length).to eq(expected_argument_names.length)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/{cucumber-cucumber-expressions-16.1.2 → cucumber-cucumber-expressions-17.0.1}/spec/cucumber/cucumber_expressions/cucumber_expression_parser_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 require 'cucumber/cucumber_expressions/cucumber_expression_parser'
 require 'cucumber/cucumber_expressions/errors'