bitclust-core 0.5.1 → 0.5.2

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/double_definitions/strategies/verification/verification_strategy.rb

@@ -0,0 +1,10 @@
+module RR
+  module DoubleDefinitions
+    module Strategies
+      module Verification
+        class VerificationStrategy < Strategy
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/double_matches.rb

@@ -0,0 +1,42 @@
+module RR
+  class DoubleMatches
+    attr_reader :matching_doubles,
+                :exact_terminal_doubles_to_attempt,
+                :exact_non_terminal_doubles_to_attempt,
+                :wildcard_terminal_doubles_to_attempt,
+                :wildcard_non_terminal_doubles_to_attempt
+    def initialize(doubles) #:nodoc:
+      @doubles = doubles
+      @matching_doubles = []
+      @exact_terminal_doubles_to_attempt = []
+      @exact_non_terminal_doubles_to_attempt = []
+      @wildcard_terminal_doubles_to_attempt = []
+      @wildcard_non_terminal_doubles_to_attempt = []
+    end
+
+    def find_all_matches(args)
+      @doubles.each do |double|
+        if double.exact_match?(*args)
+          matching_doubles << double
+          if double.attempt?
+            if double.terminal?
+              exact_terminal_doubles_to_attempt << double
+            else
+              exact_non_terminal_doubles_to_attempt << double
+            end
+          end
+        elsif double.wildcard_match?(*args)
+          matching_doubles << double
+          if double.attempt?
+            if double.terminal?
+              wildcard_terminal_doubles_to_attempt << double
+            else
+              wildcard_non_terminal_doubles_to_attempt << double
+            end
+          end
+        end
+      end
+      self
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/errors/argument_equality_error.rb

@@ -0,0 +1,6 @@
+module RR
+  module Errors
+    class ArgumentEqualityError < RRError
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/errors/double_definition_error.rb

@@ -0,0 +1,6 @@
+module RR
+  module Errors
+    class DoubleDefinitionError < RRError
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/errors/double_not_found_error.rb

@@ -0,0 +1,6 @@
+module RR
+  module Errors
+    class DoubleNotFoundError < RRError
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/errors/double_order_error.rb

@@ -0,0 +1,6 @@
+module RR
+  module Errors
+    class DoubleOrderError < RRError
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/errors/rr_error.rb

@@ -0,0 +1,20 @@
+module RR
+  module Errors
+    BACKTRACE_IDENTIFIER = Regexp.new("/lib/rr")
+
+    class RRError < RuntimeError
+      attr_writer :backtrace
+      def backtrace
+        @backtrace ||= super
+        original_backtrace = @backtrace
+        return original_backtrace unless RR.trim_backtrace
+        return original_backtrace unless original_backtrace.respond_to?(:each)
+        new_backtrace = []
+        original_backtrace.each do |line|
+          new_backtrace << line unless line =~ BACKTRACE_IDENTIFIER
+        end
+        new_backtrace
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/errors/spy_verification_errors/double_injection_not_found_error.rb

@@ -0,0 +1,8 @@
+module RR
+  module Errors
+    module SpyVerificationErrors
+      class DoubleInjectionNotFoundError < SpyVerificationError
+      end      
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/errors/spy_verification_errors/invocation_count_error.rb

@@ -0,0 +1,8 @@
+module RR
+  module Errors
+    module SpyVerificationErrors
+      class InvocationCountError < SpyVerificationError
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/errors/spy_verification_errors/spy_verification_error.rb

@@ -0,0 +1,8 @@
+module RR
+  module Errors
+    module SpyVerificationErrors
+      class SpyVerificationError < RRError
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/errors/subject_does_not_implement_method_error.rb

@@ -0,0 +1,6 @@
+module RR
+  module Errors
+    class SubjectDoesNotImplementMethodError < RRError
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/errors/subject_has_different_arity_error.rb

