woyo-world 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2c1c941040eef171a088f6ee54a6416f55eb46ba
-  data.tar.gz: 881d8203e4a35f0965a191cf47f6706cc18ee8ba
+  metadata.gz: 8cbc8a5d94754ea504e7df2e4cee823c172bec1c
+  data.tar.gz: 3aa4c6addaf017db4ceddfcbba8c062341883444
 SHA512:
-  metadata.gz: eb02560ec28f3cc4c370406424518b5c9246a69c34225903e5a17abde911be52231a9cc1670ffc37036c1da788492b39d78b141a00aa17d1f1776996b748bf84
-  data.tar.gz: 958c5a2eacdf5be0ef4e3e3a0fd0ba420040bc8842efebdf18d03a5e427cfbf5bfa05eac7eac2fb4b12e84bb653157cc11f8aaee8998a4d6c946c714bea429cd
+  metadata.gz: 0170be24f57b4fe0fbbb0bfb576b63ef8e5d5be4e20c86ee81e639728ae003336b4f4e0d035a27795fb5780b15455b6e591bfa260331af0d13b8cc2ad834ba5d
+  data.tar.gz: fa95a9aebdd52812b0940d1db8c4f60de33a3212518a5140f09f815018a6b66bec8b345b9c80966146b31ea1e3b1c50af348ed17a906f91773279967dba9717e

data/lib/woyo/world/action.rb

@@ -0,0 +1,37 @@
+require_relative 'world_object'
+
+module Woyo
+
+class Action < WorldObject
+
+  def initialize_object
+    super
+    attribute :describe
+    exclusion :result
+    @proc = proc { nil }
+  end
+
+  def execute
+    proc_result = if @proc.arity < 1
+      @context.instance_eval &@proc
+    else
+      @context.instance_exec self, &@proc
+    end
+    true_members = result.members.select { |member| result[member] }
+    true_members = true_members[0] if true_members.count == 1
+    true_members = nil if true_members.empty?
+    { result: true_members, describe: describe, execution: proc_result }
+  end
+
+  def execution &block
+    if block_given?
+      @proc = block
+    else
+      @proc
+    end
+  end
+
+end
+
+end
+

data/lib/woyo/world/attributes.rb

@@ -8,44 +8,61 @@ module Woyo
 
 module Attributes
 
+  class AttributesHash < Hash
+
+    alias_method :names, :keys
+    alias_method :set, :[]=
+
+    attr_reader :listeners
+
+    def initialize
+      @listeners = {}
+    end
+
+    def add_attribute_listener attr, listener
+      @listeners[attr] = listener
+    end
+    
+    def []= attr, value
+      old_value = self[attr]
+      super
+      if ( listener = @listeners[attr] ) && value != old_value
+        listener.notify attr, value
+      end
+    end
+
+  end
+  
   def attribute *attrs, &block
-    send :_attributes, attrs, ivn: '@attributes', &block
+    attributes *attrs, &block
   end
 
   def attributes *attrs, &block
-    send :_attributes, attrs, ivn: '@attributes', &block
-  end
-
-  def _attributes attrs, ivn:, &block
-    if instance_variable_defined? ivn
-      ivar = instance_variable_get ivn
-    else
-      ivar = instance_variable_set ivn, Woyo::Attributes::AttributesHash.new 
-    end
-    return ivar if attrs.empty?
+    @attributes ||= Woyo::Attributes::AttributesHash.new 
+    return @attributes if attrs.empty?
     attrs.each do |attr|
       case
       when attr.kind_of?( Hash )
         attr.each do |attr_sym,default|
-          define_attr_methods attr_sym, default, ivn: ivn
-          ivar[attr_sym] = send "#{attr_sym}_default"
+          define_attr_methods attr_sym, default
+          @attributes[attr_sym] = send "#{attr_sym}_default"
         end
       when block
-        define_attr_methods attr, block, ivn: ivn
-        ivar[attr] = send "#{attr}_default"
+        define_attr_methods attr, block
+        @attributes[attr] = send "#{attr}_default"
       else
