ceml 0.6.4 → 0.7.0

data/VERSION

@@ -1 +1 @@
-0.6.4
+0.7.0

data/ceml.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ceml}
-  s.version = "0.6.4"
+  s.version = "0.7.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Joe Edelman"]
-  s.date = %q{2011-02-11}
+  s.date = %q{2011-02-12}
   s.description = %q{a language for coordinating real world events}
   s.email = %q{joe@citizenlogistics.com}
   s.extra_rdoc_files = [

data/lib/ceml/casting_statement.rb

@@ -1,13 +1,4 @@
 module CEML
-
-  class Criteria < Struct.new :plus_tags, :minus_tags, :matching, :radius, :timewindow
-    def complexity; plus_tags.size; end
-    def =~(candidate)
-      candidate[:tags] ||= []
-      (plus_tags - candidate[:tags]).empty? and (minus_tags & candidate[:tags]).empty?
-    end
-  end
-
   module CastingStatement
     extend Forwardable
     def_delegators :roles, :names, :[], :min

data/lib/ceml/confluence.rb

@@ -3,14 +3,13 @@ require 'forwardable'
 
 module CEML
   class Confluence
-    attr_accessor :script, :hash, :created, :dirty, :roles_to_cast, :incident_id, :star
+    attr_accessor :hash, :created, :roles_to_cast, :incident_id, :star
     alias_method :launched?, :incident_id
 
-    def initialize script, candidate = nil
-      @script  = script
+    def initialize roles_to_cast, candidate = nil
       @hash    = {}
       @created = true
-      @roles_to_cast = script.roles_to_cast
+      @roles_to_cast = roles_to_cast
       push candidate if candidate
     end
 
@@ -38,7 +37,6 @@ module CEML
       candidate[:roles] = best_role.name.to_sym
       best_role.casted << candidate
       @star ||= candidate
-      @dirty = true
     end
 
     def full?

data/lib/ceml/driver.rb

@@ -14,60 +14,89 @@ module CEML
     def with_incident(id, script = nil, metadata = {})
       id ||= rand(36**10).to_s(36)
       PLAYERS[id] ||= []
-      INCIDENTS[id] ||= CEML::Incident.new script, id if script
+      INCIDENTS[id] ||= CEML::Incident.new to_bytecode(script), id if script
       raise "no incident #{id}" unless INCIDENTS[id]
       yield INCIDENTS[id], PLAYERS[id], metadata if block_given?
       id
     end
     alias_method :start, :with_incident
 
+    def to_bytecode bytecode_or_script
+      case bytecode_or_script
+      when String;       return CEML.parse(:script, bytecode_or_script).bytecode
+      when CEML::Script; return bytecode_or_script.bytecode
+      when Array;        return bytecode_or_script
+      else return nil
+      end
+    end
+
     def log(s)
       # puts s
     end
 
+    SCRIPTS = Hash.new{ |h,k| h[k] = [] }
+    def add_script script_collection_id, script
+      SCRIPTS[script_collection_id] << script
+    end
+
+    def ping_all script_collection_id, candidate
+      SCRIPTS[script_collection_id].each{ |s| ping script_collection_id, s.roles_to_cast, candidate }
+    end
+
+    def launch script_collection_id, roleset, *cast
+      script = SCRIPTS[script_collection_id].select{ |s| s.roles_to_cast == roleset }.sort_by{ rand }.first
+      unless script
+        rolesets = SCRIPTS[script_collection_id].map(&:roles_to_cast)
+        raise "matching roleset not found: #{roleset.inspect} in #{rolesets.inspect}"
+      end
+      push nil, script.bytecode, *cast
+    end
+
+
     LOCATIONS = Hash.new{ |h,k| h[k] = [] }
-    def ping script, candidate
-      return unless script.fits? candidate
+    def with_confluences script_collection_id, roleset
+      yield LOCATIONS["#{script_collection_id}:#{roleset.hash}"]
+    end
+
+
+    def ping script_collection_id, roleset, candidate
+      return unless roleset.any?{ |r| r.fits? candidate }
       candidate[:ts] = CEML.clock
-      script_id = script.text_value
-
-      locs = LOCATIONS[script_id].group_by{ |l| l.stage_with_candidate(candidate) }
-      if locs[:joinable]
-        log "joining..."
-        first = locs[:joinable].shift
-        first.push candidate
-        push first.incident_id, nil, candidate
-
-      elsif locs[:launchable]
-        log "launching..."
-        first = locs[:launchable].shift
-        first.push candidate
-        cast = first.cast
-        push nil, script, *cast
-        (locs[:launchable] + (locs[:listable]||[])).each{ |l| l.rm *cast }
-
-      elsif locs[:listable]
-        log "listing..."
-        locs[:listable].each{ |l| l.push candidate }
-
-      else
-        c = Confluence.new(script)
-        case c.stage_with_candidate(candidate)
-        when :launchable
-          log "start-launching..."
-          c.push candidate
-          push nil, script, candidate
-        when :listable
+
+      with_confluences script_collection_id, roleset do |confluences|
+        locs = confluences.group_by{ |l| l.stage_with_candidate(candidate) }
+        if locs[:joinable]
+          log "joining..."
+          first = locs[:joinable].shift
+          first.push candidate
+          push first.incident_id, nil, candidate     # JOIN THEM
+
+        elsif locs[:launchable]
+          log "launching..."
+          first = locs[:launchable].shift
+          first.push candidate
+          cast = first.cast
+          first.incident_id = launch script_collection_id, roleset, *cast
+          (locs[:launchable] + (locs[:listable]||[])).each{ |l| l.rm *cast }
+
+        elsif locs[:listable]
+          log "listing..."
+          locs[:listable].each{ |l| l.push candidate }
+
+        else
+          c = Confluence.new(roleset)
           log "start-listing..."
-          c.push candidate
-          LOCATIONS[script_id] << c
-        else raise "what?"
+          if c.stage_with_candidate(candidate) == :launchable
+            log "start-launching..."
+            c.push candidate
+            c.incident_id = launch script_collection_id, roleset, candidate
+          else
+            c.push candidate
+          end
+          confluences << c
         end
-
+        confluences.delete_if(&:full?)
       end
-
-      LOCATIONS[script_id].delete_if(&:full?)
-      # save the changed ones and clear dirty flag
     end
 
     def push incident_id, script, *updated_players

data/lib/ceml/incident.rb

@@ -2,24 +2,20 @@ require 'set'
 
 module CEML
   class Incident
-    attr_reader :script, :id, :this
+    attr_reader :seq, :id, :this
+    def initialize(seq, id); @id = id; @seq = seq; end
+
     def roles;      this[:roles] ||= Set.new; end
     def got;        this[:received];   end
     def recognized; this[:recognized]; end
     def pc;         this[:pc] ||= 0;   end
     def qs_answers; this[:qs_answers] ||= Hash.new; end
-    def seq; @seq ||= script.bytecode; end
 
     def handled!
       this.delete :received
       this.delete :recognized
     end
 
-    def initialize(script, id)
-      @id = id
-      @script = Script === script ? script : CEML.parse(:script, script)
-    end
-
     def cb *stuff
       @callback.call this, *stuff if @callback
     end
@@ -61,9 +57,9 @@ module CEML
 
     def expand(role, var)
       case role
-      when 'his', 'her', 'their';                 return qs_answers[var]
+      when 'his', 'her', 'their', 'my', 'its';    return qs_answers[var]
       when 'world', 'game', 'exercise', 'group';  return (cb :world, var)
-      when 'somebody', 'someone', 'buddy';        role = nil
+      when 'somebody', 'someone', 'buddy', 'teammate';  role = nil
       end
       role = role.to_sym if role
       @players.each do |p|
@@ -146,8 +142,8 @@ module CEML
       got or return false
       if recognized == :done
         cb :did_complete
-        say :ok
         handled!
+        say :ok if pc == seq.size - 2
         true
       else
         cb :did_report

data/lib/ceml/role.rb

@@ -1,4 +1,13 @@
 module CEML
+
+  class Criteria < Struct.new :plus_tags, :minus_tags, :matching, :radius, :timewindow
+    def complexity; plus_tags.size; end
+    def =~(candidate)
+      candidate[:tags] ||= []
+      (plus_tags - candidate[:tags]).empty? and (minus_tags & candidate[:tags]).empty?
+    end
+  end
+
   class Role < Struct.new :name, :criteria, :range, :casted
     # def <=>(b); b.criteria.complexity <=> criteria.complexity; end
     def affinity candidate, star
@@ -6,6 +15,13 @@ module CEML
       [ criteria.complexity, -needed, -allowed ]
     end
 
+    def comparable_object
+      [name, criteria, range]
+    end
+
+    def ==(other); comparable_object == other.comparable_object; end
+    def hash; comparable_object.hash; end
+
     def filled?;   needed == 0; end
     def one_left?; needed == 1; end
 

data/lib/ceml/script.rb

@@ -6,10 +6,6 @@ module CEML
     # = casting =
     # ===========
 
-    def fits? candidate
-      roles_to_cast.any?{ |r| r.fits? candidate }
-    end
-
     def roles_to_cast
       return [] unless cast.type == :await
       return cast.roles_to_cast(self)
@@ -114,8 +110,11 @@ module CEML
 
     def bytecode
       code = [[[:all], :start]]
-      return [[[:all], :null_assign], [[:all], :complete_assign]] if !instructions and title
-      instructions.list.each{ |inst| code.concat inst.bytecode } if instructions
+      if !instructions and title
+        code.concat [[[:all], :null_assign], [[:all], :complete_assign]]
+      elsif instructions
+        instructions.list.each{ |inst| code.concat inst.bytecode } if instructions
+      end
       code << [[:all], :finish]
       code
     end

data/test/helper.rb

@@ -16,8 +16,17 @@ class Test::Unit::TestCase
     CEML::Driver::INCIDENTS.clear
   end
 
+  def scriptfam *scripts
+    fam_id = gen_code
+    scripts.each do |script|
+      script = CEML.parse(:script, script) if String === script
+      DRIVER.add_script fam_id, script
+    end
+    fam_id
+  end
+
   def ping s, candidate
-    DRIVER.ping s, candidate
+    DRIVER.ping_all s, candidate
   end
 
   def says id, str

data/test/test_incident.rb

@@ -72,7 +72,7 @@ XXX
 class TestIncident < Test::Unit::TestCase
 
   def test_sync
-    s = CEML.parse(:script, SYNC_SCRIPT)
+    s = scriptfam SYNC_SCRIPT
     play do
       ping s, :id => 'alpha'
       ping s, :id => 'beta'
@@ -87,7 +87,7 @@ class TestIncident < Test::Unit::TestCase
   end
 
   def test_jane
-    s = CEML.parse(:script, JANE_SCRIPT)
+    s = scriptfam JANE_SCRIPT
     play do
       ping s, :id => 'fred', :tags => ['new'], :received => 'freddy'
       asked 'fred', /Hello freddy. You are Level Zero./
@@ -117,7 +117,7 @@ class TestIncident < Test::Unit::TestCase
   end
 
   def test_signup_1
-    s = CEML.parse(:script, "await 1 new signup\ntell signup: thanks")
+    s = scriptfam "await 1 new signup\ntell signup: thanks"
     play do
       ping s, :id => 'fred', :tags => ['new']
       told 'fred', /thanks/
@@ -125,7 +125,7 @@ class TestIncident < Test::Unit::TestCase
   end
 
   def test_signup_2
-    s = CEML.parse(:script, "await 2 new signups\ntell signups: thanks")
+    s = scriptfam "await 2 new signups\ntell signups: thanks"
     play do
       ping s, :id => 'fred', :tags => ['new']
       silent 'fred'
@@ -138,7 +138,7 @@ class TestIncident < Test::Unit::TestCase
 
 
   def test_inside_timewindow
-    s = CEML.parse(:script, "await 2 new signups over 10s\ntell signups: thanks")
+    s = scriptfam "await 2 new signups over 10s\ntell signups: thanks"
     play do
       ping s, :id => 'fred', :tags => ['new']
       silent 'fred'
@@ -149,7 +149,7 @@ class TestIncident < Test::Unit::TestCase
   end
 
   def test_outside_timewindow
-    s = CEML.parse(:script, "await 2 new signups over 10s\ntell signups: thanks")
+    s = scriptfam "await 2 new signups over 10s\ntell signups: thanks"
     play do
       ping s, :id => 'fred', :tags => ['new']
       silent 'fred'
@@ -177,7 +177,7 @@ class TestIncident < Test::Unit::TestCase
   end
 
   def test_await
-    s = CEML.parse(:script, "await a,b,c\ntell a: foo\ntell b: bar\ntell c: baz")
+    s = scriptfam "await a,b,c\ntell a: foo\ntell b: bar\ntell c: baz"
     play do
       ping s, :id => 'fred'
       silent 'fred'

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 6
-  - 4
-  version: 0.6.4
+  - 7
+  - 0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Joe Edelman
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-11 00:00:00 -08:00
+date: 2011-02-12 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency