woyo-world 0.0.6 → 0.0.7

data/spec/woyo/world/actions_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'woyo/world/actions'
+
+describe Woyo::Actions do
+
+  context "may be listed" do
+
+    let( :at ) { class ActionTest ; include Woyo::Actions ; end.new }
+
+    it "intially empty" do
+      expect(at.actions).to be_instance_of Woyo::Attributes::AttributesHash
+      expect(at.actions).to be_empty
+    end
+
+    it "single action" do
+      at.action( :act1 ) { Time.now }
+      expect(at.actions.count).to eq 1
+      expect(at.actions[:act1]). to be_instance_of Proc
+    end
+
+    it "multiple actions" do
+      at.action( :act1 ) { Time.now }
+      at.action( :act2 ) { Time.now }
+      expect(at.actions.count).to eq 2
+      expect(at.actions[:act2]). to be_instance_of Proc
+    end
+
+  end
+
+  context "may be defined" do
+
+    let( :at ) { class ActionTest ; include Woyo::Actions ; end.new }
+
+    it "via a block" do
+      at.action( :sum ) { 1 + 2 } 
+      expect(at.actions).to include :sum
+      expect(at.actions[:sum]).to be_instance_of Proc
+    end
+
+    it "via a proc" do
+      at.action sum: proc { 1 + 2 } 
+      expect(at.actions).to include :sum
+      expect(at.actions[:sum]).to be_instance_of Proc
+    end
+
+    it "via a lambda" do
+      at.action sum: lambda { |this| 1 + 2 } 
+      expect(at.actions).to include :sum
+      expect(at.actions[:sum]).to be_instance_of Proc
+    end
+
+  end
+
+  context "may be invoked" do
+
+    let( :at ) { class ActionTest ; include Woyo::Actions ; end.new }
+
+    it "by name" do
+      at.action( :sum ) { 1 + 2 } 
+      expect(at.sum).to eq 3
+    end
+
+    it "via #do :action" do
+      at.action( :sum ) { 1 + 2 } 
+      expect(at.do :sum).to eq 3
+    end
+
+  end
+
+end
+

data/spec/woyo/world/attributes_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'woyo/world/attributes'
 
 describe Woyo::Attributes do
@@ -5,494 +6,411 @@ describe Woyo::Attributes do
   before :all do
     class AttrTest
       include Woyo::Attributes
-      attributes :attr1, :attr2, :attr3
     end
   end
-  
-  it 'names can be listed for class' do
-    attrs = AttrTest.attributes
-    attrs.should be_instance_of Array
-    attrs.count.should eq 3
-    attrs.all? { |a| a.is_a? Symbol }.should be_true
-  end                       
-
-  it 'hash of names and values can be retrieved for instance' do
-    attr_test = AttrTest.new
-    attr_test.attributes.should be_instance_of Woyo::Attributes::AttributesHash
-    AttrTest.attributes.each do |attr|
-      attr_test.send(attr, attr.to_s.upcase)
-    end
-    attr_test.attributes.keys.should eq [ :attr1, :attr2, :attr3 ]
-    attr_test.attributes.values.should eq [ 'ATTR1', 'ATTR2', 'ATTR3' ]
-  end
-
-  it 'hash of names and nil values can be retrieved for instance before populating' do
-    attr_test = AttrTest.new
-    attr_test.attributes.should be_instance_of Woyo::Attributes::AttributesHash
-    attr_test.attributes.keys.should eq [ :attr1, :attr2, :attr3 ]  
-    attr_test.attributes.values.should eq [ nil, nil, nil ]
-  end
 
-  it 'hash of names and default values can be retrieved for instance before populating' do
-    expect { 
-      class DefTest
-        include Woyo::Attributes
-        attributes one: 1, two: 2, three: proc { 3 } 
-      end
-    }.to_not raise_error
-    def_test = DefTest.new
-    def_test.attributes.keys.should eq [ :one, :two, :three ]  
-    def_test.attributes.values.should eq [ 1, 2, 3 ]
-  end
+  context '#attributes' do
 
