gorillib 0.1.11 → 0.4.0pre

data/spec/gorillib/model_spec.rb

@@ -0,0 +1,281 @@
+require 'spec_helper'
+require 'model_test_helpers'
+
+require 'gorillib/model'
+
+describe Gorillib::Model, :model_spec => true do
+
+  let(:simple_model){ class Gorillib::Test::TestClass ; include Gorillib::Model ; field :my_field, Whatever ; self ; end }
+  let(:anon_class){    Class.new{ include Gorillib::Model ; field :my_field, :whatever } }
+  let(:example_inst){ subject.receive(:my_field => 69) }
+  let(:example_val){ mock('example val') }
+
+  let(:complex_class) do
+    class Gorillib::Test::ComplexModel
+      include Gorillib::Model
+      field :my_field,  :whatever
+      field :str_field, String
+      field :sym_field, Symbol
+      self
+    end
+  end
+  let(:complex_subclass){ Gorillib::Test::TestSubclass = Class.new(complex_class){ field :zyzzyva, Integer; field :acme, Integer } }
+
+  subject{ complex_class }
+
+  context 'examples' do
+    let(:nested_class){ Class.new(complex_class){ field :another_model, self } }
+    it 'type-converts values' do
+      obj = complex_class.receive({
+          :my_field => 'accepted as-is', :str_field => :bob, :sym_field => 'converted_to_sym'
+        })
+      obj.attributes.should == { :my_field => 'accepted as-is', :str_field => 'bob', :sym_field=>:converted_to_sym }
+    end
+    it 'handles nested structures' do
+      obj      = nested_class.receive({ :my_field => 69 })
+      obj.attributes.should == { :my_field => 69, :str_field => nil, :sym_field=>nil, :another_model => nil }
+      deep_obj = nested_class.receive(:my_field => 111, :str_field => 'deep, man',
+        :another_model => { :my_field => 69, :another_model => nil })
+      deep_obj.attributes.should == { :my_field => 111, :str_field => 'deep, man', :sym_field=>nil, :another_model => obj }
+    end
+  end
+
+  context ".field" do
+    subject{ simple_model }
+    it "describes an attribute" do
+      example_inst.attributes.should == { :my_field => 69 }
+      example_inst.write_attribute(:my_field, 3).should == 3
+      example_inst.attributes.should == { :my_field => 3 }
+      example_inst.read_attribute(:my_field).should == 3
+    end
+    it 'inherits fields from its parent class, even if they are added later' do
+      complex_class.field_names.should    == [:my_field, :str_field, :sym_field]
+      complex_subclass.field_names.should  == [:my_field, :str_field, :sym_field, :zyzzyva, :acme]
+      complex_class.field :banksy, String
+      complex_class.field_names.should    == [:my_field, :str_field, :sym_field, :banksy ]
+      complex_subclass.field_names.should  == [:my_field, :str_field, :sym_field, :banksy, :zyzzyva, :acme]
+    end
+
+    it "supplies a reader method #foo to call read_attribute(:foo)" do
+      example_inst.should_receive(:read_attribute).with(:my_field).and_return(example_val)
+      example_inst.my_field.should == example_val
+    end
+    it "supplies a writer method #foo= to call write_attribute(:foo)" do
+      example_inst.should_receive(:write_attribute).with(:my_field, example_val)
+      (example_inst.my_field = example_val).should == example_val
+    end
+    it "supplies a receiver method #receive_foo to call write_attribute(:foo) and return self" do
+      example_inst.should_receive(:write_attribute).with(:my_field, example_val)
+      (example_inst.receive_my_field(example_val)).should == example_inst
+    end
+    it "sets visibility of reader with :reader => ()" do
+      subject.field :test_field, Integer, :reader => :private, :writer => false
+      subject.public_instance_methods.should_not  include(:test_field)
+      subject.private_instance_methods.should     include(:test_field)
+      subject.public_instance_methods.should_not  include(:test_field=)
+      subject.private_instance_methods.should_not include(:test_field=)
+    end
+  end
+
+  context '.field' do
+    subject{           complex_class.new }
+    let(:sample_val){  'bob' }
+    let(:raw_val){     :bob  }
+    it_behaves_like 'a model field', :str_field
+  end
+
+  context '#attributes' do
+    it "maps field names to attribute values" do
+      example_inst = subject.receive({:my_field=>7, :str_field=>'yo', :sym_field=>:sup})
+      example_inst.attributes.should == {:my_field=>7, :str_field=>'yo', :sym_field=>:sup}
+    end
+    it "includes all field names, set and unset" do
+      example_inst.attributes.should == {:my_field=>69, :str_field=>nil, :sym_field=>nil}
+      example_inst.receive!(:my_field=>7, :str_field=>'yo')
+      example_inst.attributes.should == {:my_field=>7, :str_field=>'yo', :sym_field=>nil}
+    end
+    it "goes throught the #read_attribute interface" do
+      example_inst.should_receive(:read_attribute).with(:my_field).and_return('int')
+      example_inst.should_receive(:read_attribute).with(:str_field).and_return('str')
+      example_inst.should_receive(:read_attribute).with(:sym_field).and_return('sym')
+      example_inst.attributes.should == {:my_field=>'int', :str_field=>'str', :sym_field=>'sym'}
+    end
+    it "is an empty hash if there are no fields" do
+      subject = Class.new{ include Gorillib::Model }
+      subject.new.attributes.should == {}
+    end
+  end
+
+  context '#unset_attribute' do
+    it "unsets the attribute" do
+      example_inst.attribute_set?(:my_field).should be_true
+      example_inst.unset_attribute(:my_field)
+      example_inst.attribute_set?(:my_field).should be_false
+    end
+    it "if set, returns the former value" do
+      example_inst.unset_attribute(:my_field ).should == 69
+      example_inst.unset_attribute(:str_field).should == nil
+    end
+    it "raises an error if the field does not exist" do
+      ->{ example_inst.unset_attribute(:fnord) }.should raise_error(Gorillib::Model::UnknownFieldError, /unknown field: fnord/)
+    end
+  end
+
+  context '#update_attributes' do
+    it "consumes a map from field names to new values" do
+      example_inst.attributes.should == {:my_field=>69, :str_field=>nil, :sym_field=>nil}
+      example_inst.update_attributes({:my_field=>7, :str_field=>'yo'})
+      example_inst.attributes.should == {:my_field=>7, :str_field=>'yo', :sym_field=>nil}
+      example_inst.update_attributes({:str_field=>'ok', :sym_field => :bye})
+      example_inst.attributes.should == {:my_field=>7, :str_field=>'ok', :sym_field=>:bye}
+    end
+    it "takes string or symbol keys" do
+      example_inst.update_attributes 'my_field'=>7, :str_field=>'yo'
+      example_inst.attributes.should == {:my_field=>7, :str_field=>'yo', :sym_field=>nil}
+    end
+    it "goes throught the #write_attribute interface" do
+      example_inst.should_receive(:write_attribute).with(:my_field,  7)
+      example_inst.should_receive(:write_attribute).with(:str_field, 'yo')
+      example_inst.update_attributes 'my_field'=>7, :str_field=>'yo'
+    end
+  end
+
+  context '#receive!' do
+    it "consumes a map from field names to new values" do
+      example_inst.attributes.should == {:my_field=>69, :str_field=>nil, :sym_field=>nil}
+      example_inst.receive!({:my_field=>7, :str_field=>'yo'})
+      example_inst.attributes.should == {:my_field=>7, :str_field=>'yo', :sym_field=>nil}
+      example_inst.receive!({:str_field=>'ok', :sym_field => :bye})
+      example_inst.attributes.should == {:my_field=>7, :str_field=>'ok', :sym_field=>:bye}
+    end
+    it "takes string or symbol keys" do
+      example_inst.receive! 'my_field'=>7, :str_field=>'yo'
+      example_inst.attributes.should == {:my_field=>7, :str_field=>'yo', :sym_field=>nil}
+    end
+    it "goes throught the #write_attribute interface" do
+      example_inst.should_receive(:write_attribute).with(:my_field,  7)
+      example_inst.should_receive(:write_attribute).with(:str_field, 'yo')
+      example_inst.receive! 'my_field'=>7, :str_field=>'yo'
+    end
+  end
+
+  context '#== -- two models are equal if' do
+    let(:subklass){ Class.new(subject) }
+    let(:obj_2){ subject.receive(:my_field => 69) }
+    let(:obj_3){ subklass.receive(:my_field => 69) }
+
+    it 'they have the same class' do
+      example_inst.attributes.should == obj_2.attributes
+      example_inst.attributes.should == obj_3.attributes
+      example_inst.should     == obj_2
+      example_inst.should_not == obj_3
+    end
+    it 'and the same attributes' do
+      example_inst.attributes.should == obj_2.attributes
+      example_inst.should     == obj_2
+      obj_2.my_field = 100
+      example_inst.should_not == obj_2
+    end
+  end
+
+  context ".fields" do
+    it 'is a hash of Gorillib::Model::Field objects' do
+      subject.fields.keys.should  == [:my_field, :str_field, :sym_field]
+      subject.fields.values.each{|f| f.should be_a(Gorillib::Model::Field) }
+      subject.fields.values.map(&:name).should == [:my_field, :str_field, :sym_field]
+    end
+  end
+
+  context '.has_field?' do
+    it 'is true if the field exists' do
+      complex_class.has_field?(  :my_field).should be_true
+      complex_subclass.has_field?(:my_field).should be_true
+      complex_subclass.has_field?(:zyzzyva ).should be_true
+    end
+    it 'is false if it does not exist' do
+      complex_class.has_field?(  :zyzzyva).should be_false
+      complex_class.has_field?(  :fnord  ).should be_false
+      complex_subclass.has_field?(:fnord  ).should be_false
+    end
+  end
+
+  context '.field_names' do
+    it 'lists fields in order by class, then in order added' do
+      subject.field_names.should   == [:my_field, :str_field, :sym_field]
+      complex_subclass.field_names.should  == [:my_field, :str_field, :sym_field, :zyzzyva, :acme]
+      subject.field :banksy, String
+      subject.field_names.should   == [:my_field, :str_field, :sym_field, :banksy ]
+      complex_subclass.field_names.should  == [:my_field, :str_field, :sym_field, :banksy, :zyzzyva, :acme]
+    end
+  end
+
+  context '.typename' do
+    it 'has a typename that matches its underscored class name' do
+      subject.typename.should == 'gorillib.test.complex_model'
+    end
+  end
+
+  context '.receive' do
+    it 'creates a new instance' do
+      obj = example_inst
+      subject.should_receive(:new).with().and_return(obj)
+      result = subject.receive(:my_field => 12)
+      result.should equal(obj)
+      result.my_field.should == 12
+    end
+    it 'calls receive! to set the attributes, and returns the object' do
+      obj = example_inst
+      subject.should_receive(:new).with().and_return(obj)
+      obj.should_receive(:receive!).with(:my_field => 12)
+      subject.receive(:my_field => 12).should equal(obj)
+    end
+
+    it 'uses the given type if the _type attribute is a factory' do
+      obj = complex_class.receive(:my_field => 12, :acme => 3, :_type => complex_subclass)
+      obj.should be_a(complex_subclass)
+    end
+
+    it 'complains if the given type is not right' do
+      mock_factory = mock ; mock_factory.stub(:receive! => {}, :receive => mock, :new => mock_factory)
+      mock_factory.should_receive(:<=).and_return(false)
+      complex_class.should_receive(:warn).with(/doesn't match type/)
+      complex_class.receive(:my_field => 12, :acme => 3, :_type => mock_factory)
+    end
+
+    it 'uses the given type if the _type attribute is a typename' do
+      complex_subclass.typename.should == 'gorillib.test.test_subclass'
+      obj = complex_class.receive(:my_field => 12, :acme => 3, :_type => 'gorillib.test.test_subclass')
+      obj.should be_a(complex_subclass)
+    end
+  end
+
+  describe Gorillib::Model::NamedSchema do
+    subject{ simple_model }
+    context ".meta_module" do
+      it "is named for the class (if the class is named)" do
+        subject.send(:meta_module).should == Meta::Gorillib::Test::TestClassType
+      end
+      it "is anonymous if the class is anonymous" do
+        anon_class.name.should be_nil
+        anon_class.send(:meta_module).should be_a(Module)
+        anon_class.send(:meta_module).name.should be_nil
+      end
+      it "carries the field-specfic accessor and receive methods" do
+        subject.send(:meta_module).public_instance_methods.sort.should    == [:my_field, :my_field=, :receive_my_field]
+        anon_class.send(:meta_module).public_instance_methods.sort.should == [:my_field, :my_field=, :receive_my_field]
+      end
+      it "is injected right after the Gorillib::Model module" do
+        subject.ancestors.first(4).should == [subject, Meta::Gorillib::Test::TestClassType, Gorillib::Model, Object]
+        subject.should < Meta::Gorillib::Test::TestClassType
+      end
+      it "retrieves an existing named module if one exists" do
+        Gorillib::Test.should_not be_const_defined(:TestClass)
+        module Meta::Gorillib::Test::TestClassType ; def kilroy_was_here() '23 skidoo' ; end ; end
+        subject.send(:meta_module).public_instance_methods.sort.should == [:kilroy_was_here, :my_field, :my_field=, :receive_my_field]
+        Gorillib::Test.should be_const_defined(:TestClass)
+        subject.send(:meta_module).should == Meta::Gorillib::Test::TestClassType
+      end
+    end
+  end
+
+end

data/spec/{numeric → gorillib/numeric}/clamp_spec.rb

@@ -1,7 +1,7 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
+require 'spec_helper'
 require 'gorillib/numeric/clamp'
 
-describe Numeric do
+describe Numeric, :simple_spec => true do
   describe '#clamp' do
     it 'should return self if neither min nor max are given' do
       5.clamp().should == 5

data/spec/{object → gorillib/object}/blank_spec.rb

@@ -1,7 +1,7 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
+require 'spec_helper'
 require 'gorillib/object/blank'
 
-describe 'object/blank' do
+describe 'object/blank', :simple_spec => true do
   describe Object do
     it 'should provide blank?' do
       Object.new.should respond_to(:blank?)

data/spec/{object → gorillib/object}/try_dup_spec.rb

@@ -1,7 +1,7 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
+require 'spec_helper'
 require 'gorillib/object/try_dup'
 
-describe "try_dup" do
+describe 'try_dup', :simple_spec => true do
   it "returns a duplicate version on regular objects" do
     obj = Object.new
     oth = obj.try_dup

data/spec/{object → gorillib/object}/try_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
+require 'spec_helper'
 require 'gorillib/object/try'
 
 class Foo
@@ -7,10 +7,11 @@ class Foo
   end
 end
 
-describe Object do
+describe Object, :simple_spec => true do
   describe '#try' do
     it 'returns nil if item does not #respond_to? method' do
       Foo.new.try(:i_am_not_a_method).should be_nil
+      Foo.new.respond_to?(:i_am_not_a_method).should be_false
     end
     it 'calls the method (with args) if the item does #respond_to? it' do
       Foo.new.try(:i_am_a_method_hooray).should == "i was called! hooray!"

data/spec/gorillib/pathname_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+require 'gorillib/pathname'
+
+describe Pathname do
+  let(:mock_path){ mock(:path) }  # "We mock what we don't understand"
+
+  context '.path_to' do
+    subject{ described_class }
+    before do
+      subject.register_path(:doctor,  'doctor/doctor')
+      subject.register_path(:code,    'twenty-square-digit', 'boustrophedonic')
+      subject.register_path(:hello,   :doctor, :doctor)
+      subject.register_path(:oh_crap, '~/ninjas')
+      subject.register_path(:access,  '/would/you/like/to')
+    end
+
+    context 'examples' do
+      { ['/tmp', :code]                      => '/tmp/twenty-square-digit/boustrophedonic',
+        [:oh_crap]                           => ENV['HOME']+'/ninjas',
+        [:hello, 'doctor', :doctor, :doctor] => File.expand_path('doctor/doctor/doctor/doctor/doctor/doctor/doctor/doctor/doctor'),
+        [:oh_crap, :doctor]                  => File.join(ENV['HOME'], 'ninjas', 'doctor', 'doctor'),
+        [".."]                               => File.expand_path('..'),
+        ["..", 'bob']                        => File.expand_path(File.join('..', 'bob')),
+      }.each do |input, expected|
+        it 'expands symbols' do
+          subject.path_to(*input).should == Pathname.new(expected)
+        end
+      end
+    end
+
+    it 'delays evaluation of path segments' do
+      subject.register_path(:russia,  '/ussr/russia')
+      subject.register_path(:city,    'leningrad')
+      subject.register_path(:ermitage, :russia, :city)
+      subject.path_to(:ermitage).should == Pathname.new('/ussr/russia/leningrad')
+      subject.register_path(:city,    'st_petersburg')
+      subject.path_to(:ermitage).should == Pathname.new('/ussr/russia/st_petersburg')
+    end
+
+    it 'expands all paths into a pathname' do
+      subject.should_receive(:expand_pathseg).with(:a).and_return('/a')
+      subject.should_receive(:expand_pathseg).with('b').and_return('b')
+      subject.path_to(:a, 'b').should == Pathname.new('/a/b')
+    end
+
+    it 'expands relative paths' do
+      FileUtils.cd '/' do
+        subject.path_to(:hello).should == Pathname.new('/doctor/doctor/doctor/doctor')
+      end
+    end
+
+    it 'collapses "//" double slashes' do
+      subject.path_to('/', :access, '//have', 'a//pepsi').should == Pathname.new('/would/you/like/to/have/a/pepsi')
+    end
+
+    it 'must have at least one segment' do
+      lambda{ subject.new() }.should raise_error(ArgumentError, /wrong number of arguments/)
+    end
+  end
+
+  context '.relative_path_to' do
+    subject{ described_class }
+
+    it 'collapses "//" double slashes and useless ".." dots, but does not use the filesystem' do
+      subject.relative_path_to('/', '../..', :access, '//have', 'a//pepsi').should == Pathname.new('/would/you/like/to/have/a/pepsi')
+    end
+
+    it 'does not expand relative paths' do
+      FileUtils.cd '/' do
+        subject.register_path(:hello,  'doctor')
+        subject.relative_path_to(:hello, :hello, :hello).should == Pathname.new('doctor/doctor/doctor')
+      end
+    end
+  end
+
+  context 'registering paths' do
+    subject { described_class }
+    def expand_pathseg(*args) ; subject.send(:expand_pathseg, *args) ;  end
+    
+    context '.register_path' do
+      it 'stores a path so expand_pathseg can get it later' do
+        subject.register_path(:probe, ['skeletal', 'girth'])
+        expand_pathseg(:probe).should == ['skeletal', 'girth']
+      end
+      it 'stores a list of path segments to re-expand' do
+        subject.register_path(:ace, 'tomato', 'corporation')
+        expand_pathseg(:ace).should == ['tomato', 'corporation']
+      end
+      it 'replaces the stored path if called again' do
+        subject.register_path(:glg_20, 'boyer')
+        subject.register_path(:glg_20, ['milbarge', 'fitz-hume'])
+        expand_pathseg(:glg_20).should == ['milbarge', 'fitz-hume']
+      end
+    end
+    
+    context '.register_paths' do
+      let(:paths) { { :foo => ['foo'], :bar => [:foo, 'bar'] } }
+      
+      it 'registers multiple paths' do
+        subject.should_receive(:register_path).exactly(paths.size).times
+        subject.register_paths(paths)
+      end
+    end
+
+    context '.unregister_path' do
+      it 'unregisters a path' do
+        subject.register_path(:foo, 'foo')
+        expand_pathseg(:foo).should == ['foo']
+        subject.unregister_path(:foo)
+        expect{ expand_pathseg(:foo)}.to raise_error(ArgumentError, /expand path reference.*foo/)
+      end
+    end    
+  end
+end

data/spec/{string → gorillib/string}/constantize_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
+require 'spec_helper'
 require 'gorillib/string/constantize'
 
 module Ace
@@ -17,7 +17,7 @@ end
 
 module InflectorTest
 
-  describe 'String' do
+  describe 'String', :string_spec => true do
     describe '#constantize' do
       it "works from within instance" do
         @obj = Ace::Base::Case.new

data/spec/{string → gorillib/string}/human_spec.rb

@@ -1,10 +1,10 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
+require 'spec_helper'
 require File.expand_path('inflector_test_cases', File.dirname(__FILE__))
 require 'gorillib/string/human'
 
 include InflectorTestCases
 
-describe String do
+describe String, :string_spec => true do
 
   describe '#titleize' do
     MixtureToTitleCase.each do |raw, titleized|

data/spec/{string → gorillib/string}/inflections_spec.rb

@@ -1,11 +1,12 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
+require 'spec_helper'
 require File.expand_path('inflector_test_cases', File.dirname(__FILE__))
 require 'gorillib/string/inflections'
 
 include InflectorTestCases
 
-describe String do
-  describe 'camelize' do
+describe String, :string_spec => true do
+
+  describe '#camelize' do
     CamelToUnderscore.each do |cameled, underscored|
       it underscored do
         underscored.camelize.should == cameled

data/spec/{string → gorillib/string}/truncate_spec.rb

@@ -1,8 +1,9 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
+require 'spec_helper'
 require GORILLIB_ROOT_DIR('spec/support/kcode_test_helper')
 require 'gorillib/string/truncate'
 
-describe String do
+describe String, :string_spec => true do
+
   describe '#truncate' do
     it 'leaves a short string alone' do
       "Hello World!".truncate(12).should == "Hello World!"
@@ -25,14 +26,6 @@ describe String do
             should == "\354\225\210\353\205\225\355..."
         end
       end
-
-      # # FIXME: breaks on ruby 1.8
-      # it 'works with unicode when kcode=u' do
-      #   Gorillib::KcodeTestHelper.with_kcode('u') do
-      #     "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 \354\225\204\353\235\274\353\246\254\354\230\244".truncate(10).
-      #       should == "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 ..."
-      #   end
-      # end
     else # ruby 1.9
       it 'works with unicode' do
         "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 \354\225\204\353\235\274\353\246\254\354\230\244".force_encoding('UTF-8').truncate(10).
@@ -40,4 +33,5 @@ describe String do
       end
     end
   end
+
 end

data/spec/gorillib/type/extended_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+require 'gorillib/type/extended'
+require 'gorillib/object/blank'
+
+describe ::Long do
+  it "is_a?(Integer)" do ::Long.should < ::Integer ; end
+end
+
+describe ::Double do
+  it "is_a?(Float)" do ::Double.should < ::Float ; end
+end
+
+describe ::Binary do
+  it "is_a?(String)" do ::Binary.should < ::String ; end
+end
+
+# describe ::Boolean, :model_spec => true do
+#   let(:true_bool ){ ::Boolean.new(true)  }
+#   let(:false_bool){ ::Boolean.new(false) }
+#
+#   def it_responds_same_as(test_obj, comparable, meth, *meth_args, &block)
+#     test_obj.send(meth, *meth_args, &block).should == comparable.send(meth, *meth_args, &block)
+#   end
+#
+#   def it_responds_with_same_contents(test_obj, comparable, meth, *meth_args, &block)
+#     test_obj.send(meth, *meth_args, &block).sort.should == comparable.send(meth, *meth_args, &block).sort
+#   end
+#
+#   it("has #class ::Boolean" ){ (true_bool.class).should == ::Boolean ; (false_bool.class).should == ::Boolean }
+#
+#   it "#is_a?(Boolean)"           do true_bool.should be_a(::Boolean)             ; false_bool.should be_a(::Boolean) ; end
+#   it "#is_a?(True/False)"        do true_bool.should be_a(::TrueClass)           ; false_bool.should be_a(::FalseClass) ; end
+#   it "#kind_of?(Boolean)"        do true_bool.should be_a_kind_of(::Boolean)     ; false_bool.should be_a_kind_of(::Boolean) ; end
+#   it "#instance_of?(True/False)" do true_bool.should be_instance_of(::TrueClass) ; false_bool.should be_instance_of(::FalseClass) ; end
+#
+#   describe 'mimics true/false' do
+#     [ :!, :to_s, :blank?, :frozen?, :nil?, :present?,
+#     ].each do |meth|
+#       it "##{meth}" do
+#         it_responds_same_as(true_bool,  true,  meth)
+#         it_responds_same_as(false_bool, false, meth)
+#       end
+#     end
+#
+#     [ :private_methods, :protected_methods, :singleton_methods,
+#     ].each do |meth|
+#       it "##{meth}" do
+#         it_responds_with_same_contents(true_bool,  true,  meth)
+#         it_responds_with_same_contents(false_bool, false, meth)
+#       end
+#     end
+#     it "#methods"        do ( true.methods         - true_bool.methods  ).should be_empty ; end
+#     it "#methods"        do ( false.methods        - false_bool.methods ).should be_empty ; end
+#     it "#public_methods" do ( true.public_methods  - true_bool.public_methods  ).should be_empty ; end
+#     it "#public_methods" do ( false.public_methods - false_bool.public_methods ).should be_empty ; end
+#
+#     it ".methods"          do (TrueClass.methods | [:true, :false, :new]).sort.should ==  Boolean.methods.sort ; end
+#
+#     { :!=           => [true, false, nil],
+#       :!~           => [true, false, nil],
+#       :&            => [true, false, nil],
+#       :<=>          => [true, false, nil],
+#       :==           => [true, false, nil],
+#       :===          => [true, false, nil],
+#       :=~           => [true, false, nil],
+#       :^            => [true, false, nil],
+#       :|            => [true, false, nil],
+#       :eql?         => [true, false, nil],
+#       :equal?       => [true, false, nil],
+#       :instance_of? => [::TrueClass, ::FalseClass, ::Object],
+#       :is_a?        => [::TrueClass, ::FalseClass, ::Object],
+#       :kind_of?     => [::TrueClass, ::FalseClass, ::Object],
+#     }.each do |meth, meth_args|
+#       meth_args.each do |meth_arg|
+#         it "##{meth}(#{meth_arg})" do
+#           it_responds_same_as(true_bool,  true,  meth, meth_arg)
+#           it_responds_same_as(false_bool, false, meth, meth_arg)
+#         end
+#       end
+#     end
+#
+#   end
+#
+#   [ :==, :===, :eql?, :equal?, :<=> ].each do |meth|
+#     it "Boolean.true #{meth} itself and true" do
+#       true_bool.send(meth,  true_bool     ).should be_true
+#       true_bool.send(meth,  Boolean.true  ).should be_true
+#       true_bool.send(meth,  true          ).should be_true
+#       true_bool.send(meth,  false_bool    ).should be_false
+#       true_bool.send(meth,  Boolean.false ).should be_false
+#       true_bool.send(meth,  false         ).should be_false
+#       true_bool.send(meth,  0             ).should be_false
+#     end
+#     it "Boolean.false #{meth} itself and false" do
+#       false_bool.send(meth, false_bool    ).should be_true
+#       false_bool.send(meth, Boolean.false ).should be_true
+#       false_bool.send(meth, false         ).should be_true
+#       false_bool.send(meth, true_bool     ).should be_false
+#       false_bool.send(meth, Boolean.true  ).should be_false
+#       false_bool.send(meth, true          ).should be_false
+#       false_bool.send(meth, 0             ).should be_false
+#     end
+#     it "!=" do
+#       (true_bool  != true         ).should be_false ; (true_bool  != false        ).should be_true
+#       (true_bool  != true_bool    ).should be_false ; (true_bool  != false_bool   ).should be_true
+#       (true_bool  != Boolean.true ).should be_false ; (true_bool  != Boolean.false).should be_true
+#       (true_bool  != 0            ).should be_true  ; (true_bool  != "true"       ).should be_true
+#       (false_bool != false        ).should be_false ; (false_bool != true         ).should be_true
+#       (false_bool != false_bool   ).should be_false ; (false_bool != true_bool    ).should be_true
+#       (false_bool != Boolean.false).should be_false ; (false_bool != Boolean.true ).should be_true
+#       (false_bool != 0            ).should be_true  ; (false_bool  != "true"      ).should be_true
+#     end
+#     it "!~" do
+#       (true_bool !~ true        ).should be_true
+#       (true_bool !~ true_bool   ).should be_true
+#       (true_bool !~ Boolean.true).should be_true
+#     end
+#   end
+# end