ceml 0.7.13 → 0.8.0

data/lib/ceml/lang/basic_instruction.rb

@@ -0,0 +1,49 @@
+module CEML
+  module BasicInstruction
+
+    # TODO: bug right here
+    # def role;  id.respond_to?(:text_value) && id.text_value.to_sym || :none; end
+    def role;
+      if id.respond_to?(:text_value)
+        id.text_value.to_sym
+      else
+        raise "holy fuck"
+      end
+    end
+
+    def roles
+      [role]
+    end
+
+    def text_block
+      defined?(:text) && text.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_block; 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 case cmd
+        when :record;  [[roles, :answered_q,      {:key  => key}]]
+        when :set;     [[roles, :set,             {:key  => key, :value => text_block}]]
+        when :pick;    [[roles, :pick,            {:key  => key, :value => text_block}]]
+        when :ask;     [[roles, :ask_q,           {:text => text_block, :q => key}],
+                        [roles, :answered_q,      {:key  => key}]]
+        when :tell;    [[roles, :send_msg,        {:text => text_block}]]
+        when :assign;  [[roles, :assign,          {:text => text_block}],
+                        [roles, :complete_assign, {:text => text_block}]]
+        when :release; [[roles, :release,         {:cond => cond}]]
+        when :sync;    [[roles, :sync,            {:role => role}]]
+        end
+        code
+    end
+
+  end
+end

data/lib/ceml/{casting_statement.rb → lang/casting_statement.rb}

@@ -1,28 +1,38 @@
 module CEML
+
   module CastingStatement
     extend Forwardable
     def_delegators :roles, :names, :[], :min
     alias_method :rolenames, :names
 
-    def roles_to_cast(script)
-      return [] unless type == :await
-      roles.list.map do |r|
-        matching = []
-        matching << matching_text if matching_text
-        matching += [:city] if radius
-        c = Criteria.new(r.qualifiers, [], matching, radius, timewindow)
-        Role.new r.name, c, r.min..r.max, []
+    def casting_spec
+      return nil unless live_casting?
+      matching = []
+      matching << matching_text.to_sym if matching_text
+      matching += [:city] if radius
+      rolespecs = roles.list.map do |r|
+        RoleSpec.new(r.name, Tagspec.new(r.qualifiers,[]), r.min..r.max)
       end
+      [type, stanza_name, matching, radius, timewindow, rolespecs]
     end
 
     def type
-      elements.first.text_value.split.first.to_sym
+      elements[1].text_value.split.first.to_sym
+    end
+
+    def live_casting?
+      [:await, :accept].include?(type)
     end
 
     def max
       roles.max
     end
 
+    def stanza_name
+      return nil if stanza_marker.empty?
+      stanza_marker and stanza_marker.name and stanza_marker.name.text_value
+    end
+
     def within_phrase
       return if modifiers.empty?
       modifiers.elements.select{ |m| m.respond_to? :distance }.first

data/lib/ceml/{instruction_statements.rb → lang/instruction_statements.rb}

@@ -4,6 +4,11 @@ module CEML
       [instruction_stmt.basic_statement] + more.elements.map{ |x| x.instruction_stmt.basic_statement }
     end
 
+    def bytecode
+      # p list
+      list.map(&:bytecode)
+    end
+
     def instructions
       self
     end
@@ -16,21 +21,5 @@ module CEML
     def roles
       list.map{ |s| s.role.to_sym }.uniq
     end
-
-    def for(roles)
-      list.select{ |s| roles.include?(s.role.to_sym) }
-    end
-
-    def i_asks(roles)
-      list.select do |s|
-        s.text_value =~ /^ask/ && roles.include?(s.role.to_sym)
-      end
-    end
-
-    def i_tell(roles)
-      ss = list.select{ |s| s.text_value =~ /^tell/ && roles.include?(s.role.to_sym) }
-      raise "multiple assignments for role: #{role}" if ss.size > 1
-      ss.first
-    end
   end
 end

data/lib/ceml/{script.rb → lang/script.rb}

@@ -6,9 +6,10 @@ module CEML
     # = casting =
     # ===========
 
-    def roles_to_cast
-      return [] unless cast.type == :await
-      return cast.roles_to_cast(self)
+    def castable
+      return nil unless cast.live_casting?
+      args = cast.casting_spec + [bytecode]
+      Castable.new(*args)
     end
 
     def nabs?
