genkaio 0.0.1 → 0.0.2

data/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.9.0/lib/rspec/core/metadata_filter.rb

@@ -0,0 +1,255 @@
+module RSpec
+  module Core
+    # Contains metadata filtering logic. This has been extracted from
+    # the metadata classes because it operates ON a metadata hash but
+    # does not manage any of the state in the hash. We're moving towards
+    # having metadata be a raw hash (not a custom subclass), so externalizing
+    # this filtering logic helps us move in that direction.
+    module MetadataFilter
+      class << self
+        # @private
+        def apply?(predicate, filters, metadata)
+          filters.__send__(predicate) { |k, v| filter_applies?(k, v, metadata) }
+        end
+
+        # @private
+        def filter_applies?(key, filter_value, metadata)
+          silence_metadata_example_group_deprecations do
+            return location_filter_applies?(filter_value, metadata) if key == :locations
+            return id_filter_applies?(filter_value, metadata)       if key == :ids
+            return filters_apply?(key, filter_value, metadata)      if Hash === filter_value
+
+            meta_value = metadata.fetch(key) { return false }
+
+            return true if TrueClass === filter_value && meta_value
+            return proc_filter_applies?(key, filter_value, metadata) if Proc === filter_value
+            return filter_applies_to_any_value?(key, filter_value, metadata) if Array === meta_value
+
+            filter_value === meta_value || filter_value.to_s == meta_value.to_s
+          end
+        end
+
+        # @private
+        def silence_metadata_example_group_deprecations
+          RSpec::Support.thread_local_data[:silence_metadata_example_group_deprecations] = true
+          yield
+        ensure
+          RSpec::Support.thread_local_data.delete(:silence_metadata_example_group_deprecations)
+        end
+
+      private
+
+        def filter_applies_to_any_value?(key, value, metadata)
+          metadata[key].any? { |v| filter_applies?(key, v,  key => value) }
+        end
+
+        def id_filter_applies?(rerun_paths_to_scoped_ids, metadata)
+          scoped_ids = rerun_paths_to_scoped_ids.fetch(metadata[:rerun_file_path]) { return false }
+
+          Metadata.ascend(metadata).any? do |meta|
+            scoped_ids.include?(meta[:scoped_id])
+          end
+        end
+
+        def location_filter_applies?(locations, metadata)
+          Metadata.ascend(metadata).any? do |meta|
+            file_path = meta[:absolute_file_path]
+            line_num  = meta[:line_number]
+
+            locations[file_path].any? do |filter_line_num|
+              line_num == RSpec.world.preceding_declaration_line(file_path, filter_line_num)
+            end
+          end
+        end
+
+        def proc_filter_applies?(key, proc, metadata)
+          case proc.arity
+          when 0 then proc.call
+          when 2 then proc.call(metadata[key], metadata)
+          else proc.call(metadata[key])
+          end
+        end
+
+        def filters_apply?(key, value, metadata)
+          subhash = metadata[key]
+          return false unless Hash === subhash || HashImitatable === subhash
+          value.all? { |k, v| filter_applies?(k, v, subhash) }
+        end
+      end
+    end
+
+    # Tracks a collection of filterable items (e.g. modules, hooks, etc)
+    # and provides an optimized API to get the applicable items for the
+    # metadata of an example or example group.
+    #
+    # There are two implementations, optimized for different uses.
+    # @private
+    module FilterableItemRepository
+      # This implementation is simple, and is optimized for frequent
+      # updates but rare queries. `append` and `prepend` do no extra
+      # processing, and no internal memoization is done, since this
+      # is not optimized for queries.
+      #
+      # This is ideal for use by a example or example group, which may
+      # be updated multiple times with globally configured hooks, etc,
+      # but will not be queried frequently by other examples or examle
+      # groups.
+      # @private
+      class UpdateOptimized
+        attr_reader :items_and_filters
+
+        def initialize(applies_predicate)
+          @applies_predicate = applies_predicate
+          @items_and_filters = []
+        end
+
+        def append(item, metadata)
+          @items_and_filters << [item, metadata]
+        end
+
+        def prepend(item, metadata)
+          @items_and_filters.unshift [item, metadata]
+        end
+
+        def delete(item, metadata)
+          @items_and_filters.delete [item, metadata]
+        end
+
+        def items_for(request_meta)
+          @items_and_filters.each_with_object([]) do |(item, item_meta), to_return|
+            to_return << item if item_meta.empty? ||
+                                 MetadataFilter.apply?(@applies_predicate, item_meta, request_meta)
+          end
+        end
+
+        unless [].respond_to?(:each_with_object) # For 1.8.7
+          # :nocov:
+          undef items_for
+          def items_for(request_meta)
+            @items_and_filters.inject([]) do |to_return, (item, item_meta)|
+              to_return << item if item_meta.empty? ||
+                                   MetadataFilter.apply?(@applies_predicate, item_meta, request_meta)
+              to_return
+            end
+          end
+          # :nocov:
+        end
+      end
+
+      # This implementation is much more complex, and is optimized for
+      # rare (or hopefully no) updates once the queries start. Updates
+      # incur a cost as it has to clear the memoization and keep track
+      # of applicable keys. Queries will be O(N) the first time an item
+      # is provided with a given set of applicable metadata; subsequent
+      # queries with items with the same set of applicable metadata will
+      # be O(1) due to internal memoization.
+      #
+      # This is ideal for use by config, where filterable items (e.g. hooks)
+      # are typically added at the start of the process (e.g. in `spec_helper`)
+      # and then repeatedly queried as example groups and examples are defined.
+      # @private
+      class QueryOptimized < UpdateOptimized
+        alias find_items_for items_for
+        private :find_items_for
+
+        def initialize(applies_predicate)
+          super
+          @applicable_keys   = Set.new
+          @proc_keys         = Set.new
+          @memoized_lookups  = Hash.new do |hash, applicable_metadata|
+            hash[applicable_metadata] = find_items_for(applicable_metadata)
+          end
+        end
+
+        def append(item, metadata)
+          super
+          handle_mutation(metadata)
+        end
+
+        def prepend(item, metadata)
+          super
+          handle_mutation(metadata)
+        end
+
+        def delete(item, metadata)
+          super
+          reconstruct_caches
+        end
+
+        def items_for(metadata)
+          # The filtering of `metadata` to `applicable_metadata` is the key thing
+          # that makes the memoization actually useful in practice, since each
+          # example and example group have different metadata (e.g. location and
+          # description). By filtering to the metadata keys our items care about,
+          # we can ignore extra metadata keys that differ for each example/group.
+          # For example, given `config.include DBHelpers, :db`, example groups
+          # can be split into these two sets: those that are tagged with `:db` and those
+          # that are not. For each set, this method for the first group in the set is
+          # still an `O(N)` calculation, but all subsequent groups in the set will be
+          # constant time lookups when they call this method.
+          applicable_metadata = applicable_metadata_from(metadata)
+
+          if applicable_metadata.any? { |k, _| @proc_keys.include?(k) }
+            # It's unsafe to memoize lookups involving procs (since they can
+            # be non-deterministic), so we skip the memoization in this case.
+            find_items_for(applicable_metadata)
+          else
+            @memoized_lookups[applicable_metadata]
+          end
+        end
+
+      private
+
+        def reconstruct_caches
+          @applicable_keys.clear
+          @proc_keys.clear
+          @items_and_filters.each do |_item, metadata|
+            handle_mutation(metadata)
+          end
+        end
+
+        def handle_mutation(metadata)
+          @applicable_keys.merge(metadata.keys)
+          @proc_keys.merge(proc_keys_from metadata)
+          @memoized_lookups.clear
+        end
+
+        def applicable_metadata_from(metadata)
+          MetadataFilter.silence_metadata_example_group_deprecations do
+            @applicable_keys.inject({}) do |hash, key|
+              # :example_group is treated special here because...
+              # - In RSpec 2, example groups had an `:example_group` key
+              # - In RSpec 3, that key is deprecated (it was confusing!).
+              # - The key is not technically present in an example group metadata hash
+              #   (and thus would fail the `metadata.key?(key)` check) but a value
+              #   is provided when accessed via the hash's `default_proc`
+              # - Thus, for backwards compatibility, we have to explicitly check
+              #   for `:example_group` here if it is one of the keys being used to
+              #   filter.
+              hash[key] = metadata[key] if metadata.key?(key) || key == :example_group
+              hash
+            end
+          end
+        end
+
+        def proc_keys_from(metadata)
+          metadata.each_with_object([]) do |(key, value), to_return|
+            to_return << key if Proc === value
+          end
+        end
+
+        unless [].respond_to?(:each_with_object) # For 1.8.7
+          # :nocov:
+          undef proc_keys_from
+          def proc_keys_from(metadata)
+            metadata.inject([]) do |to_return, (key, value)|
+              to_return << key if Proc === value
+              to_return
+            end
+          end
+          # :nocov:
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.9.0/lib/rspec/core/minitest_assertions_adapter.rb

