woyo-world 0.0.6 → 0.0.7

data/spec/woyo/world/character_spec.rb

@@ -1,52 +1,54 @@
+require 'spec_helper'
 require 'woyo/world/character'
 require 'woyo/world/world'
 require 'woyo/world/location'
 
 describe Woyo::Character do
- 
+
+  let(:char) { Woyo::Character.new :boss }
+
   it 'has attributes' do
-    expected_attrs = [:name,:description]
-    Woyo::Character.attributes.sort.should eq expected_attrs.sort 
+    expect(char.attributes).to be_instance_of Woyo::Attributes::AttributesHash
+    expect(char.attributes.names.sort).to eq [:description,:name]
   end
 
   it 'name attribute defaults to id' do
-    wo = Woyo::Character.new(:boss)
-    wo.name.should eq 'Boss'
+    expect(char.name).to eq 'Boss'
   end
 
   it 'accepts world for parameter context:' do
     wo = nil
     expect { wo = Woyo::Character.new(:my_id, context: Woyo::World.new) }.to_not raise_error
-    wo.context.should be_instance_of Woyo::World
+    expect(wo.context).to be_instance_of Woyo::World
   end
 
   it 'accepts location for parameter context:' do
     wo = nil
     expect { wo = Woyo::Character.new(:my_id, context: Woyo::Location.new(:here)) }.to_not raise_error
-    wo.context.should be_instance_of Woyo::Location
-    wo.context.id.should eq :here
+    expect(wo.context).to be_instance_of Woyo::Location
+    expect(wo.context.id).to eq :here
   end
 
-  it 'can go way' do
-    world = Woyo::World.new do
-      location :home do
-        way :out do
-          to :away
-        end
-        character :tom
-      end
-      location :away do
-      end
-    end
-    home = world.locations[:home]
-    away = world.locations[:away]
-    tom = home.characters[:tom]
-    tom.location.should be home
-    tom.go :out
-    tom.location.should be away
-    home.characters[:tom].should be_nil
-    away.characters[:tom].should eq tom
-  end
+  # it 'can go way' do
+  #   world = Woyo::World.new do
+  #     location :home do
+  #       way :out do
+  #         to :away
+  #       end
+  #       character :tom
+  #     end
+  #     location :away do
+  #     end
+  #   end
+  #   home = world.locations[:home]
+  #   away = world.locations[:away]
+  #   tom = home.characters[:tom]
+  #   tom.location.should be home
+  #   tom.go :out
+  #   tom.location.should be away
+  #   home.characters[:tom].should be_nil
+  #   away.characters[:tom].should eq tom
+  # end
 
 end
 

data/spec/woyo/world/evaluate_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require 'woyo/world/evaluate'
+
+describe Woyo::Evaluate do
+
+  before :all do
+    class EvalTest
+      include Woyo::Evaluate
+      children :dog, :cat
+    end
+    class Dog ; def initialize id, context: nil ; end ; end
+    class Cat ; def initialize id, context: nil ; end ; end
+  end
+
+  context '#evaluate' do
+
+    it 'instance evals block with arity 0' do
+      evt = EvalTest.new
+      result = evt.evaluate { self.should == evt }
+      expect(result).to be evt
+    end
+
+    it 'passes self to block with arity 1' do
+      evt = EvalTest.new
+      result = evt.evaluate { |scope| expect(scope).to be evt }
+      expect(result).to be evt
+    end
+
+  end
+
+  it 'can list classes to contain' do
+    expect(EvalTest.children).to eq [ :dog, :cat ]
+  end
+
+  it 'can add classes to contain' do
+    class EvalTest
+      children :cow
+      children :duck
+    end
+    # class Cow  ; def initialize id, context: nil ; end ; end
+    # class Duck ; def initialize id, context: nil ; end ; end
+    expect(EvalTest.children).to eq [ :dog, :cat, :cow, :duck ]
+  end
+
+  it 'can create child objects' do
+    evt = EvalTest.new
+    dog = evt.dog :brown
+    expect(dog).to be_instance_of Dog
+    expect(evt.dog(:brown)).to be dog
+    expect(evt.dogs[:brown]).to be dog
+  end
+
+  it 'has hashes of each class of child objects' do
+    evt = EvalTest.new
+    dog_brown = evt.dog :brown
+    dog_black = evt.dog :black
+    cat_white = evt.cat :white
+    cat_black = evt.cat :black
+    expect(evt.dogs).to eq Hash[ brown: dog_brown, black: dog_black ]
+    expect(evt.cats).to eq Hash[ white: cat_white, black: cat_black ]
+  end
+
+  it 'hash a hash of all classes of child objects' do
+    evt = EvalTest.new
+    dog_brown = evt.dog :brown
+    dog_black = evt.dog :black
+    cat_white = evt.cat :white
+    cat_black = evt.cat :black
+    expect(evt.children.keys).to eq [ :dog, :cat ]
+    cats = Hash[ white: cat_white, black: cat_black ]
+    dogs = Hash[ brown: dog_brown, black: dog_black ]
+    expect(evt.children).to eq Hash[ dog: dogs, cat: cats ] 
+  end
+
+end

