test_gem2_dh 0.1.0

data/vendor/bundle/gems/rspec-mocks-3.6.0/lib/rspec/mocks/verifying_proxy.rb

@@ -0,0 +1,220 @@
+RSpec::Support.require_rspec_mocks 'verifying_message_expectation'
+RSpec::Support.require_rspec_mocks 'method_reference'
+
+module RSpec
+  module Mocks
+    # @private
+    class CallbackInvocationStrategy
+      def call(doubled_module)
+        RSpec::Mocks.configuration.verifying_double_callbacks.each do |block|
+          block.call doubled_module
+        end
+      end
+    end
+
+    # @private
+    class NoCallbackInvocationStrategy
+      def call(_doubled_module)
+      end
+    end
+
+    # @private
+    module VerifyingProxyMethods
+      def add_stub(method_name, opts={}, &implementation)
+        ensure_implemented(method_name)
+        super
+      end
+
+      def add_simple_stub(method_name, *args)
+        ensure_implemented(method_name)
+        super
+      end
+
+      def add_message_expectation(method_name, opts={}, &block)
+        ensure_implemented(method_name)
+        super
+      end
+
+      def ensure_implemented(method_name)
+        return unless method_reference[method_name].unimplemented?
+
+        @error_generator.raise_unimplemented_error(
+          @doubled_module,
+          method_name,
+          @object
+        )
+      end
+
+      def ensure_publicly_implemented(method_name, _object)
+        ensure_implemented(method_name)
+        visibility = method_reference[method_name].visibility
+
+        return if visibility == :public
+        @error_generator.raise_non_public_error(method_name, visibility)
+      end
+    end
+
+    # A verifying proxy mostly acts like a normal proxy, except that it
+    # contains extra logic to try and determine the validity of any expectation
+    # set on it. This includes whether or not methods have been defined and the
+    # validatiy of arguments on method calls.
+    #
+    # In all other ways this behaves like a normal proxy. It only adds the
+    # verification behaviour to specific methods then delegates to the parent
+    # implementation.
+    #
+    # These checks are only activated if the doubled class has already been
+    # loaded, otherwise they are disabled. This allows for testing in
+    # isolation.
+    #
+    # @private
+    class VerifyingProxy < TestDoubleProxy
+      include VerifyingProxyMethods
+
+      def initialize(object, order_group, doubled_module, method_reference_class)
+        super(object, order_group)
+        @object                 = object
+        @doubled_module         = doubled_module
+        @method_reference_class = method_reference_class
+
+        # A custom method double is required to pass through a way to lookup
+        # methods to determine their parameters. This is only relevant if the doubled
+        # class is loaded.
+        @method_doubles = Hash.new do |h, k|
+          h[k] = VerifyingMethodDouble.new(@object, k, self, method_reference[k])
+        end
+      end
+
+      def method_reference
+        @method_reference ||= Hash.new do |h, k|
+          h[k] = @method_reference_class.for(@doubled_module, k)
+        end
+      end
+
+      def visibility_for(method_name)
+        method_reference[method_name].visibility
+      end
+
+      def validate_arguments!(method_name, args)
+        @method_doubles[method_name].validate_arguments!(args)
+      end
+    end
+
+    # @private
+    DEFAULT_CALLBACK_INVOCATION_STRATEGY = CallbackInvocationStrategy.new
+
+    # @private
+    class VerifyingPartialDoubleProxy < PartialDoubleProxy
+      include VerifyingProxyMethods
+
+      def initialize(object, expectation_ordering, optional_callback_invocation_strategy=DEFAULT_CALLBACK_INVOCATION_STRATEGY)
+        super(object, expectation_ordering)
+        @doubled_module = DirectObjectReference.new(object)
+
+        # A custom method double is required to pass through a way to lookup
+        # methods to determine their parameters.
+        @method_doubles = Hash.new do |h, k|
+          h[k] = VerifyingExistingMethodDouble.for(object, k, self)
+        end
+
+        optional_callback_invocation_strategy.call(@doubled_module)
+      end
+
+      def ensure_implemented(_method_name)
+        return if Mocks.configuration.temporarily_suppress_partial_double_verification
+        super
+      end
+
+      def method_reference
+        @method_doubles
+      end
+    end
+
+    # @private
+    class VerifyingPartialClassDoubleProxy < VerifyingPartialDoubleProxy
+      include PartialClassDoubleProxyMethods
+    end
+
+    # @private
+    class VerifyingMethodDouble < MethodDouble
+      def initialize(object, method_name, proxy, method_reference)
+        super(object, method_name, proxy)
+        @method_reference = method_reference
+      end
+
+      def message_expectation_class
+        VerifyingMessageExpectation
+      end
+
+      def add_expectation(*args, &block)
+        # explict params necessary for 1.8.7 see #626
+        super(*args, &block).tap { |x| x.method_reference = @method_reference }
+      end
+
+      def add_stub(*args, &block)
+        # explict params necessary for 1.8.7 see #626
+        super(*args, &block).tap { |x| x.method_reference = @method_reference }
+      end
+
+      def proxy_method_invoked(obj, *args, &block)
+        validate_arguments!(args)
+        super
+      end
+
+      def validate_arguments!(actual_args)
+        @method_reference.with_signature do |signature|
+          verifier = Support::StrictSignatureVerifier.new(signature, actual_args)
+          raise ArgumentError, verifier.error_message unless verifier.valid?
+        end
+      end
+    end
+
+    # A VerifyingMethodDouble fetches the method to verify against from the
+    # original object, using a MethodReference. This works for pure doubles,
+    # but when the original object is itself the one being modified we need to
+    # collapse the reference and the method double into a single object so that
+    # we can access the original pristine method definition.
+    #
+    # @private
+    class VerifyingExistingMethodDouble < VerifyingMethodDouble
+      def initialize(object, method_name, proxy)
+        super(object, method_name, proxy, self)
+
+        @valid_method = object.respond_to?(method_name, true)
+
+        # Trigger an eager find of the original method since if we find it any
+        # later we end up getting a stubbed method with incorrect arity.
+        save_original_implementation_callable!
+      end
+
+      def with_signature
+        yield Support::MethodSignature.new(original_implementation_callable)
+      end
+
+      def unimplemented?
+        !@valid_method
+      end
+
+      def self.for(object, method_name, proxy)
+        if ClassNewMethodReference.applies_to?(method_name) { object }
+          VerifyingExistingClassNewMethodDouble
+        elsif Mocks.configuration.temporarily_suppress_partial_double_verification
+          MethodDouble
+        else
+          self
+        end.new(object, method_name, proxy)
+      end
+    end
+
+    # Used in place of a `VerifyingExistingMethodDouble` for the specific case
+    # of mocking or stubbing a `new` method on a class. In this case, we substitute
+    # the method signature from `#initialize` since new's signature is just `*args`.
+    #
+    # @private
+    class VerifyingExistingClassNewMethodDouble < VerifyingExistingMethodDouble
+      def with_signature
+        yield Support::MethodSignature.new(object.instance_method(:initialize))
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-mocks-3.6.0/lib/rspec/mocks/version.rb

