geminfo 0.1.0 → 0.1.1

data/path/gems/rspec-core-3.3.2/lib/rspec/core/configuration_options.rb

@@ -1,191 +0,0 @@
-require 'erb'
-require 'shellwords'
-
-module RSpec
-  module Core
-    # Responsible for utilizing externally provided configuration options,
-    # whether via the command line, `.rspec`, `~/.rspec`, `.rspec-local`
-    # or a custom options file.
-    class ConfigurationOptions
-      # @param args [Array<String>] command line arguments
-      def initialize(args)
-        @args = args.dup
-        organize_options
-      end
-
-      # Updates the provided {Configuration} instance based on the provided
-      # external configuration options.
-      #
-      # @param config [Configuration] the configuration instance to update
-      def configure(config)
-        process_options_into config
-        configure_filter_manager config.filter_manager
-        load_formatters_into config
-      end
-
-      # @api private
-      # Updates the provided {FilterManager} based on the filter options.
-      # @param filter_manager [FilterManager] instance to update
-      def configure_filter_manager(filter_manager)
-        @filter_manager_options.each do |command, value|
-          filter_manager.__send__ command, value
-        end
-      end
-
-      # @return [Hash] the final merged options, drawn from all external sources
-      attr_reader :options
-
-    private
-
-      def organize_options
-        @filter_manager_options = []
-
-        @options = (file_options << command_line_options << env_options).each do |opts|
-          @filter_manager_options << [:include, opts.delete(:inclusion_filter)] if opts.key?(:inclusion_filter)
-          @filter_manager_options << [:exclude, opts.delete(:exclusion_filter)] if opts.key?(:exclusion_filter)
-        end
-
-        @options = @options.inject(:libs => [], :requires => []) do |hash, opts|
-          hash.merge(opts) do |key, oldval, newval|
-            [:libs, :requires].include?(key) ? oldval + newval : newval
-          end
-        end
-      end
-
-      UNFORCED_OPTIONS = Set.new([
-        :requires, :profile, :drb, :libs, :files_or_directories_to_run,
-        :full_description, :full_backtrace, :tty
-      ])
-
-      UNPROCESSABLE_OPTIONS = Set.new([:formatters])
-
-      def force?(key)
-        !UNFORCED_OPTIONS.include?(key)
-      end
-
-      def order(keys)
-        OPTIONS_ORDER.reverse.each do |key|
-          keys.unshift(key) if keys.delete(key)
-        end
-        keys
-      end
-
-      OPTIONS_ORDER = [
-        # It's important to set this before anything that might issue a
-        # deprecation (or otherwise access the reporter).
-        :deprecation_stream,
-
-        # load paths depend on nothing, but must be set before `requires`
-        # to support load-path-relative requires.
-        :libs,
-
-        # `files_or_directories_to_run` uses `default_path` so it must be
-        # set before it.
-        :default_path, :only_failures,
-
-        # These must be set before `requires` to support checking
-        # `config.files_to_run` from within `spec_helper.rb` when a
-        # `-rspec_helper` option is used.
-        :files_or_directories_to_run, :pattern, :exclude_pattern,
-
-        # Necessary so that the `--seed` option is applied before requires,
-        # in case required files do something with the provided seed.
-        # (such as seed global randomization with it).
-        :order,
-
-        # In general, we want to require the specified files as early as
-        # possible. The `--require` option is specifically intended to allow
-        # early requires. For later requires, they can just put the require in
-        # their spec files, but `--require` provides a unique opportunity for
-        # users to instruct RSpec to load an extension file early for maximum
-        # flexibility.
-        :requires
-      ]
-
-      def process_options_into(config)
-        opts = options.reject { |k, _| UNPROCESSABLE_OPTIONS.include? k }
-
-        order(opts.keys).each do |key|
-          force?(key) ? config.force(key => opts[key]) : config.__send__("#{key}=", opts[key])
-        end
-      end
-
-      def load_formatters_into(config)
-        options[:formatters].each { |pair| config.add_formatter(*pair) } if options[:formatters]
-      end
-
-      def file_options
-        custom_options_file ? [custom_options] : [global_options, project_options, local_options]
-      end
-
-      def env_options
-        return {} unless ENV['SPEC_OPTS']
-
-        parse_args_ignoring_files_or_dirs_to_run(
-          Shellwords.split(ENV["SPEC_OPTS"]),
-          "ENV['SPEC_OPTS']"
-        )
-      end
-
-      def command_line_options
-        @command_line_options ||= Parser.parse(@args)
-      end
-
-      def custom_options
-        options_from(custom_options_file)
-      end
-
-      def local_options
-        @local_options ||= options_from(local_options_file)
-      end
-
-      def project_options
-        @project_options ||= options_from(project_options_file)
-      end
-
-      def global_options
-        @global_options ||= options_from(global_options_file)
-      end
-
-      def options_from(path)
-        args = args_from_options_file(path)
-        parse_args_ignoring_files_or_dirs_to_run(args, path)
-      end
-
-      def parse_args_ignoring_files_or_dirs_to_run(args, source)
-        options = Parser.parse(args, source)
-        options.delete(:files_or_directories_to_run)
-        options
-      end
-
-      def args_from_options_file(path)
-        return [] unless path && File.exist?(path)
-        config_string = options_file_as_erb_string(path)
-        FlatMap.flat_map(config_string.split(/\n+/), &:shellsplit)
-      end
-
-      def options_file_as_erb_string(path)
-        ERB.new(File.read(path), nil, '-').result(binding)
-      end
-
-      def custom_options_file
-        command_line_options[:custom_options_file]
-      end
-
-      def project_options_file
-        "./.rspec"
-      end
-
-      def local_options_file
-        "./.rspec-local"
-      end
-
-      def global_options_file
-        File.join(File.expand_path("~"), ".rspec")
-      rescue ArgumentError
-        RSpec.warning "Unable to find ~/.rspec because the HOME environment variable is not set"
-        nil
-      end
-    end
-  end
-end

