ceml 0.7.3 → 0.7.4

data/VERSION

@@ -1 +1 @@
-0.7.3
+0.7.4

data/ceml.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ceml}
-  s.version = "0.7.3"
+  s.version = "0.7.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Joe Edelman"]
@@ -49,6 +49,7 @@ Gem::Specification.new do |s|
      "test/test_casting.rb",
      "test/test_incident.rb",
      "test/test_instructions.rb",
+     "test/test_release.rb",
      "test/test_scripts.rb",
      "try"
   ]
@@ -62,6 +63,7 @@ Gem::Specification.new do |s|
      "test/test_casting.rb",
      "test/test_incident.rb",
      "test/test_instructions.rb",
+     "test/test_release.rb",
      "test/test_scripts.rb"
   ]
 

data/lib/ceml/driver.rb

@@ -39,16 +39,23 @@ module CEML
       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 }
+    def ping_all script_collection_id, candidate, release = false
+      candidate[:script_collection_id] = script_collection_id
+      SCRIPTS[script_collection_id].each{ |s| ping script_collection_id, s.roles_to_cast, candidate, release }
     end
 
+    def released_from_all script_collection_id, candidate
+      SCRIPTS[script_collection_id].each{ |s| release 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
+      log "launching #{script.bytecode.inspect} with cast #{cast.inspect}"
       push nil, script.bytecode, *cast
     end
 
@@ -58,8 +65,7 @@ module CEML
       yield LOCATIONS["#{script_collection_id}:#{roleset.hash}"]
     end
 
-
-    def ping script_collection_id, roleset, candidate
+    def ping script_collection_id, roleset, candidate, involvement = :sticky
       return unless roleset.any?{ |r| r.fits? candidate }
       candidate[:ts] = CEML.clock
       already_launched_with = nil
@@ -68,14 +74,15 @@ module CEML
         live_with = confluences.select{ |c| c.live_with?(candidate) }
         if not live_with.empty?
           already_launched_with = live_with.first.incident_id
-          break
+          live_with.each{ |c| c.rm candidate } if involvement != :sticky
+          break if involvement != :released
         end
 
         locs = confluences.group_by{ |l| l.stage_with_candidate(candidate) }
         if locs[:joinable]
           log "joining..."
           first = locs[:joinable].shift
-          first.push candidate
+          first.push candidate unless first.incident_id == already_launched_with
           push first.incident_id, nil, candidate     # JOIN THEM
 
         elsif locs[:launchable]
@@ -105,7 +112,8 @@ module CEML
         confluences.delete_if(&:over?)
       end
 
-      if already_launched_with
+      if already_launched_with and involvement == :sticky
+        puts "PUSHING INSTEAD"
         push already_launched_with, nil, candidate
       end
     end
@@ -152,5 +160,25 @@ module CEML
       JUST_SAID[data[:player][:id]] = what
       puts "Said #{what.inspect}"
     end
+
+    # def player_start(data, what)
+    #   puts "STARTED #{data[:player].inspect}"
+    # end
+
+    def player_released(data, tag)
+      p = data[:player].dup
+      p[:tags] -= ['new']
+      if tag =~ /^(\w+)=/
+        p[:tags].delete_if{ |t| t =~ /^#{$1}=/ }
+      end
+      p[:tags] += [tag]
+      p.delete :pc
+      p.delete :roles
+      data[:player][:released] = true
+      # data[:players].delete_if{ |pl| pl[:id] == p[:id] }
+      puts "released: #{p.inspect} with #{tag}"
+      # puts "remaining players: #{data[:players].inspect}"
+      ping_all p[:script_collection_id], p, true
+    end
   end
 end

data/lib/ceml/incident.rb

@@ -28,8 +28,12 @@ module CEML
     def run(players, &blk)
       @players = players
       @callback = blk
-      :loop while players.any? do |@this|
-        # puts "seq for roles: #{roles.inspect} #{seq.inspect}"
+      puts "playing with #{@players.map{|p|p[:id]}}"
+      :loop while @players.any? do |thing|
+        @this = thing
+        next if thing[:released]
+        puts "trying #{@this[:id]}"
+        puts "not yet released"
         next unless instr = seq[pc]
         instr = instr.dup
         if rolematch(instr.shift)
@@ -37,6 +41,7 @@ module CEML
           next unless send(*instr)
           cb(*instr)
         end
+        # next if @this[:released]
         this[:pc]+=1
       end
       @callback = @players = nil
@@ -116,7 +121,8 @@ module CEML
 
     def answered_q q
       got or return false
-      qs_answers[q[:key]] = got
+      this[:last_answer] = qs_answers[q[:key]] = got
+      this[:last_answer_recognized] = recognized
       handled!
       true
     end
@@ -152,6 +158,23 @@ module CEML
       end
     end
 
+    def last_answer_match?(value)
+      case value
+      when :yes; this[:last_answer_recognized] == :yes
+      when :no;  this[:last_answer_recognized] == :no
+      end
+    end
+
+    def expectation(type, value)
+      if type == :if then last_answer_match?(value) else !last_answer_match?(value) end
+    end
+
+    def release x
+      return true if x[:cond] and not expectation(*x[:cond])
+      cb :released, x[:tag]
+      false
+    end
+
     def null_assign
       say :proceed
       true

data/lib/ceml/tt/casting.treetop

@@ -7,7 +7,7 @@ grammar Casting
     end
 
     rule modifier_phrase
-      over_phrase / within_phrase
+      over_phrase / within_phrase / with_matching_phrase
     end
 
     rule over_phrase
@@ -18,6 +18,10 @@ grammar Casting
         ws 'within' ws distance
     end
 
+    rule with_matching_phrase
+        ws 'with' ws 'matching' ws thing:id
+    end
+
     rule roles
         role more:(and role)* {
             def list

data/lib/ceml/tt/instructions.treetop

@@ -3,7 +3,7 @@ grammar Instructions
     include Lexer
 
     rule basic_statement
-        (ask_stmt / tell_stmt / assign_stmt / record_stmt / set_stmt / sync_stmt) {
+        (ask_stmt / tell_stmt / assign_stmt / record_stmt / set_stmt / sync_stmt / release_stmt) {
 
             def delay
                 if parent.respond_to? :later and not parent.later.empty?
@@ -12,27 +12,31 @@ grammar Instructions
             end
 
             def role;  id.text_value.to_sym; end
-            def text;  super.text_value; end
+            def text;  defined?(super) && super.text_value; end
             def var
-                return varname.text_value if cmd == :record or cmd == :set
-                (!defined?(:about) || about.empty?) ? nil : about.varname.text_value;
+                return varname.text_value if cmd == :record or cmd == :set or cmd == :release
+                (!respond_to?(:about) || about.empty?) ? nil : about.varname.text_value;
             end
             def key;   var || text; end
             def cmd;  text_value.split.first.to_sym; end
+            def cond
+                (!respond_to?(:condition) || condition.empty?) ? nil : condition.value
+            end
 
             def bytecode
                 code = []
                 code.concat   [[[role], :start_delay, delay],
                                [[role], :complete_delay]] if delay
                 code.concat case cmd
-                when :record; [[[role], :answered_q,      {:key  => key}]]
-                when :set;    [[[role], :set,             {:key  => key, :value => text}]]
-                when :ask;    [[[role], :ask_q,           {:text => text}],
-                               [[role], :answered_q,      {:key  => key}]]
-                when :tell;   [[[role], :send_msg,        {:text => text}]]
-                when :assign; [[[role], :assign,          {:text => text}],
-                               [[role], :complete_assign, {:text => text}]]
-                when :sync;   [[[role], :sync]]
+                when :record;  [[[role], :answered_q,      {:key  => key}]]
+                when :set;     [[[role], :set,             {:key  => key, :value => text}]]
+                when :ask;     [[[role], :ask_q,           {:text => text}],
+                                [[role], :answered_q,      {:key  => key}]]
+                when :tell;    [[[role], :send_msg,        {:text => text}]]
+                when :assign;  [[[role], :assign,          {:text => text}],
+                                [[role], :complete_assign, {:text => text}]]
+                when :release; [[[role], :release,         {:tag  => key, :cond => cond}]]
+                when :sync;    [[[role], :sync]]
                 end
                 code
             end
@@ -70,5 +74,18 @@ grammar Instructions
     rule sync_stmt
         'sync' ws id
     end
+
+    rule release_stmt
+        'release' ws id ws 'as' ws varname:id condition:condition?
+    end
+
+    rule condition
+        ws type:('if' / 'else') ws thing:id {
+            def value
+                [type.text_value.to_sym, thing.text_value.to_sym]
+            end
+        }
+    end
+
 end
 end

data/lib/ceml/tt/lexer.treetop

@@ -38,7 +38,7 @@ grammar Lexer
     end
 
     rule id
-      !(reserved_word ws) [a-zA-Z_]+
+      !(reserved_word ws) [a-zA-Z_] [a-zA-Z_0-9=]*
     end
 
     rule duration

data/test/helper.rb

@@ -33,7 +33,11 @@ class Test::Unit::TestCase
     iid = CEML::Driver::INCIDENTS.keys.find do |iid|
       CEML::Driver::PLAYERS[iid].find{ |p| p[:id] == id }
     end
-    DRIVER.post iid, :id => id, :received => str
+    if str == 'y'
+      DRIVER.post iid, :id => id, :received => str, :recognized => :yes
+    else
+      DRIVER.post iid, :id => id, :received => str
+    end
   end
 
   def player id, *roles

data/test/test_release.rb

@@ -0,0 +1,106 @@
+require 'ceml'
+require 'test/helper'
+
+class TestRelease < Test::Unit::TestCase
+
+  def test_release_syntax
+    s = CEML.parse(:script, "release all as booger")
+    assert l=s.bytecode.find{ |line| line[1] == :release }
+    assert_equal 'booger', l[2][:tag]
+
+    s = CEML.parse(:script, "release all as booger if yes")
+    puts s.bytecode.inspect
+    assert l=s.bytecode.find{ |line| line[1] == :release }
+    assert_equal 'booger', l[2][:tag]
+    assert_equal :if, l[2][:cond][0]
+    assert_equal :yes, l[2][:cond][1]
+  end
+
+  def test_release_and_catch
+    s1 = "await 1 new signup\nrelease signup as confused"
+    s2 = "await 1 confused booger\ntell booger: you're okay dude"
+    f = scriptfam s1, s2
+    play do
+      ping f, :id => 'sam', :tags => ['new']
+      told 'sam', /okay dude/
+    end
+  end
+
+  def test_conditional_release_and_catch
+    s1 = "await 1 new signup\nask signup re coffee: want some?\nrelease signup as confused if yes"
+    s2 = "await 1 confused booger\ntell booger: you're okay dude"
+    f = scriptfam s1, s2
+    play do
+      ping f, :id => 'sam', :tags => ['new']
+      asked 'sam', /want/
+      says 'sam', 'y'
+      told 'sam', /okay dude/
+    end
+  end
+
+
+SAM_IAN_SIGNUP_SCRIPTS = <<XXXX
+await 1 new signup
+ask signup re first_name:
+ Thanks for signing up for Infatuated!
+ What's your first name?
+ask signup re couple:
+ Do you have an Infatuated Match Card you want to use?
+ (These are available at the Infatuated table on the first floor.)
+release signup as stage=couple if yes
+ask signup re tags:
+ Who are you and who are you looking for tonight? (text back one: w4w, w4m, m4m, or m4w)
+
+await stage=couple player
+ask player re code:
+ Type in your Infatuated Match Card code now.
+release player as stage=coded
+
+await 1 stage=coded alpha and 1 stage=coded beta with matching code
+release alpha as alpha
+release beta as beta
+
+await 1 w4w alpha and 1 w4w beta
+release alpha as alpha
+release beta as beta
+
+await 1 w4m alpha and 1 m4w beta
+release alpha as alpha
+release beta as beta
+
+await 1 m4m alpha and 1 m4m beta
+release alpha as alpha
+release beta as beta
+
+await 1 m4w alpha and 1 w4m beta
+release alpha as alpha
+release beta as beta
+
+await 1 alpha alpha, 1 beta beta over 5 minutes
+tell both: Your date has started, |her.first_name|, |buddy.first_name|
+XXXX
+
+
+  def test_couple
+    f = scriptfam *CEML.parse(:scripts, SAM_IAN_SIGNUP_SCRIPTS)
+    play do
+      ping f, :id => 'Sara', :tags => ['new']
+      ping f, :id => 'Jon',  :tags => ['new']
+      asked 'Sara', /Thanks/
+      says 'Sara', 'Sara'
+      asked 'Sara', /Match Card/
+      says 'Sara', 'y'
+      asked 'Jon',  /Thanks/
+      says 'Jon',  'Jon'
+      asked 'Jon',  /Match Card/
+      says 'Jon',  'y'
+      asked 'Sara', /code now/
+      says 'Sara', 'xyzzy'
+      asked 'Jon', /code now/
+      says 'Jon', 'xyZZy '
+      told 'Sara', /started, Sara, Jon/
+      told 'Jon', /started, Jon, Sara/
+    end
+  end
+
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 7
-  - 3
-  version: 0.7.3
+  - 4
+  version: 0.7.4
 platform: ruby
 authors: 
 - Joe Edelman
@@ -71,6 +71,7 @@ files:
 - test/test_casting.rb
 - test/test_incident.rb
 - test/test_instructions.rb
+- test/test_release.rb
 - test/test_scripts.rb
 - try
 has_rdoc: true
@@ -108,4 +109,5 @@ test_files:
 - test/test_casting.rb
 - test/test_incident.rb
 - test/test_instructions.rb
+- test/test_release.rb
 - test/test_scripts.rb