spec_fill 0.1.0

data/vendor/bundle/ruby/2.6.0/gems/rspec-core-3.9.0/lib/rspec/core/runner.rb

@@ -0,0 +1,204 @@
+module RSpec
+  module Core
+    # Provides the main entry point to run a suite of RSpec examples.
+    class Runner
+      # @attr_reader
+      # @private
+      attr_reader :options, :configuration, :world
+
+      # Register an `at_exit` hook that runs the suite when the process exits.
+      #
+      # @note This is not generally needed. The `rspec` command takes care
+      #       of running examples for you without involving an `at_exit`
+      #       hook. This is only needed if you are running specs using
+      #       the `ruby` command, and even then, the normal way to invoke
+      #       this is by requiring `rspec/autorun`.
+      def self.autorun
+        if autorun_disabled?
+          RSpec.deprecate("Requiring `rspec/autorun` when running RSpec via the `rspec` command")
+          return
+        elsif installed_at_exit? || running_in_drb?
+          return
+        end
+
+        at_exit { perform_at_exit }
+        @installed_at_exit = true
+      end
+
+      # @private
+      def self.perform_at_exit
+        # Don't bother running any specs and just let the program terminate
+        # if we got here due to an unrescued exception (anything other than
+        # SystemExit, which is raised when somebody calls Kernel#exit).
+        return unless $!.nil? || $!.is_a?(SystemExit)
+
+        # We got here because either the end of the program was reached or
+        # somebody called Kernel#exit. Run the specs and then override any
+        # existing exit status with RSpec's exit status if any specs failed.
+        invoke
+      end
+
+      # Runs the suite of specs and exits the process with an appropriate exit
+      # code.
+      def self.invoke
+        disable_autorun!
+        status = run(ARGV, $stderr, $stdout).to_i
+        exit(status) if status != 0
+      end
+
+      # Run a suite of RSpec examples. Does not exit.
+      #
+      # This is used internally by RSpec to run a suite, but is available
+      # for use by any other automation tool.
+      #
+      # If you want to run this multiple times in the same process, and you
+      # want files like `spec_helper.rb` to be reloaded, be sure to load `load`
+      # instead of `require`.
+      #
+      # @param args [Array] command-line-supported arguments
+      # @param err [IO] error stream
+      # @param out [IO] output stream
+      # @return [Fixnum] exit status code. 0 if all specs passed,
+      #   or the configured failure exit code (1 by default) if specs
+      #   failed.
+      def self.run(args, err=$stderr, out=$stdout)
+        trap_interrupt
+        options = ConfigurationOptions.new(args)
+
+        if options.options[:runner]
+          options.options[:runner].call(options, err, out)
+        else
+          new(options).run(err, out)
+        end
+      end
+
+      def initialize(options, configuration=RSpec.configuration, world=RSpec.world)
+        @options       = options
+        @configuration = configuration
+        @world         = world
+      end
+
+      # Configures and runs a spec suite.
+      #
+      # @param err [IO] error stream
+      # @param out [IO] output stream
+      def run(err, out)
+        setup(err, out)
+        return @configuration.reporter.exit_early(@configuration.failure_exit_code) if RSpec.world.wants_to_quit
+
+        run_specs(@world.ordered_example_groups).tap do
+          persist_example_statuses
+        end
+      end
+
+      # Wires together the various configuration objects and state holders.
+      #
+      # @param err [IO] error stream
+      # @param out [IO] output stream
+      def setup(err, out)
+        configure(err, out)
+        return if RSpec.world.wants_to_quit
+
+        @configuration.load_spec_files
+      ensure
+        @world.announce_filters
+      end
+
+      # Runs the provided example groups.
+      #
+      # @param example_groups [Array<RSpec::Core::ExampleGroup>] groups to run
+      # @return [Fixnum] exit status code. 0 if all specs passed,
+      #   or the configured failure exit code (1 by default) if specs
+      #   failed.
+      def run_specs(example_groups)
+        examples_count = @world.example_count(example_groups)
+        success = @configuration.reporter.report(examples_count) do |reporter|
+          @configuration.with_suite_hooks do
+            if examples_count == 0 && @configuration.fail_if_no_examples
+              return @configuration.failure_exit_code
+            end
+
+            example_groups.map { |g| g.run(reporter) }.all?
+          end
+        end && !@world.non_example_failure
+
+        success ? 0 : @configuration.failure_exit_code
+      end
+
+      # @private
+      def configure(err, out)
+        @configuration.error_stream = err
+        @configuration.output_stream = out if @configuration.output_stream == $stdout
+        @options.configure(@configuration)
+      end
+
+      # @private
+      def self.disable_autorun!
+        @autorun_disabled = true
+      end
+
+      # @private
+      def self.autorun_disabled?
+        @autorun_disabled ||= false
+      end
+
+      # @private
+      def self.installed_at_exit?
+        @installed_at_exit ||= false
+      end
+
+      # @private
+      def self.running_in_drb?
+        return false unless defined?(DRb)
+
+        server = begin
+                   DRb.current_server
+                 rescue DRb::DRbServerNotFound
+                   return false
+                 end
+
+        return false unless server && server.alive?
+
+        require 'socket'
+        require 'uri'
+
+        local_ipv4 = begin
+                       IPSocket.getaddress(Socket.gethostname)
+                     rescue SocketError
+                       return false
+                     end
+
+        ["127.0.0.1", "localhost", local_ipv4].any? { |addr| addr == URI(DRb.current_server.uri).host }
+      end
+
+      # @private
+      def self.trap_interrupt
+        trap('INT') { handle_interrupt }
+      end
+
+      # @private
+      def self.handle_interrupt
+        if RSpec.world.wants_to_quit
+          exit!(1)
+        else
+          RSpec.world.wants_to_quit = true
+          $stderr.puts "\nRSpec is shutting down and will print the summary report... Interrupt again to force quit."
+        end
+      end
+
+    private
+
+      def persist_example_statuses
+        return if @configuration.dry_run
+        return unless (path = @configuration.example_status_persistence_file_path)
+
+        ExampleStatusPersister.persist(@world.all_examples, path)
+      rescue SystemCallError => e
+        RSpec.warning "Could not write example statuses to #{path} (configured as " \
+                      "`config.example_status_persistence_file_path`) due to a " \
+                      "system error: #{e.inspect}. Please check that the config " \
+                      "option is set to an accessible, valid file path", :call_site => nil
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-core-3.9.0/lib/rspec/core/sandbox.rb

