honeybadger 5.3.0 → 5.4.0

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

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'cucumber/cucumber_expressions/cucumber_expression'
+require 'cucumber/cucumber_expressions/parameter_type_registry'
+
+module Cucumber
+  module CucumberExpressions
+    describe CucumberExpression do
+      Dir['../testdata/cucumber-expression/matching/*.yaml'].each do |path|
+        expectation = YAML.load_file(path)
+
+        it "matches #{path}" do
+          parameter_registry = ParameterTypeRegistry.new
+          if expectation['exception']
+            expect {
+              cucumber_expression = CucumberExpression.new(expectation['expression'], parameter_registry)
+              cucumber_expression.match(expectation['text'])
+            }.to raise_error(expectation['exception'])
+          else
+            cucumber_expression = CucumberExpression.new(expectation['expression'], parameter_registry)
+            matches = cucumber_expression.match(expectation['text'])
+            values = matches.nil? ? nil : matches.map do |arg|
+              value = arg.value(nil)
+              case value
+              when BigDecimal
+                # Format {bigdecimal} as string (because it must be a string in matches-bigdecimal.yaml)
+                value.to_s('f')
+              when Integer
+                # Format {bigint} as string (because it must be a string in matches-bigint.yaml)
+                value.bit_length > 64 ? value.to_s : value
+              else
+                value
+              end
+            end
+            expect(values).to eq(expectation['expected_args'])
+          end
+        end
+      end
+
+      it 'documents match arguments' do
+        parameter_registry = ParameterTypeRegistry.new
+
+        ### [capture-match-arguments]
+        expr = 'I have {int} cuke(s)'
+        expression = CucumberExpression.new(expr, parameter_registry)
+        args = expression.match('I have 7 cukes')
+
+        expect(args[0].value(nil)).to eq(7)
+        ### [capture-match-arguments]
+      end
+
+      it 'matches float' do
+        expect(match('{float}', '')).to eq(nil)
+        expect(match('{float}', '.')).to eq(nil)
+        expect(match('{float}', ',')).to eq(nil)
+        expect(match('{float}', '-')).to eq(nil)
+        expect(match('{float}', 'E')).to eq(nil)
+        expect(match('{float}', '1,')).to eq(nil)
+        expect(match('{float}', ',1')).to eq(nil)
+        expect(match('{float}', '1.')).to eq(nil)
+
+        expect(match('{float}', '1')).to eq([1])
+        expect(match('{float}', '-1')).to eq([-1])
+        expect(match('{float}', '1.1')).to eq([1.1])
+        expect(match('{float}', '1,000')).to eq(nil)
+        expect(match('{float}', '1,000,0')).to eq(nil)
+        expect(match('{float}', '1,000.1')).to eq(nil)
+        expect(match('{float}', '1,000,10')).to eq(nil)
+        expect(match('{float}', '1,0.1')).to eq(nil)
+        expect(match('{float}', '1,000,000.1')).to eq(nil)
+        expect(match('{float}', '-1.1')).to eq([-1.1])
+
+        expect(match('{float}', '.1')).to eq([0.1])
+        expect(match('{float}', '-.1')).to eq([-0.1])
+        expect(match('{float}', '-.1000001')).to eq([-0.1000001])
+        expect(match('{float}', '1E1')).to eq([10.0])
+        expect(match('{float}', '.1E1')).to eq([1])
+        expect(match('{float}', 'E1')).to eq(nil)
+        expect(match('{float}', '-.1E-1')).to eq([-0.01])
+        expect(match('{float}', '-.1E-2')).to eq([-0.001])
+        expect(match('{float}', '-.1E+1')).to eq([-1])
+        expect(match('{float}', '-.1E+2')).to eq([-10])
+        expect(match('{float}', '-.1E1')).to eq([-1])
+        expect(match('{float}', '-.1E2')).to eq([-10])
+      end
+
+      it 'float with zero' do
+        expect(match('{float}', '0')).to eq([0.0])
+      end
+
+      it 'matches anonymous' do
+        expect(match('{}', '0.22')).to eq(['0.22'])
+      end
+
+      it 'exposes source' do
+        expr = 'I have {int} cuke(s)'
+
+        expect(CucumberExpression.new(expr, ParameterTypeRegistry.new).source).to eq(expr)
+      end
+
+      it 'exposes source via #to_s' do
+        expr = 'I have {int} cuke(s)'
+
+        expect(CucumberExpression.new(expr, ParameterTypeRegistry.new).to_s).to eq(expr.inspect)
+      end
+
+      it 'unmatched optional groups have undefined values' do
+        parameter_type_registry = ParameterTypeRegistry.new
+        parameter_type_registry.define_parameter_type(
+          ParameterType.new(
+            'textAndOrNumber',
+            /([A-Z]+)?(?: )?([0-9]+)?/,
+            Object,
+            ->(s1, s2) { [s1, s2] },
+            false,
+            true
+          )
+        )
+        expression = CucumberExpression.new('{textAndOrNumber}', parameter_type_registry)
+
+        class World; end
+
+        expect(expression.match('TLA')[0].value(World.new)).to eq(['TLA', nil])
+        expect(expression.match('123')[0].value(World.new)).to eq([nil, '123'])
+      end
+
+      # Ruby specific
+
+      it 'delegates transform to custom object' do
+        parameter_type_registry = ParameterTypeRegistry.new
+        parameter_type_registry.define_parameter_type(
+          ParameterType.new(
+            'widget',
+            /\w+/,
+            Object,
+            ->(s) { self.create_widget(s) },
+            false,
+            true
+          )
+        )
+        expression = CucumberExpression.new(
+          'I have a {widget}',
+          parameter_type_registry
+        )
+
+        class World
+          def create_widget(s)
+            "widget:#{s}"
+          end
+        end
+
+        args = expression.match('I have a bolt')
+
+        expect(args[0].value(World.new)).to eq('widget:bolt')
+      end
+
+      it 'reports undefined parameter type name' do
+        parameter_type_registry = ParameterTypeRegistry.new
+
+        CucumberExpression.new(
+          'I have {int} {widget}(s) in {word}',
+          parameter_type_registry
+        )
+      rescue UndefinedParameterTypeError => e
+        expect(e.undefined_parameter_type_name).to eq('widget')
+      end
+
+      def match(expression, text)
+        cucumber_expression = CucumberExpression.new(expression, ParameterTypeRegistry.new)
+        args = cucumber_expression.match(text)
+        return nil if args.nil?
+
+        args.map { |arg| arg.value(nil) }
+      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_tokenizer_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 require 'cucumber/cucumber_expressions/cucumber_expression_tokenizer'
 require 'cucumber/cucumber_expressions/errors'