-        unless ivar.include? attr
-          define_attr_methods attr, ivn: ivn
-          ivar[attr] = nil
+        unless @attributes.include? attr
+          define_attr_methods attr
+          @attributes[attr] = nil
         end
       end
     end
   end
 
-  def define_attr_methods( attr, default = nil, ivn: )
+  def define_attr_methods attr, default = nil
     define_attr_default attr, default
-    define_attr_equals attr, ivn: ivn
-    define_attr attr, ivn: ivn
+    define_attr_equals attr
+    define_attr attr
     if default == true || default == false    # boolean convenience methods
       define_attr? attr
       define_attr! attr
@@ -58,26 +75,31 @@ module Attributes
     end
   end
 
-  def define_attr_equals( attr, ivn: )
+  def define_attr_equals attr
     define_singleton_method "#{attr}=" do |arg|
-      ivar = instance_variable_get ivn
-      ivar[attr] = arg
+      @attributes[attr] = arg
     end
   end
 
-  def define_attr( attr, ivn: )
+  def define_attr attr
     define_singleton_method attr do |arg = nil|
-      ivar = instance_variable_get ivn
-      return ivar[attr] = arg unless arg.nil?
+      return @attributes[attr] = arg unless arg.nil?
       case
-      when ivar[attr].kind_of?( Hash )
-        true_attribute_match = ivar[attr].detect { |name,value| ivar[name] == true }
-        return true_attribute_match[1] if true_attribute_match
-        ivar[attr]
-      when ivar[attr].respond_to?( :call )
-        return ivar[attr].arity == 0 ? ivar[attr].call : ivar[attr].call(self)
+      when @attributes[attr].kind_of?( Hash )
+        truthy_matches = @attributes[attr].collect do |name,value|
+          truthy = if @attributes[name].respond_to?( :call )
+            @attributes[name].arity == 0 ? @attributes[name].call : @attributes[name].call(self)
+          else
+            @attributes[name]
+          end
+          truthy ? value : nil
+        end.compact
+        truthy_matches = truthy_matches.count == 1 ? truthy_matches[0] : truthy_matches
+        return truthy_matches
+      when @attributes[attr].respond_to?( :call )
+        return @attributes[attr].arity == 0 ? @attributes[attr].call : @attributes[attr].call(self)
       else
-        ivar[attr]
+        @attributes[attr]
       end
     end
   end
@@ -102,54 +124,6 @@ module Attributes
     send "#{attr}=", true
   end
 
-  def groups
-    @groups
-  end
-
-  def group sym, *attrs
-    @groups ||= {}
-    grp = @groups[sym] ? @groups[sym] : ( @groups[sym] = Woyo::Attributes::Group.new attributes )
-    attributes *attrs
-    attrs.each do |attr|
-      if attr.kind_of? Hash
-        attr.each do |attr_sym,default_value|
-          grp << attr_sym
-        end
-      else
-        grp << attr
-      end
-    end
-    define_singleton_method sym do
-      @groups[sym]  
-    end
-    grp
-  end
-
-  def exclusions
-    @exclusions
-  end
- 
-  def exclusion sym, *attrs
-    @exclusions ||= {}
-    exc = @exclusions[sym] ? @exclusions[sym] : ( @exclusions[sym] = Woyo::Attributes::Exclusion.new attributes )
-    attributes *attrs
-    attrs.each do |attr|
-      define_attr? attr
-      define_attr! attr
-      if attr.kind_of? Hash
-        attr.each do |attr_sym,default_value|
-          exc << attr_sym
-        end
-      else
-        exc << attr
-      end
-    end
-    define_singleton_method sym do
-      @exclusions[sym]
-    end
-    exc
-  end
-
 end
 
 end

data/lib/woyo/world/group.rb

@@ -1,34 +1,10 @@
 require 'forwardable'
+require_relative 'attributes'
 
 module Woyo
 
 module Attributes
 
