bitclust-core 0.5.0 → 0.5.1

data/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/wildcard_matchers/duck_type.rb

@@ -0,0 +1,32 @@
+module RR
+  module WildcardMatchers
+    class DuckType
+      attr_accessor :required_methods
+
+      def initialize(*required_methods)
+        @required_methods = required_methods
+      end
+
+      def wildcard_match?(other)
+        return true if self == other
+        required_methods.each do |m|
+          return false unless other.respond_to?(m)
+        end
+        return true
+      end
+
+      def inspect
+        formatted_required_methods = required_methods.collect do |method_name|
+          method_name.inspect
+        end.join(', ')
+        "duck_type(#{formatted_required_methods})"
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        self.required_methods == other.required_methods
+      end
+      alias_method :eql?, :==
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/wildcard_matchers/hash_including.rb

@@ -0,0 +1,29 @@
+module RR
+  module WildcardMatchers
+    class HashIncluding
+      attr_reader :expected_hash
+
+      def initialize(expected_hash)
+        @expected_hash = expected_hash.clone
+      end
+
+      def wildcard_match?(other)
+        return true if self == other
+        expected_hash.each_pair do |key, value|
+          return false unless other.has_key?(key) && other[key] == expected_hash[key]
+        end
+        return true
+      end
+
+      def inspect
+        "hash_including(#{expected_hash.inspect})"
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        self.expected_hash == other.expected_hash
+      end
+      alias_method :eql?, :==
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/wildcard_matchers/is_a.rb

@@ -0,0 +1,25 @@
+module RR
+  module WildcardMatchers
+    class IsA
+      attr_reader :klass
+
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def wildcard_match?(other)
+        self == other || other.is_a?(klass)
+      end
+
+      def inspect
+        "is_a(#{klass})"
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        self.klass == other.klass
+      end
+      alias_method :eql?, :==
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/wildcard_matchers/numeric.rb

@@ -0,0 +1,13 @@
+module RR
+  module WildcardMatchers
+    class Numeric < IsA
+      def initialize
+        @klass = ::Numeric
+      end
+
+      def inspect
+        'numeric'
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/wildcard_matchers/range.rb

@@ -0,0 +1,7 @@
+class Range
+  def wildcard_match?(other)
+    return true if self == other
+    return false unless other.is_a?(Numeric)
+    self.include?(other)
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/wildcard_matchers/regexp.rb

@@ -0,0 +1,7 @@
+class Regexp
+  def wildcard_match?(other)
+    return true if self == other
+    return false unless other.is_a?(String)
+    (other =~ self) ? true : false
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/wildcard_matchers/satisfy.rb

@@ -0,0 +1,26 @@
+module RR
+  module WildcardMatchers
+    class Satisfy
+      attr_reader :expectation_proc
+
+      def initialize(expectation_proc)
+        @expectation_proc = expectation_proc
+      end
+
+      def wildcard_match?(other)
+        return true if self == other
+        !!expectation_proc.call(other)
+      end
+
+      def inspect
+        "satisfy {block}"
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        self.expectation_proc == other.expectation_proc
+      end
+      alias_method :eql?, :==
+    end
+  end
+end

data/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

data/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr.rb

