honeybadger 5.2.0 → 5.3.0

data/vendor/bundle/ruby/3.2.0/gems/guard-compat-1.2.1/spec/guard/compat/no_guard_spec.rb

@@ -0,0 +1,63 @@
+# This test requires UI be not defined to simulate using plugin outside Guard
+
+require 'guard/compat/plugin'
+
+Guard.send(:remove_const, :UI) if Guard.const_defined?(:UI)
+
+RSpec.describe Guard::Compat do
+  context 'when Guard is not loaded' do
+    describe '.color' do
+      it 'returns uncolored text' do
+        expect(Guard::Compat::UI.color('foo', 'red')).to eq('foo')
+      end
+    end
+
+    describe '.color_enabled?' do
+      it 'returns false' do
+        expect(Guard::Compat::UI.color_enabled?).to be(false)
+      end
+    end
+
+    describe '.info' do
+      it 'outputs to stdout' do
+        expect($stdout).to receive(:puts).with('foo')
+        Guard::Compat::UI.info('foo')
+      end
+    end
+
+    describe '.warning' do
+      it 'outputs to stdout' do
+        expect($stdout).to receive(:puts).with('foo')
+        Guard::Compat::UI.warning('foo')
+      end
+    end
+
+    describe '.error' do
+      it 'outputs to stdout' do
+        expect($stderr).to receive(:puts).with('foo')
+        Guard::Compat::UI.error('foo')
+      end
+    end
+
+    describe '.debug' do
+      it 'outputs to stdout' do
+        expect($stdout).to receive(:puts).with('foo')
+        Guard::Compat::UI.debug('foo')
+      end
+    end
+
+    describe '.deprecation' do
+      it 'outputs to stdout' do
+        expect($stdout).to receive(:puts).with('foo')
+        Guard::Compat::UI.deprecation('foo')
+      end
+    end
+
+    describe '.notify' do
+      it 'outputs to stdout' do
+        expect($stdout).to receive(:puts).with('foo')
+        Guard::Compat::UI.notify('foo')
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/guard-compat-1.2.1/spec/spec_helper.rb

@@ -0,0 +1,73 @@
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_doubled_constant_names = true
+    mocks.verify_partial_doubles = true
+  end
+
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run focus: ENV['CI'] != 'true'
+
+  config.run_all_when_everything_filtered = true
+
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  # config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end

data/vendor/bundle/ruby/3.2.0/gems/guard-rspec-4.7.3/lib/guard/rspec/command.rb

@@ -0,0 +1,71 @@
+require "rspec/core"
+require "pathname"
+
+require "guard/rspec"
+
+module Guard
+  class RSpec < Plugin
+    class Command < String
+      FAILURE_EXIT_CODE = 2
+
+      attr_accessor :paths, :options
+
+      def initialize(paths, options = {})
+        @paths = paths
+        @options = options
+        super(_parts.join(" "))
+      end
+
+      private
+
+      def _parts
+        parts = [options[:cmd]]
+        parts << _visual_formatter
+        parts << _guard_formatter
+        parts << "--failure-exit-code #{FAILURE_EXIT_CODE}"
+        parts << options[:cmd_additional_args] || ""
+
+        parts << _paths(options).join(" ")
+      end
+
+      def _paths(options)
+        chdir = options[:chdir]
+        return paths unless chdir
+        paths.map { |path| path.sub(File.join(chdir, "/"), "") }
+      end
+
+      def _visual_formatter
+        return if _cmd_include_formatter?
+        _rspec_formatters || "-f progress"
+      end
+
+      def _rspec_formatters
+        # RSpec::Core::ConfigurationOptions#parse_options method was renamed to
+        # #options in rspec-core v3.0.0.beta2 so call the first one if
+        # available. Fixes #249
+        config = ::RSpec::Core::ConfigurationOptions.new([])
+        config.parse_options if config.respond_to?(:parse_options)
+        formatters = config.options[:formatters] || nil
+
+        # RSpec's parser returns an array in the format
+        #
+        # [[formatter, output], ...],
+        #
+        # so match their format Construct a matching command line option,
+        # including output target
+
+        return formatters unless formatters
+        formatters.map { |entries| "-f #{entries.join ' -o '}" }.join(" ")
+      end
+
+      def _cmd_include_formatter?
+        options[:cmd] =~ /(?:^|\s)(?:-f\s*|--format(?:=|\s+))([\w:]+)/
+      end
+
+      def _guard_formatter
+        dir = Pathname.new(__FILE__).dirname.dirname
+        "-r #{dir + 'rspec_formatter.rb'} -f Guard::RSpecFormatter"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/guard-rspec-4.7.3/lib/guard/rspec/deprecator.rb