-  class AttributesHash < Hash
-
-    alias_method :names, :keys
-    alias_method :set, :[]=
-
-    attr_reader :listeners
-
-    def initialize
-      @listeners = {}
-    end
-
-    def add_attribute_listener attr, listener
-      @listeners[attr] = listener
-    end
-    
-    def []= attr, value
-      old_value = self[attr]
-      super
-      if ( listener = @listeners[attr] ) && value != old_value
-        listener.notify attr, value
-      end
-    end
-
-  end
-
   class Group
 
     extend Forwardable
@@ -110,6 +86,54 @@ module Attributes
 
   end
 
+  def groups
+    @groups
+  end
+
+  def group sym, *attrs
+    @groups ||= {}
+    grp = @groups[sym] ? @groups[sym] : ( @groups[sym] = Woyo::Attributes::Group.new attributes )
+    attributes *attrs
+    attrs.each do |attr|
+      if attr.kind_of? Hash
+        attr.each do |attr_sym,default_value|
+          grp << attr_sym
+        end
+      else
+        grp << attr
+      end
+    end
+    define_singleton_method sym do
+      @groups[sym]  
+    end
+    grp
+  end
+
+  def exclusions
+    @exclusions
+  end
+ 
+  def exclusion sym, *attrs
+    @exclusions ||= {}
+    exc = @exclusions[sym] ? @exclusions[sym] : ( @exclusions[sym] = Woyo::Attributes::Exclusion.new attributes )
+    attributes *attrs
+    attrs.each do |attr|
+      define_attr? attr
+      define_attr! attr
+      if attr.kind_of? Hash
+        attr.each do |attr_sym,default_value|
+          exc << attr_sym
+        end
+      else
+        exc << attr
+      end
+    end
+    define_singleton_method sym do
+      @exclusions[sym]
+    end
+    exc
+  end
+
 end
 
 end

data/lib/woyo/world/version.rb

@@ -1,3 +1,3 @@
 module Woyo
-  WORLD_VERSION = "0.0.7"
+  WORLD_VERSION = "0.0.8"
 end

data/lib/woyo/world/way.rb

@@ -47,7 +47,6 @@ class Way < WorldObject
       raise "Symbol required, but #{arg.class} : '#{arg}' given."
     end
   end
-
   
   def go
     { go: open?, going: self.going }

data/lib/woyo/world/world.rb

@@ -1,4 +1,5 @@
 require_relative 'world_object'
+require_relative 'action'
 require_relative 'location'
 require_relative 'way'
 require_relative 'item'

data/lib/woyo/world/world_object.rb

@@ -1,6 +1,4 @@
-
 require_relative 'attributes'
-require_relative 'actions'
 require_relative 'evaluate'
 
 module Woyo
@@ -8,12 +6,13 @@ module Woyo
 class WorldObject
 
   include Attributes
-  include Actions
   include Evaluate
 
   attr_reader :id, :context
   attr_accessor :_test
 
+  children :action
+
   def initialize id, context: nil, &block
     @id = id.to_s.downcase.to_sym
     @context = context

data/spec/woyo/dsl/dsl_spec.rb

@@ -219,9 +219,10 @@ describe 'DSL' do
 
     head 'Items'
 
-    doc 'stuff here' do
-      pending
-    end
+    doc 'stuff here'
+    # do
+    #   pending
+    # end
 
   end
 
@@ -309,17 +310,20 @@ describe 'DSL' do
     head 'Context'
     text "Other objects may be referred to in different ways."
 
-    doc 'world' do
-      pending
-    end             
+    doc 'world'
+    # do
+    #   pending
+    # end             
 
-    doc 'location' do
-      pending
-    end             
+    doc 'location'
+    # do
+    #   pending
+    # end             
 
-    doc 'context' do
-      pending
-    end             
+    doc 'context'
+    # do
+    #   pending
+    # end             
 
   end
 