data/spec/woyo/world/group_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'woyo/world/group'
 
 describe Woyo::Attributes::AttributesHash do
@@ -19,14 +20,14 @@ describe Woyo::Attributes::AttributesHash do
   end
 
   it 'is a kind of hash' do
-    @attributes.should be_kind_of Hash
-    @attributes[:test].should be nil
+    expect(@attributes).to be_kind_of Hash
+    expect(@attributes[:test]).to be nil
     @attributes[:test] = true
-    @attributes[:test].should be true
+    expect(@attributes[:test]).to be true
   end
 
   it 'provides list of attribute names' do
-    @attributes.names.should eq [:test]
+    expect(@attributes.names).to eq [:test]
   end
 
   it 'registers attribute listeners' do
@@ -34,27 +35,27 @@ describe Woyo::Attributes::AttributesHash do
   end
 
   it 'maintains list of attribute listeners' do
-    @attributes.listeners.should be_kind_of Hash
-    @attributes.listeners[:test].should be @listener
+    expect(@attributes.listeners).to be_kind_of Hash
+    expect(@attributes.listeners[:test]).to be @listener
   end
 
   it 'notifies listeners of attribute change' do
-    @listener.notified.should be false
-    @listener.attr.should be nil
-    @listener.value.should be nil
+    expect(@listener.notified).to be false
+    expect(@listener.attr).to be nil
+    expect(@listener.value).to be nil
     @attributes[:test] = :new_value
-    @listener.notified.should eq true
-    @listener.attr.should eq :test
-    @listener.value.should eq :new_value
+    expect(@listener.notified).to eq true
+    expect(@listener.attr).to eq :test
+    expect(@listener.value).to eq :new_value
   end
 
   it 'does not notify listener if attribute does not change' do
     @attributes[:test] = :same_value
     @listener = Listener.new
     @attributes.add_attribute_listener :test, @listener
-    @listener.notified.should be false
+    expect(@listener.notified).to be false
     @attributes[:test] = :same_value
-    @listener.notified.should be false
+    expect(@listener.notified).to be false
   end
 
 end
@@ -72,74 +73,74 @@ describe Woyo::Attributes::Group do
   end
 
   it 'maintains list of members' do
-    @group.members.should eq [ :larry, :curly, :moe ]
+    expect(@group.members).to eq [ :larry, :curly, :moe ]
   end
 
   it 'member names can be listed' do
-    @group.names.should eq [ :larry, :curly, :moe ]
+    expect(@group.names).to eq [ :larry, :curly, :moe ]
   end
 
   it 'members are backed by attributes' do
     @group[:larry] = 'dumb'
     @group[:curly] = 'bald'
     @group[:moe] = 'smart'
-    @group[:larry].should eq 'dumb'
-    @group[:curly].should eq 'bald'
-    @group[:moe].should eq 'smart'
-    @attributes[:larry].should eq 'dumb'
-    @attributes[:curly].should eq 'bald'
-    @attributes[:moe].should eq 'smart'
+    expect(@group[:larry]).to eq 'dumb'
+    expect(@group[:curly]).to eq 'bald'
+    expect(@group[:moe]).to eq 'smart'
+    expect(@attributes[:larry]).to eq 'dumb'
+    expect(@attributes[:curly]).to eq 'bald'
+    expect(@attributes[:moe]).to eq 'smart'
   end
   
   it 'member values can be listed' do