@@ -0,0 +1,37 @@
+module RSpec
+  module Core
+    # A sandbox isolates the enclosed code into an environment that looks 'new'
+    # meaning globally accessed objects are reset for the duration of the
+    # sandbox.
+    #
+    # @note This module is not normally available. You must require
+    #   `rspec/core/sandbox` to load it.
+    module Sandbox
+      # Execute a provided block with RSpec global objects (configuration,
+      # world) reset.  This is used to test RSpec with RSpec.
+      #
+      # When calling this the configuration is passed into the provided block.
+      # Use this to set custom configs for your sandboxed examples.
+      #
+      # ```
+      # Sandbox.sandboxed do |config|
+      #   config.before(:context) { RSpec.current_example = nil }
+      # end
+      # ```
+      def self.sandboxed
+        orig_config  = RSpec.configuration
+        orig_world   = RSpec.world
+        orig_example = RSpec.current_example
+
+        RSpec.configuration = RSpec::Core::Configuration.new
+        RSpec.world         = RSpec::Core::World.new(RSpec.configuration)
+
+        yield RSpec.configuration
+      ensure
+        RSpec.configuration   = orig_config
+        RSpec.world           = orig_world
+        RSpec.current_example = orig_example
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-core-3.9.0/lib/rspec/core/set.rb

@@ -0,0 +1,54 @@
+module RSpec
+  module Core
+    # @private
+    #
+    # We use this to replace `::Set` so we can have the advantage of
+    # constant time key lookups for unique arrays but without the
+    # potential to pollute a developers environment with an extra
+    # piece of the stdlib. This helps to prevent false positive
+    # builds.
+    #
+    class Set
+      include Enumerable
+
+      def initialize(array=[])
+        @values = {}
+        merge(array)
+      end
+
+      def empty?
+        @values.empty?
+      end
+
+      def <<(key)
+        @values[key] = true
+        self
+      end
+
+      def delete(key)
+        @values.delete(key)
+      end
+
+      def each(&block)
+        @values.keys.each(&block)
+        self
+      end
+
+      def include?(key)
+        @values.key?(key)
+      end
+
+      def merge(values)
+        values.each do |key|
+          @values[key] = true
+        end
+        self
+      end
+
+      def clear
+        @values.clear
+        self
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-core-3.9.0/lib/rspec/core/shared_context.rb