data/path/gems/rspec-core-3.3.2/lib/rspec/core/drb.rb

@@ -1,111 +0,0 @@
-require 'drb/drb'
-
-module RSpec
-  module Core
-    # @private
-    class DRbRunner
-      def initialize(options, configuration=RSpec.configuration)
-        @options       = options
-        @configuration = configuration
-      end
-
-      def drb_port
-        @options.options[:drb_port] || ENV['RSPEC_DRB'] || 8989
-      end
-
-      def run(err, out)
-        begin
-          DRb.start_service("druby://localhost:0")
-        rescue SocketError, Errno::EADDRNOTAVAIL
-          DRb.start_service("druby://:0")
-        end
-        spec_server = DRbObject.new_with_uri("druby://127.0.0.1:#{drb_port}")
-        spec_server.run(drb_argv, err, out)
-      end
-
-      def drb_argv
-        @drb_argv ||= begin
-          @options.configure_filter_manager(@configuration.filter_manager)
-          DRbOptions.new(@options.options, @configuration.filter_manager).options
-        end
-      end
-    end
-
-    # @private
-    class DRbOptions
-      def initialize(submitted_options, filter_manager)
-        @submitted_options = submitted_options
-        @filter_manager = filter_manager
-      end
-
-      def options
-        argv = []
-        argv << "--color"        if @submitted_options[:color]
-        argv << "--profile"      if @submitted_options[:profile_examples]
-        argv << "--backtrace"    if @submitted_options[:full_backtrace]
-        argv << "--tty"          if @submitted_options[:tty]
-        argv << "--fail-fast"    if @submitted_options[:fail_fast]
-        argv << "--options"      << @submitted_options[:custom_options_file] if @submitted_options[:custom_options_file]
-        argv << "--order"        << @submitted_options[:order]               if @submitted_options[:order]
-
-        add_failure_exit_code(argv)
-        add_full_description(argv)
-        add_filter(argv, :inclusion, @filter_manager.inclusions)
-        add_filter(argv, :exclusion, @filter_manager.exclusions)
-        add_formatters(argv)
-        add_libs(argv)
-        add_requires(argv)
-
-        argv + @submitted_options[:files_or_directories_to_run]
-      end
-
-      def add_failure_exit_code(argv)
-        return unless @submitted_options[:failure_exit_code]
-
-        argv << "--failure-exit-code" << @submitted_options[:failure_exit_code].to_s
-      end
-
-      def add_full_description(argv)
-        return unless @submitted_options[:full_description]
-
-        # The argument to --example is regexp-escaped before being stuffed
-        # into a regexp when received for the first time (see OptionParser).
-        # Hence, merely grabbing the source of this regexp will retain the
-        # backslashes, so we must remove them.
-        @submitted_options[:full_description].each do |description|
-          argv << "--example" << description.source.delete('\\')
-        end
-      end
-
-      CONDITIONAL_FILTERS = [:if, :unless]
-
-      def add_filter(argv, name, hash)
-        hash.each_pair do |k, v|
-          next if CONDITIONAL_FILTERS.include?(k)
-          tag = name == :inclusion ? k.to_s : "~#{k}"
-          tag << ":#{v}" if v.is_a?(String)
-          argv << "--tag" << tag
-        end unless hash.empty?
-      end
-
-      def add_formatters(argv)
-        @submitted_options[:formatters].each do |pair|
-          argv << "--format" << pair[0]
-          argv << "--out" << pair[1] if pair[1]
-        end if @submitted_options[:formatters]
-      end
-
-      def add_libs(argv)
-        @submitted_options[:libs].each do |path|
-          argv << "-I" << path
-        end if @submitted_options[:libs]
-      end
-
-      def add_requires(argv)
-        @submitted_options[:requires].each do |path|
-          argv << "--require" << path
-        end if @submitted_options[:requires]
-      end
-    end
-  end
-end

