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/space.rb

@@ -0,0 +1,119 @@
+module RR
+  # RR::Space.instance is the global state subject for the RR framework.
+  class Space
+    module Reader
+      def space
+        RR::Space.instance
+      end
+    end
+
+    class << self
+      def instance
+        @instance ||= new
+      end
+      attr_writer :instance
+
+      protected
+      def method_missing(method_name, *args, &block)
+        instance.__send__(method_name, *args, &block)
+      end
+    end
+
+    attr_reader :ordered_doubles, :recorded_calls
+    attr_accessor :trim_backtrace
+    def initialize
+      @ordered_doubles = []
+      @trim_backtrace = false
+      @recorded_calls = RR::RecordedCalls.new
+    end
+
+    # Registers the ordered Double to be verified.
+    def register_ordered_double(double)
+      @ordered_doubles << double unless ordered_doubles.include?(double)
+    end
+
+    # Verifies that the passed in ordered Double is being called
+    # in the correct position.
+    def verify_ordered_double(double)
+      unless double.terminal?
+        raise Errors::DoubleOrderError,
+              "Ordered Doubles cannot have a NonTerminal TimesCalledExpectation"
+      end
+      unless @ordered_doubles.first == double
+        message = Double.formatted_name(double.method_name, double.expected_arguments)
+        message << " called out of order in list\n"
+        message << Double.list_message_part(@ordered_doubles)
+        raise Errors::DoubleOrderError, message
+      end
+      @ordered_doubles.shift unless double.attempt?
+      double
+    end
+
+    # Verifies all the DoubleInjection objects have met their
+    # TimesCalledExpectations.
+    def verify_doubles(*subjects)
+      Injections::DoubleInjection.verify(*subjects)
+    end
+    alias_method :verify, :verify_doubles
+
+    # Resets the registered Doubles and ordered Doubles
+    def reset
+      reset_ordered_doubles
+      Injections::DoubleInjection.reset
+      reset_method_missing_injections
+      reset_singleton_method_added_injections
+      reset_recorded_calls
+      reset_bound_objects
+    end
+
+    # Verifies the DoubleInjection for the passed in subject and method_name.
+    def verify_double(subject, method_name)
+      Injections::DoubleInjection.verify_double(class << subject; self; end, method_name)
+    end
+
+    # Resets the DoubleInjection for the passed in subject and method_name.
+    def reset_double(subject, method_name)
+      Injections::DoubleInjection.reset_double(class << subject; self; end, method_name)
+    end
+
+    def record_call(subject, method_name, arguments, block)
+      @recorded_calls << [subject, method_name, arguments, block]
+    end
+
+    def blank_slate_whitelist
+      @blank_slate_whitelist ||= [
+        "object_id", "respond_to?", "respond_to_missing?", "method_missing", "instance_eval", "instance_exec", "class_eval"
+      ]
+    end
+
+    protected
+    # Removes the ordered Doubles from the list
+    def reset_ordered_doubles
+      @ordered_doubles.clear
+    end
+
+    def reset_method_missing_injections
+      Injections::MethodMissingInjection.instances.each do |subject_class, injection|
+        injection.reset
+      end
+      Injections::MethodMissingInjection.instances.clear
+    end
+
+    def reset_singleton_method_added_injections
+      Injections::SingletonMethodAddedInjection.instances.each do |subject, injection|
+        injection.reset
+      end
+      Injections::SingletonMethodAddedInjection.instances.clear
+    end
+
+    def reset_recorded_calls
+      @recorded_calls.clear
+    end
+
+    def reset_bound_objects
+      # TODO: Figure out how to clear and reset these bindings
+      #RR::Injections::DoubleInjection::BoundObjects.clear
+      #RR::Injections::DoubleInjection::MethodMissingInjection.clear
+    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/spy_verification.rb

