xaiml 0.1.3 → 0.1.4

data/vendor/bundle/ruby/2.5.0/gems/rspec-mocks-3.8.0/lib/rspec/mocks/argument_list_matcher.rb

@@ -1,100 +0,0 @@
-# We intentionally do not use the `RSpec::Support.require...` methods
-# here so that this file can be loaded individually, as documented
-# below.
-require 'rspec/mocks/argument_matchers'
-require 'rspec/support/fuzzy_matcher'
-
-module RSpec
-  module Mocks
-    # Wrapper for matching arguments against a list of expected values. Used by
-    # the `with` method on a `MessageExpectation`:
-    #
-    #     expect(object).to receive(:message).with(:a, 'b', 3)
-    #     object.message(:a, 'b', 3)
-    #
-    # Values passed to `with` can be literal values or argument matchers that
-    # match against the real objects .e.g.
-    #
-    #     expect(object).to receive(:message).with(hash_including(:a => 'b'))
-    #
-    # Can also be used directly to match the contents of any `Array`. This
-    # enables 3rd party mocking libs to take advantage of rspec's argument
-    # matching without using the rest of rspec-mocks.
-    #
-    #     require 'rspec/mocks/argument_list_matcher'
-    #     include RSpec::Mocks::ArgumentMatchers
-    #
-    #     arg_list_matcher = RSpec::Mocks::ArgumentListMatcher.new(123, hash_including(:a => 'b'))
-    #     arg_list_matcher.args_match?(123, :a => 'b')
-    #
-    # This class is immutable.
-    #
-    # @see ArgumentMatchers
-    class ArgumentListMatcher
-      # @private
-      attr_reader :expected_args
-
-      # @api public
-      # @param [Array] expected_args a list of expected literals and/or argument matchers
-      #
-      # Initializes an `ArgumentListMatcher` with a collection of literal
-      # values and/or argument matchers.
-      #
-      # @see ArgumentMatchers
-      # @see #args_match?
-      def initialize(*expected_args)
-        @expected_args = expected_args
-        ensure_expected_args_valid!
-      end
-
-      # @api public
-      # @param [Array] args
-      #
-      # Matches each element in the `expected_args` against the element in the same
-      # position of the arguments passed to `new`.
-      #
-      # @see #initialize
-      def args_match?(*args)
-        Support::FuzzyMatcher.values_match?(resolve_expected_args_based_on(args), args)
-      end
-
-      # @private
-      # Resolves abstract arg placeholders like `no_args` and `any_args` into
-      # a more concrete arg list based on the provided `actual_args`.
-      def resolve_expected_args_based_on(actual_args)
-        return [] if [ArgumentMatchers::NoArgsMatcher::INSTANCE] == expected_args
-
-        any_args_index = expected_args.index { |a| ArgumentMatchers::AnyArgsMatcher::INSTANCE == a }
-        return expected_args unless any_args_index
-
-        replace_any_args_with_splat_of_anything(any_args_index, actual_args.count)
-      end
-
-    private
-
-      def replace_any_args_with_splat_of_anything(before_count, actual_args_count)
-        any_args_count  = actual_args_count   - expected_args.count + 1
-        after_count     = expected_args.count - before_count        - 1
-
-        any_args = 1.upto(any_args_count).map { ArgumentMatchers::AnyArgMatcher::INSTANCE }
-        expected_args.first(before_count) + any_args + expected_args.last(after_count)
-      end
-
-      def ensure_expected_args_valid!
-        if expected_args.count { |a| ArgumentMatchers::AnyArgsMatcher::INSTANCE == a } > 1
-          raise ArgumentError, "`any_args` can only be passed to " \
-                "`with` once but you have passed it multiple times."
-        elsif expected_args.count > 1 && expected_args.any? { |a| ArgumentMatchers::NoArgsMatcher::INSTANCE == a }
-          raise ArgumentError, "`no_args` can only be passed as a " \
-                "singleton argument to `with` (i.e. `with(no_args)`), " \
-                "but you have passed additional arguments."
-        end
-      end
-
-      # Value that will match all argument lists.
-      #
-      # @private
-      MATCH_ALL = new(ArgumentMatchers::AnyArgsMatcher::INSTANCE)
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-mocks-3.8.0/lib/rspec/mocks/argument_matchers.rb

