dirwatch 0.0.6 → 0.0.7

data/vendor/bundle/ruby/2.3.0/gems/rspec-mocks-3.7.0/lib/rspec/mocks/standalone.rb

@@ -1,3 +0,0 @@
-require 'rspec/mocks'
-extend RSpec::Mocks::ExampleMethods
-RSpec::Mocks.setup

data/vendor/bundle/ruby/2.3.0/gems/rspec-mocks-3.7.0/lib/rspec/mocks/syntax.rb

@@ -1,325 +0,0 @@
-module RSpec
-  module Mocks
-    # @api private
-    # Provides methods for enabling and disabling the available syntaxes
-    # provided by rspec-mocks.
-    module Syntax
-      # @private
-      def self.warn_about_should!
-        @warn_about_should = true
-      end
-
-      # @private
-      def self.warn_unless_should_configured(method_name , replacement="the new `:expect` syntax or explicitly enable `:should`")
-        if @warn_about_should
-          RSpec.deprecate(
-            "Using `#{method_name}` from rspec-mocks' old `:should` syntax without explicitly enabling the syntax",
-            :replacement => replacement
-          )
-
-          @warn_about_should = false
-        end
-      end
-
-      # @api private
-      # Enables the should syntax (`dbl.stub`, `dbl.should_receive`, etc).
-      def self.enable_should(syntax_host=default_should_syntax_host)
-        @warn_about_should = false if syntax_host == default_should_syntax_host
-        return if should_enabled?(syntax_host)
-
-        syntax_host.class_exec do
-          def should_receive(message, opts={}, &block)
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-            ::RSpec::Mocks.expect_message(self, message, opts, &block)
-          end
-
-          def should_not_receive(message, &block)
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-            ::RSpec::Mocks.expect_message(self, message, {}, &block).never
-          end
-
-          def stub(message_or_hash, opts={}, &block)
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-            if ::Hash === message_or_hash
-              message_or_hash.each { |message, value| stub(message).and_return value }
-            else
-              ::RSpec::Mocks.allow_message(self, message_or_hash, opts, &block)
-            end
-          end
-
-          def unstub(message)
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__, "`allow(...).to receive(...).and_call_original` or explicitly enable `:should`")
-            ::RSpec::Mocks.space.proxy_for(self).remove_stub(message)
-          end
-
-          def stub_chain(*chain, &blk)
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-            ::RSpec::Mocks::StubChain.stub_chain_on(self, *chain, &blk)
-          end
-
-          def as_null_object
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-            @_null_object = true
-            ::RSpec::Mocks.space.proxy_for(self).as_null_object
-          end
-
-          def null_object?
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-            defined?(@_null_object)
-          end
-
-          def received_message?(message, *args, &block)
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-            ::RSpec::Mocks.space.proxy_for(self).received_message?(message, *args, &block)
-          end
-
-          unless Class.respond_to? :any_instance
-            Class.class_exec do
-              def any_instance
-                ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-                ::RSpec::Mocks.space.any_instance_proxy_for(self)
-              end
-            end
-          end
-        end
-      end
-
-      # @api private
-      # Disables the should syntax (`dbl.stub`, `dbl.should_receive`, etc).
-      def self.disable_should(syntax_host=default_should_syntax_host)
-        return unless should_enabled?(syntax_host)
-
-        syntax_host.class_exec do
-          undef should_receive
-          undef should_not_receive
-          undef stub
-          undef unstub
-          undef stub_chain
-          undef as_null_object
-          undef null_object?
-          undef received_message?
-        end
-
-        Class.class_exec do
-          undef any_instance
-        end
-      end
-
-      # @api private
-      # Enables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc).
-      def self.enable_expect(syntax_host=::RSpec::Mocks::ExampleMethods)
-        return if expect_enabled?(syntax_host)
-
-        syntax_host.class_exec do
-          def receive(method_name, &block)
-            Matchers::Receive.new(method_name, block)
-          end
-
-          def receive_messages(message_return_value_hash)
-            matcher = Matchers::ReceiveMessages.new(message_return_value_hash)
-            matcher.warn_about_block if block_given?
-            matcher
-          end
-
-          def receive_message_chain(*messages, &block)
-            Matchers::ReceiveMessageChain.new(messages, &block)
-          end
-
-          def allow(target)
-            AllowanceTarget.new(target)
-          end
-
-          def expect_any_instance_of(klass)
-            AnyInstanceExpectationTarget.new(klass)
-          end
-
-          def allow_any_instance_of(klass)
-            AnyInstanceAllowanceTarget.new(klass)
-          end
-        end
-
-        RSpec::Mocks::ExampleMethods::ExpectHost.class_exec do
-          def expect(target)
-            ExpectationTarget.new(target)
-          end
-        end
-      end
-
-      # @api private
-      # Disables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc).
-      def self.disable_expect(syntax_host=::RSpec::Mocks::ExampleMethods)
-        return unless expect_enabled?(syntax_host)
-
-        syntax_host.class_exec do
-          undef receive
-          undef receive_messages
-          undef receive_message_chain
-          undef allow
-          undef expect_any_instance_of
-          undef allow_any_instance_of
-        end
-
-        RSpec::Mocks::ExampleMethods::ExpectHost.class_exec do
-          undef expect
-        end
-      end
-
-      # @api private
-      # Indicates whether or not the should syntax is enabled.
-      def self.should_enabled?(syntax_host=default_should_syntax_host)
-        syntax_host.method_defined?(:should_receive)
-      end
-
-      # @api private
-      # Indicates whether or not the expect syntax is enabled.
-      def self.expect_enabled?(syntax_host=::RSpec::Mocks::ExampleMethods)
-        syntax_host.method_defined?(:allow)
-      end
-
-      # @api private
-      # Determines where the methods like `should_receive`, and `stub` are added.
-      def self.default_should_syntax_host
-        # JRuby 1.7.4 introduces a regression whereby `defined?(::BasicObject) => nil`
-        # yet `BasicObject` still exists and patching onto ::Object breaks things
-        # e.g. SimpleDelegator expectations won't work
-        #
-        # See: https://github.com/jruby/jruby/issues/814
-        if defined?(JRUBY_VERSION) && JRUBY_VERSION == '1.7.4' && RUBY_VERSION.to_f > 1.8
-          return ::BasicObject
-        end
-
-        # On 1.8.7, Object.ancestors.last == Kernel but
-        # things blow up if we include `RSpec::Mocks::Methods`
-        # into Kernel...not sure why.
-        return Object unless defined?(::BasicObject)
-
-        # MacRuby has BasicObject but it's not the root class.
-        return Object unless Object.ancestors.last == ::BasicObject
-
-        ::BasicObject
-      end
-    end
-  end
-end
-
-if defined?(BasicObject)
-  # The legacy `:should` syntax adds the following methods directly to
-  # `BasicObject` so that they are available off of any object. Note, however,
-  # that this syntax does not always play nice with delegate/proxy objects.
-  # We recommend you use the non-monkeypatching `:expect` syntax instead.
-  # @see Class
-  class BasicObject
-    # @method should_receive
-    # Sets an expectation that this object should receive a message before
-    # the end of the example.
-    #
-    # @example
-    #   logger = double('logger')
-    #   thing_that_logs = ThingThatLogs.new(logger)
-    #   logger.should_receive(:log)
-    #   thing_that_logs.do_something_that_logs_a_message
-    #
-    # @note This is only available when you have enabled the `should` syntax.
-    # @see RSpec::Mocks::ExampleMethods#expect
-
-    # @method should_not_receive
-    # Sets and expectation that this object should _not_ receive a message
-    # during this example.
-    # @see RSpec::Mocks::ExampleMethods#expect
-
-    # @method stub
-    # Tells the object to respond to the message with the specified value.
-    #
-    # @example
-    #   counter.stub(:count).and_return(37)
-    #   counter.stub(:count => 37)
-    #   counter.stub(:count) { 37 }
-    #
-    # @note This is only available when you have enabled the `should` syntax.
-    # @see RSpec::Mocks::ExampleMethods#allow
-
-    # @method unstub
-    # Removes a stub. On a double, the object will no longer respond to
-    # `message`. On a real object, the original method (if it exists) is
-    # restored.
-    #
-    # This is rarely used, but can be useful when a stub is set up during a
-    # shared `before` hook for the common case, but you want to replace it
-    # for a special case.
-    #
-    # @note This is only available when you have enabled the `should` syntax.
-
-    # @method stub_chain
-    # @overload stub_chain(method1, method2)
-    # @overload stub_chain("method1.method2")
-    # @overload stub_chain(method1, method_to_value_hash)
-    #
-    # Stubs a chain of methods.
-    #
-    # ## Warning:
-    #
-    # Chains can be arbitrarily long, which makes it quite painless to
-    # violate the Law of Demeter in violent ways, so you should consider any
-    # use of `stub_chain` a code smell. Even though not all code smells
-    # indicate real problems (think fluent interfaces), `stub_chain` still
-    # results in brittle examples.  For example, if you write
-    # `foo.stub_chain(:bar, :baz => 37)` in a spec and then the
-    # implementation calls `foo.baz.bar`, the stub will not work.
-    #
-    # @example
-    #   double.stub_chain("foo.bar") { :baz }
-    #   double.stub_chain(:foo, :bar => :baz)
-    #   double.stub_chain(:foo, :bar) { :baz }
-    #
-    #     # Given any of ^^ these three forms ^^:
-    #     double.foo.bar # => :baz
-    #
-    #     # Common use in Rails/ActiveRecord:
-    #     Article.stub_chain("recent.published") { [Article.new] }
-    #
-    # @note This is only available when you have enabled the `should` syntax.
-    # @see RSpec::Mocks::ExampleMethods#receive_message_chain
-
-    # @method as_null_object
-    # Tells the object to respond to all messages. If specific stub values
-    # are declared, they'll work as expected. If not, the receiver is
-    # returned.
-    #
-    # @note This is only available when you have enabled the `should` syntax.
-
-    # @method null_object?
-    # Returns true if this object has received `as_null_object`
-    #
-    # @note This is only available when you have enabled the `should` syntax.
-  end
-end
-
-# The legacy `:should` syntax adds the `any_instance` to `Class`.
-# We generally recommend you use the newer `:expect` syntax instead,
-# which allows you to stub any instance of a class using
-# `allow_any_instance_of(klass)` or mock any instance using
-# `expect_any_instance_of(klass)`.
-# @see BasicObject
-class Class
-  # @method any_instance
-  # Used to set stubs and message expectations on any instance of a given
-  # class. Returns a [Recorder](Recorder), which records messages like
-  # `stub` and `should_receive` for later playback on instances of the
-  # class.
-  #
-  # @example
-  #   Car.any_instance.should_receive(:go)
-  #   race = Race.new
-  #   race.cars << Car.new
-  #   race.go # assuming this delegates to all of its cars
-  #           # this example would pass
-  #
-  #   Account.any_instance.stub(:balance) { Money.new(:USD, 25) }
-  #   Account.new.balance # => Money.new(:USD, 25))
-  #
-  # @return [Recorder]
-  #
-  # @note This is only available when you have enabled the `should` syntax.
-  # @see RSpec::Mocks::ExampleMethods#expect_any_instance_of
-  # @see RSpec::Mocks::ExampleMethods#allow_any_instance_of
-end

