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/wildcard_matchers/anything.rb

@@ -0,0 +1,18 @@
+module RR
+  module WildcardMatchers
+    class Anything
+      def wildcard_match?(other)
+        true
+      end
+
+      def ==(other)
+        other.is_a?(self.class)
+      end
+      alias_method :eql?, :==
+
+      def inspect
+        'anything'
+      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/boolean.rb

@@ -0,0 +1,23 @@
+module RR
+  module WildcardMatchers
+    class Boolean
+      def wildcard_match?(other)
+        self == other || is_a_boolean?(other)
+      end
+
+      def ==(other)
+        other.is_a?(self.class)
+      end
+      alias_method :eql?, :==
+
+      def inspect
+        'boolean'
+      end
+
+      protected
+      def is_a_boolean?(subject)
+        subject.is_a?(TrueClass) || subject.is_a?(FalseClass)
+      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/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/bitclust-core-0.5.1/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/bitclust-core-0.5.1/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/bitclust-core-0.5.1/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/bitclust-core-0.5.1/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/bitclust-core-0.5.1/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/bitclust-core-0.5.1/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/bitclust-core-0.5.1/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
+

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/spec/api/any_instance_of/all_instances_of_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "all_instances_of" do
+  it "applies to instances instantiated before the Double expection was created" do
+    subject_class = Class.new
+    subject = subject_class.new
+    all_instances_of(subject_class) do |o|
+      o.to_s {"Subject is stubbed"}
+    end
+    subject.to_s.should == "Subject is stubbed"
+  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/spec/api/any_instance_of/any_instance_of_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "any_instance_of" do
+  context "when passed a block" do
+    it "applies to instances instantiated before the Double expection was created" do
+      subject_class = Class.new
+      subject = subject_class.new
+      class_called = false
+      any_instance_of(subject_class) do |o|
+        stub(o).to_s {"Subject is stubbed"}
+        stub.proxy(o).class {|klass| class_called = true; klass}
+        stub(o).foobar {:baz}
+      end
+
+      subject.to_s.should == "Subject is stubbed"
+      subject.class.should == subject_class
+      class_called.should == true
+      subject.foobar.should == :baz
+
+      RR.reset
+
+      subject.to_s.should_not == "Subject is stubbed"
+      class_called = false
+      subject.class.should == subject_class
+      class_called.should == false
+      subject.should_not respond_to(:baz)
+    end
+  end
+
+  context "when passed a Hash" do
+    it "stubs methods (key) with the value on instances instantiated before the Double expection was created" do
+      subject_class = Class.new
+      subject = subject_class.new
+      subject.should_not respond_to(:baz)
+
+      any_instance_of(subject_class, :to_s => "Subject is stubbed", :foobar => lambda {:baz})
+
+      subject.to_s.should == "Subject is stubbed"
+      subject.foobar.should == :baz
+
+      RR.reset
+
+      subject.to_s.should_not == "Subject is stubbed"
+      subject.should_not respond_to(:baz)
+    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/spec/api/any_instance_of/instance_of_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "instance_of" do
+  it "applies to instances instantiated before the Double expection was created" do
+    subject_class = Class.new
+    subject = subject_class.new
+    instance_of(subject_class) do |o|
+      o.to_s {"Subject is stubbed"}
+    end
+    subject.to_s.should == "Subject is stubbed"
+  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/spec/api/dont_allow/dont_allow_after_stub_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "dont_allow called after stub" do
+  context "when the subject method is called" do
+    it "raises a TimesCalledError" do
+      subject = Object.new
+      stub(subject).foobar
+      dont_allow(subject).foobar
+      lambda do
+        subject.foobar
+      end.should raise_error(RR::Errors::TimesCalledError)
+    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/spec/api/mock/mock_spec.rb