@@ -335,16 +339,124 @@ describe 'DSL' do
     text "Actions change the state of the world, usually by changing the value of attributes on world objects"
 
     doc "making changes" do
-      text "Actions may be defined for a world object, in this case, an item."
+      text "Actions may be defined for a world object, in this case, an item. Actions have an id, and optionally a name and description. The steps an action is to perform is contained within an 'execution' block, which executes in the context of the containing world object."
+      code pre:  "world.evaluate do",
+           code:   "location :here do
+                      item :thing do
+                        name 'Thing One'
+                        description 'Rename thing'
+                        action :rename do
+                          execution do
+                            name 'Thing Two'
+                          end
+                        end
+                      end
+                    end",
+           post: "end"
+      text "Initially the name is as defined"
+      code "location = world.location :here"
+      code "thing = location.item :thing" => "world.locations[:here].items[:thing]"
+      code "thing.name" => "'Thing One'"
+      text "Executing rename action changes the name."
+      code "thing.action(:rename).execute"
+      code "thing.name" => "'Thing Two'"
+    end
+
+    doc "describing the action " do
+      text "When an action is executed it returns information about the action, including a description of the action."
       code pre:  "world.evaluate do",
            code:   "location :here do
                       item :thing do
-                        name 'Thing?'
-                        action :one do
-                          name 'Thing One'
+                        name 'Thing One'
+                        action :rename do
+                          description 'Rename thing'
+                          describe 'Thing is renamed'
+                          execution do
+                            name 'Thing Two'
+                          end
                         end
-                        action :two do
-                          name 'Thing Two'
+                      end
+                    end",
+           post: "end"
+      text "Initially the name is as defined"
+      code "location = world.location :here"
+      code "thing = location.item :thing" => "world.locations[:here].items[:thing]"
+      code "thing.name" => "'Thing One'"
+      text "Executing the rename action returns a result hash."
+      code "result = thing.action(:rename).execute" => "{ result: nil, execution: 'Thing Two', describe: 'Thing is renamed' }" 
+      text "The name was changed as expected"
+      code "thing.name" => "'Thing Two'"
+      text "The contents of the result hash are useful to an application such as Woyo::Server that interacts with the world."
+      text "Action execution may be described with a default text (as in this case), or the value of :result can determine the describing text (as we'll see in the next example)."
+      code "result[:describe]" => "'Thing is renamed'"
+      text "The actual value returned by the execution block is also provided, this may be any kind of object."
+      code "result[:execution]" => "'Thing Two'" 
+    end
+
+    doc "one of many descriptions" do
+      text "An action may be described for different results. An exclusion group of results ensures that only one description will be chosen. Here possible results are :success and :failure."
+      code pre:  "world.evaluate do",
+           code:   "location :here do
+                      item :thing do
+                        name 'Thing One'
+                        action :rename do
+                          description 'Rename thing'
+                          exclusion :result, :success, :failure
+                          describe success: 'Thing is renamed',
+                                   failure: 'Not renamed'
+                          execution do |this|
+                            if name == 'Thing One'
+                              name 'Thing Two'
+                              this.success!
+                            else
+                              this.failure!
+                            end
+                          end
+                        end
+                      end
+                    end",
+           post: "end"
+      text "Initially the name is as defined"
+      code "location = world.location :here"
+      code "thing = location.item :thing" => "world.locations[:here].items[:thing]"
+      code "thing.name" => "'Thing One'"
+      text "Executing the rename action once succeeds."
+      code "thing.action(:rename).execute" => "{ result: :success, describe: 'Thing is renamed', execution: true }"
+      text "The name was changed as expected"
+      code "thing.name" => "'Thing Two'"
+      text "Executing the rename action again fails."
+      code "thing.action(:rename).execute" => "{ result: :failure, describe: 'Not renamed', execution: true }"
+      text "The name is unchanged."
+      code "thing.name" => "'Thing Two'"
+    end
+
+    doc "some of many descriptions" do
+      text "An action may be described for results other than :success and :failure, and may return multiple results and descriptions. This is achieved by specifying a group :result containing expected results."
+      code pre:  "world.evaluate do",
+           code:   "location :here do
+                      item :thing do
+                        name 'Thing One'
+                        action :rename do
+                          description 'Rename thing'
+                          group :result, :renamed, :special, :same
+                          describe renamed: 'Thing is renamed',
+                                   special: 'Newly discovered thing',
+                                   same:    'Not renamed'
+                          execution do |this|
+                            case
+                            when name == 'Thing One'
+                              name 'Thing Two'
+                              this.renamed = true
+                            when name == 'Thing Two'
+                              name 'Thing Three'
+                              this.renamed = true
+                              this.special = true
+                            else
+                              this.renamed = false
+                              this.special = false
+                              this.same = true
+                            end
+                          end
                         end
                       end
                     end",