@@ -13,7 +15,7 @@ module Cucumber
             expect { tokenizer.tokenize(expectation['expression']) }.to raise_error(expectation['exception'])
           else
             tokens = tokenizer.tokenize(expectation['expression'])
-            token_hashes = tokens.map{|token| token.to_hash}
+            token_hashes = tokens.map {|token| token.to_hash}
             expect(token_hashes).to eq(expectation['expected_tokens'])
           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_transformation_spec.rb

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

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

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require 'cucumber/cucumber_expressions/cucumber_expression'
+require 'cucumber/cucumber_expressions/regular_expression'
+require 'cucumber/cucumber_expressions/parameter_type_registry'
+
+module Cucumber
+  module CucumberExpressions
+    class Color
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def ==(other)
+        other.is_a?(Color) && other.name == name
+      end
+    end
+
+    class CssColor
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def ==(other)
+        other.is_a?(CssColor) && other.name == name
+      end
+    end
+
+    class Coordinate
+      attr_reader :x, :y, :z
+
+      def initialize(x, y, z)
+        @x, @y, @z = x, y, z
+      end
+
+      def ==(other)
+        other.is_a?(Coordinate) && other.x == x && other.y == y && other.z == z
+      end
+    end
+
+    describe 'Custom parameter type' do
+      before do
+        parameter_type_registry = ParameterTypeRegistry.new
+        parameter_type_registry.define_parameter_type(
+          ParameterType.new(
+            'color',                   # name
+            /red|blue|yellow/,         # regexp
+            Color,                     # type
+            ->(s) { Color.new(s) },    # transform
+            true,                      # use_for_snippets
+            false                      # prefer_for_regexp_match
+          )
+        )
+        @parameter_type_registry = parameter_type_registry
+      end
+
+      it 'throws exception for illegal character in parameter name' do
+        expect do
+          ParameterType.new(
+            '[string]',
+            /.*/,
+            String,
+            ->(s) { s },
+            true,
+            false
+          )
+        end.to raise_error("Illegal character in parameter name {[string]}. Parameter names may not contain '[]()$.|?*+'")
+      end
+
+      describe CucumberExpression do
+        it 'matches parameters with custom parameter type' do
+          expression = CucumberExpression.new('I have a {color} ball', @parameter_type_registry)
+          transformed_argument_value = expression.match('I have a red ball')[0].value(nil)
+
+          expect(transformed_argument_value).to eq(Color.new('red'))
+        end
+
+        it 'matches parameters with multiple capture groups' do
+          @parameter_type_registry.define_parameter_type(
+            ParameterType.new(
+              'coordinate',
+              /(\d+),\s*(\d+),\s*(\d+)/,
+              Coordinate,
+              ->(x, y, z) { Coordinate.new(x.to_i, y.to_i, z.to_i) },
+              true,
+              false
+            )
+          )
+
+          expression = CucumberExpression.new('A {int} thick line from {coordinate} to {coordinate}', @parameter_type_registry)
+          args = expression.match('A 5 thick line from 10,20,30 to 40,50,60')
+
+          thick = args[0].value(nil)
+          expect(thick).to eq(5)
+
+          from = args[1].value(nil)
+          expect(from).to eq(Coordinate.new(10, 20, 30))
+
+          to = args[2].value(nil)
+          expect(to).to eq(Coordinate.new(40, 50, 60))
+        end
+
+        it 'matches parameters with custom parameter type using optional capture group' do
+          parameter_type_registry = ParameterTypeRegistry.new
+          parameter_type_registry.define_parameter_type(
+            ParameterType.new(
+              'color',
+              [/red|blue|yellow/, /(?:dark|light) (?:red|blue|yellow)/],
+              Color,
+              ->(s) { Color.new(s) },
+              true,
+              false
+            )
+          )
+          expression = CucumberExpression.new('I have a {color} ball', parameter_type_registry)
+          transformed_argument_value = expression.match('I have a dark red ball')[0].value(nil)
+
+          expect(transformed_argument_value).to eq(Color.new('dark red'))
+        end
+
+        it 'defers transformation until queried from argument' do
+          @parameter_type_registry.define_parameter_type(
+            ParameterType.new(
+              'throwing',
+              /bad/,
+              CssColor,
+              ->(s) { raise "Can't transform [#{s}]" },
+              true,
+              false
+            )
+          )
+          expression = CucumberExpression.new('I have a {throwing} parameter', @parameter_type_registry)
+          args = expression.match('I have a bad parameter')
+
+          expect { args[0].value(nil) }.to raise_error("Can't transform [bad]")
+        end
+
+        describe 'conflicting parameter type' do
+          it 'is detected for type name' do
+            expect {
+              @parameter_type_registry.define_parameter_type(
+                ParameterType.new(
+                  'color',
+                  /.*/,
+                  CssColor,
+                  ->(s) { CssColor.new(s) },
+                  true,
+                  false
+                )
+              )
+            }.to raise_error('There is already a parameter with name color')
+          end
+
+          it 'is not detected for type' do
+            @parameter_type_registry.define_parameter_type(
+              ParameterType.new(
+                'whatever',
+                /.*/,
+                Color,
+                ->(s) { Color.new(s) },
+                false,
+                false
+              )
+            )
+          end
+
+          it 'is not detected for regexp' do
+            @parameter_type_registry.define_parameter_type(
+              ParameterType.new(
+                'css-color',
+                /red|blue|yellow/,
+                CssColor,
+                ->(s) { CssColor.new(s) },
+                true,
+                false
+              )
+            )
+            css_color = CucumberExpression.new('I have a {css-color} ball', @parameter_type_registry)
+            css_color_value = css_color.match('I have a blue ball')[0].value(nil)
+
+            expect(css_color_value).to eq(CssColor.new('blue'))
+
+            color = CucumberExpression.new('I have a {color} ball', @parameter_type_registry)
+            color_value = color.match('I have a blue ball')[0].value(nil)
+
+            expect(color_value).to eq(Color.new('blue'))
+          end
+        end
+      end
+
+      describe RegularExpression do
+        it 'matches arguments with custom parameter types without a name' do
+          parameter_type_registry = ParameterTypeRegistry.new
+          parameter_type_registry.define_parameter_type(
+            ParameterType.new(
+              nil,
+              /red|blue|yellow/,
+              Color,
+              ->(s) { Color.new(s) },
+              true,
+              false
+            )
+          )
+          expression = RegularExpression.new(/I have a (red|blue|yellow) ball/, parameter_type_registry)
+          value = expression.match('I have a red ball')[0].value(nil)
+
+          expect(value).to eq(Color.new('red'))
+        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}/spec/cucumber/cucumber_expressions/expression_factory_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/expression_factory'
 
 module Cucumber

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'cucumber/cucumber_expressions/parameter_type_registry'
+require 'cucumber/cucumber_expressions/parameter_type'
+require 'cucumber/cucumber_expressions/errors'
+
+module Cucumber
+  module CucumberExpressions
+    CAPITALISED_WORD = /[A-Z]+\w+/.freeze
+
+    class Name; end
+    class Person; end
+    class Place; end
+
+    describe ParameterTypeRegistry do
+      before do
+        @registry = ParameterTypeRegistry.new
+      end
+
+      it 'does not allow more than one prefer_for_regexp_match parameter type for each regexp' do
+        @registry.define_parameter_type(ParameterType.new('name', CAPITALISED_WORD, Name, ->(s) { Name.new }, true, true))
+        @registry.define_parameter_type(ParameterType.new('person', CAPITALISED_WORD, Person, ->(s) { Person.new }, true, false))
+        expect do
+          @registry.define_parameter_type(ParameterType.new('place', CAPITALISED_WORD, Place, ->(s) { Place.new }, true, true))
+        end.to raise_error(
+          CucumberExpressionError,
+          'There can only be one preferential parameter type per regexp. The regexp /[A-Z]+\\w+/ is used for two preferential parameter types, {name} and {place}'
+        )
+      end
+
+      it 'looks up prefer_for_regexp_match parameter type by regexp' do
+        name = ParameterType.new('name', CAPITALISED_WORD, Name, ->(s) { Name.new }, true, false)
+        person = ParameterType.new('person', CAPITALISED_WORD, Person, ->(s) { Person.new }, true, true)
+        place = ParameterType.new('place', CAPITALISED_WORD, Place, ->(s) { Place.new }, true, false)
+
+        @registry.define_parameter_type(name)
+        @registry.define_parameter_type(person)
+        @registry.define_parameter_type(place)
+
+        expect(@registry.lookup_by_regexp(CAPITALISED_WORD.source, /([A-Z]+\w+) and ([A-Z]+\w+)/, 'Lisa and Bob')).to eq(person)
+      end
+
+      it 'throws ambiguous exception when no parameter types are prefer_for_regexp_match' do
+        name = ParameterType.new('name', CAPITALISED_WORD, Name, ->(s) { Name.new }, true, false)
+        person = ParameterType.new('person', CAPITALISED_WORD, Person, ->(s) { Person.new }, true, false)
+        place = ParameterType.new('place', CAPITALISED_WORD, Place, ->(s) { Place.new }, true, false)
+
+        @registry.define_parameter_type(name)
+        @registry.define_parameter_type(person)
+        @registry.define_parameter_type(place)
+
+        expect do
+          expect(@registry.lookup_by_regexp(CAPITALISED_WORD.source, /([A-Z]+\w+) and ([A-Z]+\w+)/, 'Lisa and Bob')).to eq(person)
+        end.to raise_error(
+          CucumberExpressionError,
+          "Your Regular Expression /([A-Z]+\\w+) and ([A-Z]+\\w+)/\n" \
+          "matches multiple parameter types with regexp /[A-Z]+\\w+/:\n   " \
+          "{name}\n   " \
+          "{person}\n   " \
+          "{place}\n" \
+          "\n" \
+          "I couldn't decide which one to use. You have two options:\n" \
+          "\n" \
+          "1) Use a Cucumber Expression instead of a Regular Expression. Try one of these:\n   " \
+          "{name} and {name}\n   " \
+          "{name} and {person}\n   " \
+          "{name} and {place}\n   " \
+          "{person} and {name}\n   " \
+          "{person} and {person}\n   " \
+          "{person} and {place}\n   " \
+          "{place} and {name}\n   " \
+          "{place} and {person}\n   " \
+          "{place} and {place}\n" \
+          "\n" \
+          "2) Make one of the parameter types preferential and continue to use a Regular Expression.\n" \
+          "\n"
+        )
+      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/parameter_type_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/cucumber_expressions/parameter_type'
 
 module Cucumber
