honeybadger 5.3.0 → 5.4.0

data/vendor/bundle/ruby/3.2.0/gems/cucumber-9.0.2/lib/cucumber/deprecate.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'cucumber/platform'
-require 'cucumber/gherkin/formatter/ansi_escapes'
-
-module Cucumber
-  module Deprecate
-    class AnsiString
-      include Cucumber::Gherkin::Formatter::AnsiEscapes
-
-      def self.failure_message(message)
-        AnsiString.new.failure_message(message)
-      end
-
-      def failure_message(message)
-        failed + message + reset
-      end
-    end
-
-    class CliOption
-      def self.deprecate(stream, option, message, remove_after_version)
-        return if stream.nil?
-
-        stream.puts(
-          AnsiString.failure_message(
-            "\nWARNING: #{option} is deprecated" \
-            " and will be removed after version #{remove_after_version}.\n#{message}.\n"
-          )
-        )
-      end
-    end
-
-    module ForUsers
-      def self.call(message, method, remove_after_version)
-        $stderr.puts AnsiString.failure_message(
-          "\nWARNING: ##{method} is deprecated" \
-          " and will be removed after version #{remove_after_version}. #{message}.\n" \
-          "(Called from #{caller(3..3).first})"
-        )
-      end
-    end
-
-    module ForDevelopers
-      def self.call(_message, _method, remove_after_version)
-        raise "This method is due for removal after version #{remove_after_version}" if remove_after_version <= Cucumber::VERSION
-      end
-    end
-
-    STRATEGY = $PROGRAM_NAME =~ /rspec$/ ? ForDevelopers : ForUsers
-  end
-
-  def self.deprecate(*args)
-    Deprecate::STRATEGY.call(*args)
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-cucumber-expressions-16.1.2/lib/cucumber/cucumber_expressions/errors.rb