@@ -1,320 +0,0 @@
-# This cannot take advantage of our relative requires, since this file is a
-# dependency of `rspec/mocks/argument_list_matcher.rb`. See comment there for
-# details.
-require 'rspec/support/matcher_definition'
-
-module RSpec
-  module Mocks
-    # ArgumentMatchers are placeholders that you can include in message
-    # expectations to match arguments against a broader check than simple
-    # equality.
-    #
-    # With the exception of `any_args` and `no_args`, they all match against
-    # the arg in same position in the argument list.
-    #
-    # @see ArgumentListMatcher
-    module ArgumentMatchers
-      # Acts like an arg splat, matching any number of args at any point in an arg list.
-      #
-      # @example
-      #   expect(object).to receive(:message).with(1, 2, any_args)
-      #
-      #   # matches any of these:
-      #   object.message(1, 2)
-      #   object.message(1, 2, 3)
-      #   object.message(1, 2, 3, 4)
-      def any_args
-        AnyArgsMatcher::INSTANCE
-      end
-
-      # Matches any argument at all.
-      #
-      # @example
-      #   expect(object).to receive(:message).with(anything)
-      def anything
-        AnyArgMatcher::INSTANCE
-      end
-
-      # Matches no arguments.
-      #
-      # @example
-      #   expect(object).to receive(:message).with(no_args)
-      def no_args
-        NoArgsMatcher::INSTANCE
-      end
-
-      # Matches if the actual argument responds to the specified messages.
-      #
-      # @example
-      #   expect(object).to receive(:message).with(duck_type(:hello))
-      #   expect(object).to receive(:message).with(duck_type(:hello, :goodbye))
-      def duck_type(*args)
-        DuckTypeMatcher.new(*args)
-      end
-
-      # Matches a boolean value.
-      #
-      # @example
-      #   expect(object).to receive(:message).with(boolean())
-      def boolean
-        BooleanMatcher::INSTANCE
-      end
-
-      # Matches a hash that includes the specified key(s) or key/value pairs.
-      # Ignores any additional keys.
-      #
-      # @example
-      #   expect(object).to receive(:message).with(hash_including(:key => val))
-      #   expect(object).to receive(:message).with(hash_including(:key))
-      #   expect(object).to receive(:message).with(hash_including(:key, :key2 => val2))
-      def hash_including(*args)
-        HashIncludingMatcher.new(ArgumentMatchers.anythingize_lonely_keys(*args))
-      end
-
-      # Matches an array that includes the specified items at least once.
-      # Ignores duplicates and additional values
-      #
-      # @example
-      #   expect(object).to receive(:message).with(array_including(1,2,3))
-      #   expect(object).to receive(:message).with(array_including([1,2,3]))
-      def array_including(*args)
-        actually_an_array = Array === args.first && args.count == 1 ? args.first : args
-        ArrayIncludingMatcher.new(actually_an_array)
-      end
-
-      # Matches a hash that doesn't include the specified key(s) or key/value.
-      #
-      # @example
-      #   expect(object).to receive(:message).with(hash_excluding(:key => val))
-      #   expect(object).to receive(:message).with(hash_excluding(:key))
-      #   expect(object).to receive(:message).with(hash_excluding(:key, :key2 => :val2))
-      def hash_excluding(*args)
-        HashExcludingMatcher.new(ArgumentMatchers.anythingize_lonely_keys(*args))
-      end
-
-      alias_method :hash_not_including, :hash_excluding
-
-      # Matches if `arg.instance_of?(klass)`
-      #
-      # @example
-      #   expect(object).to receive(:message).with(instance_of(Thing))
-      def instance_of(klass)
-        InstanceOf.new(klass)
-      end
-
-      alias_method :an_instance_of, :instance_of
-
-      # Matches if `arg.kind_of?(klass)`
-      #
-      # @example
-      #   expect(object).to receive(:message).with(kind_of(Thing))
-      def kind_of(klass)
-        KindOf.new(klass)
-      end
-
-      alias_method :a_kind_of, :kind_of
-
-      # @private
-      def self.anythingize_lonely_keys(*args)
-        hash = Hash === args.last ? args.delete_at(-1) : {}
-        args.each { | arg | hash[arg] = AnyArgMatcher::INSTANCE }
-        hash
-      end
-
-      # Intended to be subclassed by stateless, immutable argument matchers.
-      # Provides a `<klass name>::INSTANCE` constant for accessing a global
-      # singleton instance of the matcher. There is no need to construct
-      # multiple instance since there is no state. It also facilities the
-      # special case logic we need for some of these matchers, by making it
-      # easy to do comparisons like: `[klass::INSTANCE] == args` rather than
-      # `args.count == 1 && klass === args.first`.
-      #
-      # @private
-      class SingletonMatcher
-        private_class_method :new
-
-        def self.inherited(subklass)
-          subklass.const_set(:INSTANCE, subklass.send(:new))
-        end
-      end
-
-      # @private
-      class AnyArgsMatcher < SingletonMatcher
-        def description
-          "*(any args)"
-        end
-      end
-
-      # @private
-      class AnyArgMatcher < SingletonMatcher
-        def ===(_other)
-          true
-        end
-
-        def description
-          "anything"
-        end
-      end
-
-      # @private
-      class NoArgsMatcher < SingletonMatcher
-        def description
-          "no args"
-        end
-      end
-
-      # @private
-      class BooleanMatcher < SingletonMatcher
-        def ===(value)
-          true == value || false == value
-        end
-
-        def description
-          "boolean"
-        end
-      end
-
-      # @private
-      class BaseHashMatcher
-        def initialize(expected)
-          @expected = expected
-        end
-
-        def ===(predicate, actual)
-          @expected.__send__(predicate) do |k, v|
-            actual.key?(k) && Support::FuzzyMatcher.values_match?(v, actual[k])
-          end
-        rescue NoMethodError
-          false
-        end
-
-        def description(name)
-          "#{name}(#{formatted_expected_hash.inspect.sub(/^\{/, "").sub(/\}$/, "")})"
-        end
-
-      private
-
-        def formatted_expected_hash
-          Hash[
-            @expected.map do |k, v|
-              k = RSpec::Support.rspec_description_for_object(k)
-              v = RSpec::Support.rspec_description_for_object(v)
-
-              [k, v]
-            end
-          ]
-        end
-      end
-
-      # @private
-      class HashIncludingMatcher < BaseHashMatcher
-        def ===(actual)
-          super(:all?, actual)
-        end
-
-        def description
-          super("hash_including")
-        end
-      end
-
-      # @private
-      class HashExcludingMatcher < BaseHashMatcher
-        def ===(actual)
-          super(:none?, actual)
-        end
-
-        def description
-          super("hash_not_including")
-        end
-      end
-
-      # @private
-      class ArrayIncludingMatcher
-        def initialize(expected)
-          @expected = expected
-        end
-
-        def ===(actual)
-          actual = actual.uniq
-          @expected.uniq.all? do |expected_element|
-            actual.any? do |actual_element|
-              RSpec::Support::FuzzyMatcher.values_match?(expected_element, actual_element)
-            end
-          end
-        end
-
-        def description
-          "array_including(#{formatted_expected_values})"
-        end
-
-      private
-
-        def formatted_expected_values
-          @expected.map do |x|
-            RSpec::Support.rspec_description_for_object(x)
-          end.join(", ")
-        end
-      end
-
-      # @private
-      class DuckTypeMatcher
-        def initialize(*methods_to_respond_to)
-          @methods_to_respond_to = methods_to_respond_to
-        end
-
-        def ===(value)
-          @methods_to_respond_to.all? { |message| value.respond_to?(message) }
-        end
-
-        def description
-          "duck_type(#{@methods_to_respond_to.map(&:inspect).join(', ')})"
-        end
-      end
-
-      # @private
-      class InstanceOf
-        def initialize(klass)
-          @klass = klass
-        end
-
-        def ===(actual)
-          actual.instance_of?(@klass)
-        end
-
-        def description
-          "an_instance_of(#{@klass.name})"
-        end
-      end
-
-      # @private
-      class KindOf
-        def initialize(klass)
-          @klass = klass
-        end
-
-        def ===(actual)
-          actual.kind_of?(@klass)
-        end
-
-        def description
-          "kind of #{@klass.name}"
-        end
-      end
-
-      matcher_namespace = name + '::'
-      ::RSpec::Support.register_matcher_definition do |object|
-        # This is the best we have for now. We should tag all of our matchers
-        # with a module or something so we can test for it directly.
-        #
-        # (Note Module#parent in ActiveSupport is defined in a similar way.)
-        begin
-          object.class.name.include?(matcher_namespace)
-        rescue NoMethodError
-          # Some objects, like BasicObject, don't implemented standard
-          # reflection methods.
-          false
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/rspec-mocks-3.8.0/lib/rspec/mocks/configuration.rb