-  it 'have convenience accessor :names for :keys' do
-    attr_test = AttrTest.new
-    attr_test.attributes.names.should eq [ :attr1, :attr2, :attr3 ]  
-  end
-
-  it 'can be written via method with =' do
-    attr_test = AttrTest.new
-    AttrTest.attributes.each do |attr|
-      attr_test.send("#{attr}=", attr.to_s.upcase)
-    end
-    attr_test.attributes.count.should eq AttrTest.attributes.count
-    attr_test.attributes.each do |name,value|
-      value.should eq name.to_s.upcase
+    it 'returns empty AttributesHash for instance with no attributes' do
+      attr_test = AttrTest.new
+      expect(attr_test.attributes).to be_instance_of Woyo::Attributes::AttributesHash
+      expect(attr_test.attributes.count).to eq 0
     end
-  end
 
-  it 'can be written via method without =' do
-    attr_test = AttrTest.new
-    AttrTest.attributes.each do |attr|
-      attr_test.send(attr, attr.to_s.upcase)
+    it 'returns AttributesHash with names and nil values for instance with unpopulated attributes' do
+      attr_test = AttrTest.new
+      attr_test.attributes :attr1, :attr2, :attr3
+      expect(attr_test.attributes).to be_instance_of Woyo::Attributes::AttributesHash
+      expect(attr_test.attributes.keys).to eq [ :attr1, :attr2, :attr3 ]  
+      expect(attr_test.attributes.values).to eq [ nil, nil, nil ]
     end
-    attr_test.attributes.count.should eq AttrTest.attributes.count
-    attr_test.attributes.each do |name,value|
-      value.should eq name.to_s.upcase
+
+    it 'returns AttributesHash with names and values for instance with populated attributes' do
+      attr_test = AttrTest.new
+      attr_test.attributes :attr1, :attr2, :attr3
+      expect(attr_test.attributes).to be_instance_of Woyo::Attributes::AttributesHash
+      expect(attr_test.attributes.keys).to eq [ :attr1, :attr2, :attr3 ]
+      attr_test.attributes.keys.each do |attr|
+        attr_test.send(attr, attr.to_s.upcase)
+      end
+      expect(attr_test.attributes.values).to eq [ 'ATTR1', 'ATTR2', 'ATTR3' ]
     end
-  end
 
-  it 'can be read via method' do
-    attr_test = AttrTest.new
-    AttrTest.attributes.each do |attr|
-      attr_test.send(attr, attr.to_s.upcase)
+    it 'returns AttributesHash with names and default values for instance with unpopulated attributes' do
+      attr_test = AttrTest.new
+      attr_test.attributes one: 1, two: 2, three: 3 
+      expect(attr_test.attributes).to be_instance_of Woyo::Attributes::AttributesHash
+      expect(attr_test.attributes.keys).to eq [ :one, :two, :three ]  
+      expect(attr_test.attributes.values).to eq [ 1, 2, 3 ]
     end
-    attr_test.attributes.count.should eq AttrTest.attributes.count
-    attr_test.attributes.each do |name,value|
-      eval("attr_test.#{name}").should eq value
+
+    it 'provides convenience accessor :names for :keys' do
+      attr_test = AttrTest.new
+      attr_test.attributes :attr1, :attr2, :attr3
+      expect(attr_test.attributes.names).to eq [ :attr1, :attr2, :attr3 ]  
     end
+
   end
 
-  it 'list can be added to' do
-    expect {
-      class AttrTest
-        attributes :attr4, :attr5, :attr6
+  context 'can be accessed' do
+    
+    it 'to write via method with =' do
+      attr_test = AttrTest.new
+      attr_test.attributes :attr1, :attr2, :attr3
+      attr_test.attributes.names.each do |attr|
+        attr_test.send("#{attr}=", attr.to_s.upcase)
+      end
+      attr_test.attributes.each do |name,value|
+        expect(value).to eq name.to_s.upcase
       end
-    }.to_not raise_error
-    AttrTest.attributes.count.should eq 6
-    attr_test = AttrTest.new
-    AttrTest.attributes.each do |attr|
-      attr_test.send(attr, attr.to_s.upcase)
     end
