bitclust-core 0.5.3 → 0.5.4

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.3/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/adapters/minitest.rb

@@ -1,31 +0,0 @@
-module RR
-  module Adapters
-    module MiniTest
-      include RRMethods
-      def self.included(mod)
-        RR.trim_backtrace = true
-        mod.class_eval do
-          unless instance_methods.any? { |method_name| method_name.to_sym == :setup_with_rr }
-            alias_method :setup_without_rr, :setup
-            def setup_with_rr
-              setup_without_rr
-              RR.reset
-            end
-            alias_method :setup, :setup_with_rr
-
-            alias_method :teardown_without_rr, :teardown
-            def teardown_with_rr
-              RR.verify
-              teardown_without_rr
-            end
-            alias_method :teardown, :teardown_with_rr
-          end
-        end
-      end
-
-      def assert_received(subject, &block)
-        block.call(received(subject)).call
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.3/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/adapters/rr_methods.rb

@@ -1,146 +0,0 @@
-module RR
-  module Adapters
-    module RRMethods
-      include ::RR::DoubleDefinitions::Strategies::StrategyMethods
-      def mock(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
-        double_definition_create.mock(subject, method_name, &definition_eval_block)
-      end
-
-      def stub(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
-        double_definition_create.stub(subject, method_name, &definition_eval_block)
-      end
-
-      def dont_allow(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
-        double_definition_create.dont_allow(subject, method_name, &definition_eval_block)
-      end
-
-      def proxy(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
-        double_definition_create.proxy(subject, method_name, &definition_eval_block)
-      end
-
-      def strong(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
-        double_definition_create.strong(subject, method_name, &definition_eval_block)
-      end
-
-      def instance_of(subject=DoubleDefinitions::DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        double_definition_create = DoubleDefinitions::DoubleDefinitionCreate.new
-        double_definition_create.instance_of(subject, method_name, &definition_eval_block)
-      end
-      alias_method :any_instance_of, :instance_of
-      alias_method :all_instances_of, :instance_of
-
-      # Verifies all the DoubleInjection objects have met their
-      # TimesCalledExpectations.
-      def verify
-        RR::Space.instance.verify_doubles
-      end
-
-      # Resets the registered Doubles and ordered Doubles
-      def reset
-        RR::Space.instance.reset
-      end
-
-      # Returns a AnyTimesMatcher. This is meant to be passed in as an argument
-      # to Double#times.
-      #
-      #   mock(object).method_name(anything).times(any_times) {return_value}
-      def any_times
-        TimesCalledMatchers::AnyTimesMatcher.new
-      end
-
-      # Sets up an Anything wildcard ArgumentEqualityExpectation
-      # that succeeds when passed any argument.
-      #   mock(object).method_name(anything) {return_value}
-      #   object.method_name("an arbitrary value") # passes
-      def anything
-        RR::WildcardMatchers::Anything.new
-      end
-
-      # Sets up an IsA wildcard ArgumentEqualityExpectation
-      # that succeeds when passed an argument of a certain type.
-      #   mock(object).method_name(is_a(String)) {return_value}
-      #   object.method_name("A String") # passes
-      def is_a(klass)
-        RR::WildcardMatchers::IsA.new(klass)
-      end
-
-      # Sets up an Numeric wildcard ArgumentEqualityExpectation
-      # that succeeds when passed an argument that is ::Numeric.
-      #   mock(object).method_name(numeric) {return_value}
-      #   object.method_name(99) # passes
-      def numeric
-        RR::WildcardMatchers::Numeric.new
-      end
-
-      # Sets up an Boolean wildcard ArgumentEqualityExpectation
-      # that succeeds when passed an argument that is a ::Boolean.
-      #   mock(object).method_name(boolean) {return_value}
-      #   object.method_name(false) # passes
-      def boolean
-        RR::WildcardMatchers::Boolean.new
-      end
-
-      # Sets up a DuckType wildcard ArgumentEqualityExpectation
-      # that succeeds when the passed argument implements the methods.
-      #   arg = Object.new
-      #   def arg.foo; end
-      #   def arg.bar; end
-      #   mock(object).method_name(duck_type(:foo, :bar)) {return_value}
-      #   object.method_name(arg) # passes
-      def duck_type(*args)
-        RR::WildcardMatchers::DuckType.new(*args)
-      end
-
-      # Sets up a HashIncluding wildcard ArgumentEqualityExpectation
-      # that succeeds when the passed argument contains at least those keys
-      # and values of the expectation.
-      #   mock(object).method_name(hash_including(:foo => 1)) {return_value}
-      #   object.method_name({:foo => 1, :bar => 2) # passes
-      def hash_including(expected_hash)
-        RR::WildcardMatchers::HashIncluding.new(expected_hash)
-      end
-
-      # Sets up a Satisfy wildcard ArgumentEqualityExpectation
-      # that succeeds when the passed argument causes the expectation's
-      # proc to return true.
-      #   mock(object).method_name(satisfy {|arg| arg == :foo}) {return_value}
-      #   object.method_name(:foo) # passes
-      def satisfy(expectation_proc=nil, &block)
-        expectation_proc ||= block
-        RR::WildcardMatchers::Satisfy.new(expectation_proc)
-      end
-
-      def spy(subject)
-        methods_to_stub = subject.public_methods.map {|method_name| method_name.to_sym} -
-          [:methods, :==, :__send__, :__id__, :object_id, :class]
-        methods_to_stub.each do |method|
-          stub.proxy(subject, method)
-        end
-      end
-
-      def received(subject)
-        RR::SpyVerificationProxy.new(subject)
-      end
-
-      def new_instance_of(*args, &block)
-        RR::DoubleDefinitions::DoubleInjections::NewInstanceOf.call(*args, &block)
-      end
-
-      def any_instance_of(*args, &block)
-        RR::DoubleDefinitions::DoubleInjections::AnyInstanceOf.call(*args, &block)
-      end
-
-      instance_methods.each do |name|
-        alias_method "rr_#{name}", name
-      end
-    end
-  end
-  module Extensions
-    InstanceMethods = Adapters::RRMethods
-  end
-end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.3/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/adapters/rspec.rb

@@ -1,61 +0,0 @@
-module RR
-  module Adapters
-    module Rspec
-      def self.included(mod)
-        patterns = ::Spec::Runner::QuietBacktraceTweaker::IGNORE_PATTERNS
-        unless patterns.include?(RR::Errors::BACKTRACE_IDENTIFIER)
-          patterns.push(RR::Errors::BACKTRACE_IDENTIFIER)
-        end
-      end
-
-      include RRMethods
-      def setup_mocks_for_rspec
-        RR.reset
-      end
-      def verify_mocks_for_rspec
-        RR.verify
-      end
-      def teardown_mocks_for_rspec
-        RR.reset
-      end
-
-      def have_received(method = nil)
-        InvocationMatcher.new(method)
-      end
-
-      class InvocationMatcher < SpyVerificationProxy
-        attr_reader :failure_message, :spy_verification_proxy
- 
-        def initialize(method = nil)
-          @verification = nil
-          @subject = nil
-          method_missing(method) if method
-        end
-
-        def matches?(subject)
-          @verification.subject = subject
-          calls = RR::Space.instance.recorded_calls
-          if error = calls.match_error(@verification)
-            @failure_message = error.message
-            false
-          else
-            true
-          end
-        end
-
-        def nil?
-          false
-        end
-
-        def method_missing(method_name, *args, &block)
-          if @verification
-            @verification.send(method_name, *args)
-          else
-            @verification = super
-          end
-          self
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.3/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/adapters/test_unit.rb

@@ -1,31 +0,0 @@
-module RR
-  module Adapters
-    module TestUnit
-      include RRMethods
-      def self.included(mod)
-        RR.trim_backtrace = true
-        mod.class_eval do
-          unless instance_methods.detect {|method_name| method_name.to_sym == :setup_with_rr}
-            alias_method :setup_without_rr, :setup
-            def setup_with_rr
-              setup_without_rr
-              RR.reset
-            end
-            alias_method :setup, :setup_with_rr
-
-            alias_method :teardown_without_rr, :teardown
-            def teardown_with_rr
-              RR.verify
-              teardown_without_rr
-            end
-            alias_method :teardown, :teardown_with_rr
-          end
-        end
-      end
-
-      def assert_received(subject, &block)
-        block.call(received(subject)).call
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.3/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/blank_slate.rb

@@ -1,17 +0,0 @@
-module RR
-  module BlankSlate
-    extend(Module.new do
-      def call(klass)
-        klass.instance_eval do
-          instance_methods.each do |unformatted_method_name|
-            method_name = unformatted_method_name.to_s
-            unless method_name =~ /^_/ || Space.blank_slate_whitelist.any? {|whitelisted_method_name| method_name == whitelisted_method_name}
-              alias_method "__blank_slated_#{method_name}", method_name
-              undef_method method_name
-            end
-          end
-        end
-      end
-    end)
-  end
-end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.3/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/class_instance_method_defined.rb

@@ -1,9 +0,0 @@
-module RR
-  module ClassInstanceMethodDefined
-    def class_instance_method_defined(klass, instance_method, include_super=true)
-      klass.instance_methods(include_super).detect {|method_name| method_name.to_sym == instance_method.to_sym} ||
-        klass.protected_instance_methods(include_super).detect {|method_name| method_name.to_sym == instance_method.to_sym} ||
-        klass.private_instance_methods(include_super).detect {|method_name| method_name.to_sym == instance_method.to_sym}
-    end
-  end
-end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.3/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/double.rb

@@ -1,154 +0,0 @@
-module RR
-  # RR::Double is the use case for a method call.
-  # It has the ArgumentEqualityExpectation, TimesCalledExpectation,
-  # and the implementation.
-  class Double
-    extend(Module.new do
-      def formatted_name(method_name, args)
-        formatted_errors = args.collect {|arg| arg.inspect}.join(', ')
-        "#{method_name}(#{formatted_errors})"
-      end
-
-      def list_message_part(doubles)
-        doubles.collect do |double|
-          "- #{formatted_name(double.method_name, double.expected_arguments)}"
-        end.join("\n")
-      end
-    end)
-
-    attr_reader :times_called, :double_injection, :definition, :times_called_expectation
-    include Space::Reader
-
-    def initialize(double_injection, definition)
-      @double_injection = double_injection
-      @definition = definition
-      @times_called = 0
-      @times_called_expectation = Expectations::TimesCalledExpectation.new(self)
-      definition.double = self
-      verify_method_signature if definition.verify_method_signature?
-      double_injection.register_double self
-    end
-
-    # Double#exact_match? returns true when the passed in arguments
-    # exactly match the ArgumentEqualityExpectation arguments.
-    def exact_match?(*arguments)
-      definition.exact_match?(*arguments)
-    end
-
-    # Double#wildcard_match? returns true when the passed in arguments
-    # wildcard match the ArgumentEqualityExpectation arguments.
-    def wildcard_match?(*arguments)
-      definition.wildcard_match?(*arguments)
-    end
-
-    # Double#attempt? returns true when the
-    # TimesCalledExpectation is satisfied.
-    def attempt?
-      verify_times_matcher_is_set
-      times_called_expectation.attempt?
-    end
-
-    # Double#verify verifies the the TimesCalledExpectation
-    # is satisfied for this double. A TimesCalledError
-    # is raised if the TimesCalledExpectation is not met.
-    def verify
-      verify_times_matcher_is_set
-      times_called_expectation.verify!
-      true
-    end
-
-    def terminal?
-      verify_times_matcher_is_set
-      times_called_expectation.terminal?
-    end
-
-    # The method name that this Double is attatched to
-    def method_name
-      double_injection.method_name
-    end
-
-    # The Arguments that this Double expects
-    def expected_arguments
-      verify_argument_expectation_is_set
-      argument_expectation.expected_arguments
-    end
-
-    # The TimesCalledMatcher for the TimesCalledExpectation
-    def times_matcher
-      definition.times_matcher
-    end
-
-    def formatted_name
-      self.class.formatted_name(method_name, expected_arguments)
-    end
-
-    def method_call(args)
-      if verbose?
-        puts Double.formatted_name(method_name, args)
-      end
-      times_called_expectation.attempt if definition.times_matcher
-      space.verify_ordered_double(self) if ordered?
-    end
-
-    def implementation_is_original_method?
-      definition.implementation_is_original_method?
-    end
-
-    protected
-    def ordered?
-      definition.ordered?
-    end
-
-    def verbose?
-      definition.verbose?
-    end
-
-    def verify_times_matcher_is_set
-      unless definition.times_matcher
-        raise RR::Errors::DoubleDefinitionError, "#definition.times_matcher is not set"
-      end
-    end
-
-    def verify_argument_expectation_is_set
-      unless definition.argument_expectation
-        raise RR::Errors::DoubleDefinitionError, "#definition.argument_expectation is not set"
-      end
-    end
-
-    def verify_method_signature
-      unless double_injection.subject_has_original_method?
-        raise RR::Errors::SubjectDoesNotImplementMethodError
-      end
-      raise RR::Errors::SubjectHasDifferentArityError unless arity_matches?
-    end
-
-    def subject_arity
-      double_injection.original_method.arity
-    end
-
-    def subject_accepts_only_varargs?
-      subject_arity == -1
-    end
-
-    def subject_accepts_varargs?
-      subject_arity < 0
-    end
-
-    def arity_matches?
-      return true if subject_accepts_only_varargs?
-      if subject_accepts_varargs?
-        return ((subject_arity * -1) - 1) <= args.size
-      else
-        return subject_arity == args.size
-      end
-    end
-
-    def args
-      definition.argument_expectation.expected_arguments
-    end
-
-    def argument_expectation
-      definition.argument_expectation
-    end
-  end
-end