@@ -0,0 +1,86 @@
+module Guard
+  class RSpec < Plugin
+    class Deprecator
+      attr_accessor :options
+
+      def self.warns_about_deprecated_options(options = {})
+        new(options).warns_about_deprecated_options
+      end
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def warns_about_deprecated_options
+        _spec_opts_env
+        _version_option
+        _exclude_option
+        _use_cmd_option
+        _keep_failed_option
+        _focus_on_failed_option
+      end
+
+      private
+
+      def _spec_opts_env
+        return if ENV["SPEC_OPTS"].nil?
+        Compat::UI.warning(
+          "The SPEC_OPTS environment variable is present." \
+          " This can conflict with guard-rspec."
+        )
+      end
+
+      def _version_option
+        return unless options.key?(:version)
+        _deprecated(
+          "The :version option is deprecated." \
+          " Only RSpec ~> 2.14 is now supported."
+        )
+      end
+
+      def _exclude_option
+        return unless options.key?(:exclude)
+        _deprecated(
+          "The :exclude option is deprecated." \
+          " Please Guard ignore method instead." \
+          " https://github.com/guard/guard#ignore"
+        )
+      end
+
+      def _use_cmd_option
+        %w(color drb fail_fast formatter env bundler
+           binstubs rvm cli spring turnip zeus foreman).each do |option|
+          next unless options.key?(option.to_sym)
+          _deprecated(
+            "The :#{option} option is deprecated." \
+            " Please customize the new :cmd option to fit your need."
+          )
+        end
+      end
+
+      def _keep_failed_option
+        return unless options.key?(:keep_failed)
+        _deprecated(
+          "The :keep_failed option is deprecated." \
+          " Please set new :failed_mode option value to" \
+          " :keep instead." \
+          " https://github.com/guard/guard-rspec#list-of-available-options"
+        )
+      end
+
+      def _focus_on_failed_option
+        return unless options.key?(:focus_on_failed)
+        _deprecated(
+          "The :focus_on_failed option is deprecated." \
+          " Please set new :failed_mode option value to" \
+          " :focus instead." \
+          " https://github.com/guard/guard-rspec#list-of-available-options"
+        )
+      end
+
+      def _deprecated(message)
+        Compat::UI.warning %(Guard::RSpec DEPRECATION WARNING: #{message})
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/guard-rspec-4.7.3/lib/guard/rspec/dsl.rb

@@ -0,0 +1,72 @@
+require "ostruct"
+
+require "guard/rspec"
+
+module Guard
+  class RSpec < Plugin
+    class Dsl
+      def initialize(dsl)
+        @dsl = dsl
+      end
+
+      def watch_spec_files_for(expr)
+        @dsl.send(:watch, expr) { |m| rspec.spec.call(m[1]) }
+      end
+
+      def self.detect_spec_file_for(rspec, file)
+        # TODO: when spec not found ... run specs in topmost found path?
+        # Or show warning?
+
+        path = "#{rspec.spec_dir}/#{file}_spec.rb"
+        return path unless file.start_with?("lib/")
+        return path if Dir.exist?("#{rspec.spec_dir}/lib")
+
+        without_lib = file.sub(%r{^lib/}, "")
+        "#{rspec.spec_dir}/#{without_lib}_spec.rb"
+      end
+
+      def rspec
+        @rspec ||= OpenStruct.new(to_s: "spec").tap do |rspec|
+          rspec.spec_dir = "spec"
+          rspec.spec = ->(m) { Dsl.detect_spec_file_for(rspec, m) }
+          rspec.spec_helper = "#{rspec.spec_dir}/spec_helper.rb"
+          rspec.spec_files = %r{^#{rspec.spec_dir}/.+_spec\.rb$}
+          rspec.spec_support = %r{^#{rspec.spec_dir}/support/(.+)\.rb$}
+        end
+      end
+
+      def ruby
+        # Ruby apps
+        @ruby ||= OpenStruct.new.tap do |ruby|
+          ruby.lib_files = %r{^(lib/.+)\.rb$}
+        end
+      end
+
+      def rails(options = {})
+        # Rails example
+        @rails ||= _build_rails_rules(_view_extensions(options) * "|")
+      end
+
+      private
+
+      def _view_extensions(options)
+        options.dup.delete(:view_extensions) || %w(erb haml slim)
+      end
+
+      def _build_rails_rules(exts)
+        OpenStruct.new.tap do |rails|
+          rails.app_files = %r{^app/(.+)\.rb$}
+
+          rails.views = %r{^app/(views/.+/[^/]*\.(?:#{exts}))$}
+          rails.view_dirs = %r{^app/views/(.+)/[^/]*\.(?:#{exts})$}
+          rails.layouts = %r{^app/layouts/(.+)/[^/]*\.(?:#{exts})$}
+
+          rails.controllers = %r{^app/controllers/(.+)_controller\.rb$}
+          rails.routes = "config/routes.rb"
+          rails.app_controller = "app/controllers/application_controller.rb"
+          rails.spec_helper = "#{rspec.spec_dir}/rails_helper.rb"
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/guard-rspec-4.7.3/lib/guard/rspec/inspectors/base_inspector.rb

@@ -0,0 +1,73 @@
+module Guard
+  class RSpec < Plugin
+    module Inspectors
+      class BaseInspector
+        attr_accessor :options, :spec_paths
+
+        def initialize(options = {})
+          @options = options
+          @spec_paths = @options[:spec_paths]
+          @chdir = @options[:chdir]
+        end
+
+        def paths(_paths)
+          raise NotImplementedError
+        end
+
+        def failed(_locations)
+          raise NotImplementedError
+        end
+
+        def reload
+          raise NotImplementedError
+        end
+
+        private
+
+        # Leave only spec/feature files from spec_paths, remove others
+        def _clean(paths)
+          paths.uniq!
+          paths.compact!
+          spec_dirs = _select_only_spec_dirs(paths)
+          spec_files = _select_only_spec_files(paths)
+          (spec_dirs + spec_files).uniq
+        end
+
+        def _select_only_spec_dirs(paths)
+          chdir_paths = _spec_paths_with_chdir
+          paths.select do |path|
+            File.directory?(path) || chdir_paths.include?(path)
+          end
+        end
+
+        def _select_only_spec_files(paths)
+          spec_files = _collect_files("*[_.]spec.rb")
+          feature_files = _collect_files("*.feature")
+          files = (spec_files + feature_files).flatten
+
+          paths.select do |path|
+            (files & [@chdir ? File.join(@chdir, path) : path]).any?
+          end
+        end
+
+        def _spec_paths_with_chdir
+          _paths_with_chdir(spec_paths, @chdir)
+        end
+
+        def _collect_files(pattern)
+          base_paths = _spec_paths_with_chdir
+          base_paths.map do |path|
+            # TODO: not tested properly
+            Dir[File.join(path, "**{,/*/**}", pattern)]
+          end
+        end
+
+        def _paths_with_chdir(paths, chdir)
+          paths.map do |path|
+            chdir ? File.join(chdir, path) : path
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/guard-rspec-4.7.3/lib/guard/rspec/inspectors/factory.rb

@@ -0,0 +1,23 @@
+require "guard/rspec/inspectors/simple_inspector.rb"
+require "guard/rspec/inspectors/keeping_inspector.rb"
+require "guard/rspec/inspectors/focused_inspector.rb"
+
+module Guard
+  class RSpec < Plugin
+    module Inspectors
+      class Factory
+        class << self
+          def create(options = {})
+            case options[:failed_mode]
+            when :focus  then FocusedInspector.new(options)
+            when :keep   then KeepingInspector.new(options)
+            else; SimpleInspector.new(options)
+            end
+          end
+
+          private :new
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/guard-rspec-4.7.3/lib/guard/rspec/inspectors/focused_inspector.rb

@@ -0,0 +1,39 @@
+require "guard/rspec/inspectors/base_inspector.rb"
+
+module Guard
+  class RSpec < Plugin
+    module Inspectors
+      # Inspector that focuses on set of paths if any of them is failing.
+      # Returns only that set of paths on all future calls to #paths
+      # until they all pass
+      class FocusedInspector < BaseInspector
+        attr_accessor :focused_locations
+
+        def initialize(options = {})
+          super
+          @focused_locations = []
+        end
+
+        def paths(paths)
+          if focused_locations.any?
+            focused_locations
+          else
+            _clean(paths)
+          end
+        end
+
+        def failed(locations)
+          if locations.empty?
+            @focused_locations = []
+          elsif focused_locations.empty?
+            @focused_locations = locations
+          end
+        end
+
+        def reload
+          @focused_locations = []
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/guard-rspec-4.7.3/lib/guard/rspec/inspectors/keeping_inspector.rb

@@ -0,0 +1,97 @@
+require "guard/rspec/inspectors/base_inspector.rb"
+
+module Guard
+  class RSpec < Plugin
+    module Inspectors
+      # Inspector that remembers all failed paths and
+      # returns that paths in future calls to #paths method
+      # along with any new paths passed as parameter to #paths
+      class KeepingInspector < BaseInspector
+        attr_accessor :failed_locations
+
+        def initialize(options = {})
+          super
+          @failed_locations = []
+        end
+
+        def paths(paths)
+          _with_failed_locations(_clean(paths))
+        end
+
+        def failed(locations)
+          @failed_locations = locations
+        end
+
+        def reload
+          @failed_locations = []
+        end
+
+        private
+
+        # Return paths + failed locations.
+        # Do not include location in result if its path is already included.
+        def _with_failed_locations(paths)
+          failed_paths = failed_locations.map { |l| _location_path(l) }
+          (paths | failed_paths).uniq
+        end
+
+        # Extract file path from location
+        def _location_path(location)
+          location.match(%r{^(\./)?(.*?)(:\d+)?$})[2]
+        end
+      end
+    end
+  end
+end
+
+#
+#  FIXME uncomment when RSpec #952 will be resolved
+#
+#  This is correct version of KeepingInspector class,
+#  bit it doesn't work because of bug with RSpec
+#  https://github.com/rspec/rspec-core/issues/952
+#
+# module Guard
+#  class RSpec < Plugin
+#    module Inspectors
+#      # Inspector that remembers all failed paths and
+#      # returns that paths in future calls to #paths method
+#      # along with any new paths passed as parameter to #paths
+#      class KeepingInspector < BaseInspector
+#        attr_accessor :failed_locations
+#
+#        def initialize(options = {})
+#          super
+#          @failed_locations = []
+#        end
+#
+#        def paths(paths)
+#          _with_failed_locations(_clean(paths))
+#        end
+#
+#        def failed(locations)
+#          @failed_locations = locations
+#        end
+#
+#        def reload
+#          @failed_locations = []
+#        end
+#
+#        private
+#
+#        # Return paths + failed locations.
+#        # Do not include location in result if its path is already included.
+#        def _with_failed_locations(paths)
+#          locations = failed_locations.select { |l|
+#          !paths.include?(_location_path(l)) }
+#          paths | locations
+#        end
+#
+#        # Extract file path from location
+#        def _location_path(location)
+#          location.match(/^(\.\/)?(.*?)(:\d+)?$/)[2]
+#        end
+#      end
+#    end
+#  end
+# end

data/vendor/bundle/ruby/3.2.0/gems/guard-rspec-4.7.3/lib/guard/rspec/inspectors/simple_inspector.rb

@@ -0,0 +1,21 @@
+require "guard/rspec/inspectors/base_inspector"
+
+module Guard
+  class RSpec < Plugin
+    module Inspectors
+      class SimpleInspector < BaseInspector
+        def paths(paths)
+          _clean(paths)
+        end
+
+        def failed(_locations)
+          # Don't care
+        end
+
+        def reload
+          # Nothing to reload
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/guard-rspec-4.7.3/lib/guard/rspec/notifier.rb

@@ -0,0 +1,55 @@
+module Guard
+  class RSpec < Plugin
+    class Notifier
+      attr_accessor :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def notify(summary)
+        return unless options[:notification]
+        failure_count, pending_count = _parse_summary(summary)
+        image = _image(failure_count, pending_count)
+        priority = _priority(image)
+        Guard::Compat::UI.notify(summary,
+                                 title: @options[:title],
+                                 image: image,
+                                 priority: priority)
+      end
+
+      def notify_failure
+        return unless options[:notification]
+        Guard::Compat::UI.notify("Failed",
+                                 title: @options[:title],
+                                 image: :failed,
+                                 priority: 2)
+      end
+
+      private
+
+      def _parse_summary(summary)
+        summary.match(/(\d+) failures( \((\d+) pending\))?/) do |m|
+          return m[1].to_i, m[3].to_i
+        end
+        [0, 0]
+      end
+
+      def _image(failure_count, pending_count)
+        if failure_count > 0
+          :failed
+        elsif pending_count > 0
+          :pending
+        else
+          :success
+        end
+      end
+
+      def _priority(image)
+        { failed:   2,
+          pending: -1,
+          success: -2 }[image]
+      end
+    end
+  end
+end