-    attr_test.attributes.count.should eq 6
-  end
 
-  it 'can be defined with "attribute"' do
-    expect {
-      class AttrTest
-        attribute :open
+    it 'to write via method without =' do
+      attr_test = AttrTest.new
+      attr_test.attributes :attr1, :attr2, :attr3
+      attr_test.attributes.names.each do |attr|
+        attr_test.send(attr, attr.to_s.upcase)
       end
-    }.to_not raise_error
-    attr_test = AttrTest.new
-    attr_test.open.should be_nil
-    attr_test.open = true
-    attr_test.open.should be_true
-  end
-      
-  it 'can have a default value' do
-    expect { 
-      class AttrTest
-        attributes attr_with_array___default: [ 1, 2, 3 ]
-        attributes attr_with_hash____default: { a: 1, b: 2, c: 3 }
-        attributes attr_with_number__default: 12345
-        attributes attr_with_string__default: "abcde"
-        attributes attr_with_boolean_default: true
+      attr_test.attributes.each do |name,value|
+        expect(value).to eq name.to_s.upcase
       end
-    }.to_not raise_error
-    attr_test = AttrTest.new
-    attr_test.attr_with_array___default.should eq [ 1, 2, 3 ]
-    attr_test.attr_with_array___default = :array
-    attr_test.attr_with_array___default.should eq :array
-    attr_test.attr_with_hash____default.should eq ( { a: 1, b: 2, c: 3 } )
-    attr_test.attr_with_hash____default = :hash
-    attr_test.attr_with_hash____default.should eq :hash
-    attr_test.attr_with_number__default.should eq 12345
-    attr_test.attr_with_number__default = :number
-    attr_test.attr_with_number__default.should eq :number
-    attr_test.attr_with_string__default.should eq "abcde"
-    attr_test.attr_with_string__default = :string
-    attr_test.attr_with_string__default.should eq :string
-    attr_test.attr_with_boolean_default.should eq true
-    attr_test.attr_with_boolean_default = :boolean
-    attr_test.attr_with_boolean_default.should eq :boolean
-  end
+    end
 
-  it 'can have a default proc' do
-    expect {
-      class AttrTest
-        attributes attr_with_proc_default: proc { Time.now }
+    it 'to read via method' do
+      attr_test = AttrTest.new
+      attr_test.attributes :attr1, :attr2, :attr3
+      attr_test.attributes.names.each do |attr|
+        attr_test.send(attr, attr.to_s.upcase)
+      end
+      attr_test.attributes.each do |name,value|
+        expect(eval("attr_test.#{name}")).to eq value
       end
-    }.to_not raise_error
-    attr_test = AttrTest.new
-    attr_test.attr_with_proc_default.should be < Time.now
+    end
+
   end
 