@@ -352,13 +464,16 @@ describe 'DSL' do
       text "Initially the name is as defined"
       code "location = world.location :here"
       code "thing = location.item :thing" => "world.locations[:here].items[:thing]"
-      code "thing.name" => "'Thing?'"
-      text "Invoking action 'one', changes the name."
-      code "thing.one"
       code "thing.name" => "'Thing One'"
-      text "Invoking action 'two', changes the name again."
-      code "thing.two"
+      text "Executing the rename action once."
+      code "thing.action(:rename).execute" => "{ result: :renamed, describe: 'Thing is renamed', execution: true }"
       code "thing.name" => "'Thing Two'"
+      text "Executing the rename action again."
+      code "thing.action(:rename).execute" => "{ result: [ :renamed, :special ], describe: [ 'Thing is renamed', 'Newly discovered thing' ], execution: true }"
+      code "thing.name" => "'Thing Three'"
+      text "Executing the rename action one more time."
+      code "thing.action(:rename).execute" => "{ result: :same, describe: 'Not renamed', execution: true }"
+      code "thing.name" => "'Thing Three'"
     end
 
   end

data/spec/woyo/world/action_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'woyo/world/action'
+
+describe Woyo::Action do
+
+  let( :action ) { Woyo::Action.new :test }
+
+  context 'has exclusions' do
+
+    context ':result' do
+
+      it 'exists' do
+        expect(action.exclusions.names).to include :result
+      end
+
+      it 'has no members' do
+        expect(action.result.members).to be_empty 
+      end
+
+    end
+
+  end
+
+  context "execution may be defined" do
+
+    it "as a block" do
+      action.execution { :answer } 
+      expect(action.execution).to be_instance_of Proc
+    end
+
+  end
+
+  context "may be executed" do
+
+    it 'by calling #execution directly' do
+      action.execution { :answer } 
+      expect(action.execution.call).to eq :answer 
+    end
+
+    it 'calling #execution returns nil by default' do
+      expect(action.execution.call).to be_nil
+    end
+
+    context 'by calling #execute wrapper' do
+
+      context 'with result exclusion' do
+
+        it 'returns result hash with single values for single truthy result' do
+          action.exclusion :result, :success, :failure
+          action.execution { |this| this.success! } 
+          action.describe success: "Succeeded"
+          expect(action.execute).to eq( { result: :success, describe: "Succeeded", execution: true } )
+        end
+
+        it 'returns result hash with empty results for empty result exclusion' do
+          action.describe "Empty"
+          expect(action.execute).to eq( { result: nil, describe: "Empty", execution: nil } )
+        end
+
+      end
+
+      context 'with result group' do
+
+        it 'returns result hash with single value for single truthy result' do
+          action.group :result, a: false, b: true, c: false
+          action.describe a: 'aaa', b: 'bbb', c: 'ccc'
+          expect(action.execute).to eq( { result: :b, describe: 'bbb', execution: nil } )
+        end
+
+        it 'returns result hash with multiple values for multiple truthy results' do
+          action.group :result, a: true, b: false, c: true
+          action.describe a: 'aaa', b: 'bbb', c: 'ccc'
+          expect(action.execute).to eq( { result: [ :a, :c ], describe: [ 'aaa', 'ccc' ], execution: nil } )
+        end
+
+        it 'returns result hash with empty results for empty result group' do
+          action.describe "Empty"
+          expect(action.execute).to eq( { result: nil, describe: "Empty", execution: nil } )
+        end
+
+        it 'returns result hash with empty results for no truthy results' do
+          action.group :result, a: false, b: false, c: false
+          action.describe "Empty"
+          expect(action.execute).to eq( { result: nil, describe: "Empty", execution: nil } )
+        end
+
+      end
+
+    end
+
+  end
+
+end
+