@@ -0,0 +1,48 @@
+module RR
+  class SpyVerification
+    def initialize(subject, method_name, args)
+      @subject = subject
+      @method_name = method_name.to_sym
+      set_argument_expectation_for_args(args)
+      @ordered = false
+      once
+    end
+
+    attr_reader :argument_expectation, :method_name, :times_matcher
+    attr_accessor :subject
+
+    include RR::DoubleDefinitions::DoubleDefinition::TimesDefinitionConstructionMethods
+    include RR::DoubleDefinitions::DoubleDefinition::ArgumentDefinitionConstructionMethods
+  
+    def ordered
+      @ordered = true
+      self
+    end
+  
+    def ordered?
+      @ordered
+    end
+
+    def call
+      (error = RR.recorded_calls.match_error(self)) && raise(error)
+    end
+
+    def to_proc
+      lambda do
+        call
+      end
+    end
+  
+  protected
+    attr_writer :times_matcher
+
+    def set_argument_expectation_for_args(args)
+      # with_no_args and with actually set @argument_expectation
+      args.empty? ? with_no_args : with(*args)
+    end
+  
+    def install_method_callback(return_value_block)
+      # Do nothing. This is to support DefinitionConstructionMethods
+    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/spy_verification_proxy.rb

@@ -0,0 +1,13 @@
+module RR
+  class SpyVerificationProxy
+    BlankSlate.call(self)
+
+    def initialize(subject)
+      @subject = subject
+    end
+  
+    def method_missing(method_name, *args, &block)
+      SpyVerification.new(@subject, method_name, args)
+    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/times_called_matchers/any_times_matcher.rb

@@ -0,0 +1,18 @@
+module RR
+  module TimesCalledMatchers #:nodoc:
+    class AnyTimesMatcher < TimesCalledMatcher
+      include NonTerminal
+
+      def initialize
+      end
+
+      def matches?(times_called)
+        true
+      end
+
+      def expected_times_message
+        "any number of times"
+      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/times_called_matchers/at_least_matcher.rb

@@ -0,0 +1,15 @@
+module RR
+  module TimesCalledMatchers #:nodoc:
+    class AtLeastMatcher < TimesCalledMatcher
+      include NonTerminal
+
+      def matches?(times_called)
+        times_called >= @times
+      end
+
+      def expected_times_message
+        "at least #{@times.inspect} times"
+      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/times_called_matchers/at_most_matcher.rb

@@ -0,0 +1,23 @@
+module RR
+  module TimesCalledMatchers #:nodoc:
+    class AtMostMatcher < TimesCalledMatcher
+      include Terminal
+
+      def possible_match?(times_called)
+        times_called <= @times
+      end
+
+      def matches?(times_called)
+        times_called <= @times
+      end
+
+      def attempt?(times_called)
+        times_called < @times
+      end
+
+      def expected_times_message
+        "at most #{@times.inspect} times"
+      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/times_called_matchers/integer_matcher.rb

@@ -0,0 +1,19 @@
+module RR
+  module TimesCalledMatchers #:nodoc:
+    class IntegerMatcher < TimesCalledMatcher
+      include Terminal
+
+      def possible_match?(times_called)
+        times_called <= @times
+      end
+
+      def matches?(times_called)
+        times_called == @times
+      end
+
+      def attempt?(times_called)
+        times_called < @times
+      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/times_called_matchers/never_matcher.rb

@@ -0,0 +1,23 @@
+module RR
+  module TimesCalledMatchers #:nodoc:
+    class NeverMatcher < TimesCalledMatcher
+      include Terminal
+
+      def initialize
+        super 0
+      end
+
+      def possible_match?(times_called)
+        true
+      end
+
+      def matches?(times_called)
+        true
+      end
+
+      def attempt?(times_called)
+        raise RR::Errors::TimesCalledError, error_message(1)
+      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/times_called_matchers/non_terminal.rb