-    @group.values.should eq %w( dumb bald smart )
+    expect(@group.values).to eq %w( dumb bald smart )
   end
 
 end
 
-describe Woyo::Attributes::BooleanGroup do
+describe Woyo::Attributes::Exclusion do
 
   before :all do
-    @group = Woyo::Attributes::BooleanGroup.new Woyo::Attributes::AttributesHash.new, :warm, :cool, :cold
+    @group = Woyo::Attributes::Exclusion.new Woyo::Attributes::AttributesHash.new, :warm, :cool, :cold
   end
 
   it 'has default' do
-    @group.default.should eq :warm
+    expect(@group.default).to eq :warm
   end
 
   it 'defaults to first member true, the rest false' do
-    @group[:warm].should be true
-    @group[:cool].should be false
-    @group[:cold].should be false
+    expect(@group[:warm]).to be true
+    expect(@group[:cool]).to be false
+    expect(@group[:cold]).to be false
   end
   
   it 'registers as listener for attributes' do
     @group.members.each do |member|
-      @group.attributes.listeners[member].should be @group
+      expect(@group.attributes.listeners[member]).to be @group
     end
   end
 
   it 'setting a member true changes the rest to false' do
     @group[:cold] = true
-    @group[:warm].should be false
-    @group[:cool].should be false
-    @group[:cold].should be true
+    expect(@group[:warm]).to be false
+    expect(@group[:cool]).to be false
+    expect(@group[:cold]).to be true
   end
 
   it 'for a group > 2 members setting a true member false reverts to default' do
     @group[:cold] = false
-    @group[:warm].should be true
-    @group[:cool].should be false
-    @group[:cold].should be false
+    expect(@group[:warm]).to be true
+    expect(@group[:cool]).to be false
+    expect(@group[:cold]).to be false
   end
 
   it 'for a binary group setting a true member false sets the other true' do
-    @binary_group = Woyo::Attributes::BooleanGroup.new Woyo::Attributes::AttributesHash.new, :yes, :no
-    @binary_group[:yes].should be true
-    @binary_group[:no].should be false
+    @binary_group = Woyo::Attributes::Exclusion.new Woyo::Attributes::AttributesHash.new, :yes, :no
+    expect(@binary_group[:yes]).to be true
+    expect(@binary_group[:no]).to be false
     @binary_group[:yes] = false
-    @binary_group[:yes].should be false
-    @binary_group[:no].should be true
+    expect(@binary_group[:yes]).to be false
+    expect(@binary_group[:no]).to be true
   end
 
   it 'can only set existing members' do
@@ -149,14 +150,14 @@ describe Woyo::Attributes::BooleanGroup do
   it 'can be reset to default!' do
     @group[:cool] = true 
     @group.default!
-    @group[:warm].should eq true
+    expect(@group[:warm]).to eq true
   end
 
   it '#value returns name of true member' do
     @group[:warm] = true
-    @group.value.should eq :warm
+    expect(@group.value).to eq :warm
     @group[:cold] = true
-    @group.value.should eq :cold
+    expect(@group.value).to eq :cold
   end
 
 end

data/spec/woyo/world/item_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'woyo/world/world'
+require 'woyo/world/item'
+
+describe Woyo::Item do
+
+  context 'in world' do
+
+    let(:item) { Woyo::Item.new :thing, context: Woyo::World.new }
+
+    it 'accepts world for parameter context' do
+      expect(item.context).to be_instance_of Woyo::World
+    end
+
+    it '#world' do
+      expect(item.world).to be_instance_of Woyo::World
+    end
+
+    it '#location' do
+      expect(item.location).to be_nil
+    end
+
+  end
+
+  context 'in a location' do
+
+    let(:item) { Woyo::Item.new :thing, context: Woyo::Location.new(:here, context: Woyo::World.new) }
+
+    it 'accepts location for parameter context:' do
+      expect(item.context).to be_instance_of Woyo::Location
+      expect(item.context.id).to eq :here
+    end
+
+    it '#location' do
+      expect(item.location).to be_instance_of Woyo::Location
+      expect(item.location.id).to eq :here
+    end
+
+    it '#world' do
+      expect(item.world).to be_instance_of Woyo::World
+    end
+
+  end
+
+end
+ 

