ceml 0.2.0

data/lib/ceml/engine.rb

@@ -0,0 +1,138 @@
+require 'set'
+
+module CEML
+  class Dummy
+    def method_missing(meth, *args, &blk)
+      # puts "#{meth}: #{args.to_s.inspect}"
+    end
+  end
+
+  class Engine
+    attr_reader :script, :parts
+    def this;       @parts[@current_id]; 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 initialize(script_text, delg = Dummy.new)
+      @script = CEML.parse(:script, script_text)
+      @delg   = delg
+      @parts  = {}
+      @seq    = {}
+    end
+
+    def add(id, *roles)
+      obj = Hash === roles[-1] ? roles.pop : {}
+      parts[id] = obj.merge :roles => Set.new(roles)
+    end
+
+    def run
+      :loop while parts.keys.any? do |@current_id|
+        # puts "trying: #{@current_id}: #{seq[pc]}"
+        next unless seq[pc] and send(*seq[pc])
+        @delg.send(*seq[pc] + [@current_id])
+        this[:pc]+=1
+      end
+    end
+
+    def seq
+      @seq[roles] ||= begin
+        bytecode = [[:start]]
+        instrs = script.instructions_for(roles)
+        instrs.each do |inst|
+          case inst.cmd
+          when :ask
+            bytecode << [:ask_q, inst]
+            bytecode << [:answered_q, inst]
+          when :tell
+            if script.title
+              bytecode << [:assign, inst]
+              bytecode << [:complete_assign, inst]
+            else
+              bytecode << [:send_msg, inst]
+            end
+          end
+        end
+        if instrs.empty? and script.title
+          bytecode << [:null_assign]
+          bytecode << [:complete_assign]
+        end
+        bytecode << [:finish]
+      end
+    end
+
+    def say x, params = {}
+      this[:said] = x
+      this.merge! params
+    end
+
+    def qs_answers
+      this[:qs_answers] ||= Hash.new
+    end
+
+    def expand(role, var)
+      role = nil if role == 'otherguy'
+      role = role.to_sym if role
+      parts.each do |key, thing|
+        next if key == @current_id
+        next if role and not thing[:roles].include? role
+        value = (thing[:qs_answers]||{})[var] and return value
+      end
+      nil
+    end
+
+    # ==============
+    # = basic flow =
+    # ==============
+
+    def start
+      roles.include? :agent or return false
+      true
+    end
+
+    def ask_q q
+      text = q.interpolate(self) or return false
+      say :ask, :q => text
+      true
+    end
+
+    def answered_q q
+      got or return false
+      qs_answers[q.key] = got
+      true
+    end
+
+    def send_msg a
+      text = a.interpolate(self) or return false
+      say :message, :msg => text
+      true
+    end
+
+    def assign a
+      text = a.interpolate(self) or return false
+      say :assignment, :msg => text
+      true
+    end
+
+    def complete_assign a = nil
+      got or return false
+      if recognized == :done
+        say :ok
+        true
+      else
+        @delg.send :did_report
+        false
+      end
+    end
+
+    def null_assign
+      say :proceed
+      true
+    end
+
+    def finish
+      true
+    end
+  end
+end

data/lib/ceml/instructions.rb

@@ -0,0 +1,31 @@
+module CEML
+  module Instructions
+    def validate!(allowed_roles)
+      extra_roles = roles - allowed_roles
+      raise "unrecognized rolenames: #{extra_roles.inspect}" unless extra_roles.empty?
+
+      # max one tell per role
+      roles.each{ |r| tell([r]) }
+    end
+
+    def roles
+      elements.map{ |s| s.role.to_sym }.uniq
+    end
+
+    def for(roles)
+      elements.select{ |s| roles.include?(s.role.to_sym) }
+    end
+
+    def asks(roles)
+      elements.select do |s|
+        s.text_value =~ /^ask/ && roles.include?(s.role.to_sym)
+      end
+    end
+
+    def tell(roles)
+      ss = elements.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

@@ -0,0 +1,103 @@
+module CEML
+  module Script
+
+    def to_hash *fields
+      fields.inject({}){ |h, s| x = send(s); h[s] = x if x; h }
+    end
+
+    def script
+      text_value
+    end
+
+    def title
+      super && !super.empty? && super.value
+    end
+
+    def name
+      title || label
+    end
+
+    def radius
+      casting_statement.empty? ? nil : casting_statement.radius
+    end
+
+    def roles
+      return [:agents] if casting_statement.empty?
+      return casting_statement.roles
+    end
+
+    def dramatis_personae
+      casting_statement.empty? ? nil : casting_statement
+    end
+
+    alias_method :dp, :dramatis_personae
+
+    def simple?
+      (roles - [:agents, :organizer]).empty?
+    end
+
+    def expand_roles(roles)
+      roles.map{ |r| r == :agent ? [:agent, :agents] : r }.flatten.concat([:both, :all, :everyone])
+    end
+
+    def instructions_for(roles)
+      return [] if !instructions or instructions.empty?
+      return instructions.for(expand_roles(roles))
+    end
+
+    def asks(roles)
+      return [] if instructions.empty?
+      instructions.asks([*roles])
+    end
+
+    def params
+      asks(:organizer).map do |ask|
+        [ask.var, ask.var.capitalize, ask.text]
+      end
+    end
+
+    def tell(roles)
+      return nil if instructions.empty?
+      instructions.tell([*roles])
+    end
+
+    def type
+      return 'mission'  if title
+      return 'unknown'  if instructions.empty?
+      return 'question' if not instructions.asks.empty?
+      return 'message'  if instructions.tell(:agents)
+      return 'unknown'
+    end
+
+    def message?
+      type == 'message'
+    end
+
+    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
+        else
+          "unknown"
+        end
+      end
+    end
+
+    def validate!
+      instructions.validate!(allowed_roles) unless instructions.empty?
+    end
+
+    def allowed_roles
+      allowed_roles = [:organizer, :agents]
+      allowed_roles += casting_statement.roles unless casting_statement.empty?
+      allowed_roles
+    end
+
+    def concludes_immediately?
+      !title and instructions.asks([:agents]).empty?
+    end
+  end
+end