@@ -5,10 +7,11 @@ module Cucumber
     describe ParameterType do
       it 'does not allow ignore flag on regexp' do
         expect do
-          ParameterType.new("case-insensitive", /[a-z]+/i, String, lambda {|s| s}, true, true)
+          ParameterType.new('case-insensitive', /[a-z]+/i, String, ->(s) { s }, true, true)
         end.to raise_error(
           CucumberExpressionError,
-          "ParameterType Regexps can't use option Regexp::IGNORECASE")
+          "ParameterType Regexps can't use option Regexp::IGNORECASE"
+        )
       end
     end
   end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'cucumber/cucumber_expressions/regular_expression'
+require 'cucumber/cucumber_expressions/parameter_type_registry'
+
+module Cucumber
+  module CucumberExpressions
+    describe RegularExpression do
+      Dir['../testdata/regular-expression/matching/*.yaml'].each do |path|
+        expectation = YAML.load_file(path)
+
+        it "matches #{path}" do
+          parameter_registry = ParameterTypeRegistry.new
+          expression = RegularExpression.new(Regexp.new(expectation['expression']), parameter_registry)
+          matches = expression.match(expectation['text'])
+          values = matches.map { |arg| arg.value(nil) }
+
+          expect(values).to eq(expectation['expected_args'])
+        end
+      end
+
+      it 'does not transform by default' do
+        expect(match(/(\d\d)/, '22')).to eq(['22'])
+      end
+
+      it 'does not transform anonymous' do
+        expect(match(/(.*)/, '22')).to eq(['22'])
+      end
+
+      it 'transforms negative int' do
+        expect(match(/(-?\d+)/, '-22')).to eq([-22])
+      end
+
+      it 'transforms positive int' do
+        expect(match(/(\d+)/, '22')).to eq([22])
+      end
+
+      it 'returns nil when there is no match' do
+        expect(match(/hello/, 'world')).to be_nil
+      end
+
+      it 'matches empty string when there is an empty string match' do
+        expect(match(/^The value equals "([^"]*)"$/, 'The value equals ""')).to eq([''])
+      end
+
+      it 'matches nested capture group without match' do
+        expect(match(/^a user( named "([^"]*)")?$/, 'a user')).to eq([nil])
+      end
+
+      it 'matches nested capture group with match' do
+        expect(match(/^a user( named "([^"]*)")?$/, 'a user named "Charlie"')).to eq(['Charlie'])
+      end
+
+      it 'ignores non capturing groups' do
+        expect(
+          match(
+            /(\S+) ?(can|cannot) (?:delete|cancel) the (\d+)(?:st|nd|rd|th) (attachment|slide) ?(?:upload)?/,
+            'I can cancel the 1st slide upload'
+          )
+        ).to eq(['I', 'can', 1, 'slide'])
+      end
+
+      it 'matches capture group nested in optional one' do
+        regexp = /^a (pre-commercial transaction |pre buyer fee model )?purchase(?: for \$(\d+))?$/
+
+        expect(match(regexp, 'a purchase')).to eq([nil, nil])
+        expect(match(regexp, 'a purchase for $33')).to eq([nil, 33])
+        expect(match(regexp, 'a pre buyer fee model purchase')).to eq(['pre buyer fee model ', nil])
+      end
+
+      it 'works with escaped parentheses' do
+        expect(match(/Across the line\(s\)/, 'Across the line(s)')).to eq([])
+      end
+
+      it 'exposes source and regexp' do
+        regexp = /I have (\d+) cukes? in my (\+) now/
+        expression = RegularExpression.new(regexp, ParameterTypeRegistry.new)
+
+        expect(expression.regexp).to eq(regexp)
+        expect(expression.source).to eq(regexp.source)
+      end
+
+      def match(expression, text)
+        regular_expression = RegularExpression.new(expression, ParameterTypeRegistry.new)
+        arguments = regular_expression.match(text)
+        return nil if arguments.nil?
+
+        arguments.map { |arg| arg.value(nil) }
+      end
+    end
+  end
+end