logstash-output-scalyr 0.1.5 → 0.1.10.beta

data/vendor/bundle/jruby/2.5.0/gems/rspec-core-3.9.2/lib/rspec/core/metadata_filter.rb

@@ -1,255 +0,0 @@
-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/jruby/2.5.0/gems/rspec-core-3.9.2/lib/rspec/core/minitest_assertions_adapter.rb

@@ -1,31 +0,0 @@
-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/jruby/2.5.0/gems/rspec-core-3.9.2/lib/rspec/core/mocking_adapters/flexmock.rb

@@ -1,31 +0,0 @@
-#  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/jruby/2.5.0/gems/rspec-core-3.9.2/lib/rspec/core/mocking_adapters/mocha.rb

@@ -1,57 +0,0 @@
-# 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/jruby/2.5.0/gems/rspec-core-3.9.2/lib/rspec/core/mocking_adapters/null.rb

@@ -1,14 +0,0 @@
-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/jruby/2.5.0/gems/rspec-core-3.9.2/lib/rspec/core/mocking_adapters/rr.rb

@@ -1,31 +0,0 @@
-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/jruby/2.5.0/gems/rspec-core-3.9.2/lib/rspec/core/mocking_adapters/rspec.rb

@@ -1,32 +0,0 @@
-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