-  it 'default proc runs in instance scope' do
-    expect {
-      class AttrTest
-        attributes attr_with_proc_default: proc { |this| this.my_method }
-        def my_method
-          "okay"
+  context 'can be defined' do
+
+    it 'via "attribute"' do
+      attr_test = AttrTest.new
+      attr_test.attribute :open
+      expect(attr_test.open).to be_nil
+      attr_test.open = true
+      expect(attr_test.open).to be true
+    end
+
+    it 'attribute list can be added to' do
+      attr_test = AttrTest.new
+      attr_test.attributes :attr1, :attr2, :attr3
+      attr_test.attributes :attr4, :attr5, :attr6
+      expect(attr_test.attributes.count).to eq 6
+      expect(attr_test.attributes.names).to eq [ :attr1, :attr2, :attr3, :attr4, :attr5, :attr6 ]
+    end
+
+    it 'attribute list can be added to without duplication' do
+      attr_test = AttrTest.new
+      attr_test.attributes :attr1, :attr2, :attr3
+      attr_test.attributes :attr2, :attr3, :attr4
+      expect(attr_test.attributes.count).to eq 4
+      expect(attr_test.attributes.names).to eq [ :attr1, :attr2, :attr3, :attr4 ]
+    end
+        
+    it 'with a default value' do
+      attr_test = AttrTest.new
+      attr_test.attributes attr_with_array___default: [ 1, 2, 3 ]
+      attr_test.attributes attr_with_hash____default: { a: 1, b: 2, c: 3 }
+      attr_test.attributes attr_with_number__default: 12345
+      attr_test.attributes attr_with_string__default: "abcde"
+      attr_test.attributes attr_with_boolean_default: true
+      expect(attr_test.attr_with_array___default).to eq [ 1, 2, 3 ]
+      expect(attr_test.attr_with_hash____default).to eq ( { a: 1, b: 2, c: 3 } )
+      expect(attr_test.attr_with_number__default).to eq 12345
+      expect(attr_test.attr_with_string__default).to eq "abcde"
+      expect(attr_test.attr_with_boolean_default).to eq true
+    end
+
+    context 'wth a dynamic value' do
+
+      context 'a proc' do
+
+        it 'runs' do
+          attr_test = AttrTest.new
+          attr_test.attributes attr_with_proc_default: proc { Time.now }
+          expect(attr_test.attr_with_proc_default).to be < Time.now
         end
-      end
-    }.to_not raise_error
-    attr_test = AttrTest.new
-    attr_test.attr_with_proc_default.should eq "okay"
-  end
 
-  it 'can have a default lambda' do
-    expect {
-      class AttrTest
-        attributes attr_with_lambda_default: lambda { Time.now }
-      end
-    }.to_not raise_error
-    attr_test = AttrTest.new
-    attr_test.attr_with_lambda_default.should be < Time.now
-  end
+        it 'runs in instance scope' do
+          attr_test = AttrTest.new
+          attr_test.define_singleton_method(:my_method) { "okay" }
+          attr_test.attributes attr_with_proc_default: proc { |this| this.my_method }
+          expect(attr_test.attr_with_proc_default).to eq "okay"
+        end
+
+        it 'runs on each access via method' do
+          attr_test = AttrTest.new
+          attr_test.attributes time_proc: proc { Time.now }
+          old_time = attr_test.time_proc
+          expect(attr_test.time_proc).to be > old_time
+        end
 
-  it 'default lambda runs in instance scope' do
-    expect {
-      class AttrTest
-        attributes attr_with_lambda_default: lambda { |this| this.my_method }
-        def my_method
-          "okay"
+        it 'is returned on direct access to attribute' do
+          attr_test = AttrTest.new
+          attr_test.attributes time_proc: proc { Time.now }
+          expect(attr_test.attributes[:time_proc]).to respond_to :call
         end
+
       end
-    }.to_not raise_error
-    attr_test = AttrTest.new
-    attr_test.attr_with_lambda_default.should eq "okay"
-  end
 
-  context 'that are boolean' do
+      context 'a lambda' do
+        
+        it 'runs' do
+          attr_test = AttrTest.new
+          attr_test.attributes attr_with_lambda_default: lambda { Time.now }
+          expect(attr_test.attr_with_lambda_default).to be < Time.now
+        end
 
-    context 'have convenient instance accessors' do
+        it 'runs in instance scope' do
+          attr_test = AttrTest.new
+          attr_test.define_singleton_method(:my_method) { "okay" }
+          attr_test.attributes attr_with_lambda_default: lambda { |this| this.my_method }
+          expect(attr_test.attr_with_lambda_default).to eq "okay"
+        end
 
-      before :all do
-        expect {
-          class BooleanAttrTest
-            include Woyo::Attributes
-            attribute open: true
-            attribute light: false 
-          end
-        }.to_not raise_error
-      end
+        it 'runs on each access via method' do
+          attr_test = AttrTest.new
+          attr_test.attributes time_lambda: lambda { Time.now }
+          old_time = attr_test.time_lambda
+          expect(attr_test.time_lambda).to be > old_time
+        end
 