@@ -1,214 +0,0 @@
-require 'cucumber/cucumber_expressions/ast'
-
-module Cucumber
-  module CucumberExpressions
-    class CucumberExpressionError < StandardError
-
-      def build_message(
-          index,
-          expression,
-          pointer,
-          problem,
-          solution
-      )
-        m = <<-EOF
-This Cucumber Expression has a problem at column #{index + 1}:
-
-#{expression}
-#{pointer}
-#{problem}.
-#{solution}
-        EOF
-        m.strip
-      end
-
-      def point_at(index)
-        ' ' * index + '^'
-      end
-
-      def point_at_located(node)
-        pointer = [point_at(node.start)]
-        if node.start + 1 < node.end
-          for _ in node.start + 1...node.end - 1
-            pointer.push('-')
-          end
-          pointer.push('^')
-        end
-        pointer.join('')
-      end
-    end
-
-    class AlternativeMayNotExclusivelyContainOptionals < CucumberExpressionError
-      def initialize(node, expression)
-        super(build_message(
-                  node.start,
-                  expression,
-                  point_at_located(node),
-                  'An alternative may not exclusively contain optionals',
-                  "If you did not mean to use an optional you can use '\\(' to escape the the '('"
-              ))
-      end
-    end
-
-    class AlternativeMayNotBeEmpty < CucumberExpressionError
-      def initialize(node, expression)
-        super(build_message(
-                  node.start,
-                  expression,
-                  point_at_located(node),
-                  'Alternative may not be empty',
-                  "If you did not mean to use an alternative you can use '\\/' to escape the the '/'"
-              ))
-      end
-    end
-
-    class CantEscape < CucumberExpressionError
-      def initialize(expression, index)
-        super(build_message(
-                  index,
-                  expression,
-                  point_at(index),
-                  "Only the characters '{', '}', '(', ')', '\\', '/' and whitespace can be escaped",
-                  "If you did mean to use an '\\' you can use '\\\\' to escape it"
-              ))
-      end
-    end
-
-    class OptionalMayNotBeEmpty < CucumberExpressionError
-      def initialize(node, expression)
-        super(build_message(
-                  node.start,
-                  expression,
-                  point_at_located(node),
-                  'An optional must contain some text',
-                  "If you did not mean to use an optional you can use '\\(' to escape the the '('"
-              ))
-      end
-    end
-
-    class ParameterIsNotAllowedInOptional < CucumberExpressionError
-      def initialize(node, expression)
-        super(build_message(
-                  node.start,
-                  expression,
-                  point_at_located(node),
-                  'An optional may not contain a parameter type',
-                  "If you did not mean to use an parameter type you can use '\\{' to escape the the '{'"
-              ))
-      end
-    end
-
-    class OptionalIsNotAllowedInOptional < CucumberExpressionError
-      def initialize(node, expression)
-        super(build_message(
-                  node.start,
-                  expression,
-                  point_at_located(node),
-                  'An optional may not contain an other optional',
-                  "If you did not mean to use an optional type you can use '\\(' to escape the the '('. For more complicated expressions consider using a regular expression instead."
-              ))
-      end
-    end
-
-    class TheEndOfLineCannotBeEscaped < CucumberExpressionError
-      def initialize(expression)
-        index = expression.codepoints.length - 1
-        super(build_message(
-                  index,
-                  expression,
-                  point_at(index),
-                  'The end of line can not be escaped',
-                  "You can use '\\\\' to escape the the '\\'"
-              ))
-      end
-    end
-
-    class MissingEndToken < CucumberExpressionError
-      def initialize(expression, begin_token, end_token, current)
-        begin_symbol = Token::symbol_of(begin_token)
-        end_symbol = Token::symbol_of(end_token)
-        purpose = Token::purpose_of(begin_token)
-        super(build_message(
-                  current.start,
-                  expression,
-                  point_at_located(current),
-                  "The '#{begin_symbol}' does not have a matching '#{end_symbol}'",
-                  "If you did not intend to use #{purpose} you can use '\\#{begin_symbol}' to escape the #{purpose}"
-              ))
-      end
-    end
-
-    class AlternationNotAllowedInOptional < CucumberExpressionError
-      def initialize(expression, current)
-        super(build_message(
-                  current.start,
-                  expression,
-                  point_at_located(current),
-                  "An alternation can not be used inside an optional",
-                  "You can use '\\/' to escape the the '/'"
-              ))
-      end
-    end
-
-    class InvalidParameterTypeName < CucumberExpressionError
-      def initialize(type_name)
-        super("Illegal character in parameter name {#{type_name}}. " +
-                  "Parameter names may not contain '{', '}', '(', ')', '\\' or '/'")
-      end
-    end
-
-
-    class InvalidParameterTypeNameInNode < CucumberExpressionError
-      def initialize(expression, token)
-        super(build_message(
-                  token.start,
-                  expression,
-                  point_at_located(token),
-                  "Parameter names may not contain '{', '}', '(', ')', '\\' or '/'",
-                  "Did you mean to use a regular expression?"
-              ))
-      end
-    end
-
-    class UndefinedParameterTypeError < CucumberExpressionError
-      attr_reader :undefined_parameter_type_name
-
-      def initialize(node, expression, undefined_parameter_type_name)
-        super(build_message(node.start,
-                            expression,
-                            point_at_located(node),
-                            "Undefined parameter type '#{undefined_parameter_type_name}'",
-                            "Please register a ParameterType for '#{undefined_parameter_type_name}'"))
-        @undefined_parameter_type_name = undefined_parameter_type_name
-      end
-    end
-
-    class AmbiguousParameterTypeError < CucumberExpressionError
-      def initialize(parameter_type_regexp, expression_regexp, parameter_types, generated_expressions)
-        super(<<-EOM)
-Your Regular Expression /#{expression_regexp.source}/
-matches multiple parameter types with regexp /#{parameter_type_regexp}/:
-   #{parameter_type_names(parameter_types)}
-
-I couldn't decide which one to use. You have two options:
-
-1) Use a Cucumber Expression instead of a Regular Expression. Try one of these:
-   #{expressions(generated_expressions)}
-
-2) Make one of the parameter types preferential and continue to use a Regular Expression.
-
-        EOM
-      end
-
-      private
-
-      def parameter_type_names(parameter_types)
-        parameter_types.map { |p| "{#{p.name}}" }.join("\n   ")
-      end
-
-      def expressions(generated_expressions)
-        generated_expressions.map { |ge| ge.source }.join("\n   ")
-      end
-    end
-  end
-end

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

@@ -1,231 +0,0 @@
-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,
-          lambda {|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 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,
-            lambda {|s| s},
-            true,
-            false
-        ))
-        @parameter_type_registry.define_parameter_type(ParameterType.new(
-            'optional-hotel',
-            /(1 hotel)?/,
-            String,
-            lambda {|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,
-              lambda {|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,
-            lambda {|s| s},
-            true,
-            false
-        ))
-        @parameter_type_registry.define_parameter_type(ParameterType.new(
-            'exactly-one',
-            /[a-z]/,
-            String,
-            lambda {|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,
-              lambda {|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,
-              lambda {|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)
-        if match.nil?
-          raise "Expected text '#{text}' to match generated expression '#{generated_expression.source}'"
-        end
-        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/spec/cucumber/cucumber_expressions/cucumber_expression_spec.rb

@@ -1,181 +0,0 @@
-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
-
-        begin
-          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
-      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