data/spec/woyo/world/attributes_spec.rb

@@ -115,15 +115,13 @@ describe Woyo::Attributes do
       expect(attr_test.attributes.names).to eq [ :attr1, :attr2, :attr3, :attr4 ]
     end
         
-    it 'with a default value' do
+    it 'with a default value (non-hash)' 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
@@ -391,26 +389,33 @@ describe Woyo::Attributes do
     let(:hat) { AttrTest.new }
 
     before :each do
-      hat.attributes :reaction, :hot, :cold
+      hat.attributes :reaction, :hot, :warm, :cool, :cold
     end
 
     it 'accept a hash as value' do
-      expect { hat.reaction hot: 'Sweat', cold: 'Shiver' }.to_not raise_error
+      expect { hat.reaction hot: 'Sweat', warm: 'Relax', cool: 'Huddle', cold: 'Shiver', not_attr: 'Nothing' }.to_not raise_error
     end
 
-    it 'return the value of the first key that evaluates as a true attribute' do
-      hat.reaction hot: 'Sweat', cold: 'Shiver' 
+    it 'return a list values of the multiple keys that are truthy attributes' do
+      hat.reaction hot: 'Sweat', warm: 'Relax', cool: 'Huddle', cold: 'Shiver' 
+      expect(hat.reaction).to eq [ ]
       hat.cold = true
-      expect(hat.reaction).to eq 'Shiver'
-      hat.hot = true
-      expect(hat.reaction).to eq 'Sweat'
+      hat.cool = proc { 'truthy' }
+      hat.warm = proc { nil } # falsey
+      hat.hot  = false
+      expect(hat.reaction).to eq [ 'Huddle', 'Shiver' ]
     end
 
-    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' } )
+    it 'return a single value of a single key that is a truthy attribute' do
+      hat.reaction hot: 'Sweat', warm: 'Relax', cool: 'Huddle', cold: 'Shiver' 
+      expect(hat.reaction).to eq [ ]
+      hat.warm = true
+      expect(hat.reaction).to eq 'Relax'
+    end
+
+    it 'returns empty list if no keys are truthy attributes' do
+      hat.reaction hot: 'Sweat', warm: 'Relax', cool: 'Huddle', cold: 'Shiver' 
+      expect(hat.reaction).to eq [ ]
     end
 
   end

data/spec/woyo/world/item_spec.rb

@@ -42,5 +42,26 @@ describe Woyo::Item do
 
   end
 
+  context 'actions' do
+
+    let( :item ) do
+      item = Woyo::Item.new :item do
+        action( :action1 ) { :empty }
+        action( :action2 ) { :empty }
+      end
+    end
+
+    it 'are listed' do
+      expect(item.actions.count).to eq 2
+      expect(item.actions.keys).to eq [ :action1, :action2 ]
+    end
+
+    it 'are accessible' do
+      expect(action = item.actions[:action1]).to be_instance_of Woyo::Action
+      expect(action.id).to eq :action1
+    end
+
+  end
+
 end
  

data/spec/woyo/world/world_object_spec.rb

@@ -62,10 +62,12 @@ describe Woyo::WorldObject do
     it 'actions' do
       wo = Woyo::WorldObject.new :thing do
         action :time do
-          Time.now
+          execution do
+            Time.now
+          end
         end
       end