-      it '#attr?' do
-        attr_test = BooleanAttrTest.new
-        attr_test.open.should eq true
-        attr_test.open?.should eq true
-      end
+        it 'is returned on direct access to attribute' do
+          attr_test = AttrTest.new
+          attr_test.attributes time_lambda: lambda { Time.now }
+          expect(attr_test.attributes[:time_lambda]).to respond_to :call
+        end
 
-      it '#attr!' do
-        attr_test = BooleanAttrTest.new
-        attr_test.open = false
-        attr_test.open.should eq false
-        attr_test.open!.should eq true
-        attr_test.open.should eq true
       end
+      
+      context 'a block' do
 
-      it '#is? :attr' do
-        attr_test = BooleanAttrTest.new
-        attr_test.is?(:open).should eq true
-        attr_test.open = false
-        attr_test.is?(:open).should eq false
-      end
+        it 'runs' do
+          attr_test = AttrTest.new
+          attr_test.attribute( :attr_with_block_default ) { Time.now }
+          expect(attr_test.attr_with_block_default).to be < Time.now
+        end
+
+        it 'runs in instance scope' do
+          attr_test = AttrTest.new
+          attr_test.define_singleton_method(:my_method) { "okay" }
+          attr_test.attribute( :attr_with_block_default )  { |this| this.my_method }
+          expect(attr_test.attr_with_block_default).to eq "okay"
+        end
+
+        it 'runs on each access via method' do
+          attr_test = AttrTest.new
+          attr_test.attribute( :time_block ) { Time.now }
+          old_time = attr_test.time_block
+          expect(attr_test.time_block).to be > old_time
+        end
+
+        it 'is returned on direct access to attribute' do
+          attr_test = AttrTest.new
+          attr_test.attribute( :time_block ) { Time.now }
+          expect(attr_test.attributes[:time_block]).to respond_to :call
+        end
 
-      it '#is :attr' do
-        attr_test = BooleanAttrTest.new
-        attr_test.light.should eq false
-        attr_test.is(:light)
-        attr_test.light.should eq true
       end
+
     end
 
-    context 'have class accessor ::is' do
+  end
 
-      # I was confused here, this may not be needed as a class method at all!!!
-      
-      it 'that defines new attribute with true default' do 
-        expect {
-          class BooleanIsTest1
-            include Woyo::Attributes
-            is :attr1
-          end
-        }.to_not raise_error
-        attr_test = BooleanIsTest1.new
-        attr_test.attr1.should eq true 
-      end
+  context 'that are boolean have convenient instance accessors' do
 
-      it 'that sets true default for existing attribute' do
-        expect {
-          class BooleanIsTest2
-            include Woyo::Attributes
-            attribute :attr2
-            is :attr2
-          end
-        }.to_not raise_error
-        attr_test = BooleanIsTest2.new
-        attr_test.attr2.should eq true 
-      end
+    let(:bat) { class BooleanAttrTest; include Woyo::Attributes; end.new }
 
-      it 'that changes default to true for existing attribute' do
-        expect {
-          class BooleanIsTest3
-            include Woyo::Attributes
-            attribute :attr3 => false
-            is :attr3
-          end
-        }.to_not raise_error
-        attr_test = BooleanIsTest3.new
-        attr_test.attr3.should eq true 
-      end
+    before :each do
+      bat.attribute open: true
+    end
 
-      it 'that works for attribute in BooleanGroup' do
-        expect {
-          class BooleanIsTest4
-            include Woyo::Attributes
-            group! :temp, :hot, :warm, :cool, :cold
-            # :hot is true by default
-            is :cold
-            # :cold is now true
-          end
-        }.to_not raise_error
-        attr_test = BooleanIsTest4.new
-        attr_test.hot.should eq false
-        attr_test.warm.should eq false
-        attr_test.cool.should eq false
-        attr_test.cold.should eq true
-      end
+    it '#attr?' do
+      expect(bat.open).to eq true
+      expect(bat.open?).to eq true
+    end
+
+    it '#attr!' do
+      bat.open = false
+      expect(bat.open).to eq false
+      expect(bat.open!).to eq true
+      expect(bat.open).to eq true
+    end
 