@@ -66,7 +67,7 @@ module CEML
     DefaultDP = Struct.new :radius, :rolenames, :max, :type
 
     def cast
-      return casting_statement if respond_to? :casting_statement
+      return elements.first.casting_statement if elements.first.respond_to? :casting_statement
       return DefaultDP.new nil, [:agents], 0, :gather
     end
 
@@ -87,7 +88,7 @@ module CEML
     end
 
     def allowed_roles
-      allowed_roles = [:organizer, :agents, :both, :all, :everyone, :each, :players]
+      allowed_roles = [:organizer, :agents, :both, :all, :everyone, :each, :players, :them, :either]
       allowed_roles += cast.rolenames
       allowed_roles.uniq
     end
@@ -98,44 +99,42 @@ module CEML
     # ================
 
     def instructions
-      return self if Instructions === self
-      return super if defined?(super)
-      nil
+      elements.first.instructions if elements.first.respond_to? :instructions
+      # return self if Instructions === self
+      # return super if defined?(super)
+      # nil
     end
 
-    def instructions_for(roles)
-      return [] unless instructions
-      return instructions.for(expand_roles(roles))
+    def title
+      elements.first.title.title_value if elements.first.respond_to? :title
+      # if defined?(super)
+      #   super.title_value
+      # elsif respond_to? :title_value
+      #   self.title_value
+      # else nil
+      # end
     end
 
+
     def bytecode
       code = [[[:all], :start]]
+      # puts "instructions: #{instructions.inspect}"
       if !instructions and title
         code.concat [[[:all], :null_assign], [[:all], :complete_assign]]
       elsif instructions
-        instructions.list.each{ |inst| code.concat inst.bytecode } if instructions
+        code.concat(instructions.bytecode.flatten(1))
       end
       code << [[:all], :finish]
       code
     end
 
-    def asks(roles)
-      return [] unless instructions
-      instructions.i_asks([*roles])
-    end
-
-    def tell(roles)
-      return unless instructions
-      instructions.i_tell([*roles])
-    end
-
     def validate!
-      return unless instructions
-      instructions.validate_instructions!(allowed_roles)
+      # return unless instructions
+      # instructions.validate_instructions!(allowed_roles)
     end
 
     def concludes_immediately?
-      !title and instructions.asks([:agents]).empty?
+      !title and bytecode.none?{ |line| [:assign, :ask_q].include?(line[1]) }
     end
 
 
@@ -151,33 +150,44 @@ module CEML
       text_value
     end
 
-    def title
-      if defined?(super)
-        super.title_value
-      elsif respond_to? :title_value
-        self.title_value
-      else nil
-      end
-    end
-
     def name
       title || label
     end
 
     def params
-      asks(:organizer).map do |ask|
-        [ask.var, ask.var.capitalize, ask.text]
-      end
+      bytecode.map do |line|
+        next unless line[0].include?(:organizer)
+        next unless line[1] == :ask_q
+        [line[2][:q], line[2][:q].capitalize, line[2][:text]]
+      end.compact
     end
 
     def type
       return 'mission'  if title
       return 'unknown'  if instructions.empty?
-      return 'question' if not instructions.asks(:agents).empty?
-      return 'message'  if instructions.tell(:agents)
+      return 'question' if simple_question
+      return 'message'  if simple_message
       return 'unknown'
     end
 
+    def simple_message
+      # puts "bytecode size: #{bytecode.size}"
+      # p bytecode
+      return unless bytecode.size == 3
+      # puts "bytecode core: #{bytecode[1][1]}"
+      return unless bytecode[1][1] == :send_msg
+      return bytecode[1][2][:text]
+    end
+
+    def simple_question
+      # puts "bytecode size: #{bytecode.size}"
+      # p bytecode
+      return unless bytecode.size == 4
+      # puts "bytecode core: #{bytecode[1][1]}"
+      return unless bytecode[1][1] == :ask_q
+      return bytecode[1][2][:text]
+    end
+
     def message?
       type == 'message'
     end
@@ -185,10 +195,10 @@ module CEML
     def label
       return title || begin
         return "unknown" unless simple?
-        if q = instructions.asks(:agents).first
-          "Question: #{q.text}"
-        elsif tell = instructions.tell(:agents)
-          "Message: #{tell}" if tell
+        if simple_question
+          "Question: #{simple_question}"
+        elsif simple_message
+          "Message: #{simple_message}"
         else
           "unknown"
         end