honeybadger 5.3.0 → 5.4.0

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

@@ -1,197 +0,0 @@
-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
-            lambda {|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,
-              lambda {|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,
-              lambda {|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,
-              lambda {|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,
-              lambda {|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,
-                  lambda {|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,
-                lambda {|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,
-                lambda {|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 type without name" do
-          parameter_type_registry = ParameterTypeRegistry.new
-          parameter_type_registry.define_parameter_type(ParameterType.new(
-              nil,
-              /red|blue|yellow/,
-              Color,
-              lambda {|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/spec/cucumber/cucumber_expressions/parameter_type_registry_spec.rb

@@ -1,86 +0,0 @@
-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+/
-
-    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, lambda {|s| Name.new}, true, true))
-        @registry.define_parameter_type(ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, false))
-        expect do
-          @registry.define_parameter_type(ParameterType.new("place", CAPITALISED_WORD, Place, lambda {|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, lambda {|s| Name.new}, true, false)
-        person = ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, true)
-        place = ParameterType.new("place", CAPITALISED_WORD, Place, lambda {|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, lambda {|s| Name.new}, true, false)
-        person = ParameterType.new("person", CAPITALISED_WORD, Person, lambda {|s| Person.new}, true, false)
-        place = ParameterType.new("place", CAPITALISED_WORD, Place, lambda {|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/spec/cucumber/cucumber_expressions/regular_expression_spec.rb

@@ -1,84 +0,0 @@
-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 no 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 parenthesis" 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

data/vendor/bundle/ruby/3.2.0/gems/cucumber-messages-21.0.1/spec/capture_warnings.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-# With thanks to @myronmarston
-# https://github.com/vcr/vcr/blob/master/spec/capture_warnings.rb
-
-module CaptureWarnings
-  def report_warnings(&block)
-    current_dir = Dir.pwd
-    warnings, errors = capture_error(&block).partition { |line| line.include?('warning') }
-    project_warnings, other_warnings = warnings.uniq.partition { |line| line.include?(current_dir) }
-
-    if errors.any?
-      puts errors.join("\n")
-    end
-
-    if other_warnings.any?
-      puts "#{ other_warnings.count } warnings detected, set VIEW_OTHER_WARNINGS=true to see them."
-      print_warnings('other', other_warnings) if ENV['VIEW_OTHER_WARNINGS']
-    end
-
-    # Until they fix https://bugs.ruby-lang.org/issues/10661
-    if RUBY_VERSION == "2.2.0"
-      project_warnings = project_warnings.reject { |w| w =~ /warning: possible reference to past scope/ }
-    end
-
-    if project_warnings.any?
-      puts "#{ project_warnings.count } warnings detected"
-      print_warnings('cucumber-expressions', project_warnings)
-      fail "Please remove all cucumber-expressions warnings."
-    end
-
-    ensure_system_exit_if_required
-  end
-
-  def capture_error(&block)
-    old_stderr = STDERR.clone
-    pipe_r, pipe_w = IO.pipe
-    pipe_r.sync    = true
-    error          = String.new
-    reader = Thread.new do
-      begin
-        loop do
-          error << pipe_r.readpartial(1024)
-        end
-      rescue EOFError
-      end
-    end
-    STDERR.reopen(pipe_w)
-    block.call
-  ensure
-    capture_system_exit
-    STDERR.reopen(old_stderr)
-    pipe_w.close
-    reader.join
-    return error.split("\n")
-  end
-
-  def print_warnings(type, warnings)
-    puts
-    puts "-" * 30 + " #{type} warnings: " + "-" * 30
-    puts
-    puts warnings.join("\n")
-    puts
-    puts "-" * 75
-    puts
-  end
-
-  def ensure_system_exit_if_required
-    raise @system_exit if @system_exit
-  end
-
-  def capture_system_exit
-    @system_exit = $!
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-tag-expressions-4.1.0/spec/capture_warnings.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-# With thanks to @myronmarston
-# https://github.com/vcr/vcr/blob/master/spec/capture_warnings.rb
-
-module CaptureWarnings
-  def report_warnings(&block)
-    current_dir = Dir.pwd
-    warnings, errors = capture_error(&block).partition { |line| line.include?('warning') }
-    project_warnings, other_warnings = warnings.uniq.partition { |line| line.include?(current_dir) }
-
-    if errors.any?
-      puts errors.join("\n")
-    end
-
-    if other_warnings.any?
-      puts "#{ other_warnings.count } warnings detected, set VIEW_OTHER_WARNINGS=true to see them."
-      print_warnings('other', other_warnings) if ENV['VIEW_OTHER_WARNINGS']
-    end
-
-    # Until they fix https://bugs.ruby-lang.org/issues/10661
-    if RUBY_VERSION == "2.2.0"
-      project_warnings = project_warnings.reject { |w| w =~ /warning: possible reference to past scope/ }
-    end
-
-    if project_warnings.any?
-      puts "#{ project_warnings.count } warnings detected"
-      print_warnings('cucumber-expressions', project_warnings)
-      fail "Please remove all cucumber-expressions warnings."
-    end
-
-    ensure_system_exit_if_required
-  end
-
-  def capture_error(&block)
-    old_stderr = STDERR.clone
-    pipe_r, pipe_w = IO.pipe
-    pipe_r.sync    = true
-    error          = String.new
-    reader = Thread.new do
-      begin
-        loop do
-          error << pipe_r.readpartial(1024)
-        end
-      rescue EOFError
-      end
-    end
-    STDERR.reopen(pipe_w)
-    block.call
-  ensure
-    capture_system_exit
-    STDERR.reopen(old_stderr)
-    pipe_w.close
-    reader.join
-    return error.split("\n")
-  end
-
-  def print_warnings(type, warnings)
-    puts
-    puts "-" * 30 + " #{type} warnings: " + "-" * 30
-    puts
-    puts warnings.join("\n")
-    puts
-    puts "-" * 75
-    puts
-  end
-
-  def ensure_system_exit_if_required
-    raise @system_exit if @system_exit
-  end
-
-  def capture_system_exit
-    @system_exit = $!
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-tag-expressions-4.1.0/spec/expressions_spec.rb

@@ -1,84 +0,0 @@
-require 'cucumber/tag_expressions/parser'
-
-describe 'Expression node' do
-  shared_examples 'expression node' do |infix_expression, data|
-    data.each do |tags, result|
-      it "#{infix_expression.inspect} with variables: #{tags.inspect}'" do
-        expression = Cucumber::TagExpressions::Parser.new.parse(infix_expression)
-        expect(expression.evaluate(tags)).to eq(result)
-      end
-    end
-  end
-
-  describe Cucumber::TagExpressions::Not do
-    context '#evaluate' do
-      infix_expression = 'not x'
-      data = [[%w(x), false],
-              [%w(y), true]]
-      include_examples 'expression node', infix_expression, data
-    end
-  end
-
-  describe Cucumber::TagExpressions::And do
-    context '#evaluate' do
-      infix_expression = 'x and y'
-      data = [[%w(x y), true],
-              [%w(x), false],
-              [%w(y), false]]
-      include_examples 'expression node', infix_expression, data
-    end
-  end
-
-  describe Cucumber::TagExpressions::Or do
-    context '#evaluate' do
-      infix_expression = 'x or y'
-      data = [[%w(), false],
-              [%w(x), true],
-              [%w(y), true],
-              [%w(x q), true],
-              [%w(x y), true]]
-      include_examples 'expression node', infix_expression, data
-    end
-  end
-
-  describe Cucumber::TagExpressions::Or do
-    context '#evaluate' do
-      infix_expression = 'x\\(1\\) or (y\\(2\\))'
-      data = [[%w(), false],
-              [%w(x), false],
-              [%w(y), false],
-              [%w(x(1)), true],
-              [%w(y(2)), true]]
-      include_examples 'expression node', infix_expression, data
-    end
-  end
-
-  describe Cucumber::TagExpressions::Or do
-    context '#evaluate' do
-      infix_expression = 'x\\\\ or (y\\\\\\)) or (z\\\\)'
-      data = [[%w(), false],
-              [%w(x), false],
-              [%w(y\)), false],
-              [%w(z), false],
-              [%w(x\\), true],
-              [%w(y\\\)), true],
-              [%w(z\\), true]]
-      include_examples 'expression node', infix_expression, data
-    end
-  end
-
-  describe Cucumber::TagExpressions::Or do
-    context '#evaluate' do
-      infix_expression = '\\x or y\\ or z\\'
-      data = [[%w(), false],
-              [%w(\\x), false],
-              [%w(y\\), false],
-              [%w(z\\), false],
-              [%w(x), true],
-              [%w(y), true],
-              [%w(z), true]]
-      include_examples 'expression node', infix_expression, data
-    end
-  end
-
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-tag-expressions-4.1.0/spec/parser_spec.rb

@@ -1,50 +0,0 @@
-require 'cucumber/tag_expressions/parser'
-
-describe Cucumber::TagExpressions::Parser do
-  correct_test_data = [
-    ['a and b', '( a and b )'],
-    ['a or (b)', '( a or b )'],
-    ['not   a', 'not ( a )'],
-    ['( a and b ) or ( c and d )', '( ( a and b ) or ( c and d ) )'],
-    ['not a or b and not c or not d or e and f',
-     '( ( ( not ( a ) or ( b and not ( c ) ) ) or not ( d ) ) or ( e and f ) )'],
-    ['not a\\(\\) or b and not c or not d or e and f',
-     '( ( ( not ( a\\(\\) ) or ( b and not ( c ) ) ) or not ( d ) ) or ( e and f ) )'],
-     ['a\\\\ and b', '( a\\\\ and b )'],
-     ['\\a and b\\ and c\\', '( ( a and b ) and c )'],
-     ['(a and b\\\\)', '( a and b\\\\ )'],
-     ['a\\\\\\( and b\\\\\\)', '( a\\\\\\( and b\\\\\\) )']
-  ]
-
-  error_test_data = [
-    ['@a @b or', 'Syntax error. Expected operator'],
-    ['@a and (@b not)', 'Syntax error. Expected operator'],
-    ['@a and (@b @c) or', 'Syntax error. Expected operator'],
-    ['@a and or', 'Syntax error. Expected operand'],
-    ['or or', 'Syntax error. Expected operand'],
-    ['a b', 'Syntax error. Expected operator'],
-    ['( a and b ) )', 'Syntax error. Unmatched )'],
-    ['( ( a and b )', 'Syntax error. Unmatched ('],
-  ]
-
-  context '#parse' do
-    context 'with correct test data' do
-      correct_test_data.each do |infix_expression, to_string|
-        parser = Cucumber::TagExpressions::Parser.new
-        it "parses correctly #{infix_expression.inspect}" do
-          expect(parser.parse(infix_expression).to_s).to eq(to_string)
-        end
-      end
-    end
-
-    context 'with error test data' do
-      error_test_data.each do |infix_expression, message|
-        parser = Cucumber::TagExpressions::Parser.new
-        it "raises an error parsing #{infix_expression.inspect}" do
-          expect { parser.parse(infix_expression) }
-            .to raise_error(RuntimeError, message)
-        end
-      end
-    end
-  end
-end