data/spec/woyo/world/location_spec.rb

@@ -1,23 +1,28 @@
+require 'spec_helper'
 require 'woyo/world/world'
 require 'woyo/world/location'
+require 'woyo/world/item'
 require 'woyo/world/way'
 
 describe Woyo::Location do
 
-  it 'has attributes' do
-    expected_attrs = [:name,:description]
-    Woyo::Location.attributes.sort.should eq expected_attrs.sort 
-  end
-
-  it 'name attribute defaults to id' do
-    wo = Woyo::Location.new(:home)
-    wo.name.should eq 'Home'
-  end
+  let(:location) { Woyo::Location.new :home }
 
   it 'accepts world for parameter context:' do
     wo = nil
     expect { wo = Woyo::Location.new(:my_id, context: Woyo::World.new) }.to_not raise_error
-    wo.context.should be_instance_of Woyo::World
+    expect(wo.context).to be_instance_of Woyo::World
+  end
+
+  it '#here' do
+    home = Woyo::Location.new :home 
+    expect(home.here).to be home
+  end
+
+  it '#world' do
+    world = Woyo::World.new
+    home = Woyo::Location.new :home, context: world
+    expect(home.world).to eq world
   end
 
   context 'ways' do
@@ -28,8 +33,8 @@ describe Woyo::Location do
         way( :down ) { to :cellar }
         way( :out  ) { to :garden }
       end
-      home.ways.count.should eq 3
-      home.ways.keys.should eq [ :up, :down, :out ]
+      expect(home.ways.count).to eq 3
+      expect(home.ways.keys).to eq [ :up, :down, :out ]
     end
 
     it 'are from here' do
@@ -39,7 +44,7 @@ describe Woyo::Location do
         end
       end
       door = home.ways[:door]
-      door.from.should eq home
+      expect(door.from).to eq home
     end
 
     it 'go to locations' do
@@ -49,32 +54,43 @@ describe Woyo::Location do
         end
       end
       door = home.ways[:door]
-      door.to.should be_instance_of Woyo::Location
-      door.to.id.should eq :away
+      expect(door.to).to be_instance_of Woyo::Location
+      expect(door.to.id).to eq :away
     end
 
   end
 
-  it '#here' do
-    home = Woyo::Location.new :home 
-    home.here.should be home
-  end
+  context 'items' do
 
-  it '#world' do
-    world = Woyo::World.new
-    home = Woyo::Location.new :home, context: world
-    home.world.should eq world
-  end
-
-  it '#characters' do
-    home = Woyo::Location.new :home do
-      character :peter do
+    let( :home ) do
+      home = Woyo::Location.new :home do
+        item( :thing1 ) { description 'Thing One' }
+        item( :thing2 ) { description 'Thing two' }
       end
     end
-    home.characters.size.should eq 1
-    peter = home.characters[:peter]
-    peter.should be_instance_of Woyo::Character
-    peter.location.should be home
+
+    it 'are listed' do
+      expect(home.items.count).to eq 2
+      expect(home.items.keys).to eq [ :thing1, :thing2 ]
+    end
+
+    it 'are accessible' do
+      expect(thing = home.items[:thing1]).to be_instance_of Woyo::Item
+      expect(thing.id).to eq :thing1
+      expect(thing.description).to eq 'Thing One'
+    end
+
   end
 
+  # it '#characters' do
+  #   home = Woyo::Location.new :home do
+  #     character :peter do
+  #     end
+  #   end
+  #   home.characters.size.should eq 1
+  #   peter = home.characters[:peter]
+  #   peter.should be_instance_of Woyo::Character
+  #   peter.location.should be home
+  # end
+
 end