-      expect(wo.time).to be < Time.now
+      expect(wo.action(:time).execution.call).to be < Time.now
     end
 
   end

data/todo.txt

@@ -1,40 +1,24 @@
 
-world object features...
-
-# world
-
+World featutes...
+
+# actions
+
+  action.execute #=> { 
+    result:   :symbol,                           # from result exclusion 
+    describe: 'text'                             # first (only) matching symbol
+    execution: return_value_from_execution_block
+  }
+ 
+  action.execute #=> { 
+    result:   [ :symbol1, :symbol2, :symbol3 ]   # from result group
+    describe: [ 'text1', 'text2', 'text3' ]      # all true/truthy members 
+    execution: return_value_from_execution_block
+  }
+ 
 # attributes
 
-
-  default procs will be called upon access, not at initialization
-    this will fix the problem of WorldObject#id being nil when Attributes is prepended and Attributes#initialize is run first 
-
-  boolean attributes
-
-ok    detected by class level definition boolean default value
-
-      attribute open: true
-      attribute dark: false
-
-ok    after defintion, set boolean attribute values...
-
-      open = true
-      open true
-      open!       # ... open true
-
-ok    query boolean attribute values... ?
-
-      dark
-      dark?        # ... dark ? true : false
-      is? :dark    # ... def is? attr ; attributes[attr] ? true : false ; end
-
-ok    additional class level define (and detect?) boolean attribute values... 
-
-      is :open
-      is :dark
-      is :warm, :bright
-
-  group...
+  attribute returns whole attribute hash
+  attribute.render returns array of values with truthy keys
 
     group weapons: [ :sword, :knife, :rock, :fists ]   # hash - key will be group name, value an array of symbols for members
     group :weapons, [ :sword, :knife, :rock, :fists ]  # symbol will be group name, array of symbols for members
@@ -43,45 +27,11 @@ ok    group :weapons, :sword, :knife, :rock, :fists      # symbols, first will b
     group stats: [ speed: 10, charisma: 20, strength: 30 ]  # defaults like attributes (these are attributes)
 ok    group :stats, speed: 10, charisma: 20, strength: 30     # ditto
 
-ok    group is hash-like
-       alias :names, :keys
-
-        world_object.weapons.names         #=> weapons.keys
-        world_object.weapons.values        #=> weapons.values
-
-ok    group is not an enum, it has no value itself
-ok    attribute methods for members in parent
-
-      world_object.sword
-      world_object.knife
-
-no    is group a namespace ? - optional ... attribute methods in group
-
-      world_object.weapons.sword
-      world_object.weapons.knife
-
-ok   access attributes via group hash
-
-      world_object.weapons[:sword]                #=> rusty_sword
-      world_object.weapons[:sword] = sharp_sword
-
-ok  exclusive group (booleans)...
-  
-ok    exclusive_group passable: , :open, :close 
-    exclusive_group light: [ :dark, :dim, :bright ]
-    exclusive_group temperature: [ :cold, :cool, :warm, :hot ]
-
-ok    same as regular group +...
-
-ok    first member will be true, the rest false
-ok    additional convenience methods for members...
-
-      world_object.open?
-      world_object.close?
-      world_object.open!
-      world_object.close!
+ok    exclusion passable: , :open, :close 
+    exclusion light: [ :dark, :dim, :bright ]
+    exclusion temperature: [ :cold, :cool, :warm, :hot ]
 
-# descriptions
+# descriptions (an attribute)
   
   displayed everytime a location is visited...
 
@@ -136,18 +86,8 @@ ok    additional convenience methods for members...
 
 # location 
 
-  locations do NOT contain locations
-  locations are a graph, linked by ways
-
-  location :here do
-    name 'Home'
-    description 'Cosy'
-  end
-
   location :here, name: 'Home', description: 'cosy'
 
-  mass assignment...
-
   locations do
     home   name: 'Home',     description: 'Cosy'
     yard   name: 'Garden',   description: 'Green'