@@ -0,0 +1,9 @@
+module RSpec
+  module Mocks
+    # Version information for RSpec mocks.
+    module Version
+      # Version of RSpec mocks currently in use in SemVer format.
+      STRING = '3.6.0'
+    end
+  end
+end

data/vendor/bundle/gems/rspec-support-3.6.0/Changelog.md

@@ -0,0 +1,211 @@
+### 3.6.0 / 2017-05-04
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.6.0.beta2...3.6.0)
+
+Enhancements:
+
+* Import `Source` classes from rspec-core. (Yuji Nakayama, #315)
+
+### 3.6.0.beta2 / 2016-12-12
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.6.0.beta1...v3.6.0.beta2)
+
+No user-facing changes.
+
+### 3.6.0.beta1 / 2016-10-09
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.5.0...v3.6.0.beta1)
+
+Bug Fixes:
+
+* Prevent truncated formatted object output from mangling console codes. (#294, Anson Kelly)
+
+### 3.5.0 / 2016-07-01
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.5.0.beta4...v3.5.0)
+
+**No user facing changes since beta4**
+
+### 3.5.0.beta4 / 2016-06-05
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.5.0.beta3...v3.5.0.beta4)
+
+Enhancements:
+* Improve `MethodSignature` to better support keyword arguments. (#250, Rob Smith).
+
+### 3.5.0.beta3 / 2016-04-02
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.5.0.beta2...v3.5.0.beta3)
+
+Bug Fixes:
+
+* Fix `EncodedString` to properly handle the behavior of `String#split`
+  on JRuby when the string contains invalid bytes. (Jon Rowe, #268)
+* Fix `ObjectFormatter` so that formatting objects that don't respond to
+  `#inspect` (such as `BasicObject`) does not cause `NoMethodError`.
+  (Yuji Nakayama, #269)
+* Fix `ObjectFormatter` so that formatting recursive array or hash does not
+  cause `SystemStackError`. (Yuji Nakayama, #270, #272)
+
+### 3.5.0.beta2 / 2016-03-10
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.5.0.beta1...v3.5.0.beta2)
+
+No user-facing changes.
+
+### 3.5.0.beta1 / 2016-02-06
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.4.1...v3.5.0.beta1)
+
+Enhancements:
+
+* Improve formatting of objects by allowing truncation to a pre-configured length.
+  (Liam M, #256)
+
+### 3.4.1 / 2015-11-20
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.4.0...v3.4.1)
+
+Bug Fixes:
+
+* Fix `RSpec::Support::RubyFeature.ripper_supported?` so it returns
+  `false` on Rubinius since the Rubinius team has no plans to support
+  it. This prevents rspec-core from trying to load and use ripper to
+  extract failure snippets. (Aaron Stone, #251)
+
+Changes:
+
+* Remove `VersionChecker` in favor of `ComparableVersion`. (Yuji Nakayama, #266)
+
+### 3.4.0 / 2015-11-11
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.3.0...v3.4.0)
+
+Enhancements:
+
+* Improve formatting of `Delegator` based objects (e.g. `SimpleDelgator`) in
+  failure messages and diffs. (Andrew Horner, #215)
+* Add `ComparableVersion`. (Yuji Nakayama, #245)
+* Add `Ripper` support detection. (Yuji Nakayama, #245)
+
+Bug Fixes:
+
+* Work around bug in JRuby that reports that `attr_writer` methods
+  have no parameters, causing RSpec's verifying doubles to wrongly
+  fail when mocking or stubbing a writer method on JRuby. (Myron Marston, #225)
+
+### 3.3.0 / 2015-06-12
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.2.2...v3.3.0)
+
+Enhancements:
+
+* Improve formatting of arrays and hashes in failure messages so they
+  use our custom formatting of matchers, time objects, etc.
+  (Myron Marston, Nicholas Chmielewski, #205)
+* Use improved formatting for diffs as well. (Nicholas Chmielewski, #205)
+
+Bug Fixes:
+
+* Fix `FuzzyMatcher` so that it checks `expected == actual` rather than
+  `actual == expected`, which avoids errors in situations where the
+  `actual` object's `==` is improperly implemented to assume that only
+  objects of the same type will be given. This allows rspec-mocks'
+  `anything` to match against objects with buggy `==` definitions.
+  (Myron Marston, #193)
+
+### 3.2.2 / 2015-02-23
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.2.1...v3.2.2)
+
+Bug Fixes:
+
+* Fix an encoding issue with `EncodedString#split` when encountering an
+  invalid byte string. (Benjamin Fleischer, #1760)
+
+### 3.2.1 / 2015-02-04
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.2.0...v3.2.1)
+
+Bug Fixes:
+
+* Fix `RSpec::CallerFilter` to work on Rubinius 2.2.
+  (Myron Marston, #169)
+
+### 3.2.0 / 2015-02-03
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.1.2...v3.2.0)
+
+Enhancements:
+
+* Add extra Ruby type detection. (Jon Rowe, #133)
+* Make differ instance re-usable. (Alexey Fedorov, #160)
+
+Bug Fixes:
+
+* Do not consider `[]` and `{}` to match when performing fuzzy matching.
+  (Myron Marston, #157)
+
+### 3.1.2 / 2014-10-08
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.1.1...v3.1.2)
+
+Bug Fixes:
+
+* Fix method signature to not blow up with a `NoMethodError` on 1.8.7 when
+  verifying against an RSpec matcher. (Myron Marston, #116)
+
+### 3.1.1 / 2014-09-26
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.1.0...v3.1.1)
+
+Bug Fixes:
+
+* Fix `RSpec::Support::DirectoryMaker` (used by `rspec --init` and
+  `rails generate rspec:install`) so that it detects absolute paths
+   on Windows properly. (Scott Archer, #107, #108, #109) (Jon Rowe, #110)
+
+### 3.1.0 / 2014-09-04
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.0.4...v3.1.0)
+
+Bug Fixes:
+
+* Fix `FuzzyMatcher` so that it does not wrongly match a struct against
+  an array. (Myron Marston, #97)
+* Prevent infinitely recursing `#flatten` methods from causing the differ
+  to hang. (Jon Rowe, #101)
+
+### 3.0.4 / 2014-08-14
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.0.3...v3.0.4)
+
+Bug Fixes:
+
+* Fix `FuzzyMatcher` so that it does not silence `ArgumentError` raised
+  from broken implementations of `==`. (Myron Marston, #94)
+
+### 3.0.3 / 2014-07-21
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.0.2...v3.0.3)
+
+Bug Fixes:
+
+* Fix regression in `Support#method_handle_for` where proxy objects
+  with method delegated would wrongly not return a method handle.
+  (Jon Rowe, #90)
+* Properly detect Module#prepend support in Ruby 2.1+ (Ben Langfeld, #91)
+* Fix `rspec/support/warnings.rb` so it can be loaded and used in
+  isolation. (Myron Marston, #93)
+
+### 3.0.2 / 2014-06-20
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.0.1...v3.0.2)
+
+* Revert `BlockSignature` change from 3.0.1 because of a ruby bug that
+  caused it to change the block's behavior (https://bugs.ruby-lang.org/issues/9967).
+  (Myron Marston, rspec-mocks#721)
+
+### 3.0.1 / 2014-06-19
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.0.0...v3.0.1)
+
+* Fix `BlockSignature` so that it correctly differentiates between
+  required and optional block args. (Myron Marston, rspec-mocks#714)
+
+### 3.0.0 / 2014-06-01
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.0.0.rc1...v3.0.0)
+
+### 3.0.0.rc1 / 2014-05-18
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.0.0.beta2...v3.0.0.rc1)
+
+### 3.0.0.beta2 / 2014-02-17
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.0.0.beta1...v3.0.0.beta2)
+
+Bug Fixes:
+
+* Issue message when :replacement is passed to `RSpec.warn_with`. (Jon Rowe)
+
+### 3.0.0.beta1 / 2013-11-07
+[Full Changelog](https://github.com/rspec/rspec-support/compare/0dc12d1bdbbacc757a9989f8c09cd08ef3a4837e...v3.0.0.beta1)
+
+Initial release.

data/vendor/bundle/gems/rspec-support-3.6.0/LICENSE.md

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+====================
+
+* Copyright © 2013 David Chelimsky, Myron Marston, Jon Rowe, Sam Phippen, Xavier Shay, Bradley Schaefer
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.