@@ -0,0 +1,6 @@
+module RR
+  module Errors
+    class SubjectHasDifferentArityError < RRError
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/errors/times_called_error.rb

@@ -0,0 +1,6 @@
+module RR
+  module Errors
+    class TimesCalledError < RRError
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/expectations/any_argument_expectation.rb

@@ -0,0 +1,21 @@
+module RR
+  module Expectations
+    class AnyArgumentExpectation < ArgumentEqualityExpectation #:nodoc:
+      def initialize
+        super
+      end
+
+      def exact_match?(*arguments)
+        false
+      end
+
+      def wildcard_match?(*arguments)
+        true
+      end
+
+      def ==(other)
+        other.is_a?(self.class)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/expectations/argument_equality_expectation.rb

@@ -0,0 +1,41 @@
+module RR
+  module Expectations
+    class ArgumentEqualityExpectation #:nodoc:
+      attr_reader :expected_arguments
+
+      def initialize(*expected_arguments)
+        @expected_arguments = expected_arguments
+      end
+
+      def exact_match?(*arguments)
+        return false unless arguments.length == expected_arguments.length
+        arguments.each_with_index do |arg, index|
+          return false unless equality_match(expected_arguments[index], arg)
+        end
+        true
+      end
+
+      def wildcard_match?(*arguments)
+        return false unless arguments.length == expected_arguments.length
+        arguments.each_with_index do |arg, index|
+          expected_argument = expected_arguments[index]
+          if expected_argument.respond_to?(:wildcard_match?)
+            return false unless expected_argument.wildcard_match?(arg)
+          else
+            return false unless equality_match(expected_argument, arg)
+          end
+        end
+        true
+      end
+
+      def ==(other)
+        expected_arguments == other.expected_arguments
+      end
+
+      protected
+      def equality_match(arg1, arg2)
+        arg1.respond_to?(:'__rr__original_==') ? arg1.__send__(:'__rr__original_==', arg2) : arg1 == arg2
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/expectations/times_called_expectation.rb

@@ -0,0 +1,57 @@
+module RR
+  module Expectations
+    class TimesCalledExpectation #:nodoc:
+      attr_reader :double, :times_called
+
+      def initialize(double)
+        @double = double
+        @times_called = 0
+        @verify_backtrace = caller[1..-1]
+      end
+
+      def attempt?
+        times_matcher.attempt?(@times_called)
+      end
+
+      def attempt
+        @times_called += 1
+        verify_input_error unless times_matcher.possible_match?(@times_called)
+        return
+      end
+
+      def verify
+        return false unless times_matcher.is_a?(TimesCalledMatchers::TimesCalledMatcher)
+        return times_matcher.matches?(@times_called)
+      end
+
+      def verify!
+        unless verify
+          if @verify_backtrace
+            error = Errors::TimesCalledError.new(error_message)
+            error.backtrace = @verify_backtrace
+            raise error
+          else
+            raise Errors::TimesCalledError, error_message
+          end
+        end
+      end
+
+      def terminal?
+        times_matcher.terminal?
+      end
+
+      protected
+      def times_matcher
+        double.definition.times_matcher
+      end
+
+      def verify_input_error
+        raise Errors::TimesCalledError, error_message
+      end
+
+      def error_message
+        "#{double.formatted_name}\n#{times_matcher.error_message(@times_called)}"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/hash_with_object_id_key.rb

@@ -0,0 +1,46 @@
+module RR
+  # TODO: Refactor to a side-effect-free strategy.
+  class HashWithObjectIdKey < ::Hash #:nodoc:
+    def initialize
+      @keys = {}
+      super
+    end
+
+    alias_method :get_with_object_id, :[]
+
+    def [](key)
+      @keys[key.__id__] = key
+      super(key.__id__)
+    end
+
+    def has_key?(key)
+      super(key.__id__)
+    end
+
+    alias_method :set_with_object_id, :[]=
+
+    def []=(key, value)
+      @keys[key.__id__] = key
+      super(key.__id__, value)
+    end
+
+    def each
+      super do |object_id, value|
+        yield @keys[object_id], value
+      end
+    end
+
+    def delete(key)
+      @keys.delete(key.__id__)
+      super(key.__id__)
+    end
+
+    def keys
+      @keys.values
+    end
+
+    def include?(key)
+      super(key.__id__)
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/injections/double_injection.rb