+    it '#is? :attr' do
+      expect(bat.is?(:open)).to eq true
+      bat.open = false
+      expect(bat.is?(:open)).to eq false
+    end
+
+    it '#is :attr' do
+      bat.open = false
+      expect(bat.open).to eq false
+      bat.is(:open)
+      expect(bat.open).to eq true
     end
 
   end
 
   context 'can be re-defined' do
 
+    let(:ard) { AttrTest.new }
+
     it 'without duplication' do
-      expect {
-        class AttrReDef1
-          include Woyo::Attributes
-          attribute :attr1
-        end
-        class AttrReDef1
-          attribute :attr1
-        end
-      }.to_not raise_error
-      AttrReDef1.attributes.count.should eq 1
-      AttrReDef1.attributes.should eq [:attr1] 
-      attr_rd1 = AttrReDef1.new
-      attr_rd1.attr1.should be_nil
+      ard.attribute :attr
+      ard.attribute :attr
+      expect(ard.attributes.count).to eq 1
+      expect(ard.attributes.names).to eq [:attr] 
+      expect(ard.attr).to eq nil 
     end
 
     it 'to set default' do
-      expect {
-        class AttrReDef2
-          include Woyo::Attributes
-          attribute :attr2
-        end
-        class AttrReDef2
-          attribute attr2: 'two'
-        end
-      }.to_not raise_error
-      AttrReDef2.attributes.count.should eq 1
-      AttrReDef2.attributes.should eq [:attr2] 
-      attr_rd2 = AttrReDef2.new
-      attr_rd2.attr2.should eq 'two'
+      ard.attribute :attr
+      ard.attribute :attr => 'default'
+      expect(ard.attributes.count).to eq 1
+      expect(ard.attributes.names).to eq [:attr] 
+      expect(ard.attr).to eq 'default' 
     end
 
     it 'to change default'  do
-      expect {
-        class AttrReDef3
-          include Woyo::Attributes
-          attribute attr3: '333'
-        end
-        class AttrReDef3
-          attribute attr3: 'three'
-        end
-      }.to_not raise_error
-      AttrReDef3.attributes.count.should eq 1
-      AttrReDef3.attributes.should eq [:attr3] 
-      attr_rd3 = AttrReDef3.new
-      attr_rd3.attr3.should eq 'three'
+      ard.attribute :attr => 'old_default'
+      ard.attribute :attr => 'new_default'
+      expect(ard.attributes.count).to eq 1
+      expect(ard.attributes.names).to eq [:attr] 
+      expect(ard.attr).to eq 'new_default' 
     end
 
   end
 
   context 'groups' do
 
-    before :all do
-      class AT
-        include Woyo::Attributes
-        group :stooges, :larry, :curly, :moe
-        group :cars,    :mustang, :ferarri, :mini 
-      end
-      @at = AT.new
-    end
+    let(:gat) { AttrTest.new }
 
-    it 'can be listed for class' do
-      groups = AT.groups
-      groups.should be_instance_of Hash
-      groups.count.should eq 2
-      groups.keys.should eq [ :stooges, :cars ]
-      groups[:stooges].should eq [ :larry, :curly, :moe ]
-      groups[:cars].should eq [ :mustang, :ferarri, :mini ]
+    before :each do
+      gat.group :stooges, :larry, :curly, :moe
     end
 
-    it 'have convenience accessor :names for :keys' do
-      @at.stooges.names.should eq [ :larry, :curly, :moe ]  
+    it 'can be accessed by named instance methods' do
+      expect(gat.stooges).to be_instance_of Woyo::Attributes::Group
     end
 