@@ -0,0 +1,31 @@
+begin
+  # Only the minitest 5.x gem includes the minitest.rb and assertions.rb files.
+  require 'minitest'
+  require 'minitest/assertions'
+rescue LoadError
+  # We must be using Ruby Core's MiniTest or the Minitest gem 4.x.
+  require 'minitest/unit'
+  Minitest = MiniTest
+end
+
+module RSpec
+  module Core
+    # @private
+    module MinitestAssertionsAdapter
+      include ::Minitest::Assertions
+      # Need to forcefully include Pending after Minitest::Assertions
+      # to make sure our own #skip method beats Minitest's.
+      include ::RSpec::Core::Pending
+
+      # Minitest 5.x requires this accessor to be available. See
+      # https://github.com/seattlerb/minitest/blob/38f0a5fcbd9c37c3f80a3eaad4ba84d3fc9947a0/lib/minitest/assertions.rb#L8
+      #
+      # It is not required for other extension libraries, and RSpec does not
+      # report or make this information available to formatters.
+      attr_writer :assertions
+      def assertions
+        @assertions ||= 0
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.9.0/lib/rspec/core/mocking_adapters/flexmock.rb

@@ -0,0 +1,31 @@
+#  Created by Jim Weirich on 2007-04-10.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'flexmock/rspec'
+
+module RSpec
+  module Core
+    module MockingAdapters
+      # @private
+      module Flexmock
+        include ::FlexMock::MockContainer
+
+        def self.framework_name
+          :flexmock
+        end
+
+        def setup_mocks_for_rspec
+          # No setup required.
+        end
+
+        def verify_mocks_for_rspec
+          flexmock_verify
+        end
+
+        def teardown_mocks_for_rspec
+          flexmock_close
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.9.0/lib/rspec/core/mocking_adapters/mocha.rb