@@ -0,0 +1,220 @@
+module RR
+  module Injections
+    # RR::DoubleInjection is the binding of an subject and a method.
+    # A double_injection has 0 to many Double objects. Each Double
+    # has Argument Expectations and Times called Expectations.
+    class DoubleInjection < Injection
+      extend(Module.new do
+        def find_or_create(subject_class, method_name)
+          instances[subject_class][method_name.to_sym] ||= begin
+            new(subject_class, method_name.to_sym).bind
+          end
+        end
+
+        def find_or_create_by_subject(subject, method_name)
+          find_or_create(class << subject; self; end, method_name)
+        end
+
+        def find(subject_class, method_name)
+          instances[subject_class] && instances[subject_class][method_name.to_sym]
+        end
+
+        def find_by_subject(subject, method_name)
+          find(class << subject; self; end, method_name)
+        end
+
+        def exists?(subject_class, method_name)
+          !!find(subject_class, method_name)
+        end
+
+        def exists_by_subject?(subject, method_name)
+          exists?((class << subject; self; end), method_name)
+        end
+
+        def dispatch_method(subject, subject_class, method_name, arguments, block)
+          subject_eigenclass = (class << subject; self; end)
+          if (
+            exists?(subject_class, method_name) &&
+            (subject_class == subject_eigenclass) || !subject.is_a?(Class)
+          )
+            find(subject_class, method_name.to_sym).dispatch_method(subject, arguments, block)
+          else
+            new(subject_class, method_name.to_sym).dispatch_original_method(subject, arguments, block)
+          end
+        end
+
+        def reset
+          instances.each do |subject_class, method_double_map|
+            SingletonMethodAddedInjection.find(subject_class) && SingletonMethodAddedInjection.find(subject_class).reset
+            method_double_map.keys.each do |method_name|
+              reset_double(subject_class, method_name)
+            end
+            Injections::DoubleInjection.instances.delete(subject_class) if Injections::DoubleInjection.instances.has_key?(subject_class)
+          end
+        end
+
+        def verify(*subjects)
+          subject_classes = subjects.empty? ?
+            Injections::DoubleInjection.instances.keys :
+            subjects.map {|subject| class << subject; self; end}
+          subject_classes.each do |subject_class|
+            instances.include?(subject_class) &&
+              instances[subject_class].keys.each do |method_name|
+                verify_double(subject_class, method_name)
+              end &&
+              instances.delete(subject_class)
+          end
+        end
+
+        # Verifies the DoubleInjection for the passed in subject and method_name.
+        def verify_double(subject_class, method_name)
+          Injections::DoubleInjection.find(subject_class, method_name).verify
+        ensure
+          reset_double subject_class, method_name
+        end
+
+        # Resets the DoubleInjection for the passed in subject and method_name.
+        def reset_double(subject_class, method_name)
+          double_injection = Injections::DoubleInjection.instances[subject_class].delete(method_name)
+          double_injection.reset
+          Injections::DoubleInjection.instances.delete(subject_class) if Injections::DoubleInjection.instances[subject_class].empty?
+        end
+
+        def instances
+          @instances ||= HashWithObjectIdKey.new do |hash, subject_class|
+            hash.set_with_object_id(subject_class, {})
+          end
+        end
+      end)
+      include ClassInstanceMethodDefined
+
+      attr_reader :subject_class, :method_name, :doubles
+
+      MethodArguments = Struct.new(:arguments, :block)
+
+      def initialize(subject_class, method_name)
+        @subject_class = subject_class
+        @method_name = method_name.to_sym
+        @doubles = []
+        @dispatch_method_delegates_to_dispatch_original_method = nil
+      end
+
+      # RR::DoubleInjection#register_double adds the passed in Double
+      # into this DoubleInjection's list of Double objects.
+      def register_double(double)
+        @doubles << double
+      end
+
+      # RR::DoubleInjection#bind injects a method that acts as a dispatcher
+      # that dispatches to the matching Double when the method
+      # is called.
+      def bind
+        if subject_has_method_defined?(method_name)
+          bind_method_with_alias
+        else
+          Injections::MethodMissingInjection.find_or_create(subject_class)
+          Injections::SingletonMethodAddedInjection.find_or_create(subject_class)
+          bind_method_that_self_destructs_and_delegates_to_method_missing
+        end
+        self
+      end
+
+      BoundObjects = {}
+
+      def bind_method_that_self_destructs_and_delegates_to_method_missing
+        id = BoundObjects.size
+        BoundObjects[id] = subject_class
+
+        subject_class.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def #{method_name}(*args, &block)
+          ::RR::Injections::DoubleInjection::BoundObjects[#{id}].class_eval do
+            remove_method(:#{method_name})
+          end
+          method_missing(:#{method_name}, *args, &block)
+        end
+        RUBY
+        self
+      end
+
+      def bind_method
+        id = BoundObjects.size
+        BoundObjects[id] = subject_class
+
+        subject_class.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def #{method_name}(*args, &block)
+          arguments = MethodArguments.new(args, block)
+          obj = ::RR::Injections::DoubleInjection::BoundObjects[#{id}]
+          RR::Injections::DoubleInjection.dispatch_method(self, obj, :#{method_name}, arguments.arguments, arguments.block)
+        end
+        RUBY
+        self
+      end
+
+      # RR::DoubleInjection#verify verifies each Double
+      # TimesCalledExpectation are met.
+      def verify
+        @doubles.each do |double|
+          double.verify
+        end
+      end
+
+      # RR::DoubleInjection#reset removes the injected dispatcher method.
+
+      # It binds the original method implementation on the subject
+      # if one exists.
+      def reset
+        if subject_has_original_method?
+          subject_class.__send__(:remove_method, method_name)
+          subject_class.__send__(:alias_method, method_name, original_method_alias_name)
+          subject_class.__send__(:remove_method, original_method_alias_name)
+        else
+          if subject_has_method_defined?(method_name)
+            subject_class.__send__(:remove_method, method_name)
+          end
+        end
+      end
+
+      def dispatch_method(subject, args, block)
+        if @dispatch_method_delegates_to_dispatch_original_method
+          dispatch_original_method(subject, args, block)
+        else
+          dispatch = MethodDispatches::MethodDispatch.new(self, subject, args, block)
+          dispatch.call
+        end
+      end
+
+      def dispatch_original_method(subject, args, block)
+        dispatch = MethodDispatches::MethodDispatch.new(self, subject, args, block)
+        dispatch.call_original_method
+      end
+
+      def subject_has_original_method_missing?
+        class_instance_method_defined(subject_class, MethodDispatches::MethodMissingDispatch.original_method_missing_alias_name)
+      end
+
+      def original_method_alias_name
+        "__rr__original_#{@method_name}"
+      end
+
+      def dispatch_method_delegates_to_dispatch_original_method
+        @dispatch_method_delegates_to_dispatch_original_method = true
+        yield
+      ensure
+        @dispatch_method_delegates_to_dispatch_original_method = nil
+      end
+
+      protected
+      def deferred_bind_method
+        unless subject_has_method_defined?(original_method_alias_name)
+          bind_method_with_alias
+        end
+        @performed_deferred_bind = true
+      end
+
+      def bind_method_with_alias
+        subject_class.__send__(:alias_method, original_method_alias_name, method_name)
+        bind_method
+      end
+    end
+  end
+end