data/path/gems/rspec-core-3.3.2/lib/rspec/core/dsl.rb

@@ -1,96 +0,0 @@
-module RSpec
-  module Core
-    # DSL defines methods to group examples, most notably `describe`,
-    # and exposes them as class methods of {RSpec}. They can also be
-    # exposed globally (on `main` and instances of `Module`) through
-    # the {Configuration} option `expose_dsl_globally`.
-    #
-    # By default the methods `describe`, `context` and `example_group`
-    # are exposed. These methods define a named context for one or
-    # more examples. The given block is evaluated in the context of
-    # a generated subclass of {RSpec::Core::ExampleGroup}.
-    #
-    # ## Examples:
-    #
-    #     RSpec.describe "something" do
-    #       context "when something is a certain way" do
-    #         it "does something" do
-    #           # example code goes here
-    #         end
-    #       end
-    #     end
-    #
-    # @see ExampleGroup
-    # @see ExampleGroup.example_group
-    module DSL
-      # @private
-      def self.example_group_aliases
-        @example_group_aliases ||= []
-      end
-
-      # @private
-      def self.exposed_globally?
-        @exposed_globally ||= false
-      end
-
-      # @private
-      def self.expose_example_group_alias(name)
-        return if example_group_aliases.include?(name)
-
-        example_group_aliases << name
-
-        (class << RSpec; self; end).__send__(:define_method, name) do |*args, &example_group_block|
-          RSpec.world.register RSpec::Core::ExampleGroup.__send__(name, *args, &example_group_block)
-        end
-
-        expose_example_group_alias_globally(name) if exposed_globally?
-      end
-
-      class << self
-        # @private
-        attr_accessor :top_level
-      end
-
-      # Adds the describe method to Module and the top level binding.
-      # @api private
-      def self.expose_globally!
-        return if exposed_globally?
-
-        example_group_aliases.each do |method_name|
-          expose_example_group_alias_globally(method_name)
-        end
-
-        @exposed_globally = true
-      end
-
-      # Removes the describe method from Module and the top level binding.
-      # @api private
-      def self.remove_globally!
-        return unless exposed_globally?
-
-        example_group_aliases.each do |method_name|
-          change_global_dsl { undef_method method_name }
-        end
-
-        @exposed_globally = false
-      end
-
-      # @private
-      def self.expose_example_group_alias_globally(method_name)
-        change_global_dsl do
-          remove_method(method_name) if method_defined?(method_name)
-          define_method(method_name) { |*a, &b| ::RSpec.__send__(method_name, *a, &b) }
-        end
-      end
-
-      # @private
-      def self.change_global_dsl(&changes)
-        (class << top_level; self; end).class_exec(&changes)
-        Module.class_exec(&changes)
-      end
-    end
-  end
-end
-
-# Capture main without an eval.
-::RSpec::Core::DSL.top_level = self

data/path/gems/rspec-core-3.3.2/lib/rspec/core/example.rb

