honeybadger 5.2.0 → 5.3.0

data/vendor/bundle/ruby/3.2.0/gems/cucumber-core-11.1.0/lib/cucumber/core/test/doc_string.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+require 'delegate'
+module Cucumber
+  module Core
+    module Test
+      # Represents an inline argument in a step. Example:
+      #
+      #   Given the message
+      #     """
+      #     I like
+      #     Cucumber sandwich
+      #     """
+      #
+      # The text between the pair of <tt>"""</tt> is stored inside a DocString,
+      # which is yielded to the StepDefinition block as the last argument.
+      #
+      # The StepDefinition can then access the String via the #to_s method. In the
+      # example above, that would return: <tt>"I like\nCucumber sandwich"</tt>
+      #
+      # Note how the indentation from the source is stripped away.
+      #
+      class DocString < SimpleDelegator
+        attr_reader :content_type, :content
+
+        def initialize(content, content_type)
+          @content = content
+          @content_type = content_type
+          super @content
+        end
+
+        def describe_to(visitor, *args)
+          visitor.doc_string(self, *args)
+        end
+
+        def data_table?
+          false
+        end
+
+        def doc_string?
+          true
+        end
+
+        def map
+          raise ArgumentError, "No block given" unless block_given?
+          new_content = yield content
+          self.class.new(new_content, content_type)
+        end
+
+        def to_step_definition_arg
+          self
+        end
+
+        def lines_count
+          lines.count + 2
+        end
+
+        def ==(other)
+          if other.respond_to?(:content_type)
+            return false unless content_type == other.content_type
+          end
+          if other.respond_to?(:to_str)
+            return content == other.to_str
+          end
+          false
+        end
+
+        def inspect
+          [
+            %{#<#{self.class}},
+            %{  """#{content_type}},
+            %{  #{@content}},
+            %{  """>}
+          ].join("\n")
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-core-11.1.0/lib/cucumber/core/test/empty_multiline_argument.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Cucumber
+  module Core
+    module Test
+      class EmptyMultilineArgument
+        def describe_to(*)
+          self
+        end
+
+        def data_table?
+          false
+        end
+
+        def doc_string?
+          false
+        end
+
+        def map(&block)
+          self
+        end
+
+        def lines_count
+          0
+        end
+
+        def inspect
+          "#<#{self.class}>"
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-core-11.1.0/lib/cucumber/core/test/filters/activate_steps_for_self_test.rb

@@ -0,0 +1,35 @@
+module Cucumber
+  module Core
+    module Test
+      module Filters
+
+        # This filter is used for testing Cucumber itself. It adds step definitions
+        # that will activate steps to have passed / failed / pending results
+        # if they use conventional names.
+        #
+        # It was extracted from our test code, and does not have any tests of its own.
+        class ActivateStepsForSelfTest < Core::Filter.new
+          Failure = Class.new(StandardError)
+
+          def test_case(test_case)
+            test_steps = test_case.test_steps.map do |step|
+              case step.text
+              when /fail/
+                step.with_action { raise Failure }
+              when /pending/
+                step.with_action { raise Test::Result::Pending }
+              when /pass/
+                step.with_action {}
+              else
+                step
+              end
+            end
+
+            test_case.with_steps(test_steps).describe_to(receiver)
+          end
+        end
+
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-core-11.1.0/lib/cucumber/core/test/filters/locations_filter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require 'cucumber/core/filter'
+
+module Cucumber
+  module Core
+    module Test
+
+      # Sorts and filters scenarios based on a list of locations
+      class LocationsFilter < Filter.new(:filter_locations)
+
+        def test_case(test_case)
+          test_cases[test_case.location.file] << test_case
+          self
+        end
+
+        def done
+          sorted_test_cases.each do |test_case|
+            test_case.describe_to receiver
+          end
+          receiver.done
+          self
+        end
+
+        private
+
+        def sorted_test_cases
+          filter_locations.map { |filter_location|
+            test_cases[filter_location.file].select { |test_case|
+              test_case.match_locations?([filter_location])
+            }
+          }.flatten.uniq
+        end
+
+        def test_cases
+          @test_cases ||= Hash.new { |hash, key| hash[key] = [] }
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-core-11.1.0/lib/cucumber/core/test/filters/name_filter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require 'cucumber/core/filter'
+
+module Cucumber
+  module Core
+    module Test
+      class NameFilter < Filter.new(:name_regexps)
+
+        def test_case(test_case)
+          if accept?(test_case)
+            test_case.describe_to(receiver)
+          end
+          self
+        end
+
+        private
+
+        def accept?(test_case)
+          name_regexps.empty? || name_regexps.any? { |name_regexp| test_case.match_name?(name_regexp) }
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-core-11.1.0/lib/cucumber/core/test/filters/tag_filter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+require 'cucumber/core/filter'
+
+module Cucumber
+  module Core
+    module Test
+      class TagFilter < Filter.new(:filter_expressions)
+
+        def test_case(test_case)
+          test_cases << test_case
+          if test_case.match_tags?(filter_expressions)
+            test_case.describe_to(receiver)
+          end
+          self
+        end
+
+        def done
+          receiver.done
+          self
+        end
+
+        private
+
+        def test_cases
+          @test_cases ||= TestCases.new
+        end
+
+        class TestCases
+          attr_reader :test_cases_by_tag_name
+          private :test_cases_by_tag_name
+          def initialize
+            @test_cases_by_tag_name = Hash.new { [] }
+          end
+
+          def <<(test_case)
+            test_case.tags.each do |tag|
+              test_cases_by_tag_name[tag.name] += [test_case]
+            end
+            self
+          end
+
+          def with_tag_name(tag_name)
+            test_cases_by_tag_name[tag_name]
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-core-11.1.0/lib/cucumber/core/test/filters.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+require 'cucumber/core/test/filters/locations_filter'
+require 'cucumber/core/test/filters/name_filter'
+require 'cucumber/core/test/filters/tag_filter'

data/vendor/bundle/ruby/3.2.0/gems/cucumber-core-11.1.0/lib/cucumber/core/test/location.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+require 'forwardable'
+require 'cucumber/core/platform'
+module Cucumber
+  module Core
+    module Test
+      IncompatibleLocations = Class.new(StandardError)
+
+      module Location
+
+        def self.of_caller(additional_depth = 0)
+          from_file_colon_line(*caller[1 + additional_depth])
+        end
+
+        def self.from_file_colon_line(file_colon_line)
+          file, raw_line = file_colon_line.match(/(.*):(\d+)/)[1..2]
+          from_source_location(file, raw_line.to_i)
+        end
+
+        def self.from_source_location(file, line)
+          file = File.expand_path(file)
+          pwd = File.expand_path(Dir.pwd)
+          pwd.force_encoding(file.encoding)
+          if file.index(pwd)
+            file = file[pwd.length + 1..-1]
+          elsif file =~ /.*\/gems\/(.*\.rb)$/
+            file = $1
+          end
+          new(file, line)
+        end
+
+        def self.new(file, raw_lines=nil)
+          file || raise(ArgumentError, "file is mandatory")
+          if raw_lines
+            Precise.new(file, Lines.new(raw_lines))
+          else
+            Wildcard.new(file)
+          end
+        end
+
+        class Wildcard < Struct.new(:file)
+          def to_s
+            file
+          end
+
+          def match?(other)
+            other.file == file
+          end
+
+          def include?(lines)
+            true
+          end
+        end
+
+        class Precise < Struct.new(:file, :lines)
+          def include?(other_lines)
+            lines.include?(other_lines)
+          end
+
+          def line
+            lines.first
+          end
+
+          def match?(other)
+            return false unless other.file == file
+
+            other.include?(lines)
+          end
+
+          def to_s
+            [file, lines.to_s].join(":")
+          end
+
+          def hash
+            [self.class, to_s].hash
+          end
+
+          def to_str
+            to_s
+          end
+
+          def merge(multiline_arg)
+            new_lines = (0..multiline_arg.lines_count).map do |offset|
+              lines.min + offset
+            end
+            Location.new(file, new_lines)
+          end
+
+          def on_line(new_line)
+            Location.new(file, new_line)
+          end
+
+          def inspect
+            "<#{self.class}: #{to_s}>"
+          end
+        end
+
+        require 'set'
+        class Lines < Struct.new(:data)
+          protected :data
+
+          def initialize(raw_data)
+            super Array(raw_data).to_set
+          end
+
+          def first
+            data.first
+          end
+
+          def min
+            data.min
+          end
+
+          def max
+            data.max
+          end
+
+          def include?(other)
+            other.data.subset?(data) || data.subset?(other.data)
+          end
+
+          def +(other)
+            new_data = data + other.data
+            self.class.new(new_data)
+          end
+
+          def to_s
+            return first.to_s if data.length == 1
+            return "#{data.min}..#{data.max}" if range?
+
+            data.to_a.join(":")
+          end
+
+          def inspect
+            "<#{self.class}: #{self}>"
+          end
+
+          protected
+
+          def range?
+            data.size == (data.max - data.min + 1)
+          end
+        end
+      end
+
+      module HasLocation
+        def file_colon_line
+          location.to_s
+        end
+
+        def file
+          location.file
+        end
+
+        def line
+          location.line
+        end
+
+        def location
+          raise('Please set @location in the constructor') unless defined?(@location)
+
+          @location
+        end
+
+        def attributes
+          [tags, comments, multiline_arg].flatten
+        end
+
+        def tags
+          # will be overriden by nodes that actually have tags
+          []
+        end
+
+        def comments
+          # will be overriden by nodes that actually have comments
+          []
+        end
+
+        def multiline_arg
+          # will be overriden by nodes that actually have a multiline_argument
+          Test::EmptyMultilineArgument.new
+        end
+
+      end
+    end
+  end
+end