@@ -0,0 +1,55 @@
+module RSpec
+  module Core
+    # Exposes {ExampleGroup}-level methods to a module, so you can include that
+    # module in an {ExampleGroup}.
+    #
+    # @example
+    #
+    #     module LoggedInAsAdmin
+    #       extend RSpec::Core::SharedContext
+    #       before(:example) do
+    #         log_in_as :admin
+    #       end
+    #     end
+    #
+    #     describe "admin section" do
+    #       include LoggedInAsAdmin
+    #       # ...
+    #     end
+    module SharedContext
+      # @private
+      def included(group)
+        __shared_context_recordings.each do |recording|
+          recording.playback_onto(group)
+        end
+      end
+
+      # @private
+      def __shared_context_recordings
+        @__shared_context_recordings ||= []
+      end
+
+      # @private
+      Recording = Struct.new(:method_name, :args, :block) do
+        def playback_onto(group)
+          group.__send__(method_name, *args, &block)
+        end
+      end
+
+      # @private
+      def self.record(methods)
+        methods.each do |meth|
+          define_method(meth) do |*args, &block|
+            __shared_context_recordings << Recording.new(meth, args, block)
+          end
+        end
+      end
+
+      # @private
+      record [:describe, :context] + Hooks.instance_methods(false) +
+        MemoizedHelpers::ClassMethods.instance_methods(false)
+    end
+  end
+  # @private
+  SharedContext = Core::SharedContext
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-core-3.9.0/lib/rspec/core/shared_example_group.rb