@@ -0,0 +1,193 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "mock" do
+  attr_reader :subject
+  before(:each) do
+    @subject = Object.new
+    extend RR::Adapters::RRMethods
+  end
+
+  after(:each) do
+    RR.reset
+  end
+
+  it "mocks via inline call" do
+    mock(subject).to_s {"a value"}
+    subject.to_s.should == "a value"
+    lambda {subject.to_s}.should raise_error(RR::Errors::TimesCalledError)
+  end
+
+  describe ".once.ordered" do
+    it "returns the values in the ordered called" do
+      mock(subject).to_s {"value 1"}.ordered
+      mock(subject).to_s {"value 2"}.twice
+      subject.to_s.should == "value 1"
+      subject.to_s.should == "value 2"
+      subject.to_s.should == "value 2"
+      lambda {subject.to_s}.should raise_error(RR::Errors::TimesCalledError)
+    end
+  end
+
+  context "when the subject is a proxy for the object with the defined method" do
+    it "stubs the method on the proxy object" do
+      proxy_target = Class.new {def foobar; :original_foobar; end}.new
+      proxy = Class.new do
+        def initialize(target)
+          @target = target
+        end
+
+        instance_methods.each do |m|
+          unless m =~ /^_/ || m.to_s == 'object_id' || m.to_s == 'method_missing'
+            alias_method "__blank_slated_#{m}", m
+            undef_method m
+          end
+        end
+
+        def method_missing(method_name, *args, &block)
+          @target.send(method_name, *args, &block)
+        end
+      end.new(proxy_target)
+      proxy.methods.should =~ proxy_target.methods
+
+      mock(proxy).foobar {:new_foobar}
+      proxy.foobar.should == :new_foobar
+    end
+  end
+
+  it 'allows terse chaining' do
+    mock(subject).first(1) {mock(Object.new).second(2) {mock(Object.new).third(3) {4}}}
+    subject.first(1).second(2).third(3).should == 4
+
+    mock(subject).first(1) {mock!.second(2) {mock!.third(3) {4}}}
+    subject.first(1).second(2).third(3).should == 4
+
+    mock(subject).first(1) {mock!.second(2).mock!.third(3) {4}}
+    subject.first(1).second(2).third(3).should == 4
+
+    mock(subject).first(1) {mock!.second(2).mock! {third(3) {4}}}
+    subject.first(1).second(2).third(3).should == 4
+
+    mock(subject).first(1).mock!.second(2).mock!.third(3) {4}
+    subject.first(1).second(2).third(3).should == 4
+  end
+
+  it 'allows chaining with proxy' do
+    find_return_value = Object.new
+    def find_return_value.child
+      :the_child
+    end
+    (class << subject; self; end).class_eval do
+      define_method(:find) do |id|
+        id == '1' ? find_return_value : raise(ArgumentError)
+      end
+    end
+
+    mock.proxy(subject).find('1').mock.proxy!.child
+    subject.find('1').child.should == :the_child
+  end
+
+  it 'allows branched chaining' do
+    mock(subject).first do
+      mock! do |expect|
+        expect.branch1 {mock!.branch11 {11}}
+        expect.branch2 {mock!.branch22 {22}}
+      end
+    end
+    o = subject.first
+    o.branch1.branch11.should == 11
+    o.branch2.branch22.should == 22
+  end
+
+  it 'allows chained ordering' do
+    mock(subject).to_s {"value 1"}.then.to_s {"value 2"}.twice.then.to_s {"value 3"}.once
+    subject.to_s.should == "value 1"
+    subject.to_s.should == "value 2"
+    subject.to_s.should == "value 2"
+    subject.to_s.should == "value 3"
+    lambda {subject.to_s}.should raise_error(RR::Errors::TimesCalledError)
+  end
+
+  it "mocks via block with argument" do
+    mock subject do |c|
+      c.to_s {"a value"}
+      c.to_sym {:crazy}
+    end
+    subject.to_s.should == "a value"
+    subject.to_sym.should == :crazy
+  end
+
+  it "mocks via block without argument" do
+    mock subject do
+      to_s {"a value"}
+      to_sym {:crazy}
+    end
+    subject.to_s.should == "a value"
+    subject.to_sym.should == :crazy
+  end
+
+  it "has wildcard matchers" do
+    mock(subject).foobar(
+      is_a(String),
+      anything,
+      numeric,
+      boolean,
+      duck_type(:to_s),
+      /abc/
+    ) {"value 1"}.twice
+    subject.foobar(
+      'hello',
+      Object.new,
+      99,
+      false,
+      "My String",
+      "Tabcola"
+    ).should == "value 1"
+    lambda do
+      subject.foobar(:failure)
+    end.should raise_error( RR::Errors::DoubleNotFoundError )
+  end
+
+  it "mocks methods without letters" do
+    mock(subject, :==).with(55)
+
+    subject == 55
+    lambda do
+      subject == 99
+    end.should raise_error(RR::Errors::DoubleNotFoundError)
+  end
+
+  it "expects a method call to a mock via another mock's block yield only once" do
+    cage = Object.new
+    cat = Object.new
+    mock(cat).miau    # should be expected to be called only once
+    mock(cage).find_cat.yields(cat)
+    mock(cage).cats
+    cage.find_cat { |c| c.miau }
+    cage.cats
+  end
+
+  describe "on class method" do
+    class SampleClass1
+      def self.hello; "hello!"; end
+    end
+
+    class SampleClass2 < SampleClass1; end
+
+    it "can mock" do
+      mock(SampleClass1).hello { "hola!" }
+
+      SampleClass1.hello.should == "hola!"
+    end
+
+    it "does not override subclasses" do
+      mock(SampleClass1).hello { "hi!" }
+
+      SampleClass2.hello.should == "hello!"
+    end
+
+    it "should not get affected from a previous example" do
+      SampleClass2.hello.should == "hello!"
+    end
+
+  end
+end