@@ -0,0 +1,57 @@
+# In order to support all versions of mocha, we have to jump through some
+# hoops here.
+#
+# mocha >= '0.13.0':
+#   require 'mocha/api' is required.
+#   require 'mocha/object' raises a LoadError b/c the file no longer exists.
+# mocha < '0.13.0', >= '0.9.7'
+#   require 'mocha/api' is required.
+#   require 'mocha/object' is required.
+# mocha < '0.9.7':
+#   require 'mocha/api' raises a LoadError b/c the file does not yet exist.
+#   require 'mocha/standalone' is required.
+#   require 'mocha/object' is required.
+begin
+  require 'mocha/api'
+
+  begin
+    require 'mocha/object'
+  rescue LoadError
+    # Mocha >= 0.13.0 no longer contains this file nor needs it to be loaded.
+  end
+rescue LoadError
+  require 'mocha/standalone'
+  require 'mocha/object'
+end
+
+module RSpec
+  module Core
+    module MockingAdapters
+      # @private
+      module Mocha
+        def self.framework_name
+          :mocha
+        end
+
+        # Mocha::Standalone was deprecated as of Mocha 0.9.7.
+        begin
+          include ::Mocha::API
+        rescue NameError
+          include ::Mocha::Standalone
+        end
+
+        def setup_mocks_for_rspec
+          mocha_setup
+        end
+
+        def verify_mocks_for_rspec
+          mocha_verify
+        end
+
+        def teardown_mocks_for_rspec
+          mocha_teardown
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.9.0/lib/rspec/core/mocking_adapters/null.rb

@@ -0,0 +1,14 @@
+module RSpec
+  module Core
+    module MockingAdapters
+      # @private
+      module Null
+        def setup_mocks_for_rspec; end
+
+        def verify_mocks_for_rspec; end
+
+        def teardown_mocks_for_rspec; end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.9.0/lib/rspec/core/mocking_adapters/rr.rb

@@ -0,0 +1,31 @@
+require 'rr'
+
+RSpec.configuration.backtrace_exclusion_patterns.push(RR::Errors::BACKTRACE_IDENTIFIER)
+
+module RSpec
+  module Core
+    # @private
+    module MockingAdapters
+      # @private
+      module RR
+        def self.framework_name
+          :rr
+        end
+
+        include ::RR::Extensions::InstanceMethods
+
+        def setup_mocks_for_rspec
+          ::RR::Space.instance.reset
+        end
+
+        def verify_mocks_for_rspec
+          ::RR::Space.instance.verify_doubles
+        end
+
+        def teardown_mocks_for_rspec
+          ::RR::Space.instance.reset
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rspec-core-3.9.0/lib/rspec/core/mocking_adapters/rspec.rb

@@ -0,0 +1,32 @@
+require 'rspec/mocks'
+
+module RSpec
+  module Core
+    module MockingAdapters
+      # @private
+      module RSpec
+        include ::RSpec::Mocks::ExampleMethods
+
+        def self.framework_name
+          :rspec
+        end
+
+        def self.configuration
+          ::RSpec::Mocks.configuration
+        end
+
+        def setup_mocks_for_rspec
+          ::RSpec::Mocks.setup
+        end
+
+        def verify_mocks_for_rspec
+          ::RSpec::Mocks.verify
+        end
+
+        def teardown_mocks_for_rspec
+          ::RSpec::Mocks.teardown
+        end
+      end
+    end
+  end
+end