@@ -156,39 +96,8 @@ ok    additional convenience methods for members...
 
 # way
 
-  a way leads one-way to a location
-
-  way :out do
-    name 'Door'
-    description 'Big strong'
-    to :garden
-  end
-
-  way can describe being open closed
-
-    way :out do
-      name 'Door'
-      to :garden
-      description 'Wooden door'
-      description :open   => 'An open wooden door leading to sunlit garden',
-                  :closed => 'A closed solid wooden door'
-    end
-
-  way can describe going (open) or not (closed)
-
-    way :out do
-      name 'Door'
-      to :garden
-      go  :open   => 'Stepping into the warm sunlight',
-          :closed => 'The solid wooden door remains stubbornly closed' 
-    end
-
   way :door, to: :other_location, description: 'Big'
 
-  is openable, default open
-
-  mass assignment...  
-
   ways do
     east to: :china,     name: 'slow boat'
     west to: :wild_west, name: 'fast horse'
@@ -196,17 +105,13 @@ ok    additional convenience methods for members...
     down to: :pit,       name: 'hole'
   end
 
-  standard ways map to directions and movements ?
-  - north,south,east,west,up,down,forward,back,left,right 
+  absolute directions
+  - north, south, east, west, high, low
 
-# items
-
-  items may be in a location
+  relative directions
+  - forward, back, left, right, up, down
 
-  item :id do
-    name 'Thing'
-    description 'Useful object'
-  end
+# items
 
   item :id, name: 'Thing', description: "...", detail: "..."
 
@@ -223,14 +128,6 @@ ok    additional convenience methods for members...
     longer description when examined
     detail "....."
 
-  have attributes
-
-    attributes :small, :light
-
-  may know their location ?
-
-    if item.location == :home
-
   may know their relation to other items ?
 
     if item.contains? :water
@@ -248,8 +145,6 @@ ok    additional convenience methods for members...
 
 end
 
-# code for ... triggers, events, handlers, conditions, etc...
-
 # can locations, items be subclassed in DSL ?
 
 class Vase < Item

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: woyo-world
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Gerard Fowley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-09 00:00:00.000000000 Z
+date: 2014-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -81,7 +81,7 @@ files:
 - README.md
 - Rakefile
 - lib/woyo/world.rb
-- lib/woyo/world/actions.rb
+- lib/woyo/world/action.rb
 - lib/woyo/world/attributes.rb
 - lib/woyo/world/character.rb
 - lib/woyo/world/evaluate.rb
@@ -97,7 +97,7 @@ files:
 - spec/spec_doc_formatter.rb
 - spec/spec_helper.rb
 - spec/woyo/dsl/dsl_spec.rb
-- spec/woyo/world/actions_spec.rb
+- spec/woyo/world/action_spec.rb
 - spec/woyo/world/attributes_spec.rb
 - spec/woyo/world/character_spec.rb
 - spec/woyo/world/evaluate_spec.rb
@@ -139,7 +139,7 @@ test_files:
 - spec/spec_doc_formatter.rb
 - spec/spec_helper.rb
 - spec/woyo/dsl/dsl_spec.rb
-- spec/woyo/world/actions_spec.rb
+- spec/woyo/world/action_spec.rb
 - spec/woyo/world/attributes_spec.rb
 - spec/woyo/world/character_spec.rb
 - spec/woyo/world/evaluate_spec.rb

data/lib/woyo/world/actions.rb

@@ -1,24 +0,0 @@
-require_relative 'attributes'
-
-module Woyo
-
-module Actions
-
-  include Attributes
-
-  def action *acts, &block
-    send :_attributes, acts, ivn: '@actions', &block
-  end
-
-  def actions *acts, &block
-    send :_attributes, acts, ivn: '@actions', &block
-  end
-
-  def do act
-    send act
-  end
-
-end
-
-end
-

data/spec/woyo/world/actions_spec.rb

@@ -1,71 +0,0 @@
-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
-