-    it 'names and nil values can be retrieved from instance without populating' do
-      @at.stooges.should be_instance_of Woyo::Attributes::Group
-      @at.stooges.count.should eq 3
-      @at.stooges.names.should eq [ :larry, :curly, :moe ] 
-      @at.stooges.values.should eq [ nil, nil, nil ] 
+    it 'names and nil values can be retrieved' do
+      expect(gat.stooges).to be_instance_of Woyo::Attributes::Group
+      expect(gat.stooges.count).to eq 3
+      expect(gat.stooges.names).to eq [ :larry, :curly, :moe ] 
+      expect(gat.stooges.values).to eq [ nil, nil, nil ] 
     end
 
-    it 'names and default values can be retrieved from instance without populating' do
-      expect { 
-        class GroupDefTest
-          include Woyo::Attributes
-          group :numbers, one: 1, two: 2, three: proc { 3 } 
-        end
-      }.to_not raise_error
-      def_test = GroupDefTest.new
-      groups = def_test.groups
-      groups.should be_instance_of Hash
-      groups.count.should eq 1
-      groups.names.should eq [ :numbers ]
-      groups[:numbers].should be_instance_of Woyo::Attributes::Group
-      groups[:numbers].names.should eq [ :one, :two, :three ]
-      groups[:numbers].values.should eq [ 1, 2, 3 ]
-      def_test.numbers.names.should eq [ :one, :two, :three ]  
-      def_test.numbers.values.should eq [ 1, 2, 3 ]
+    it 'names and default values can be retrieved' do
+      gat.group :numbers, one: 1, two: 2, three: 3  
+      expect(gat.numbers).to be_instance_of Woyo::Attributes::Group
+      expect(gat.numbers.count).to eq 3
+      expect(gat.numbers.names).to eq [ :one, :two, :three ]  
+      expect(gat.numbers.values).to eq [ 1, 2, 3 ]
     end
 
     it 'members can be accessed via group' do
-      @at.stooges[:curly].should eq nil
-      @at.stooges[:curly] = 'bald'
-      @at.stooges[:curly].should eq 'bald'
-    end
-
-    it 'members are also attributes' do
-      all_attrs = [ :larry, :curly, :moe, :mustang, :ferarri, :mini ]  
-      @at.attributes.keys.should eq all_attrs 
-      all_attrs.each do |attr|
-        @at.should respond_to attr
-      end
+      expect(gat.stooges[:curly]).to eq nil
+      gat.stooges[:curly] = 'bald'
+      expect(gat.stooges[:curly]).to eq 'bald'
     end
 
     it 'members are attributes' do
-      @at.stooges[:moe] = 'knucklehead'
-      @at.stooges[:moe].should eq 'knucklehead'
-      @at.moe.should eq 'knucklehead' 
+      expect(gat.attributes.keys).to eq [ :larry, :curly, :moe ]  
+      gat.stooges[:larry] = 'knucklehead'
+      expect(gat.larry).to eq 'knucklehead' 
     end
 
     it 'attributes are members' do
-      @at.ferarri = 'fast'
-      @at.ferarri.should eq 'fast'
-      @at.cars[:ferarri].should eq 'fast'
+      gat.moe = 'smart'
+      expect(gat.stooges[:moe]).to eq 'smart'
+    end
+
+    it '#groups returns hash with names and groups' do
+      gat.group :numbers, one: 1, two: 2, three: proc { 3 } 
+      expect(gat.groups).to eq( { stooges: gat.stooges, numbers: gat.numbers } )
     end
 
   end
 
-  context 'boolean groups' do
+  context 'exclusions' do
 
-    before :all do
-      class ExGroupTest
-        include Woyo::Attributes
-        group! :temp, :hot, :warm, :cool, :cold
-        group! :light, :dark, :dim, :bright
-      end
-    end
+    let(:xat) { AttrTest.new }
 
