honeybadger 5.4.0 → 5.4.1

data/vendor/bundle/ruby/3.2.0/gems/cucumber-core-12.0.0/lib/cucumber/core/gherkin/writer.rb

@@ -1,259 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/gherkin/writer/helpers'
-require 'cucumber/core/gherkin/document'
-
-module Cucumber
-  module Core
-    module Gherkin
-
-      module Writer
-        NEW_LINE = ''
-        def gherkin(uri = nil, &source)
-          uri ||= 'features/test.feature'
-          builder = Gherkin.new(uri, &source)
-          builder.build
-        end
-
-        class Gherkin
-          def initialize(uri, &source)
-            @uri, @source = uri, source
-          end
-
-          def comment(line)
-            comment_lines << "# #{line}"
-          end
-
-          def comment_lines
-            @comment_lines ||= []
-          end
-
-          def feature(*args, &source)
-            @feature = Feature.new(comment_lines, *args).tap do |builder|
-              builder.instance_exec(&source) if source
-            end
-            self
-          end
-
-          def build
-            instance_exec(&@source)
-            Document.new(@uri, @feature.build.join("\n"))
-          end
-        end
-
-        class Feature
-          include HasElements
-          include HasOptionsInitializer
-          include HasDescription
-          include Indentation.level(0)
-
-          default_keyword 'Feature'
-
-          elements :background, :rule, :scenario, :scenario_outline
-
-          def build(source = [])
-            elements.inject(source + statements) { |acc, el| el.build(acc) + [NEW_LINE] }
-          end
-
-          private
-          def language
-            options[:language]
-          end
-
-          def statements
-            prepare_statements(
-              language_statement,
-              comments_statement,
-              tag_statement,
-              name_statement,
-              description_statement,
-              NEW_LINE
-            )
-          end
-
-          def language_statement
-            "# language: #{language}" if language
-          end
-        end
-
-        class Background
-          include HasElements
-          include HasOptionsInitializer
-          include HasDescription
-          include Indentation.level 2
-
-          default_keyword 'Background'
-
-          elements :step
-
-          private
-          def statements
-            prepare_statements(
-              comments_statement,
-              tag_statement,
-              name_statement,
-              description_statement
-            )
-          end
-        end
-
-        class Rule
-          include HasElements
-          include HasOptionsInitializer
-          include HasDescription
-          include Indentation.level 2
-
-          default_keyword 'Rule'
-
-          elements :example, :scenario
-
-          private
-          def statements
-            prepare_statements(
-              comments_statement,
-              name_statement,
-              description_statement,
-              NEW_LINE
-            )
-          end
-        end
-
-        class Scenario
-          include HasElements
-          include HasOptionsInitializer
-          include HasDescription
-          include Indentation.level 2
-
-          default_keyword 'Scenario'
-
-          elements :step
-
-          private
-          def statements
-            prepare_statements(
-              comments_statement,
-              tag_statement,
-              name_statement,
-              description_statement
-            )
-          end
-        end
-
-        class Example < Scenario
-          include Indentation.level 4
-
-          default_keyword 'Example'
-        end
-
-        class ScenarioOutline
-          include HasElements
-          include HasOptionsInitializer
-          include HasDescription
-          include Indentation.level 2
-
-          default_keyword 'Scenario Outline'
-
-          elements :step, :examples
-
-          private
-          def statements
-            prepare_statements comments_statement, tag_statement, name_statement, description_statement
-          end
-        end
-
-        class Step
-          include HasElements
-          include HasOptionsInitializer
-          include Indentation.level 4
-
-          default_keyword 'Given'
-
-          elements :table
-
-          def doc_string(string, content_type='')
-            elements << DocString.new(string, content_type)
-          end
-
-          private
-          def statements
-            prepare_statements comments_statement, name_statement
-          end
-
-          def name_statement
-            "#{keyword} #{name}"
-          end
-        end
-
-        class Table
-          include Indentation.level(6)
-          include HasRows
-
-          def initialize(*)
-          end
-
-          def build(source)
-            source + statements
-          end
-
-          private
-          def statements
-            row_statements
-          end
-        end
-
-        class DocString
-          include Indentation.level(6)
-
-          attr_reader :strings, :content_type
-          private :strings, :content_type
-
-          def initialize(string, content_type)
-            @strings = string.split("\n").map(&:strip)
-            @content_type = content_type
-          end
-
-          def build(source)
-            source + statements
-          end
-
-          private
-          def statements
-            prepare_statements doc_string_statement
-          end
-
-          def doc_string_statement
-            [
-              %["""#{content_type}],
-              strings,
-              '"""'
-            ]
-          end
-        end
-
-        class Examples
-          include HasOptionsInitializer
-          include HasRows
-          include HasDescription
-          include Indentation.level(4)
-
-          default_keyword 'Examples'
-
-          def build(source)
-            source + statements
-          end
-
-          private
-          def statements
-            prepare_statements(
-              NEW_LINE,
-              comments_statement,
-              tag_statement,
-              name_statement,
-              description_statement,
-              row_statements(2)
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-core-12.0.0/lib/cucumber/core/platform.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-# Detect the platform we're running on so we can tweak behaviour
-# in various places.
-require 'rbconfig'
-
-module Cucumber
-  unless defined?(Cucumber::VERSION)
-    JRUBY         = defined?(JRUBY_VERSION)
-    IRONRUBY      = defined?(RUBY_ENGINE) && RUBY_ENGINE == "ironruby"
-    WINDOWS       = RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
-    OS_X          = RbConfig::CONFIG['host_os'] =~ /darwin/
-    WINDOWS_MRI   = WINDOWS && !JRUBY && !IRONRUBY
-    RUBY_2_0      = RUBY_VERSION =~ /^2\.0/
-    RUBY_1_9      = RUBY_VERSION =~ /^1\.9/
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-core-12.0.0/lib/cucumber/core/report/summary.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-module Cucumber
-  module Core
-    module Report
-      class Summary
-        attr_reader :test_cases, :test_steps
-
-        def initialize(event_bus)
-          @previous_test_case = nil
-          @test_cases = Test::Result::Summary.new
-          @test_steps = Test::Result::Summary.new
-          subscribe_to(event_bus)
-        end
-
-        def ok?(be_strict = Test::Result::StrictConfiguration.new)
-          test_cases.ok?(be_strict)
-        end
-
-        private
-
-        def subscribe_to(event_bus)
-          event_bus.on(:test_case_finished) do |event|
-            if event.test_case != @previous_test_case
-              @previous_test_case = event.test_case
-              event.result.describe_to test_cases
-            elsif event.result.passed? || event.result.skipped?
-              test_cases.flaky
-              test_cases.decrement_failed
-            end
-          end
-          event_bus.on(:test_step_finished) do |event|
-            event.result.describe_to test_steps unless event.test_step.hook?
-          end
-          self
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-core-12.0.0/lib/cucumber/core/test/action.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/test/location'
-require 'cucumber/core/test/result'
-require 'cucumber/core/test/timer'
-
-module Cucumber
-  module Core
-    module Test
-      class Action
-        def initialize(location = nil, &block)
-          raise ArgumentError, "Passing a block to execute the action is mandatory." unless block
-          @location = location ? location : Test::Location.new(*block.source_location)
-          @block = block
-          @timer = Timer.new
-        end
-
-        def skip(*)
-          skipped
-        end
-
-        def execute(*args)
-          @timer.start
-          @block.call(*args)
-          passed
-        rescue Result::Raisable => exception
-          exception.with_duration(@timer.duration)
-        rescue Exception => exception
-          failed(exception)
-        end
-
-        def location
-          @location
-        end
-
-        def inspect
-          "#<#{self.class}: #{location}>"
-        end
-
-        private
-
-        def passed
-          Result::Passed.new(@timer.duration)
-        end
-
-        def failed(exception)
-          Result::Failed.new(@timer.duration, exception)
-        end
-
-        def skipped
-          Result::Skipped.new
-        end
-      end
-
-      class UnskippableAction < Action
-        def skip(*args)
-          execute(*args)
-        end
-      end
-
-      class UndefinedAction
-        attr_reader :location
-
-        def initialize(source_location)
-          @location = source_location
-        end
-
-        def execute(*)
-          undefined
-        end
-
-        def skip(*)
-          undefined
-        end
-
-        private
-
-        def undefined
-          Result::Undefined.new
-        end
-      end
-
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-core-12.0.0/lib/cucumber/core/test/around_hook.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-module Cucumber
-  module Core
-    module Test
-      class AroundHook
-        def initialize(&block)
-          @block = block
-          @timer = Timer.new
-        end
-
-        def describe_to(visitor, *args, &continue)
-          visitor.around_hook(self, *args, &continue)
-        end
-
-        def hook?
-          true
-        end
-
-        def execute(*args, &continue)
-          @timer.start
-          @block.call(continue)
-          Result::Unknown.new # Around hook does not know the result of the inner test steps
-        rescue Result::Raisable => exception
-          exception.with_duration(@timer.duration)
-        rescue Exception => exception
-          failed(exception)
-        end
-
-        private
-        def failed(exception)
-          Result::Failed.new(@timer.duration, exception)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-core-12.0.0/lib/cucumber/core/test/case.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require 'cucumber/core/test/result'
-require 'cucumber/tag_expressions'
-
-module Cucumber
-  module Core
-    module Test
-      class Case
-        attr_reader :id, :name, :test_steps, :location, :tags, :language, :around_hooks
-
-        def initialize(id, name, test_steps, location, tags, language, around_hooks = [])
-          raise ArgumentError.new("test_steps should be an Array but is a #{test_steps.class}") unless test_steps.is_a?(Array)
-          @id = id
-          @name = name
-          @test_steps = test_steps
-          @location = location
-          @tags = tags
-          @language = language
-          @around_hooks = around_hooks
-        end
-
-        def step_count
-          test_steps.count
-        end
-
-        def describe_to(visitor, *args)
-          visitor.test_case(self, *args) do |child_visitor|
-            compose_around_hooks(child_visitor, *args) do
-              test_steps.each do |test_step|
-                test_step.describe_to(child_visitor, *args)
-              end
-            end
-          end
-          self
-        end
-
-        def with_steps(test_steps)
-          self.class.new(id, name, test_steps, location, tags, language, around_hooks)
-        end
-
-        def with_around_hooks(around_hooks)
-          self.class.new(id, name, test_steps, location, tags, language, around_hooks)
-        end
-
-        def match_tags?(*expressions)
-          expressions.flatten.all? { |expression| match_single_tag_expression?(expression) }
-        end
-
-        def match_name?(name_regexp)
-          name =~ name_regexp
-        end
-
-        def match_locations?(queried_locations)
-          queried_locations.any? do |queried_location|
-            matching_locations.any? do |location|
-              queried_location.match? location
-            end
-          end
-        end
-
-        def matching_locations
-          [
-            location,
-            tags.map(&:location),
-            test_steps.map(&:matching_locations)
-          ].flatten
-        end
-
-        def inspect
-          "#<#{self.class}: #{location}>"
-        end
-
-        def hash
-          location.hash
-        end
-
-        def eql?(other)
-          other.hash == hash
-        end
-
-        def ==(other)
-          eql?(other)
-        end
-
-        private
-
-        def compose_around_hooks(visitor, *args, &block)
-          around_hooks.reverse.reduce(block) do |continue, hook|
-            -> { hook.describe_to(visitor, *args, &continue) }
-          end.call
-        end
-
-        def match_single_tag_expression?(expression)
-          Cucumber::TagExpressions::Parser.new.parse(expression).evaluate(tags.map(&:name))
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-core-12.0.0/lib/cucumber/core/test/data_table.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module Cucumber
-  module Core
-    module Test
-      # Step Definitions that match a plain text Step with a multiline argument table
-      # will receive it as an instance of DataTable. A DataTable object holds the data of a
-      # table parsed from a feature file and lets you access and manipulate the data
-      # in different ways.
-      #
-      # For example:
-      #
-      #   Given I have:
-      #     | a | b |
-      #     | c | d |
-      #
-      # And a matching StepDefinition:
-      #
-      #   Given /I have:/ do |table|
-      #     data = table.raw
-      #   end
-      #
-      # This will store <tt>[['a', 'b'], ['c', 'd']]</tt> in the <tt>data</tt> variable.
-      #
-      class DataTable
-        # Creates a new instance. +raw+ should be an Array of Array of String
-        # or an Array of Hash
-        # You don't typically create your own DataTable objects - Cucumber will do
-        # it internally and pass them to your Step Definitions.
-        #
-        def initialize(rows)
-          raw = ensure_array_of_array(rows)
-          verify_rows_are_same_length(raw)
-          @raw = raw.freeze
-        end
-        attr_reader :raw
-
-        def describe_to(visitor, *args)
-          visitor.data_table(self, *args)
-        end
-
-        def to_step_definition_arg
-          dup
-        end
-
-        def data_table?
-          true
-        end
-
-        def doc_string?
-          false
-        end
-
-        # Creates a copy of this table
-        #
-        def dup
-          self.class.new(raw.dup)
-        end
-
-        # Returns a new, transposed table. Example:
-        #
-        #   | a | 7 | 4 |
-        #   | b | 9 | 2 |
-        #
-        # Gets converted into the following:
-        #
-        #   | a | b |
-        #   | 7 | 9 |
-        #   | 4 | 2 |
-        #
-        def transpose
-          self.class.new(raw.transpose)
-        end
-
-        def map(&block)
-          new_raw = raw.map do |row|
-            row.map(&block)
-          end
-
-          self.class.new(new_raw)
-        end
-
-        def lines_count
-          raw.count
-        end
-
-        def ==(other)
-          other.class == self.class && raw == other.raw
-        end
-
-        def inspect
-          %{#<#{self.class} #{raw.inspect})>}
-        end
-
-        private
-
-        def verify_rows_are_same_length(raw)
-          begin
-            raw.transpose
-          rescue IndexError
-            raise ArgumentError, "Rows must all be the same length"
-          end
-        end
-
-        def ensure_array_of_array(array)
-          Hash === array[0] ? hashes_to_array(array) : array
-        end
-
-        def hashes_to_array(hashes)
-          header = hashes[0].keys.sort
-          [header] + hashes.map {|hash| header.map {|key| hash[key]}}
-        end
-
-      end
-    end
-  end
-end