@@ -0,0 +1,100 @@
+dir = File.dirname(__FILE__)
+require 'forwardable'
+
+require "#{dir}/rr/class_instance_method_defined"
+require "#{dir}/rr/blank_slate"
+
+require "#{dir}/rr/errors/rr_error"
+require "#{dir}/rr/errors/subject_does_not_implement_method_error"
+require "#{dir}/rr/errors/subject_has_different_arity_error"
+require "#{dir}/rr/errors/double_definition_error"
+require "#{dir}/rr/errors/double_not_found_error"
+require "#{dir}/rr/errors/double_order_error"
+require "#{dir}/rr/errors/argument_equality_error"
+require "#{dir}/rr/errors/times_called_error"
+require "#{dir}/rr/errors/spy_verification_errors/spy_verification_error"
+require "#{dir}/rr/errors/spy_verification_errors/double_injection_not_found_error"
+require "#{dir}/rr/errors/spy_verification_errors/invocation_count_error"
+
+require "#{dir}/rr/space"
+
+require "#{dir}/rr/double_definitions/strategies/strategy"
+require "#{dir}/rr/double_definitions/strategies/strategy_methods"
+require "#{dir}/rr/double_definitions/strategies/verification/verification_strategy"
+require "#{dir}/rr/double_definitions/strategies/verification/mock"
+require "#{dir}/rr/double_definitions/strategies/verification/stub"
+require "#{dir}/rr/double_definitions/strategies/verification/dont_allow"
+require "#{dir}/rr/double_definitions/strategies/implementation/implementation_strategy"
+require "#{dir}/rr/double_definitions/strategies/implementation/reimplementation"
+require "#{dir}/rr/double_definitions/strategies/implementation/strongly_typed_reimplementation"
+require "#{dir}/rr/double_definitions/strategies/implementation/proxy"
+require "#{dir}/rr/double_definitions/strategies/double_injection/double_injection_strategy"
+require "#{dir}/rr/double_definitions/strategies/double_injection/instance"
+require "#{dir}/rr/double_definitions/strategies/double_injection/any_instance_of"
+require "#{dir}/rr/adapters/rr_methods"
+require "#{dir}/rr/double_definitions/double_injections/instance"
+require "#{dir}/rr/double_definitions/double_injections/any_instance_of"
+require "#{dir}/rr/double_definitions/double_definition"
+
+require "#{dir}/rr/injections/injection"
+require "#{dir}/rr/injections/double_injection"
+require "#{dir}/rr/injections/method_missing_injection"
+require "#{dir}/rr/injections/singleton_method_added_injection"
+require "#{dir}/rr/method_dispatches/base_method_dispatch"
+require "#{dir}/rr/method_dispatches/method_dispatch"
+require "#{dir}/rr/method_dispatches/method_missing_dispatch"
+require "#{dir}/rr/hash_with_object_id_key"
+require "#{dir}/rr/recorded_calls"
+require "#{dir}/rr/proc_from_block"
+
+require "#{dir}/rr/double_definitions/double_definition_create_blank_slate"
+require "#{dir}/rr/double_definitions/double_definition_create"
+require "#{dir}/rr/double_definitions/child_double_definition_create"
+
+require "#{dir}/rr/double"
+require "#{dir}/rr/double_matches"
+
+require "#{dir}/rr/expectations/argument_equality_expectation"
+require "#{dir}/rr/expectations/any_argument_expectation"
+require "#{dir}/rr/expectations/times_called_expectation"
+
+require "#{dir}/rr/wildcard_matchers/anything"
+require "#{dir}/rr/wildcard_matchers/is_a"
+require "#{dir}/rr/wildcard_matchers/numeric"
+require "#{dir}/rr/wildcard_matchers/boolean"
+require "#{dir}/rr/wildcard_matchers/duck_type"
+require "#{dir}/rr/wildcard_matchers/regexp"
+require "#{dir}/rr/wildcard_matchers/range"
+require "#{dir}/rr/wildcard_matchers/satisfy"
+require "#{dir}/rr/wildcard_matchers/hash_including"
+
+require "#{dir}/rr/times_called_matchers/terminal"
+require "#{dir}/rr/times_called_matchers/non_terminal"
+require "#{dir}/rr/times_called_matchers/times_called_matcher"
+require "#{dir}/rr/times_called_matchers/never_matcher"
+require "#{dir}/rr/times_called_matchers/any_times_matcher"
+require "#{dir}/rr/times_called_matchers/integer_matcher"
+require "#{dir}/rr/times_called_matchers/range_matcher"
+require "#{dir}/rr/times_called_matchers/proc_matcher"
+require "#{dir}/rr/times_called_matchers/at_least_matcher"
+require "#{dir}/rr/times_called_matchers/at_most_matcher"
+
+require "#{dir}/rr/spy_verification_proxy"
+require "#{dir}/rr/spy_verification"
+
+require "#{dir}/rr/adapters/rspec"
+require "#{dir}/rr/adapters/test_unit"
+require "#{dir}/rr/adapters/minitest"
+
+module RR
+  class << self
+    include Adapters::RRMethods
+    (RR::Space.instance_methods - Object.instance_methods).each do |method_name|
+      class_eval((<<-METHOD), __FILE__, __LINE__ + 1)
+        def #{method_name}(*args, &block)
+          RR::Space.instance.__send__(:#{method_name}, *args, &block)
+        end
+      METHOD
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/rr.gemspec

@@ -0,0 +1,37 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rr}
+  s.version = "1.0.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Brian Takita"]
+  s.date = %q{2011-06-16}
+  s.description = %q{RR (Double Ruby) is a double framework that features a rich selection of double techniques and a terse syntax. http://xunitpatterns.com/Test%20Double.html}
+  s.email = %q{brian@pivotallabs.com}
+  s.extra_rdoc_files = [
+    "CHANGES",
+    "README.rdoc"
+  ]
+  s.files              = `git ls-files`.split("\n")
+  s.test_files         = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.homepage = %q{http://pivotallabs.com}
+  s.rdoc_options = ["--main", "README.rdoc", "--inline-source", "--line-numbers"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{pivotalrb}
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{RR (Double Ruby) is a double framework that features a rich selection of double techniques and a terse syntax. http://xunitpatterns.com/Test%20Double.html}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+