data/vendor/bundle/ruby/2.3.0/gems/rspec-mocks-3.7.0/lib/rspec/mocks/targets.rb

@@ -1,124 +0,0 @@
-module RSpec
-  module Mocks
-    # @private
-    module TargetDelegationClassMethods
-      def delegate_to(matcher_method)
-        define_method(:to) do |matcher, &block|
-          unless matcher_allowed?(matcher)
-            raise_unsupported_matcher(:to, matcher)
-          end
-          define_matcher(matcher, matcher_method, &block)
-        end
-      end
-
-      def delegate_not_to(matcher_method, options={})
-        method_name = options.fetch(:from)
-        define_method(method_name) do |matcher, &block|
-          case matcher
-          when Matchers::Receive, Matchers::HaveReceived
-            define_matcher(matcher, matcher_method, &block)
-          when Matchers::ReceiveMessages, Matchers::ReceiveMessageChain
-            raise_negation_unsupported(method_name, matcher)
-          else
-            raise_unsupported_matcher(method_name, matcher)
-          end
-        end
-      end
-
-      def disallow_negation(method_name)
-        define_method(method_name) do |matcher, *_args|
-          raise_negation_unsupported(method_name, matcher)
-        end
-      end
-    end
-
-    # @private
-    module TargetDelegationInstanceMethods
-      attr_reader :target
-
-    private
-
-      def matcher_allowed?(matcher)
-        Matchers::Matcher === matcher
-      end
-
-      def define_matcher(matcher, name, &block)
-        matcher.__send__(name, target, &block)
-      end
-
-      def raise_unsupported_matcher(method_name, matcher)
-        raise UnsupportedMatcherError,
-              "only the `receive`, `have_received` and `receive_messages` matchers are supported " \
-              "with `#{expression}(...).#{method_name}`, but you have provided: #{matcher}"
-      end
-
-      def raise_negation_unsupported(method_name, matcher)
-        raise NegationUnsupportedError,
-              "`#{expression}(...).#{method_name} #{matcher.name}` is not supported since it " \
-              "doesn't really make sense. What would it even mean?"
-      end
-    end
-
-    # @private
-    class TargetBase
-      def initialize(target)
-        @target = target
-      end
-
-      extend TargetDelegationClassMethods
-      include TargetDelegationInstanceMethods
-    end
-
-    # @private
-    module ExpectationTargetMethods
-      extend TargetDelegationClassMethods
-      include TargetDelegationInstanceMethods
-
-      delegate_to :setup_expectation
-      delegate_not_to :setup_negative_expectation, :from => :not_to
-      delegate_not_to :setup_negative_expectation, :from => :to_not
-
-      def expression
-        :expect
-      end
-    end
-
-    # @private
-    class ExpectationTarget < TargetBase
-      include ExpectationTargetMethods
-    end
-
-    # @private
-    class AllowanceTarget < TargetBase
-      def expression
-        :allow
-      end
-
-      delegate_to :setup_allowance
-      disallow_negation :not_to
-      disallow_negation :to_not
-    end
-
-    # @private
-    class AnyInstanceAllowanceTarget < TargetBase
-      def expression
-        :allow_any_instance_of
-      end
-
-      delegate_to :setup_any_instance_allowance
-      disallow_negation :not_to
-      disallow_negation :to_not
-    end
-
-    # @private
-    class AnyInstanceExpectationTarget < TargetBase
-      def expression
-        :expect_any_instance_of
-      end
-
-      delegate_to :setup_any_instance_expectation
-      delegate_not_to :setup_any_instance_negative_expectation, :from => :not_to
-      delegate_not_to :setup_any_instance_negative_expectation, :from => :to_not
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rspec-mocks-3.7.0/lib/rspec/mocks/test_double.rb

