woyo-world 0.0.1.pre2

data/README.md

@@ -0,0 +1,29 @@
+# Woyo
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'woyo'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install woyo
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/woyo/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/woyo/world/attributes.rb

@@ -0,0 +1,41 @@
+
+module Woyo
+
+module Attributes
+
+  module ClassMethods
+
+    def attributes *attrs
+      @attributes ||= []                 # class instance variable in ClassMethods scope
+      return @attributes if attrs.empty?
+      @attributes = attrs                # todo: allow additions to existing attributes
+      @attributes.each do |attr|
+        class_eval("
+          def #{attr}= arg
+            attributes[:#{attr}] = @#{attr} = arg
+          end
+          def #{attr}(arg=nil)
+            if arg.nil?
+              @#{attr}
+            else
+              self.#{attr} = arg
+            end
+          end
+        ")
+      end
+    end
+
+  end 
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  def attributes
+    @attributes ||= {}
+  end
+
+end
+
+end
+

data/lib/woyo/world/character.rb

@@ -0,0 +1,32 @@
+require_relative 'world_object'
+
+module Woyo
+
+class Character < WorldObject
+
+  attributes :name, :description
+
+  def world
+    @world ||= context if context.is_a? World
+  end
+
+  def location
+    @location ||= context if context.is_a? Location
+  end
+
+  def me
+    self
+  end
+
+  def go way_or_id
+    id = way_or_id.kind_of?(Way) ? way_or_id.id : way_or_id
+    way = @location.ways[id]
+    @location.characters.delete me.id
+    @location = way.to
+    @location.characters[me.id] = me
+  end
+
+end
+
+end
+

data/lib/woyo/world/dsl.rb

@@ -0,0 +1,59 @@
+
+module Woyo
+
+module DSL
+  
+  def evaluate &block
+    (block.arity < 1 ? (instance_eval &block) : block.call(self)) if block_given?
+    self
+  end
+
+  module ClassMethods
+
+    def contains *conts
+      @contains ||= []                      # class instance variable in ClassMethods scope
+      return @contains if conts.empty?
+      conts.each { |cont| @contains << cont unless @contains.include? cont }
+      @contains.each do |cont|
+        class_eval("
+
+          def #{cont}s
+            ( @contains ||= {} )[:#{cont}] ||= ( @#{cont}s ||= {} )
+          end
+
+          def #{cont} cont_or_id, &block
+            #{cont} = cont_or_id.kind_of?( #{cont.capitalize} ) ? cont_or_id : nil
+            id = #{cont} ? #{cont}.id : cont_or_id
+            known = self.#{cont}s[id] ? true : false
+            case
+            when  #{cont} &&  known &&  block_given? then #{cont}.evaluate &block
+            when  #{cont} &&  known && !block_given? then #{cont}
+            when  #{cont} && !known &&  block_given? then self.#{cont}s[id] = #{cont}.evaluate &block
+            when  #{cont} && !known && !block_given? then self.#{cont}s[id] = #{cont}
+            when !#{cont} &&  known &&  block_given? then #{cont} = self.#{cont}s[id].evaluate &block
+            when !#{cont} &&  known && !block_given? then #{cont} = self.#{cont}s[id]
+            when !#{cont} && !known &&  block_given? then #{cont} = self.#{cont}s[id] = #{cont.capitalize}.new id, context: self, &block
+            when !#{cont} && !known && !block_given? then #{cont} = self.#{cont}s[id] = #{cont.capitalize}.new id, context: self
+            end
+            # maybe: god-like lists of everything at world level... would need unique ids... self.world.#{cont}s[id] = #{cont} if !known && self.world
+            #{cont}
+          end
+
+        ")
+      end
+    end
+
+  end 
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  def contains
+    @contains ||= {}
+  end
+
+end
+
+end
+

data/lib/woyo/world/location.rb

@@ -0,0 +1,22 @@
+require_relative 'world_object'
+
+module Woyo
+
+class Location < WorldObject
+
+  attributes :name, :description
+
+  contains   :way, :character
+
+  def world
+    self.context
+  end
+
+  def here
+    self
+  end
+
+end
+
+end
+

data/lib/woyo/world/version.rb

@@ -0,0 +1,3 @@
+module Woyo
+  WORLD_VERSION = "0.0.1.pre2"
+end

data/lib/woyo/world/way.rb

@@ -0,0 +1,43 @@
+require_relative 'world_object'
+
+module Woyo
+
+class Way < WorldObject
+
+  attributes :name, :description
+
+  def from
+    @from ||= context
+  end
+
+  def world
+    from ? from.world : nil
+  end
+
+  def to= arg
+    if arg.instance_of? Symbol
+      case
+      when from && arg == from.id
+        @to = from                        # way loops back to the same location
+      when world && world.locations[arg]
+        @to = world.locations[arg]        # destination location already exists in world
+      when world
+        @to = world.location arg          # create destination location in world 
+      else
+        @to = Location.new arg            # create free-standing destination location
+      end
+    end
+  end
+
+  def to arg=nil
+    if arg.nil?
+      @to
+    else
+      self.to = arg
+    end
+  end
+
+end
+
+end
+

data/lib/woyo/world/world.rb

@@ -0,0 +1,18 @@
+require_relative 'world_object'
+require_relative 'location'
+require_relative 'way'
+require_relative 'character'
+
+module Woyo
+
+class World < WorldObject
+
+  contains :location, :character
+
+  def initialize &block
+    super nil, context: nil, &block
+  end
+
+end
+
+end

data/lib/woyo/world/world_object.rb

@@ -0,0 +1,24 @@
+
+require_relative 'attributes'
+require_relative 'dsl'
+
+module Woyo
+
+class WorldObject
+
+  include Attributes
+  include DSL
+
+  attr_reader :id, :context
+  attr_accessor :_test
+
+  def initialize id, context: nil, &block
+    @id = id.to_s.downcase.to_sym
+    @context = context
+    evaluate &block
+  end
+
+end
+
+end
+

data/lib/woyo/world.rb

@@ -0,0 +1,3 @@
+require_relative 'world/version'
+require_relative 'world/world'
+

data/spec/woyo/world/attributes_spec.rb

@@ -0,0 +1,62 @@
+require 'woyo/world/attributes'
+
+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 'names and values can be retrieved for instance' do
+    attrs = AttrTest.new.attributes
+    attrs.should be_instance_of Hash
+  end
+
+  it 'can be written with =' do
+    attr_test = AttrTest.new
+    AttrTest.attributes.each do |attr|
+      eval "attr_test.#{attr} = '#{attr}'.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
+    end
+  end
+
+  it 'can be written without =' do
+    attr_test = AttrTest.new
+    AttrTest.attributes.each do |attr|
+      eval "attr_test.#{attr} '#{attr}'.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
+    end
+  end
+
+  it 'can be read' do
+    attr_test = AttrTest.new
+    AttrTest.attributes.each do |attr|
+      eval "attr_test.#{attr} '#{attr}'.upcase"
+    end
+    attr_test.attributes.count.should eq AttrTest.attributes.count
+    attr_test.attributes.each do |name,value|
+      eval("attr_test.#{name}").should eq value
+    end
+  end
+
+  it 'accepts string or symbol key for retrieval'
+
+  it 'accepts string of symbol key for assignment'
+
+end
+

data/spec/woyo/world/character_spec.rb

@@ -0,0 +1,42 @@
+require 'woyo/world/character'
+require 'woyo/world/world'
+require 'woyo/world/location'
+
+describe Woyo::Character do
+
+  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
+  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
+  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/dsl_spec.rb

@@ -0,0 +1,79 @@
+require 'woyo/world/dsl'
+
+describe Woyo::DSL do
+
+  before :all do
+    class DSLTest
+      include Woyo::DSL
+      contains :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
+      dsl = DSLTest.new
+      result = dsl.evaluate { self.should == dsl }
+      result.should be dsl
+    end
+
+    it 'passes self to block with arity 1' do
+      dsl = DSLTest.new
+      result = dsl.evaluate { |scope| scope.should be dsl }
+      result.should be dsl
+    end
+
+  end
+
+  it 'can list classes to contain' do
+    DSLTest.contains.should eq [ :dog, :cat ]
+  end
+
+  it 'can add classes to contain' do
+    pending 'fix containment'
+    class DSLTestMore < DSLTest
+      contains :cow
+      contains :duck
+    end
+    # class Cow  ; def initialize id, context: nil ; end ; end
+    # class Duck ; def initialize id, context: nil ; end ; end
+    DSLTestMore.contains.should eq [ :dog, :cat, :cow, :duck ]
+  end
+
+  it 'can create contained objects' do
+    dsl = DSLTest.new
+    dog = dsl.dog :brown
+    dog.should be_instance_of Dog
+    dsl.dog(:brown).should be dog
+    dsl.dogs[:brown].should be dog
+  end
+
+  it 'can list each contained object by class' do
+    dsl = DSLTest.new
+    dog_brown = dsl.dog :brown
+    dog_black = dsl.dog :black
+    cat_white = dsl.cat :white
+    cat_black = dsl.cat :black
+    dsl.dogs.should eq Hash[ brown: dog_brown, black: dog_black ]
+    dsl.cats.should eq Hash[ white: cat_white, black: cat_black ]
+  end
+
+  it 'can list all contained objects' do
+    dsl = DSLTest.new
+    dog_brown = dsl.dog :brown
+    dog_black = dsl.dog :black
+    cat_white = dsl.cat :white
+    cat_black = dsl.cat :black
+    dsl.contains.keys.should eq [ :dog, :cat ]
+    cats = Hash[ white: cat_white, black: cat_black ]
+    dogs = Hash[ brown: dog_brown, black: dog_black ]
+    dsl.contains.should eq Hash[ dog: dogs, cat: cats ] 
+  end
+
+  it 'accepts string or symbol key for contained object retrieval'
+
+  it 'accepts string of symbol key for contained object assignment'
+
+end