@@ -0,0 +1,269 @@
+module RSpec
+  module Core
+    # Represents some functionality that is shared with multiple example groups.
+    # The functionality is defined by the provided block, which is lazily
+    # eval'd when the `SharedExampleGroupModule` instance is included in an example
+    # group.
+    class SharedExampleGroupModule < Module
+      # @private
+      attr_reader :definition
+
+      def initialize(description, definition, metadata)
+        @description = description
+        @definition  = definition
+        @metadata    = metadata
+      end
+
+      # Provides a human-readable representation of this module.
+      def inspect
+        "#<#{self.class.name} #{@description.inspect}>"
+      end
+      alias to_s inspect
+
+      # Ruby callback for when a module is included in another module is class.
+      # Our definition evaluates the shared group block in the context of the
+      # including example group.
+      def included(klass)
+        inclusion_line = klass.metadata[:location]
+        include_in klass, inclusion_line, [], nil
+      end
+
+      # @private
+      def include_in(klass, inclusion_line, args, customization_block)
+        klass.update_inherited_metadata(@metadata) unless @metadata.empty?
+
+        SharedExampleGroupInclusionStackFrame.with_frame(@description, inclusion_line) do
+          klass.class_exec(*args, &@definition)
+          klass.class_exec(&customization_block) if customization_block
+        end
+      end
+    end
+
+    # Shared example groups let you define common context and/or common
+    # examples that you wish to use in multiple example groups.
+    #
+    # When defined, the shared group block is stored for later evaluation.
+    # It can later be included in an example group either explicitly
+    # (using `include_examples`, `include_context` or `it_behaves_like`)
+    # or implicitly (via matching metadata).
+    #
+    # Named shared example groups are scoped based on where they are
+    # defined. Shared groups defined in an example group are available
+    # for inclusion in that example group or any child example groups,
+    # but not in any parent or sibling example groups. Shared example
+    # groups defined at the top level can be included from any example group.
+    module SharedExampleGroup
+      # @overload shared_examples(name, &block)
+      #   @param name [String, Symbol, Module] identifer to use when looking up
+      #     this shared group
+      #   @param block The block to be eval'd
+      # @overload shared_examples(name, metadata, &block)
+      #   @param name [String, Symbol, Module] identifer to use when looking up
+      #     this shared group
+      #   @param metadata [Array<Symbol>, Hash] metadata to attach to this
+      #     group; any example group or example with matching metadata will
+      #     automatically include this shared example group.
+      #   @param block The block to be eval'd
+      #
+      # Stores the block for later use. The block will be evaluated
+      # in the context of an example group via `include_examples`,
+      # `include_context`, or `it_behaves_like`.
+      #
+      # @example
+      #   shared_examples "auditable" do
+      #     it "stores an audit record on save!" do
+      #       expect { auditable.save! }.to change(Audit, :count).by(1)
+      #     end
+      #   end
+      #
+      #   RSpec.describe Account do
+      #     it_behaves_like "auditable" do
+      #       let(:auditable) { Account.new }
+      #     end
+      #   end
+      #
+      # @see ExampleGroup.it_behaves_like
+      # @see ExampleGroup.include_examples
+      # @see ExampleGroup.include_context
+      def shared_examples(name, *args, &block)
+        top_level = self == ExampleGroup
+        if top_level && RSpec::Support.thread_local_data[:in_example_group]
+          raise "Creating isolated shared examples from within a context is " \
+                "not allowed. Remove `RSpec.` prefix or move this to a " \
+                "top-level scope."
+        end
+
+        RSpec.world.shared_example_group_registry.add(self, name, *args, &block)
+      end
+      alias shared_context      shared_examples
+      alias shared_examples_for shared_examples
+
+      # @api private
+      #
+      # Shared examples top level DSL.
+      module TopLevelDSL
+        # @private
+        def self.definitions
+          proc do
+            def shared_examples(name, *args, &block)
+              RSpec.world.shared_example_group_registry.add(:main, name, *args, &block)
+            end
+            alias shared_context      shared_examples
+            alias shared_examples_for shared_examples
+          end
+        end
+
+        # @private
+        def self.exposed_globally?
+          @exposed_globally ||= false
+        end
+
+        # @api private
+        #
+        # Adds the top level DSL methods to Module and the top level binding.
+        def self.expose_globally!
+          return if exposed_globally?
+          Core::DSL.change_global_dsl(&definitions)
+          @exposed_globally = true
+        end
+
+        # @api private
+        #
+        # Removes the top level DSL methods to Module and the top level binding.
+        def self.remove_globally!
+          return unless exposed_globally?
+
+          Core::DSL.change_global_dsl do
+            undef shared_examples
+            undef shared_context
+            undef shared_examples_for
+          end
+
+          @exposed_globally = false
+        end
+      end
+
+      # @private
+      class Registry
+        def add(context, name, *metadata_args, &block)
+          unless block
+            RSpec.warning "Shared example group #{name} was defined without a "\
+                          "block and will have no effect. Please define a "\
+                          "block or remove the definition."
+          end
+
+          if RSpec.configuration.shared_context_metadata_behavior == :trigger_inclusion
+            return legacy_add(context, name, *metadata_args, &block)
+          end
+
+          unless valid_name?(name)
+            raise ArgumentError, "Shared example group names can only be a string, " \
+                                 "symbol or module but got: #{name.inspect}"
+          end
+
+          ensure_block_has_source_location(block) { CallerFilter.first_non_rspec_line }
+          warn_if_key_taken context, name, block
+
+          metadata = Metadata.build_hash_from(metadata_args)
+          shared_module = SharedExampleGroupModule.new(name, block, metadata)
+          shared_example_groups[context][name] = shared_module
+        end
+
+        def find(lookup_contexts, name)
+          lookup_contexts.each do |context|
+            found = shared_example_groups[context][name]
+            return found if found
+          end
+
+          shared_example_groups[:main][name]
+        end
+
+      private
+
+        # TODO: remove this in RSpec 4. This exists only to support
+        # `config.shared_context_metadata_behavior == :trigger_inclusion`,
+        # the legacy behavior of shared context metadata, which we do
+        # not want to support in RSpec 4.
+        def legacy_add(context, name, *metadata_args, &block)
+          ensure_block_has_source_location(block) { CallerFilter.first_non_rspec_line }
+          shared_module = SharedExampleGroupModule.new(name, block, {})
+
+          if valid_name?(name)
+            warn_if_key_taken context, name, block
+            shared_example_groups[context][name] = shared_module
+          else
+            metadata_args.unshift name
+          end
+
+          return if metadata_args.empty?
+          RSpec.configuration.include shared_module, *metadata_args
+        end
+
+        def shared_example_groups
+          @shared_example_groups ||= Hash.new { |hash, context| hash[context] = {} }
+        end
+
+        def valid_name?(candidate)
+          case candidate
+          when String, Symbol, Module then true
+          else false
+          end
+        end
+
+        def warn_if_key_taken(context, key, new_block)
+          existing_module = shared_example_groups[context][key]
+          return unless existing_module
+
+          old_definition_location = formatted_location existing_module.definition
+          new_definition_location = formatted_location new_block
+          loaded_spec_files = RSpec.configuration.loaded_spec_files
+
+          if loaded_spec_files.include?(new_definition_location) && old_definition_location == new_definition_location
+            RSpec.warn_with <<-WARNING.gsub(/^ +\|/, ''), :call_site => nil
+              |WARNING: Your shared example group, '#{key}', defined at:
+              | #{old_definition_location}
+              |was automatically loaded by RSpec because the file name
+              |matches the configured autoloading pattern (#{RSpec.configuration.pattern}),
+              |and is also being required from somewhere else. To fix this
+              |warning, either rename the file to not match the pattern, or
+              |do not explicitly require the file.
+            WARNING
+          else
+            RSpec.warn_with <<-WARNING.gsub(/^ +\|/, ''), :call_site => nil
+              |WARNING: Shared example group '#{key}' has been previously defined at:
+              |  #{old_definition_location}
+              |...and you are now defining it at:
+              |  #{new_definition_location}
+              |The new definition will overwrite the original one.
+            WARNING
+          end
+        end
+
+        if RUBY_VERSION.to_f >= 1.9
+          def formatted_location(block)
+            block.source_location.join(":")
+          end
+        else # 1.8.7
+          # :nocov:
+          def formatted_location(block)
+            block.source_location.join(":").gsub(/:in.*$/, '')
+          end
+          # :nocov:
+        end
+
+        if Proc.method_defined?(:source_location)
+          def ensure_block_has_source_location(_block); end
+        else # for 1.8.7
+          # :nocov:
+          def ensure_block_has_source_location(block)
+            source_location = yield.split(':')
+            block.extend(Module.new { define_method(:source_location) { source_location } })
+          end
+          # :nocov:
+        end
+      end
+    end
+  end
+
+  instance_exec(&Core::SharedExampleGroup::TopLevelDSL.definitions)
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-core-3.9.0/lib/rspec/core/shell_escape.rb

@@ -0,0 +1,49 @@
+module RSpec
+  module Core
+    # @private
+    # Deals with the fact that `shellwords` only works on POSIX systems.
+    module ShellEscape
+      module_function
+
+      def quote(argument)
+        "'#{argument.to_s.gsub("'", "\\\\'")}'"
+      end
+
+      if RSpec::Support::OS.windows?
+        # :nocov:
+        alias escape quote
+        # :nocov:
+      else
+        require 'shellwords'
+
+        def escape(shell_command)
+          Shellwords.escape(shell_command.to_s)
+        end
+      end
+
+      # Known shells that require quoting: zsh, csh, tcsh.
+      #
+      # Feel free to add other shells to this list that are known to
+      # allow `rspec ./some_spec.rb[1:1]` syntax without quoting the id.
+      #
+      # @private
+      SHELLS_ALLOWING_UNQUOTED_IDS = %w[ bash ksh fish ]
+
+      def conditionally_quote(id)
+        return id if shell_allows_unquoted_ids?
+        quote(id)
+      end
+
+      def shell_allows_unquoted_ids?
+        # Note: ENV['SHELL'] isn't necessarily the shell the user is currently running.
+        # According to http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap08.html:
+        # "This variable shall represent a pathname of the user's preferred command language interpreter."
+        #
+        # It's the best we can easily do, though. We err on the side of safety (quoting
+        # the id when not actually needed) so it's not a big deal if the user is actually
+        # using a different shell.
+        SHELLS_ALLOWING_UNQUOTED_IDS.include?(ENV['SHELL'].to_s.split('/').last)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-core-3.9.0/lib/rspec/core/test_unit_assertions_adapter.rb

@@ -0,0 +1,30 @@
+require 'test/unit/assertions'
+
+module RSpec
+  module Core
+    # @private
+    module TestUnitAssertionsAdapter
+      include ::Test::Unit::Assertions
+
+      # If using test/unit from Ruby core with Ruby 1.9+, it includes
+      # MiniTest::Assertions by default. Note the upcasing of 'Test'.
+      #
+      # If the test/unit gem is being loaded, it will not include any minitest
+      # assertions.
+      #
+      # Only if Minitest 5.x is included / loaded do we need to worry about
+      # adding a shim for the new updates. Thus instead of checking on the
+      # RUBY_VERSION we need to check ancestors.
+      begin
+        # MiniTest is 4.x.
+        # Minitest is 5.x.
+        if ancestors.include?(::Minitest::Assertions)
+          require 'rspec/core/minitest_assertions_adapter'
+          include ::RSpec::Core::MinitestAssertionsAdapter
+        end
+      rescue NameError
+        # No-op. Minitest 5.x was not loaded.
+      end
+    end
+  end
+end