-    it 'are listed for a class' do
-      groups = ExGroupTest.boolean_groups
-      groups.should be_instance_of Hash
-      groups.count.should eq 2
-      groups.keys.should eq [ :temp, :light ]
-      groups[:temp].should eq [ :hot, :warm, :cool, :cold ] 
-      groups[:light].should eq [ :dark, :dim, :bright ]
+    before :each do
+      xat.exclusion :temp, :warm, :cool, :cold
     end
 
-    it 'accessor returns BooleanGroup instance' do
-      egt = ExGroupTest.new
-      egt.temp.should be_instance_of Woyo::Attributes::BooleanGroup
+    it 'can be accessed by named instance methods' do
+      expect(xat.temp).to be_instance_of Woyo::Attributes::Exclusion
     end
 
     it 'first member is true, rest are false' do
-      egt = ExGroupTest.new
-      egt.light[:dark].should eq true
-      egt.light[:dim].should eq false
-      egt.light[:bright].should eq false
+      expect(xat.temp[:warm]).to eq true
+      expect(xat.temp[:cool]).to eq false
+      expect(xat.temp[:cold]).to eq false
+    end
+
+    it '#value returns true member' do
+      expect(xat.temp.value).to eq :warm
+      xat.temp[:cold] = true
+      expect(xat.temp.value).to eq :cold
     end
 
     it 'making group member true affects member attributes' do
-      egt = ExGroupTest.new
-      egt.temp[:cold] = true
-      egt.cold.should be true
-      egt.cool.should be false
-      egt.warm.should be false
-      egt.hot.should be false
+      xat.temp[:cold] = true
+      expect(xat.cold).to be true
+      expect(xat.cool).to be false
+      expect(xat.warm).to be false
     end
 
     it 'making attribute true affects group members' do
-      egt = ExGroupTest.new
-      egt.cold = true
-      egt.light[:cold].should be true
-      egt.light[:cool].should be false
-      egt.light[:warm].should be false
-      egt.light[:hot].should be false
+      xat.cool = true
+      expect(xat.temp[:cold]).to be false
+      expect(xat.temp[:cool]).to be true
+      expect(xat.temp[:warm]).to be false
+    end
+
+    it '#exclusions returns hash with names and exlcusions' do
+      xat.exclusion :light, :dark, :dim, :bright
+      expect(xat.exclusions).to eq( { temp: xat.temp, light: xat.light } )
     end
 
   end
 
-  context 'assigned a Hash as a value' do
+  context 'with Hash value' do
 
-    before :all do
-      class AttrHashTest
-        include Woyo::Attributes
-        attributes :reaction, :hot, :cold
-      end
-      @aht = AttrHashTest.new
+    let(:hat) { AttrTest.new }
+
+    before :each do
+      hat.attributes :reaction, :hot, :cold
     end
 
-    it 'accepts the hash as a value' do
-      expect { @aht.reaction hot: 'Sweat', cold: 'Shiver' }.to_not raise_error
+    it 'accept a hash as value' do
+      expect { hat.reaction hot: 'Sweat', cold: 'Shiver' }.to_not raise_error
     end
 
-    it 'returns the value of the first key that evaluates as a true attribute' do
-      @aht.cold = true
-      @aht.reaction.should eq 'Shiver'
-      @aht.hot = true
-      @aht.reaction.should eq 'Sweat'
+    it 'return the value of the first key that evaluates as a true attribute' do
+      hat.reaction hot: 'Sweat', cold: 'Shiver' 
+      hat.cold = true
+      expect(hat.reaction).to eq 'Shiver'
+      hat.hot = true
+      expect(hat.reaction).to eq 'Sweat'
     end
 
-    it 'otherwise it returns the hash' do
-      reactions = { :hot => 'Sweat', :cold => 'Shiver' }
-      @aht.cold = false
-      @aht.hot = false
-      @aht.reaction.should eq reactions
+    it 'otherwise return the hash' do
+      hat.reaction hot: 'Sweat', cold: 'Shiver' 
+      hat.cold = false
+      hat.hot = false
+      expect(hat.reaction).to eq ( { :hot => 'Sweat', :cold => 'Shiver' } )
     end
 
   end