@@ -1,171 +0,0 @@
-module RSpec
-  module Mocks
-    # Implements the methods needed for a pure test double.  RSpec::Mocks::Double
-    # includes this module, and it is provided for cases where you want a
-    # pure test double without subclassing RSpec::Mocks::Double.
-    module TestDouble
-      # Creates a new test double with a `name` (that will be used in error
-      # messages only)
-      def initialize(name=nil, stubs={})
-        @__expired = false
-        if Hash === name && stubs.empty?
-          stubs = name
-          @name = nil
-        else
-          @name = name
-        end
-        assign_stubs(stubs)
-      end
-
-      # Tells the object to respond to all messages. If specific stub values
-      # are declared, they'll work as expected. If not, the receiver is
-      # returned.
-      def as_null_object
-        __mock_proxy.as_null_object
-      end
-
-      # Returns true if this object has received `as_null_object`
-      def null_object?
-        __mock_proxy.null_object?
-      end
-
-      # This allows for comparing the mock to other objects that proxy such as
-      # ActiveRecords belongs_to proxy objects. By making the other object run
-      # the comparison, we're sure the call gets delegated to the proxy
-      # target.
-      def ==(other)
-        other == __mock_proxy
-      end
-
-      # @private
-      def inspect
-        TestDoubleFormatter.format(self)
-      end
-
-      # @private
-      def to_s
-        inspect.gsub('<', '[').gsub('>', ']')
-      end
-
-      # @private
-      def respond_to?(message, incl_private=false)
-        __mock_proxy.null_object? ? true : super
-      end
-
-      # @private
-      def __build_mock_proxy_unless_expired(order_group)
-        __raise_expired_error || __build_mock_proxy(order_group)
-      end
-
-      # @private
-      def __disallow_further_usage!
-        @__expired = true
-      end
-
-      # Override for default freeze implementation to prevent freezing of test
-      # doubles.
-      def freeze
-        RSpec.warn_with("WARNING: you attempted to freeze a test double. This is explicitly a no-op as freezing doubles can lead to undesired behaviour when resetting tests.")
-        self
-      end
-
-    private
-
-      def method_missing(message, *args, &block)
-        proxy = __mock_proxy
-        proxy.record_message_received(message, *args, &block)
-
-        if proxy.null_object?
-          case message
-          when :to_int        then return 0
-          when :to_a, :to_ary then return nil
-          when :to_str        then return to_s
-          else return self
-          end
-        end
-
-        # Defined private and protected methods will still trigger `method_missing`
-        # when called publicly. We want ruby's method visibility error to get raised,
-        # so we simply delegate to `super` in that case.
-        # ...well, we would delegate to `super`, but there's a JRuby
-        # bug, so we raise our own visibility error instead:
-        # https://github.com/jruby/jruby/issues/1398
-        visibility = proxy.visibility_for(message)
-        if visibility == :private || visibility == :protected
-          ErrorGenerator.new(self).raise_non_public_error(
-            message, visibility
-          )
-        end
-
-        # Required wrapping doubles in an Array on Ruby 1.9.2
-        raise NoMethodError if [:to_a, :to_ary].include? message
-        proxy.raise_unexpected_message_error(message, args)
-      end
-
-      def assign_stubs(stubs)
-        stubs.each_pair do |message, response|
-          __mock_proxy.add_simple_stub(message, response)
-        end
-      end
-
-      def __mock_proxy
-        ::RSpec::Mocks.space.proxy_for(self)
-      end
-
-      def __build_mock_proxy(order_group)
-        TestDoubleProxy.new(self, order_group)
-      end
-
-      def __raise_expired_error
-        return false unless @__expired
-        ErrorGenerator.new(self).raise_expired_test_double_error
-      end
-
-      def initialize_copy(other)
-        as_null_object if other.null_object?
-        super
-      end
-    end
-
-    # A generic test double object. `double`, `instance_double` and friends
-    # return an instance of this.
-    class Double
-      include TestDouble
-    end
-
-    # @private
-    module TestDoubleFormatter
-      def self.format(dbl, unwrap=false)
-        format = "#{type_desc(dbl)}#{verified_module_desc(dbl)} #{name_desc(dbl)}"
-        return format if unwrap
-        "#<#{format}>"
-      end
-
-      class << self
-      private
-
-        def type_desc(dbl)
-          case dbl
-          when InstanceVerifyingDouble then "InstanceDouble"
-          when ClassVerifyingDouble    then "ClassDouble"
-          when ObjectVerifyingDouble   then "ObjectDouble"
-          else "Double"
-          end
-        end
-
-        # @private
-        IVAR_GET = Object.instance_method(:instance_variable_get)
-
-        def verified_module_desc(dbl)
-          return nil unless VerifyingDouble === dbl
-          "(#{IVAR_GET.bind(dbl).call(:@doubled_module).description})"
-        end
-
-        def name_desc(dbl)
-          return "(anonymous)" unless (name = IVAR_GET.bind(dbl).call(:@name))
-          name.inspect
-        end
-      end
-    end
-  end
-end