@@ -0,0 +1,27 @@
+module RR
+  module TimesCalledMatchers
+    # Including this module marks the TimesCalledMatcher as NonTerminal.
+    # Being NonTerminal means the Double will not "terminate" even when
+    # called infinite times.
+    #
+    # The Double that uses a NonTerminal TimesCalledMatcher will
+    # continue using the Double when passed the matching arguments.
+    # This is done by the attempt? always returning true.
+    #
+    # This is in opposition to Terminal TimesCalledMatchers, where
+    # attempt? will eventually return false.
+    module NonTerminal #:nodoc:
+      def terminal?
+        false
+      end
+
+      def possible_match?(times_called)
+        true
+      end
+
+      def attempt?(times_called)
+        true
+      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/times_called_matchers/proc_matcher.rb

@@ -0,0 +1,11 @@
+module RR
+  module TimesCalledMatchers
+    class ProcMatcher < TimesCalledMatcher #:nodoc:
+      include NonTerminal
+
+      def matches?(times_called)
+        @times.call(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/times_called_matchers/range_matcher.rb

@@ -0,0 +1,21 @@
+module RR
+  module TimesCalledMatchers
+    class RangeMatcher < TimesCalledMatcher #:nodoc:
+      include Terminal
+
+      def possible_match?(times_called)
+        return true if times_called < @times.begin
+        return true if @times.include?(times_called)
+        return false
+      end
+
+      def matches?(times_called)
+        @times.include?(times_called)
+      end
+
+      def attempt?(times_called)
+        possible_match?(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/times_called_matchers/terminal.rb

@@ -0,0 +1,20 @@
+module RR
+  module TimesCalledMatchers
+    # Including this module marks the TimesCalledMatcher as Terminal.
+    # Being Terminal the Double will "terminate" when times called is
+    # finite.
+    #
+    # The Double that uses a Terminal TimesCalledMatcher will
+    # eventually be passed over to the next Double when passed
+    # the matching arguments enough times. This is done by the attempt?
+    # method returning false when executed a finite number of times.
+    #
+    # This is in opposition to NonTerminal TimesCalledMatchers, where
+    # attempt? will always return true.
+    module Terminal #:nodoc:
+      def terminal?
+        true
+      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/times_called_matchers/times_called_matcher.rb

@@ -0,0 +1,44 @@
+module RR
+  module TimesCalledMatchers
+    class TimesCalledMatcher #:nodoc:
+      extend(Module.new do
+        def create(value)
+          return value if value.is_a?(TimesCalledMatcher)
+          return IntegerMatcher.new(value) if value.is_a?(Integer)
+          return RangeMatcher.new(value) if value.is_a?(Range )
+          return ProcMatcher.new(value) if value.is_a?(Proc)
+          raise ArgumentError, "There is no TimesCalledMatcher for #{value.inspect}."
+        end
+      end)
+
+      attr_reader :times
+
+      def initialize(times)
+        @times = times
+      end
+
+      def matches?(times_called)
+      end
+
+      def attempt?(times_called)
+      end
+
+      def error_message(times_called)
+        "Called #{times_called.inspect} #{pluralized_time(times_called)}.\nExpected #{expected_times_message}."
+      end
+
+      def ==(other)
+        self.class == other.class && self.times == other.times
+      end
+
+      def expected_times_message
+        "#{@times.inspect} times"
+      end
+
+      protected
+      def pluralized_time(times_called)
+        (times_called == 1) ? "time" : "times"
+      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/wildcard_matchers.rb

@@ -0,0 +1,158 @@
+=begin rdoc
+
+= Writing your own custom wildcard matchers.
+Writing new wildcard matchers is not too difficult.  If you've ever written
+a custom expectation in RSpec, the implementation is very similar.
+
+As an example, let's say that you want a matcher that will match any number
+divisible by a certain integer.  In use, it might look like this:
+
+  # Will pass if BananaGrabber#bunch_bananas is called with an integer
+  # divisible by 5.
+
+  mock(BananaGrabber).bunch_bananas(divisible_by(5))
+
+To implement this, we need a class RR::WildcardMatchers::DivisibleBy with 
+these instance methods:
+
+* ==(other)
+* eql?(other) (usually aliased to #==)
+* inspect
+* wildcard_match?(other)
+
+and optionally, a sensible initialize method.  Let's look at each of these.
+
+=== .initialize
+
+Most custom wildcard matchers will want to define initialize to store
+some information about just what should be matched.  DivisibleBy#initialize
+might look like this:
+
+  class RR::WildcardMatchers::DivisibleBy
+    def initialize(divisor)
+      @expected_divisor = divisor
+    end
+  end
+
+=== #==(other)
+DivisibleBy#==(other) should return true if other is a wildcard matcher that
+matches the same things as self, so a natural way to write DivisibleBy#== is:
+
+  
+  class RR::WildcardMatchers::DivisibleBy
+    def ==(other)
+      # Ensure that other is actually a DivisibleBy
+      return false unless other.is_a?(self.class)
+
+      # Does other expect to match the same divisor we do?
+      self.expected_divisor = other.expected_divisor
+    end
+  end
+
+Note that this implementation of #== assumes that we've also declared
+  attr_reader :expected_divisor
+
+=== #inspect
+
+Technically we don't have to declare DivisibleBy#inspect, since inspect is
+defined for every object already.  But putting a helpful message in inspect
+will make test failures much clearer, and it only takes about two seconds to
+write it, so let's be nice and do so:
+
+  class RR::WildcardMatchers::DivisibleBy
+    def inspect
+      "integer divisible by #{expected.divisor}"
+    end
+  end
+
+Now if we run the example from above:
+
+  mock(BananaGrabber).bunch_bananas(divisible_by(5))
+
+and it fails, we get a helpful message saying
+
+  bunch_bananas(integer divisible by 5)
+  Called 0 times.
+  Expected 1 times.
+
+=== #wildcard_matches?(other)
+
+wildcard_matches? is the method that actually checks the argument against the
+expectation.  It should return true if other is considered to match,
+false otherwise.  In the case of DivisibleBy, wildcard_matches? reads:
+
+  class RR::WildcardMatchers::DivisibleBy
+    def wildcard_matches?(other)
+      # If other isn't a number, how can it be divisible by anything?
+      return false unless other.is_a?(Numeric)
+
+      # If other is in fact divisible by expected_divisor, then 
+      # other modulo expected_divisor should be 0.
+
+      other % expected_divisor == 0
+    end
+  end
+
+=== A finishing touch: wrapping it neatly
+
+We could stop here if we were willing to resign ourselves to using
+DivisibleBy this way:
+
+  mock(BananaGrabber).bunch_bananas(DivisibleBy.new(5))
+
+But that's less expressive than the original:
+
+  mock(BananaGrabber).bunch_bananas(divisible_by(5))
+
+To be able to use the convenient divisible_by matcher rather than the uglier
+DivisibleBy.new version, re-open the module RR::Adapters::RRMethods and
+define divisible_by there as a simple wrapper around DivisibleBy.new:
+
+  module RR::Adapters::RRMethods
+    def divisible_by(expected_divisor)
+      RR::WildcardMatchers::DivisibleBy.new(expected_divisor)
+    end
+  end
+
+== Recap
+
+Here's all the code for DivisibleBy in one place for easy reference:
+
+  class RR::WildcardMatchers::DivisibleBy
+    def initialize(divisor)
+      @expected_divisor = divisor
+    end
+
+    def ==(other)
+      # Ensure that other is actually a DivisibleBy
+      return false unless other.is_a?(self.class)
+
+      # Does other expect to match the same divisor we do?
+      self.expected_divisor = other.expected_divisor
+    end
+
+    def inspect
+      "integer divisible by #{expected.divisor}"
+    end
+  
+    def wildcard_matches?(other)
+      # If other isn't a number, how can it be divisible by anything?
+      return false unless other.is_a?(Numeric)
+
+      # If other is in fact divisible by expected_divisor, then 
+      # other modulo expected_divisor should be 0.
+
+      other % expected_divisor == 0
+    end
+  end
+  
+  module RR::Adapters::RRMethods
+    def divisible_by(expected_divisor)
+      RR::WildcardMatchers::DivisibleBy.new(expected_divisor)
+    end
+  end
+
+=end
+
+module RR::WildcardMatchers
+end