@@ -1,212 +0,0 @@
-module RSpec
-  module Mocks
-    # Provides configuration options for rspec-mocks.
-    class Configuration
-      def initialize
-        @allow_message_expectations_on_nil = nil
-        @yield_receiver_to_any_instance_implementation_blocks = true
-        @verify_doubled_constant_names = false
-        @transfer_nested_constants = false
-        @verify_partial_doubles = false
-        @temporarily_suppress_partial_double_verification = false
-        @color = false
-      end
-
-      # Sets whether RSpec will warn, ignore, or fail a test when
-      # expectations are set on nil.
-      # By default, when this flag is not set, warning messages are issued when
-      # expectations are set on nil. This is to prevent false-positives and to
-      # catch potential bugs early on.
-      # When set to `true`, warning messages are suppressed.
-      # When set to `false`, it will raise an error.
-      #
-      # @example
-      #   RSpec.configure do |config|
-      #     config.mock_with :rspec do |mocks|
-      #       mocks.allow_message_expectations_on_nil = false
-      #     end
-      #   end
-      attr_accessor :allow_message_expectations_on_nil
-
-      def yield_receiver_to_any_instance_implementation_blocks?
-        @yield_receiver_to_any_instance_implementation_blocks
-      end
-
-      # Sets whether or not RSpec will yield the receiving instance of a
-      # message to blocks that are used for any_instance stub implementations.
-      # When set, the first yielded argument will be the receiving instance.
-      # Defaults to `true`.
-      #
-      # @example
-      #   RSpec.configure do |rspec|
-      #     rspec.mock_with :rspec do |mocks|
-      #       mocks.yield_receiver_to_any_instance_implementation_blocks = false
-      #     end
-      #   end
-      attr_writer :yield_receiver_to_any_instance_implementation_blocks
-
-      # Adds `stub` and `should_receive` to the given
-      # modules or classes. This is usually only necessary
-      # if you application uses some proxy classes that
-      # "strip themselves down" to a bare minimum set of
-      # methods and remove `stub` and `should_receive` in
-      # the process.
-      #
-      # @example
-      #   RSpec.configure do |rspec|
-      #     rspec.mock_with :rspec do |mocks|
-      #       mocks.add_stub_and_should_receive_to Delegator
-      #     end
-      #   end
-      #
-      def add_stub_and_should_receive_to(*modules)
-        modules.each do |mod|
-          Syntax.enable_should(mod)
-        end
-      end
-
-      # Provides the ability to set either `expect`,
-      # `should` or both syntaxes. RSpec uses `expect`
-      # syntax by default. This is needed if you want to
-      # explicitly enable `should` syntax and/or explicitly
-      # disable `expect` syntax.
-      #
-      # @example
-      #   RSpec.configure do |rspec|
-      #     rspec.mock_with :rspec do |mocks|
-      #       mocks.syntax = [:expect, :should]
-      #     end
-      #  end
-      #
-      def syntax=(*values)
-        syntaxes = values.flatten
-        if syntaxes.include?(:expect)
-          Syntax.enable_expect
-        else
-          Syntax.disable_expect
-        end
-
-        if syntaxes.include?(:should)
-          Syntax.enable_should
-        else
-          Syntax.disable_should
-        end
-      end
-
-      # Returns an array with a list of syntaxes
-      # that are enabled.
-      #
-      # @example
-      #   unless RSpec::Mocks.configuration.syntax.include?(:expect)
-      #     raise "this RSpec extension gem requires the rspec-mocks `:expect` syntax"
-      #   end
-      #
-      def syntax
-        syntaxes = []
-        syntaxes << :should  if Syntax.should_enabled?
-        syntaxes << :expect if Syntax.expect_enabled?
-        syntaxes
-      end
-
-      def verify_doubled_constant_names?
-        !!@verify_doubled_constant_names
-      end
-
-      # When this is set to true, an error will be raised when
-      # `instance_double` or `class_double` is given the name of an undefined
-      # constant. You probably only want to set this when running your entire
-      # test suite, with all production code loaded. Setting this for an
-      # isolated unit test will prevent you from being able to isolate it!
-      attr_writer :verify_doubled_constant_names
-
-      # Provides a way to perform customisations when verifying doubles.
-      #
-      # @example
-      #  RSpec::Mocks.configuration.before_verifying_doubles do |ref|
-      #    ref.some_method!
-      #  end
-      def before_verifying_doubles(&block)
-        verifying_double_callbacks << block
-      end
-      alias :when_declaring_verifying_double :before_verifying_doubles
-
-      # @api private
-      # Returns an array of blocks to call when verifying doubles
-      def verifying_double_callbacks
-        @verifying_double_callbacks ||= []
-      end
-
-      def transfer_nested_constants?
-        !!@transfer_nested_constants
-      end
-
-      # Sets the default for the `transfer_nested_constants` option when
-      # stubbing constants.
-      attr_writer :transfer_nested_constants
-
-      # When set to true, partial mocks will be verified the same as object
-      # doubles. Any stubs will have their arguments checked against the original
-      # method, and methods that do not exist cannot be stubbed.
-      def verify_partial_doubles=(val)
-        @verify_partial_doubles = !!val
-      end
-
-      def verify_partial_doubles?
-        @verify_partial_doubles
-      end
-
-      # @private
-      # Used to track wether we are temporarily suppressing verifying partial
-      # doubles with `without_partial_double_verification { ... }`
-      attr_accessor :temporarily_suppress_partial_double_verification
-
-      if ::RSpec.respond_to?(:configuration)
-        def color?
-          ::RSpec.configuration.color_enabled?
-        end
-      else
-        # Indicates whether or not diffs should be colored.
-        # Delegates to rspec-core's color option if rspec-core
-        # is loaded; otherwise you can set it here.
-        attr_writer :color
-
-        # Indicates whether or not diffs should be colored.
-        # Delegates to rspec-core's color option if rspec-core
-        # is loaded; otherwise you can set it here.
-        def color?
-          @color
-        end
-      end
-
-      # Monkey-patch `Marshal.dump` to enable dumping of mocked or stubbed
-      # objects. By default this will not work since RSpec mocks works by
-      # adding singleton methods that cannot be serialized. This patch removes
-      # these singleton methods before serialization. Setting to falsey removes
-      # the patch.
-      #
-      # This method is idempotent.
-      def patch_marshal_to_support_partial_doubles=(val)
-        if val
-          RSpec::Mocks::MarshalExtension.patch!
-        else
-          RSpec::Mocks::MarshalExtension.unpatch!
-        end
-      end
-
-      # @api private
-      # Resets the configured syntax to the default.
-      def reset_syntaxes_to_default
-        self.syntax = [:should, :expect]
-        RSpec::Mocks::Syntax.warn_about_should!
-      end
-    end
-
-    # Mocks specific configuration, as distinct from `RSpec.configuration`
-    # which is core RSpec configuration.
-    def self.configuration
-      @configuration ||= Configuration.new
-    end
-
-    configuration.reset_syntaxes_to_default
-  end
-end