ceml 0.7.13 → 0.8.0

data/lib/ceml/tt/instructions.treetop

@@ -1,91 +0,0 @@
-module CEML
-grammar Instructions
-    include Lexer
-
-    rule basic_statement
-        (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?
-                    parent.later.duration.seconds
-                end
-            end
-
-            def role;  id.text_value.to_sym; end
-            def text;  defined?(super) && super.text_value; end
-            def var
-                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 :release; [[[role], :release,         {:tag  => key, :cond => cond}]]
-                when :sync;    [[[role], :sync]]
-                end
-                code
-            end
-        }
-    end
-
-    rule instruction_stmt
-        later:later? basic_statement
-    end
-
-    rule later
-        duration ws 'later' ws
-    end
-
-    rule record_stmt
-        'record' ws id ws varname:id
-    end
-
-    rule tell_stmt
-        'tell' ws id ':' ws? text
-    end
-
-    rule assign_stmt
-        'assign' ws id ':' ws? text
-    end
-
-    rule ask_stmt
-        'ask' ws id about:(ws 're' ws varname:id)? ':' ws? text
-    end
-
-    rule set_stmt
-        'set' ws id ws varname:id ':' ws? text
-    end
-
-    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/test/test_instructions.rb

@@ -1,27 +0,0 @@
-require 'ceml'
-
-class TestInstructions < Test::Unit::TestCase
-  def pi text
-    CEML.parse(:instructions, text)
-  end
-
-  def assert_bad text
-    assert_raise(RuntimeError){ pi text }
-  end
-
-  def test_bad
-    assert_bad "love your mother"
-    assert_bad "tell jim re susan: i hate you"
-    assert_bad "tell phil"
-    assert_bad "ask susan re clothing"
-    assert_bad "ask susan re clothing: "
-  end
-
-  def test_instructions
-    assert_equal "run to the kitchen", pi('tell joe: run to the kitchen').i_tell([:joe]).text
-    assert_equal ["favorite color?", "favorite soup?"], pi(
-      "ask joe re color: favorite color?\nask joe re soup: favorite soup?"
-    ).i_asks([:joe]).map(&:text)
-  end
-
-end

data/test/test_release.rb

@@ -1,78 +0,0 @@
-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 code:
- Type in your Infatuated Match Card code now.
-release signup as coded
-
-await 1 coded alpha and 1 coded beta with matching code
-tell alpha: You are alpha |her.first_name|, beta is |buddy.first_name|
-tell beta: You are beta |her.first_name|, alpha is |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 'Jon',  /Thanks/
-      says 'Jon',  'Jon'
-
-      asked 'Sara', /Match Card/
-      asked 'Jon',  /Match Card/
-      says 'Sara', 'xyzzy'
-      says 'Jon', 'xyZZy '
-
-      told 'Sara', /alpha Sara, beta is Jon/
-      told 'Jon', /beta Jon, alpha is Sara/
-    end
-  end
-
-end