ceml 0.8.0 → 0.9.0

data/VERSION

@@ -1 +1 @@
-0.8.0
+0.9.0

data/ceml.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ceml}
-  s.version = "0.8.0"
+  s.version = "0.9.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Joe Edelman"]
-  s.date = %q{2011-05-27}
+  s.date = %q{2011-06-07}
   s.description = %q{a language for coordinating real world events}
   s.email = %q{joe@citizenlogistics.com}
   s.extra_rdoc_files = [
@@ -24,6 +24,7 @@ Gem::Specification.new do |s|
     "Rakefile",
     "VERSION",
     "ceml.gemspec",
+    "cemltest",
     "editors/CEML.tmbundle/Syntaxes/ceml.tmLanguage",
     "editors/CEML.tmbundle/info.plist",
     "examples/breakfast-exchange.ceml",
@@ -48,10 +49,11 @@ Gem::Specification.new do |s|
     "lib/ceml/lang/tt/scripts.rb",
     "lib/ceml/lang/tt/scripts.treetop",
     "lib/ceml/models.rb",
-    "lib/ceml/models/audition.rb",
     "lib/ceml/models/bundle.rb",
     "lib/ceml/models/cast.rb",
     "lib/ceml/models/castable.rb",
+    "lib/ceml/models/casting_pool.rb",
+    "lib/ceml/models/casting_tokens.rb",
     "lib/ceml/models/incident.rb",
     "lib/ceml/models/incident_model.rb",
     "lib/ceml/models/incident_role_slot.rb",
@@ -59,6 +61,7 @@ Gem::Specification.new do |s|
     "lib/ceml/models/queue.rb",
     "lib/ceml/models/waiting_room.rb",
     "lib/ceml/processor.rb",
+    "lib/ceml/recognizer.rb",
     "test/askchain.ceml",
     "test/compliment.ceml",
     "test/dialogues/accept.ceml",

data/cemltest

@@ -0,0 +1,15 @@
+#! /usr/bin/env ruby
+require 'rubygems'
+require 'ceml'
+
+f = ARGV.shift
+name = File.basename(f, '.ceml')
+err, log = CEML.test(File.new(f).read)
+if !err
+  puts "PASS cemltest #{name}.  logged #{log.split("\n").size} lines"
+elsif RuntimeError === err
+  puts log
+  raise "ERROR with cemltest #{name}: #{err.message}!"
+else
+  raise err
+end

data/lib/ceml.rb

@@ -2,17 +2,40 @@ require 'forwardable'
 
 require 'ceml/models'
 require 'ceml/lang'
+require 'ceml/recognizer'
 require 'ceml/processor'
+require 'stringio'
 
 module CEML
   extend self
   @extra_seconds = 0
+  @log_io = STDERR
+  attr_reader :tells
   def clock; Time.now.utc.to_i + @extra_seconds; end
   def incr_clock(s); @extra_seconds += s; end
   def dur(n, unit)
     n * case unit
     when /^h/; 60*60; when /^mi/; 60; else 1; end
   end
+
+  def capture_log
+    log = ""
+    err = nil
+    prev_io, @log_io = @log_io, StringIO.new(log)
+    yield
+  rescue Exception => err
+    @log_io.puts "\nERROR: #{err}\n\n\n"
+  ensure
+    @log_io = prev_io
+    return err, log
+  end
+
+  def log lvl, msg
+    if lvl > 1
+      msg = "    #{msg}"
+    end
+    @log_io.puts msg
+  end
 end
 
 module CEML
@@ -39,4 +62,46 @@ module CEML
     end
     result
   end
+
+  def test test, p = CEML::Processor
+    scripts, test = test.split("\n---\n")
+    s = CEML.parse(:scripts, scripts).map(&:castable)
+    bundle_id = gen_code # s.hash.to_s
+    @tells = Hash.new{ |h,k| h[k] = [] }
+    p.set_bundle(bundle_id, s)
+    p.reset_bundle(bundle_id)
+    pl = Set.new
+    CEML.capture_log do
+      test.each_line do |line|
+        line = line.strip
+        next if line =~ /^#/ or line =~ /^\s*$/
+        CEML.log 1, "#{line}"
+        case line
+        when /^(\w+) *< *(.*)$/
+          player_id, msg = $1, $2
+          heard = tells[player_id].shift
+          next if msg.empty? and !heard
+          raise "Expected silence from #{player_id}, got #{heard}" if msg.empty? and heard
+          raise "Expected #{player_id} < #{msg}, got silence" if !msg.empty? and !heard
+          heard = (heard||={})[:msg] || (heard||={})[:q] || ''
+          raise "Expected #{player_id} < #{msg}, got #{heard}" unless heard =~ /#{msg}/
+          next
+        when /^(\w+) *> *(.*)$/
+          player_id, msg = $1, $2
+          player = {:id => player_id, :received => msg }
+          if !pl.include?(player_id)
+            player[:tags] = ['new']
+            p.reset_player(bundle_id, player_id)
+            pl << player_id
+          end
+          player[:recognized] = CEML::Recognizer.recognize(msg)
+          p.ping(bundle_id, player)
+        when /^\((\d+)\s*(\w+)\)$/
+          CEML.incr_clock CEML.dur($1.to_i, $2)
+          p.run_latest
+        end
+        p.run
+      end
+    end
+  end
 end

data/lib/ceml/models.rb

@@ -6,7 +6,8 @@ Redis::Objects.redis = Redis.new
 require 'ceml/models/cast'
 require 'ceml/models/castable'
 require 'ceml/models/incident'
-require 'ceml/models/audition'
+require 'ceml/models/casting_pool'
+require 'ceml/models/casting_tokens'
 require 'ceml/models/incident_model'
 require 'ceml/models/incident_role_slot'
 require 'ceml/models/player'

data/lib/ceml/models/bundle.rb

@@ -3,31 +3,68 @@ module CEML
     include Redis::Objects
     value :castables, :marshal => true
 
-    def clear_from_all_rooms(player_id)
-      Audition.new(player_id).clear_from_all_rooms
-    end
+    # =============
+    # = castables =
+    # =============
 
     def find_castables(stanza_name = nil)
       return castables.value unless stanza_name
       return [castables.value.find{ |c| c.stanza_name == stanza_name }]
     end
 
+
+    # =================
+    # = waiting rooms =
+    # =================
+
+    def clear_from_all_rooms(player_id)
+      CastingPool.destroy_everywhere(id, player_id)
+    end
+
     def all_rooms
       find_castables.map(&:all_rooms).flatten.uniq
     end
 
     def reset
-      all_rooms.each(&:clear)
+      # puts "TOTAL RESET"
+      CastingTokens.destroy_all(id)
+      all_rooms.each{ |room| room.waiting_incident_roles.clear }
     end
 
     def rooms_for_player(player, stanza_name = nil)
-      roomnames = find_castables(stanza_name).map{ |c| c.waiting_rooms_for_player(player, stanza_name) }.flatten.uniq
-      roomnames.map{ |r| WaitingRoom.new(r) }
+      find_castables(stanza_name).map{ |c| c.waiting_rooms_for_player(player, stanza_name) }.flatten.uniq
+    end
+
+    def register_in_rooms(player, stanza_name = nil)
+      room_ids = rooms_for_player(player, stanza_name)
+      CastingPool.new(room_ids).post(id, player[:id])
     end
 
+    def reset_player(player_id)
+      CastingPool.destroy_everywhere(id, player_id)
+      Player.new(player_id).reset
+    end
+
+    def grab_cast?(player, castable, seeded_p)
+      room_ids = castable.hot_waiting_rooms_given_player(player, seeded_p)
+      # CEML.log 1, "Checking cast for #{castable.stanza_name}: #{room_ids.inspect}"
+      casting_pool = CastingPool.new(room_ids)
+      loop do
+        hot_players = casting_pool.hot_players + [player]
+        # CEML.log 1, "Hot players: #{hot_players.inspect}"
+        return nil unless cast = castable.cast_from(hot_players)
+        return cast if casting_pool.claim(cast.player_ids - [player[:id]])
+        sleep 0.02
+      end
+    end
+
+    # ==============================
+    # = incident joining/launching =
+    # ==============================
+
     def join_running_incident?(player, stanza_name = nil)
-      rooms_for_player(player, stanza_name).each do |room|
-        if incident_id = room.audition_for_incidents(player)
+      rooms_for_player(player, stanza_name).each do |room_id|
+        if incident_id = WaitingRoom.new(room_id).audition_for_incidents(player)
           return incident_id
         end
       end
@@ -37,7 +74,8 @@ module CEML
     def cast_player?(player, stanza_name = nil)
       incident_id  = gen_code
       find_castables(stanza_name).each do |castable|
-        if cast = castable.cast_player?(incident_id, player, stanza_name)
+        if cast = grab_cast?(player, castable, seeded=stanza_name)
+          castable.advertise_roles(incident_id, cast)
           i = IncidentModel.new(incident_id)
           i.bytecode.value = castable.bytecode
           i.add_castings(cast.castings)
@@ -48,16 +86,7 @@ module CEML
     end
 
     def absorb?(player, stanza_name = nil)
-      x = join_running_incident?(player, stanza_name)
-      puts "X1: #{x.inspect}"
-      return x if x
-      x = cast_player?(player, stanza_name)
-      puts "X2: #{x.inspect}"
-      x
-    end
-
-    def register_in_rooms(player, stanza_name = nil)
-      Audition.new("#{player[:id]}").list_in_rooms(rooms_for_player(player, stanza_name))  ##{gen_code}:
+      join_running_incident?(player, stanza_name) or cast_player?(player, stanza_name)
     end
 
   end

data/lib/ceml/models/cast.rb

@@ -102,6 +102,7 @@ module CEML
 
   class Tagspec < Struct.new :with, :without
     def =~(c)
+      return false if (c[:tags]||[]).include?('new') and not with.include?('new')
       with.all?{ |t| (c[:tags]||[]).include?(t) } and without.all?{ |t| !(c[:tags]||[]).include?(t) }
     end
   end

data/lib/ceml/models/castable.rb

@@ -1,30 +1,12 @@
 module CEML
-  class Castable < Struct.new :type, :stanza_name, :matching, :radius, :timewindow, :roles, :bytecode
+  class Castable < Struct.new :type, :stanza_name, :matching, :radius, :timewindow, :roles, :bytecode, :bundle_id
 
-    def cast_player?(incident_id, player, seeded=false)
-      room_ids = hot_waiting_rooms_given_player(player, seeded)
-      hotties = Audition.from_rooms(room_ids)
-      # puts "hotties are... #{hotties.inspect} from rooms #{room_ids.inspect}"
-      hot_players = hotties.keys.map{ |id| Player.new(id).data.value } + [player]
-      # puts "casting from #{hot_players.inspect}"
-      if cast = cast_from(hot_players)
-        puts "...cast with cast #{cast.player_ids.inspect}"
-        audition_ids = (cast.player_ids & hotties.keys).map{ |id| hotties[id] }
-        puts "consuming #{audition_ids.inspect}"
-        if Audition.consume(audition_ids, room_ids)
-          # post audition signs in waiting rooms for remaining parts
-          with_open_roles(cast) do |idx, role, count|
-            waiting_rooms_to_watch(role, cast).each do |room|
-              room.list_job(incident_id, idx, role.name, count)
-            end
-          end
-          return cast
-        else
-          sleep 0.02
-          return cast_player?(incident_id, player)
+    def advertise_roles(incident_id, cast)
+      with_open_roles(cast) do |idx, role, count|
+        waiting_rooms_to_watch(role, cast).each do |room|
+          room.list_job(incident_id, idx, role.name, count)
         end
       end
-      return
     end
 
     def waiting_rooms_for_player(player, seeded=false)
@@ -37,8 +19,8 @@ module CEML
 
     def hot_waiting_rooms_given_player(player, seeded=false)
       rooms = waiting_rooms_for_player(player, seeded)
-      roles.each{ |r| rooms.concat(["#{stanza_name}:#{r.name}", *r.tagspec.with]) }
-      rooms << "#{stanza_name}:*"
+      roles.each{ |r| rooms.concat(["#{bundle_id}:#{stanza_name}:#{r.name}", *r.tagspec.with]) }
+      rooms << "#{bundle_id}:#{stanza_name}:*"
       # rooms << 'generic'
       rooms.uniq
     end
@@ -47,8 +29,8 @@ module CEML
       # skip for now: radius, timewindow, matching, general
       result = []
       if stanza_name
-        result << "#{stanza_name}:#{role.name}"
-        result << "#{stanza_name}:*"
+        result << "#{bundle_id}:#{stanza_name}:#{role.name}"
+        result << "#{bundle_id}:#{stanza_name}:*"
       end
       if !role.tagspec.with.empty?
         result.concat role.tagspec.with

data/lib/ceml/models/casting_pool.rb

@@ -0,0 +1,26 @@
+module CEML
+  class CastingPool < Struct.new :room_ids
+    def self.destroy_everywhere(bundle_id, player_id)
+      CastingTokens.destroy([player_id])
+    end
+
+    def player_ids
+      tokens = CastingTokens.all_tokens(room_ids)
+      @tokens_by_player_id = tokens.inject({}){ |m,o| m[o]=o; m }
+      @tokens_by_player_id.keys
+    end
+
+    def hot_players
+      player_ids.map{ |id| Player.new(id).data.value }
+    end
+
+    def claim(player_ids)
+      tokens = @tokens_by_player_id.values_at(*player_ids)
+      CastingTokens.collect(tokens)
+    end
+
+    def post(bundle_id, player_id)
+      CastingTokens.post(bundle_id, player_id, room_ids)
+    end
+  end
+end

data/lib/ceml/models/casting_tokens.rb

@@ -0,0 +1,51 @@
+module CEML
+  class Audition < Struct.new(:id)
+    include Redis::Objects
+    set :rooms
+  end
+
+  module CastingTokens
+    def self.post(bundle_id, token, room_ids)
+      room_ids << bundle_id
+      room_ids.each do |room_id|
+        Audition.new(token).rooms << room_id
+        WaitingRoom.new(room_id).waiting_auditions << token
+      end
+    end
+
+    def self.all_tokens(room_ids)
+      rooms = room_ids.map{ |r| WaitingRoom.new(r) }
+      rooms.map{ |r| r.waiting_auditions.members }.flatten.uniq
+    end
+
+    def self.destroy_all(bundle_id)
+      all = WaitingRoom.new(bundle_id).waiting_auditions.members
+      # puts "DESTROYING tokens: #{all.inspect}"
+      destroy(all)
+    end
+
+    def self.destroy(tokens)
+      roomsets = tokens.map{ |id| Audition.new(id).rooms }
+      rooms = roomsets.map(&:members).flatten.uniq
+      # puts "Consuming ids #{ids.inspect} from rooms #{rooms.inspect}"
+      # TODO: install new redis and re-enable watchlist
+      # redis.watch(*roomsets.map(&:key))
+      # redis.multi do
+      # rooms = roomsets.first.union(roomsets[1,-1]) || []
+      rooms.product(tokens).each do |r, id|
+        # puts "DELETING #{id} from room #{r}"
+        WaitingRoom.new(r).waiting_auditions.delete(id)
+      end
+      roomsets.map(&:clear)
+      # end
+      true
+    end
+
+    # this one should collect none unless all can be collected
+    # using multi/exec
+    def self.collect(tokens)
+      destroy(tokens)
+    end
+
+  end
+end

data/lib/ceml/models/incident.rb

@@ -31,13 +31,14 @@ module CEML
       guyroles = roles.to_a - [:everyone, :players, :them, :all, :either, :each, :agents, :both]
       instr ||= []
 
-      puts "[#{id}] #{p[:id]}(#{guyroles}) ##{pc} #{state} -- #{instr[1]}/#{instr[0]} -- #{instr[2].inspect}"
+      # CEML.log 3, "#{p[:id]}: #{state} -- #{instr[1]}/#{instr[0]} -- #{instr[2].inspect} -- #{id}##{pc}(#{guyroles})"
     end
 
-
     def run(players, &blk)
       @players = players
       @callback = blk
+      was_blocked = {}
+      # CEML.log 1, "running players: #{players.inspect}"
 
       loop do
         players = @players
@@ -45,24 +46,25 @@ module CEML
         players.each do |p|
           @this = p
           instr = seq[pc]
+          # log "running: #{pc}: #{instr.inspect}"
           unless instr = seq[pc]
-            log 'off schedule'
             @players.delete(p)
-            cb :released
             next
           end
           instr = instr.dup
           rolespec = instr.shift
           if not rolematch(rolespec)
-            log "skipping[#{rolespec}]"
+            # log "skipping[#{rolespec}]"
             this[:pc]+=1
             advanced = true
           else
             instr << role_info if instr.first == :start  #tmp hack
             if send(*instr)
               log 'completed'
+              was_blocked[p] = false
             else
-              log 'blocked'
+              log 'blocked' unless was_blocked[p]
+              was_blocked[p] = true
               next
             end
             cb(*instr)

data/lib/ceml/models/incident_model.rb

@@ -20,13 +20,13 @@ module CEML
         folks.each do |player|
           Player.new(player[:id]).touch(id)
           player_roles[player[:id]] = [rolename.to_sym]
-          puts "ADDED(#{id}) #{player[:id]} = #{rolename.to_sym}"
+          CEML.log 3, "#{player[:id]}: added as #{rolename.to_sym} (#{id})"
         end
       end
     end
 
     def release(player_id)
-      puts "Releasing player #{player_id} from incident #{id}"
+      CEML.log 3, "#{player_id}: releasing from incident #{id}"
       Player.new(player_id).clear_incident(id)
       player_roles.delete(player_id)
     end
@@ -51,17 +51,17 @@ module CEML
         metadata, player_data = *data.value
         metadata    ||= { :id => id }
         player_data ||= {}
-        puts "[#{id}] Player data loaded: #{player_data.inspect}"
         players = []
 
-        puts "[#{id}] Player roles: #{player_roles.all.inspect}"
+        CEML.log 3, ">>> #{player_roles.all.inspect} (#{id})"
         player_roles.each do |player_id, roles|
-          puts "#{id}: #{player_id.inspect} => #{roles.inspect}, #{player_data[player_id].inspect}"
+          CEML.log 3, "#{player_id}: casted as #{roles.inspect} -- #{id}: #{player_data[player_id].inspect}"
           player = { :id => player_id, :roles => Set.new(roles) }
           player[:roles] << :agents << :players << :both << :all << :each << :everyone << :them << :either
           player.merge! player_data[player_id] if player_data[player_id]
           p = Player.new(player_id)
           stored_player = p.data.value
+          PLAYER_THREAD_FIELDS.each{ |x| stored_player.delete x }
           msg = p.message.value
           player.merge! msg if msg
           player.merge! stored_player if stored_player
@@ -86,8 +86,9 @@ module CEML
         players.each do |p|
           Player.new(p[:id]).message.value = p.like(:received, :recognized, :situation)
           player_data[p[:id]] = p.like *PLAYER_THREAD_FIELDS
+          # PLAYER_THREAD_FIELDS.each{ |x| p.delete x }
         end
-        puts "Player data saving: #{player_data.inspect}"
+        # CEML.log 1, "Player data saving: #{player_data.inspect}"
         data.value = [metadata, player_data]
 
         if next_run = players.map{ |p| p[:continue_at] }.compact.min

data/lib/ceml/models/player.rb

@@ -6,17 +6,20 @@ module CEML
     value :message, :marshal => true
     sorted_set :current_incidents
 
-    def touch(incident_id)
-      current_incidents[incident_id] = Time.now.to_i
-    end
-
     def reset
-      Audition.new(id).clear_from_all_rooms
       data.clear
       message.clear
       current_incidents.clear
     end
 
+    # =============
+    # = incidents =
+    # =============
+
+    def touch(incident_id)
+      current_incidents[incident_id] = Time.now.to_i
+    end
+
     def top_incident_id
       current_incidents.last
     end
@@ -31,6 +34,11 @@ module CEML
       current_incidents.delete(id)
     end
 
+
+    # ========
+    # = data =
+    # ========
+
     def self.update bundle_id, player, cb_obj, &blk
       player[:bundle_id] = player[:squad_id] = bundle_id
       new(player[:id].to_s).update player, cb_obj, &blk
@@ -69,7 +77,7 @@ module CEML
       new_message, player = split(player)
       merge_new_player_data(player)
       cmd = new_message[:recognized]
-      if cmd and cb_obj.recognize_override(cmd, new_message, player, self)
+      if cmd and cb_obj and cb_obj.recognize_override(cmd, new_message, player, self)
         message.delete
       else
         message.value = new_message

data/lib/ceml/models/waiting_room.rb

@@ -5,18 +5,11 @@ module CEML
     set :waiting_auditions
     set :waiting_incident_roles
 
-    def clear
-      waiting_auditions.each do |audition_id|
-        Audition.new(audition_id).clear_from_all_rooms(id)
-      end
-      waiting_incident_roles.clear
-    end
-
     def audition_for_incidents(player)
-      # puts "auditioning #{player[:id]} for incidents in room #{id}"
-      waiting_incident_roles.members.each do |key|
+      reorder = waiting_incident_roles.members.sort_by{ |irs| irs.split(':')[1] }
+      reorder.each do |key|
         incident_id, idx, role, count = *key.split(':')
-        # puts "checking against #{incident_id}: #{role}"
+        CEML.log 3, "#{player[:id]}: auditioning against #{incident_id}: #{role}"
         count = count.to_i
         role_slot = IncidentRoleSlot.new(incident_id, role, count)
         next unless role_slot.reserve_spot!
@@ -30,11 +23,6 @@ module CEML
     def list_job(incident_id, idx, rolename, count)
       waiting_incident_roles << [incident_id, idx, rolename, count].join(':')
     end
-
-    def add(audition_id)
-      puts "adding #{audition_id} to waiting room #{id.inspect}"
-      waiting_auditions << audition_id
-    end
   end
 
 end

data/lib/ceml/processor.rb

@@ -15,6 +15,7 @@ module CEML
 
     def set_bundle(id, castables)
       # log "set_bundle(): #{id}, #{castables.inspect}"
+      castables.each{ |c| c.bundle_id = id }
       Bundle.new(id).castables = castables
     end
 
@@ -62,7 +63,7 @@ module CEML
     end
 
     def reset_player(bundle_id, player_id)
-      Player.new(player_id).reset
+      Bundle.new(bundle_id).reset_player(player_id)
     end
 
     # =============
@@ -70,9 +71,10 @@ module CEML
     # =============
 
     def simple_audition(bundle_id, player)
-      log "audition(): #{bundle_id}, #{player[:id]}"
+      # log "audition(): #{bundle_id}, #{player[:id]}"
       b = Bundle.new(bundle_id)
-      b.clear_from_all_rooms(player)
+      b.clear_from_all_rooms(player[:id])
+
       if incident_id = b.absorb?(player)
         IncidentModel.new(incident_id).run(self)
         return true
@@ -82,13 +84,20 @@ module CEML
     end
 
     def seed(bundle_id, stanza_name, player)
-      log "seed(): #{bundle_id}, #{stanza_name}, #{player[:id]}"
+      # log "seed(): #{bundle_id}, #{stanza_name}, #{player[:id]}"
+      player[:tags].delete('new')
+      Player.new(player[:id]).merge_new_player_data(player)
+
+      # CEML.log 1, "UPDATED"
+
       b = Bundle.new(bundle_id)
       if incident_id = b.absorb?(player, stanza_name)
         IncidentModel.new(incident_id).run(self)
-        return true
+        true
+      else
+        b.register_in_rooms(player, stanza_name)
+        false
       end
-      b.register_in_rooms(player, stanza_name)
     end
 
     # =============
@@ -107,16 +116,16 @@ module CEML
       if incident
         incident.release(player_obj.id)
         unlatch(player[:squad_id], player[:id], incident.id)
-        player_obj.reset
+        reset_player(player[:squad_id], player[:id])
         tell(player[:squad_id], player[:id], :message, :msg => 'aborted')
       else
-        player_obj.reset
+        reset_player(player[:squad_id], player[:id])
         tell(player[:squad_id], player[:id], :message, :msg => 'nothing to abort from')
       end
     end
 
     def log(s)
-      puts s
+      CEML.log 1, s
     end
 
     def player_said(data, what)
@@ -127,11 +136,8 @@ module CEML
       #no op
     end
 
-    JUST_SAID = {}
     def tell(sqid, player_id, key, meta)
-      JUST_SAID[player_id] ||= []
-      JUST_SAID[player_id] << meta.merge(:key => key)
-      # puts "Said #{key} #{meta.inspect}"
+      CEML.tells[player_id] << meta.merge(:key => key) if CEML.tells
     end
 
     def player_answered_q(data, what)
@@ -142,8 +148,8 @@ module CEML
     def player_seeded(data, what)
       p = data[:player].dup
       p.delete(:roles)
-      p[:seeded] = "#{what[:target]}:#{what[:role]}"
-      puts "SEEDED #{p[:id]} AS #{what[:target]}:#{what[:role]}"
+      p[:seeded] = "#{p[:bundle_id]}:#{what[:target]}:#{what[:role]}"
+      CEML.log 3, "#{p[:id]}: seeded as #{p[:seeded]}"
 
       self.class.seed(p[:bundle_id], what[:target], p)
     end

data/lib/ceml/recognizer.rb

@@ -0,0 +1,9 @@
+module CEML
+  class Recognizer
+    def self.recognize msg
+      return :yes if msg == 'y' || msg =~ /^yes/i
+      return :abort if msg == 'abort'
+      return :done if msg =~ /^done/i || msg == 'd'
+    end
+  end
+end

data/test/dialogues/jordan.ceml

@@ -81,41 +81,43 @@ D < Please text
 D > done
 D <
 
-// K > Kiley
-// K < Welcome
-// K < You wanna
-// K > Yes
-// K < Awesome!
-// (20s)
-// K < If you want to opt out
-//
-// P > Paul
-// P < Welcome
-// P < You wanna
-// P > Yes
-// P < Awesome!
-// (20s)
-// P < If you want to opt out
-//
-// D <  Amazing work
-// D > Yes
-// D < new challenge
-// D > Wave and smile at three strangers on the street
-// D < Thanks for playing
-// K < Another player has issued
-// K > Yes
-// K < Please text
-// K > done
-// K <
-//
-// # (challenge_loop2)
-// # K <  Amazing work
-// # K > Yes
-// # K < new challenge
-// # K > Wave and smile at three strangers on the street
-// # K < Thanks for playing
-// # P < Another player has issued
-// # P > Yes
-// # P < Please text
-// # P > done
-// # P <
+K > Kiley
+
+P > Paul
+P < Welcome
+P < You wanna
+P > Yes
+
+# P < Awesome!
+# (20s)
+# P < If you want to opt out
+#
+# K < Welcome
+# K < You wanna
+# K > Yes
+# K < Awesome!
+# (20s)
+# K < If you want to opt out
+#
+# D <  Amazing work
+# D > Yes
+# D < new challenge
+# D > Wave and smile at three strangers on the street
+# D < Thanks for playing
+# K < Another player has issued
+# K > Yes
+# K < Please text
+# K > done
+# K <
+#
+# (challenge_loop2)
+# K <  Amazing work
+# K > Yes
+# K < new challenge
+# K > Wave and smile at three strangers on the street
+# K < Thanks for playing
+# P < Another player has issued
+# P > Yes
+# P < Please text
+# P > done
+# P <

data/test/helper.rb

@@ -18,7 +18,7 @@ class Test::Unit::TestCase
     end
     if script
       @iid = gen_code
-      puts "launching w. bytecode #{script.bytecode.inspect}"
+      # puts "launching w. bytecode #{script.bytecode.inspect}"
       CEML::Processor.launch(@iid, script.bytecode)
       CEML::Processor.run
     end
@@ -40,7 +40,7 @@ class Test::Unit::TestCase
     player = {:id => id.to_s, :received => str}
     player[:recognized] = :yes if str.downcase == 'y' || str.downcase == 'yes'
     player[:recognized] = :abort if str == 'abort'
-    puts "SAYING(#{id}): #{str}"
+    # puts "SAYING(#{id}): #{str}"
     CEML::Processor.ping(nil, player)
     CEML::Processor.run
   end

data/test/test_dialogues.rb

@@ -8,51 +8,20 @@ class TestCemlTests < Test::Unit::TestCase
     CEML::Queue.new.calls.clear
   end
 
-  def test_cemltests
-    Dir["test/dialogues/*.ceml"].each do |f|
-      name = File.basename(f, '.ceml')
-      test    = File.new(f).read
-      scripts, test = test.split("\n---\n")
-
-      puts "Running cemltest #{name}..."
-
-      s = CEML.parse(:scripts, scripts).map(&:castable)
-      bundle_id = s.hash.to_s
-      CEML::Processor.set_bundle(bundle_id, s)
-      CEML::Processor.reset_bundle(bundle_id)
-      pl = Set.new
-      play do
-        test.each_line do |line|
-          puts ">>>> #{line}"
-          case line.strip
-          when /^(\w+) *< *(.*)$/
-            if $2.empty?
-              silent $1
-            else
-              told $1, /#{$2}/
-            end
-          when /^(\w+) *> *(.*)$/
-            player_id, msg = $1, $2
-            player = {:id => player_id, :received => msg }
-            if !pl.include?(player_id)
-              player[:tags] = ['new']
-              pl << player_id
-            end
-            player[:recognized] = :yes if msg == 'y' || msg =~ /^yes/i
-            player[:recognized] = :abort if msg == 'abort'
-            player[:recognized] = :done if msg =~ /^done/i || msg == 'd'
-            CEML::Processor.ping(bundle_id, player)
-            CEML::Processor.run
-          when /^\((\d+)\s*(\w+)\)$/
-            CEML.incr_clock CEML.dur($1.to_i, $2)
-            CEML::Processor.run_latest
-            CEML::Processor.run
-          when /^#/
-          else "Skipping line #{line}..."
-          end
-        end
-      end
+  def run_cemltest f
+    name = File.basename(f, '.ceml')
+    err, log = CEML.test(File.new(f).read)
+    if !err
+      puts "PASS cemltest #{name}.  logged #{log.split("\n").size} lines"
+    elsif RuntimeError === err
+      puts log
+      raise "ERROR with cemltest #{name}: #{err.message}!"
+    else
+      raise err
     end
   end
 
+  def test_cemltests
+    Dir["test/dialogues/*.ceml"].each{ |f| run_cemltest(f) }
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ceml
 version: !ruby/object:Gem::Version 
-  hash: 63
+  hash: 59
   prerelease: 
   segments: 
   - 0
-  - 8
+  - 9
   - 0
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors: 
 - Joe Edelman
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-27 00:00:00 -07:00
+date: 2011-06-07 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -49,6 +49,7 @@ files:
 - Rakefile
 - VERSION
 - ceml.gemspec
+- cemltest
 - editors/CEML.tmbundle/Syntaxes/ceml.tmLanguage
 - editors/CEML.tmbundle/info.plist
 - examples/breakfast-exchange.ceml
@@ -73,10 +74,11 @@ files:
 - lib/ceml/lang/tt/scripts.rb
 - lib/ceml/lang/tt/scripts.treetop
 - lib/ceml/models.rb
-- lib/ceml/models/audition.rb
 - lib/ceml/models/bundle.rb
 - lib/ceml/models/cast.rb
 - lib/ceml/models/castable.rb
+- lib/ceml/models/casting_pool.rb
+- lib/ceml/models/casting_tokens.rb
 - lib/ceml/models/incident.rb
 - lib/ceml/models/incident_model.rb
 - lib/ceml/models/incident_role_slot.rb
@@ -84,6 +86,7 @@ files:
 - lib/ceml/models/queue.rb
 - lib/ceml/models/waiting_room.rb
 - lib/ceml/processor.rb
+- lib/ceml/recognizer.rb
 - test/askchain.ceml
 - test/compliment.ceml
 - test/dialogues/accept.ceml

data/lib/ceml/models/audition.rb

@@ -1,65 +0,0 @@
-module CEML
-
-  class Audition < Struct.new(:id)  # "#{code}:#{player_id}"
-    include Redis::Objects
-    set :rooms
-
-    def list_in_rooms(da_rooms)
-      # p "Listing in rooms #{da_rooms.map(&:id)}"
-      da_rooms.each{ |room| self.rooms << room.id; room.add(id) }
-    end
-
-    def clear_from_all_rooms(*extra_rooms)
-      rooms_to_clear = rooms.members + extra_rooms
-      redis.multi do
-        rooms_to_clear.each do |r|
-          WaitingRoom.new(r).waiting_auditions.delete(id)
-        end
-        redis.del rooms.key
-      end
-    end
-
-    def self.consume(ids, extra_rooms = [])
-      roomsets = ids.map{ |id| Audition.new(id).rooms }
-      rooms = (roomsets.map(&:members) + extra_rooms).flatten.uniq
-      # puts "Consuming ids #{ids.inspect} from rooms #{rooms.inspect}"
-      # TODO: install new redis and re-enable watchlist
-      # redis.watch(*roomsets.map(&:key))
-      # redis.multi do
-        # rooms = roomsets.first.union(roomsets[1,-1]) || []
-        rooms.each do |r|
-          # puts "PROCESSING ROOM #{r.key}"
-          ids.each do |id|
-            # puts "DELETING #{id} from room #{r}"
-            WaitingRoom.new(r).waiting_auditions.delete(id)
-          end
-        end
-        roomsets.map(&:clear)
-      # end
-      true
-    end
-
-    def self.from_rooms(room_ids)
-      players = {}
-      rooms = room_ids.map{ |r| WaitingRoom.new(r) }
-      auditions = rooms.map{ |r| r.waiting_auditions.members }.flatten
-
-      # clear old style
-      auditions.each do |a|
-        next unless a =~ /:/
-        Audition.new(a).rooms.clear
-        rooms.each{ |r| r.waiting_auditions.delete(a) }
-      end
-
-      puts "Auditions found: #{auditions.inspect}"
-      auditions.each do |audition|
-        # next if audition =~ /:/
-        # code, player_id = audition.split(':')
-        player_id = audition
-        players[player_id] ||= audition
-      end
-      players
-    end
-  end
-
-end