@@ -1,573 +0,0 @@
-module RSpec
-  module Core
-    # Wrapper for an instance of a subclass of {ExampleGroup}. An instance of
-    # `RSpec::Core::Example` is returned by example definition methods
-    # such as {ExampleGroup.it it} and is yielded to the {ExampleGroup.it it},
-    # {Hooks#before before}, {Hooks#after after}, {Hooks#around around},
-    # {MemoizedHelpers::ClassMethods#let let} and
-    # {MemoizedHelpers::ClassMethods#subject subject} blocks.
-    #
-    # This allows us to provide rich metadata about each individual
-    # example without adding tons of methods directly to the ExampleGroup
-    # that users may inadvertantly redefine.
-    #
-    # Useful for configuring logging and/or taking some action based
-    # on the state of an example's metadata.
-    #
-    # @example
-    #
-    #     RSpec.configure do |config|
-    #       config.before do |example|
-    #         log example.description
-    #       end
-    #
-    #       config.after do |example|
-    #         log example.description
-    #       end
-    #
-    #       config.around do |example|
-    #         log example.description
-    #         example.run
-    #       end
-    #     end
-    #
-    #     shared_examples "auditable" do
-    #       it "does something" do
-    #         log "#{example.full_description}: #{auditable.inspect}"
-    #         auditable.should do_something
-    #       end
-    #     end
-    #
-    # @see ExampleGroup
-    # @note Example blocks are evaluated in the context of an instance
-    #   of an `ExampleGroup`, not in the context of an instance of `Example`.
-    class Example
-      # @private
-      #
-      # Used to define methods that delegate to this example's metadata.
-      def self.delegate_to_metadata(key)
-        define_method(key) { @metadata[key] }
-      end
-
-      # @return [ExecutionResult] represents the result of running this example.
-      delegate_to_metadata :execution_result
-      # @return [String] the relative path to the file where this example was
-      #   defined.
-      delegate_to_metadata :file_path
-      # @return [String] the full description (including the docstrings of
-      #   all parent example groups).
-      delegate_to_metadata :full_description
-      # @return [String] the exact source location of this example in a form
-      #   like `./path/to/spec.rb:17`
-      delegate_to_metadata :location
-      # @return [Boolean] flag that indicates that the example is not expected
-      #   to pass. It will be run and will either have a pending result (if a
-      #   failure occurs) or a failed result (if no failure occurs).
-      delegate_to_metadata :pending
-      # @return [Boolean] flag that will cause the example to not run.
-      #   The {ExecutionResult} status will be `:pending`.
-      delegate_to_metadata :skip
-
-      # Returns the string submitted to `example` or its aliases (e.g.
-      # `specify`, `it`, etc). If no string is submitted (e.g.
-      # `it { is_expected.to do_something }`) it returns the message generated
-      # by the matcher if there is one, otherwise returns a message including
-      # the location of the example.
-      def description
-        description = if metadata[:description].to_s.empty?
-                        location_description
-                      else
-                        metadata[:description]
-                      end
-
-        RSpec.configuration.format_docstrings_block.call(description)
-      end
-
-      # Returns a description of the example that always includes the location.
-      def inspect_output
-        inspect_output = "\"#{description}\""
-        unless metadata[:description].to_s.empty?
-          inspect_output << " (#{location})"
-        end
-        inspect_output
-      end
-
-      # Returns the location-based argument that can be passed to the `rspec` command to rerun this example.
-      def location_rerun_argument
-        @location_rerun_argument ||= begin
-          loaded_spec_files = RSpec.configuration.loaded_spec_files
-
-          Metadata.ascending(metadata) do |meta|
-            return meta[:location] if loaded_spec_files.include?(meta[:absolute_file_path])
-          end
-        end
-      end
-
-      # Returns the location-based argument that can be passed to the `rspec` command to rerun this example.
-      #
-      # @deprecated Use {#location_rerun_argument} instead.
-      # @note If there are multiple examples identified by this location, they will use {#id}
-      #   to rerun instead, but this method will still return the location (that's why it is deprecated!).
-      def rerun_argument
-        location_rerun_argument
-      end
-
-      # @return [String] the unique id of this example. Pass
-      #   this at the command line to re-run this exact example.
-      def id
-        @id ||= Metadata.id_from(metadata)
-      end
-
-      # @attr_reader
-      #
-      # Returns the first exception raised in the context of running this
-      # example (nil if no exception is raised).
-      attr_reader :exception
-
-      # @attr_reader
-      #
-      # Returns the metadata object associated with this example.
-      attr_reader :metadata
-
-      # @attr_reader
-      # @private
-      #
-      # Returns the example_group_instance that provides the context for
-      # running this example.
-      attr_reader :example_group_instance
-
-      # @attr
-      # @private
-      attr_accessor :clock
-
-      # Creates a new instance of Example.
-      # @param example_group_class [Class] the subclass of ExampleGroup in which
-      #   this Example is declared
-      # @param description [String] the String passed to the `it` method (or
-      #   alias)
-      # @param user_metadata [Hash] additional args passed to `it` to be used as
-      #   metadata
-      # @param example_block [Proc] the block of code that represents the
-      #   example
-      # @api private
-      def initialize(example_group_class, description, user_metadata, example_block=nil)
-        @example_group_class = example_group_class
-        @example_block       = example_block
-
-        @metadata = Metadata::ExampleHash.create(
-          @example_group_class.metadata, user_metadata,
-          example_group_class.method(:next_runnable_index_for),
-          description, example_block
-        )
-
-        # This should perhaps be done in `Metadata::ExampleHash.create`,
-        # but the logic there has no knowledge of `RSpec.world` and we
-        # want to keep it that way. It's easier to just assign it here.
-        @metadata[:last_run_status] = RSpec.configuration.last_run_statuses[id]
-
-        @example_group_instance = @exception = nil
-        @clock = RSpec::Core::Time
-        @reporter = RSpec::Core::NullReporter
-      end
-
-      # @return [RSpec::Core::Reporter] the current reporter for the example
-      attr_reader :reporter
-
-      # Returns the example group class that provides the context for running
-      # this example.
-      def example_group
-        @example_group_class
-      end
-
-      alias_method :pending?, :pending
-      alias_method :skipped?, :skip
-
-      # @api private
-      # instance_execs the block passed to the constructor in the context of
-      # the instance of {ExampleGroup}.
-      # @param example_group_instance the instance of an ExampleGroup subclass
-      def run(example_group_instance, reporter)
-        @example_group_instance = example_group_instance
-        @reporter = reporter
-        hooks.register_global_singleton_context_hooks(self, RSpec.configuration.hooks)
-        RSpec.configuration.configure_example(self)
-        RSpec.current_example = self
-
-        start(reporter)
-        Pending.mark_pending!(self, pending) if pending?
-
-        begin
-          if skipped?
-            Pending.mark_pending! self, skip
-          elsif !RSpec.configuration.dry_run?
-            with_around_and_singleton_context_hooks do
-              begin
-                run_before_example
-                @example_group_instance.instance_exec(self, &@example_block)
-
-                if pending?
-                  Pending.mark_fixed! self
-
-                  raise Pending::PendingExampleFixedError,
-                        'Expected example to fail since it is pending, but it passed.',
-                        [location]
-                end
-              rescue Pending::SkipDeclaredInExample
-                # no-op, required metadata has already been set by the `skip`
-                # method.
-              rescue Exception => e
-                set_exception(e)
-              ensure
-                run_after_example
-              end
-            end
-          end
-        rescue Exception => e
-          set_exception(e)
-        ensure
-          @example_group_instance = nil # if you love something... let it go
-        end
-
-        finish(reporter)
-      ensure
-        RSpec.current_example = nil
-      end
-
-      # Wraps both a `Proc` and an {Example} for use in {Hooks#around
-      # around} hooks. In around hooks we need to yield this special
-      # kind of object (rather than the raw {Example}) because when
-      # there are multiple `around` hooks we have to wrap them recursively.
-      #
-      # @example
-      #
-      #     RSpec.configure do |c|
-      #       c.around do |ex| # Procsy which wraps the example
-      #         if ex.metadata[:key] == :some_value && some_global_condition
-      #           raise "some message"
-      #         end
-      #         ex.run         # run delegates to ex.call.
-      #       end
-      #     end
-      #
-      # @note This class also exposes the instance methods of {Example},
-      #   proxying them through to the wrapped {Example} instance.
-      class Procsy
-        # The {Example} instance.
-        attr_reader :example
-
-        Example.public_instance_methods(false).each do |name|
-          next if name.to_sym == :run || name.to_sym == :inspect
-
-          define_method(name) { |*a, &b| @example.__send__(name, *a, &b) }
-        end
-
-        Proc.public_instance_methods(false).each do |name|
-          next if name.to_sym == :call || name.to_sym == :inspect || name.to_sym == :to_proc
-
-          define_method(name) { |*a, &b| @proc.__send__(name, *a, &b) }
-        end
-
-        # Calls the proc and notes that the example has been executed.
-        def call(*args, &block)
-          @executed = true
-          @proc.call(*args, &block)
-        end
-        alias run call
-
-        # Provides a wrapped proc that will update our `executed?` state when
-        # executed.
-        def to_proc
-          method(:call).to_proc
-        end
-
-        def initialize(example, &block)
-          @example  = example
-          @proc     = block
-          @executed = false
-        end
-
-        # @private
-        def wrap(&block)
-          self.class.new(example, &block)
-        end
-
-        # Indicates whether or not the around hook has executed the example.
-        def executed?
-          @executed
-        end
-
-        # @private
-        def inspect
-          @example.inspect.gsub('Example', 'ExampleProcsy')
-        end
-      end
-
-      # @private
-      #
-      # The exception that will be displayed to the user -- either the failure of
-      # the example or the `pending_exception` if the example is pending.
-      def display_exception
-        @exception || execution_result.pending_exception
-      end
-
-      # @private
-      #
-      # Assigns the exception that will be displayed to the user -- either the failure of
-      # the example or the `pending_exception` if the example is pending.
-      def display_exception=(ex)
-        if pending? && !(Pending::PendingExampleFixedError === ex)
-          @exception = nil
-          execution_result.pending_fixed = false
-          execution_result.pending_exception = ex
-        else
-          @exception = ex
-        end
-      end
-
-      # rubocop:disable Style/AccessorMethodName
-
-      # @private
-      #
-      # Used internally to set an exception in an after hook, which
-      # captures the exception but doesn't raise it.
-      def set_exception(exception)
-        return self.display_exception = exception unless display_exception
-
-        unless RSpec::Core::MultipleExceptionError === display_exception
-          self.display_exception = RSpec::Core::MultipleExceptionError.new(display_exception)
-        end
-
-        display_exception.add exception
-      end
-
-      # @private
-      #
-      # Used to set the exception when `aggregate_failures` fails.
-      def set_aggregate_failures_exception(exception)
-        return set_exception(exception) unless display_exception
-
-        exception = RSpec::Core::MultipleExceptionError::InterfaceTag.for(exception)
-        exception.add display_exception
-        self.display_exception = exception
-      end
-
-      # rubocop:enable Style/AccessorMethodName
-
-      # @private
-      #
-      # Used internally to set an exception and fail without actually executing
-      # the example when an exception is raised in before(:context).
-      def fail_with_exception(reporter, exception)
-        start(reporter)
-        set_exception(exception)
-        finish(reporter)
-      end
-
-      # @private
-      #
-      # Used internally to skip without actually executing the example when
-      # skip is used in before(:context).
-      def skip_with_exception(reporter, exception)
-        start(reporter)
-        Pending.mark_skipped! self, exception.argument
-        finish(reporter)
-      end
-
-      # @private
-      def instance_exec(*args, &block)
-        @example_group_instance.instance_exec(*args, &block)
-      end
-
-    private
-
-      def hooks
-        example_group_instance.singleton_class.hooks
-      end
-
-      def with_around_example_hooks
-        hooks.run(:around, :example, self) { yield }
-      rescue Exception => e
-        set_exception(e)
-      end
-
-      def start(reporter)
-        reporter.example_started(self)
-        execution_result.started_at = clock.now
-      end
-
-      def finish(reporter)
-        pending_message = execution_result.pending_message
-
-        if @exception
-          record_finished :failed
-          execution_result.exception = @exception
-          reporter.example_failed self
-          false
-        elsif pending_message
-          record_finished :pending
-          execution_result.pending_message = pending_message
-          reporter.example_pending self
-          true
-        else
-          record_finished :passed
-          reporter.example_passed self
-          true
-        end
-      end
-
-      def record_finished(status)
-        execution_result.record_finished(status, clock.now)
-      end
-
-      def run_before_example
-        @example_group_instance.setup_mocks_for_rspec
-        hooks.run(:before, :example, self)
-      end
-
-      def with_around_and_singleton_context_hooks
-        singleton_context_hooks_host = example_group_instance.singleton_class
-        singleton_context_hooks_host.run_before_context_hooks(example_group_instance)
-        with_around_example_hooks { yield }
-      ensure
-        singleton_context_hooks_host.run_after_context_hooks(example_group_instance)
-      end
-
-      def run_after_example
-        assign_generated_description if defined?(::RSpec::Matchers)
-        hooks.run(:after, :example, self)
-        verify_mocks
-      ensure
-        @example_group_instance.teardown_mocks_for_rspec
-      end
-
-      def verify_mocks
-        @example_group_instance.verify_mocks_for_rspec if mocks_need_verification?
-      rescue Exception => e
-        set_exception(e)
-      end
-
-      def mocks_need_verification?
-        exception.nil? || execution_result.pending_fixed?
-      end
-
-      def assign_generated_description
-        if metadata[:description].empty? && (description = generate_description)
-          metadata[:description] = description
-          metadata[:full_description] << description
-        end
-      ensure
-        RSpec::Matchers.clear_generated_description
-      end
-
-      def generate_description
-        RSpec::Matchers.generated_description
-      rescue Exception => e
-        location_description + " (Got an error when generating description " \
-          "from matcher: #{e.class}: #{e.message} -- #{e.backtrace.first})"
-      end
-
-      def location_description
-        "example at #{location}"
-      end
-
-      # Represents the result of executing an example.
-      # Behaves like a hash for backwards compatibility.
-      class ExecutionResult
-        include HashImitatable
-
-        # @return [Symbol] `:passed`, `:failed` or `:pending`.
-        attr_accessor :status
-
-        # @return [Exception, nil] The failure, if there was one.
-        attr_accessor :exception
-
-        # @return [Time] When the example started.
-        attr_accessor :started_at
-
-        # @return [Time] When the example finished.
-        attr_accessor :finished_at
-
-        # @return [Float] How long the example took in seconds.
-        attr_accessor :run_time
-
-        # @return [String, nil] The reason the example was pending,
-        #   or nil if the example was not pending.
-        attr_accessor :pending_message
-
-        # @return [Exception, nil] The exception triggered while
-        #   executing the pending example. If no exception was triggered
-        #   it would no longer get a status of `:pending` unless it was
-        #   tagged with `:skip`.
-        attr_accessor :pending_exception
-
-        # @return [Boolean] For examples tagged with `:pending`,
-        #   this indicates whether or not it now passes.
-        attr_accessor :pending_fixed
-
-        alias pending_fixed? pending_fixed
-
-        # @return [Boolean] Indicates if the example was completely skipped
-        #   (typically done via `:skip` metadata or the `skip` method). Skipped examples
-        #   will have a `:pending` result. A `:pending` result can also come from examples
-        #   that were marked as `:pending`, which causes them to be run, and produces a
-        #   `:failed` result if the example passes.
-        def example_skipped?
-          status == :pending && !pending_exception
-        end
-
-        # @api private
-        # Records the finished status of the example.
-        def record_finished(status, finished_at)
-          self.status      = status
-          self.finished_at = finished_at
-          self.run_time    = (finished_at - started_at).to_f
-        end
-
-      private
-
-        # For backwards compatibility we present `status` as a string
-        # when presenting the legacy hash interface.
-        def hash_for_delegation
-          super.tap do |hash|
-            hash[:status] &&= status.to_s
-          end
-        end
-
-        def set_value(name, value)
-          value &&= value.to_sym if name == :status
-          super(name, value)
-        end
-
-        def get_value(name)
-          if name == :status
-            status.to_s if status
-          else
-            super
-          end
-        end
-
-        def issue_deprecation(_method_name, *_args)
-          RSpec.deprecate("Treating `metadata[:execution_result]` as a hash",
-                          :replacement => "the attributes methods to access the data")
-        end
-      end
-    end
-
-    # @private
-    # Provides an execution context for before/after :suite hooks.
-    class SuiteHookContext < Example
-      def initialize
-        super(AnonymousExampleGroup, "", {})
-        @example_group_instance = AnonymousExampleGroup.new
-      end
-
-      # rubocop:disable Style/AccessorMethodName
-
-      # To ensure we don't silence errors.
-      def set_exception(exception)
-        raise exception
-      end
-      # rubocop:enable Style/AccessorMethodName
-    end
-  end
-end