ceml 0.3.1 → 0.4.0

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.4.0

data/ceml.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ceml}
-  s.version = "0.3.1"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Joe Edelman"]
-  s.date = %q{2010-12-26}
+  s.date = %q{2011-01-09}
   s.description = %q{a language for coordinating real world events}
   s.email = %q{joe@citizenlogistics.com}
   s.extra_rdoc_files = [
@@ -31,11 +31,13 @@ Gem::Specification.new do |s|
      "examples/breakfast-exchange.ceml",
      "examples/citizen-investigation.ceml",
      "examples/high-fives.ceml",
+     "examples/sample_delegate.rb",
      "lib/ceml.rb",
-     "lib/ceml/casting.rb",
      "lib/ceml/casting_criterion.rb",
+     "lib/ceml/casting_statement.rb",
+     "lib/ceml/delegate.rb",
      "lib/ceml/incident.rb",
-     "lib/ceml/instructions.rb",
+     "lib/ceml/instruction_statements.rb",
      "lib/ceml/script.rb",
      "lib/ceml/tt/casting.treetop",
      "lib/ceml/tt/instructions.treetop",

data/lib/ceml/casting_criterion.rb

@@ -4,11 +4,53 @@ require "forwardable"
 module CEML
   class Candidate < Struct.new :uid, :tags, :matchables, :lat, :lng
     include Geokit::Mappable
+    attr_reader :criteria
+
+    def load(criteria)
+      @criteria = criteria.select{ |c| c =~ self }
+      if @criteria.empty? then nil else self end
+    end
+
+    def criteria_for_location(star)
+      criteria.select{ |c| c.fits?(self, star) }
+    end
+  end
+
+  class CastingLocation < Struct.new :script, :hash, :created
+    attr_accessor :added
+    def star; hash.values.flatten.first; end
+
+    def criteria
+      @criteria ||= script.awaited_criteria.sort_by{ |c| [-c.complexity, c.min_match] }
+    end
+
+    def push candidate
+      matching_criteria = candidate.criteria_for_location(star)
+      return if matching_criteria.empty?
+      matching_criteria.each{ |c| (hash[c] ||= []) << candidate }
+      @added = true
+    end
+
+    def self.create script, candidate
+      new(script, {}, true).tap{ |x| x.push candidate }
+    end
+
+    # this method will miss possible castings and does not handle ranges at all
+    def cast
+      {}.tap do |casting|
+        criteria.each do |c|
+          return nil unless folks = hash[c].dup
+          folks -= casting.keys
+          return nil unless folks.size >= c.min_match
+          c.role_counts.each do |role, minct|
+            folks.shift(minct).each{ |guy| casting[guy.uid] = role.to_sym }
+          end
+        end
+      end
+    end
   end
 
   class CastingCriterion < Struct.new :script, :plus_tags, :minus_tags, :grouped_by, :radius, :role_counts
-    extend Forwardable
-    def_delegators :script, :locations
     def min_match;  role_counts.values.reduce(:+); end
     def complexity; plus_tags.size; end
 
@@ -16,24 +58,28 @@ module CEML
       (plus_tags - candidate.tags).empty? and (minus_tags & candidate.tags).empty?
     end
 
-    def satisfied_by_group?(people, already_used)
-      if (people - already_used).size >= min_match
-        already_used.concat((people - already_used).first(min_match))
-        true
-      end
-    end
-
-    def list_candidate(candidate)
-      locs = locations.select do |l|
-        star = l.values.flatten.first
-        next unless grouped_by.all?{ |g| candidate.matchables[g] == star.matchables[g] }
-        !radius or candidate.distance_to(star, :meters) <= radius
-      end
-      if locs.empty?
-        new_loc = {}
-        [locations, locs].each{ |l| l << new_loc }
-      end
-      locs.each{ |l| (l[hash] ||= []) << candidate }
+    def fits?(candidate, star)
+      return true unless star
+      return unless grouped_by.all?{ |g| candidate.matchables[g] == star.matchables[g] }
+      p radius
+      !radius or candidate.distance_to(star, :meters) <= radius
     end
   end
 end
+
+# def satisfied_by_group?(people, already_used)
+#   if (people - already_used).size >= min_match
+#     already_used.concat((people - already_used).first(min_match))
+#     true
+#   end
+# end
+
+# this method and the one below will miss possible
+# castings and do not handle ranges at all
+# def complete?(loc)
+#   people_used = []
+#   @criteria.all? do |c|
+#     next unless folks = loc[c.hash]
+#     c.satisfied_by_group?(folks, people_used)
+#   end
+# end

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

@@ -24,7 +24,7 @@ module CEML
     end
 
     def radius
-      within_phrase.empty? ? 1600 * 50 : within_phrase.distance.meters
+      within_phrase.empty? ? nil : within_phrase.distance.meters
     end
 
     def nab?

data/lib/ceml/delegate.rb

@@ -0,0 +1,28 @@
+module Kernel
+  def gen_code(size = 8)
+    rand(36**size).to_s(36)
+  end
+end
+
+module CEML
+  class Delegate
+    LOCATIONS = {}
+    PLAYERS   = {}
+
+    # yields thing w. #keys, #each, #[], #[]=
+    def with_players id
+      yield PLAYERS[id] ||= {}
+    end
+
+    # yields a thing with #each and #<<
+    def with_locations script
+      yield LOCATIONS[script] ||= []
+      LOCATIONS[script].delete_if{ |loc| loc.cast and Incident.new(script, loc.cast).run }
+    end
+
+    def method_missing(meth, *args, &blk)
+      puts "#{meth}: #{args.map(&:to_s).join(', ')}"
+    end
+
+  end
+end

data/lib/ceml/incident.rb

@@ -2,34 +2,39 @@ require 'set'
 
 module CEML
   class Incident
-    attr_reader :script
-    def this;       players[@current_id]; end
+    attr_reader :script, :id, :players
+    def this;       @players[@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 qs_answers; this[:qs_answers] ||= Hash.new; end
 
-    def initialize(script_text, id = rand(36**10).to_s(36))
-      @script = CEML.parse(:script, script_text)
-      @id     = id
-    end
-
-    def players
-      @players ||= CEML.delegate.players(@id) || {}
+    def initialize(script, cast = {}, id = rand(36**10).to_s(36))
+      @id = id
+      @script = Script === script ? script : CEML.parse(:script, script)
+      run do
+        cast.each{ |guy,role| add guy, role }
+      end
     end
 
     def add(id, *roles)
       obj = Hash === roles[-1] ? roles.pop : {}
-      players[id] = obj.merge :roles => Set.new(roles)
+      @players[id] = obj.merge :roles => Set.new(roles)
     end
 
     def run
-      :loop while players.keys.any? do |@current_id|
-        # puts "trying: #{@current_id}: #{seq[pc]}"
-        next unless seq[pc] and send(*seq[pc])
-        CEML.delegate.send(*seq[pc] + [@iid, @current_id])
-        this[:pc]+=1
+      CEML.delegate.with_players(@id) do |players|
+        @players = players
+        yield self if block_given?
+        :loop while players.keys.any? do |@current_id|
+          # puts "seq for roles: #{roles.inspect} #{seq.inspect}"
+          # puts "trying: #{@current_id}: #{seq[pc]}"
+          next unless seq[pc] and send(*seq[pc])
+          CEML.delegate.send(*seq[pc] + [@iid, @current_id])
+          this[:pc]+=1
+        end
+        @players = nil
       end
     end
 
@@ -68,7 +73,7 @@ module CEML
     def expand(role, var)
       role = nil if role == 'otherguy'
       role = role.to_sym if role
-      players.each do |key, thing|
+      @players.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
@@ -81,7 +86,7 @@ module CEML
     # ==============
 
     def start
-      roles.include? :agent or return false
+      # roles.include? :agent or return false
       true
     end
 

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

@@ -1,9 +1,13 @@
 module CEML
-  module Instructions
+  module InstructionStatements
     def list
         [instruction_stmt] + more.elements.map(&:instruction_stmt)
     end
 
+    def instructions
+      self
+    end
+
     def validate_instructions!(allowed_roles)
       extra_roles = roles - allowed_roles
       raise "unrecognized rolenames: #{extra_roles.inspect}" unless extra_roles.empty?

data/lib/ceml/script.rb

@@ -8,23 +8,13 @@ module CEML
     # = casting =
     # ===========
 
-    def locations
-      @locations ||= (delegate.locations(self) || [])
-    end
-
-    def launchable_location
-      criteria = awaited_criteria.sort_by{ |c| [-c.complexity, c.min_match] }
-      locations.find do |l|
-        people_used = []
-        criteria.all?{ |c| folks = l[c.hash] and c.satisfied_by_group?(folks, people_used) }
-      end
-    end
-
     # public
     def post candidate
-      criteria = awaited_criteria.select{ |c| c =~ candidate }
-      criteria.each{ |c| c.list_candidate(candidate) }
-      not criteria.empty?
+      return unless candidate = candidate.dup.load(awaited_criteria)
+      delegate.with_locations(self) do |locs|
+        locs.each{ |l| l.push candidate }
+        locs << CastingLocation.create(self, candidate) if locs.none?(&:added)
+      end
     end
 
     def awaited_criteria
@@ -115,8 +105,8 @@ module CEML
     # ================
 
     def instructions
-      return super if defined?(super)
       return self if Instructions === self
+      return super if defined?(super)
       nil
     end
 

data/lib/ceml/tt/casting.treetop

@@ -34,8 +34,14 @@ grammar Casting
     rule role
       (rolename &and / range ws qualifier ws rolename / range ws rolename / qualifier ws rolename / rolename) {
         def name; if respond_to? :rolename then rolename.text_value else text_value end; end
-        def min;  if respond_to? :range then range.min else 2 end; end
-        def max;  if respond_to? :range then range.max else 10000 end; end
+        def min
+            return range.min if respond_to? :range
+            name =~ /s$/ ? 2 : 1
+        end
+        def max
+            return range.max if respond_to? :range
+            name =~ /s$/ ? 10000 : 1
+        end
         def qualifiers
             return [qualifier.text_value] if respond_to? :qualifier
             return []

data/lib/ceml/tt/scripts.treetop

@@ -40,7 +40,7 @@ grammar Scripts
   end
 
   rule instructions
-      instruction_stmt more:(nl instruction_stmt)* <Instructions>
+      instruction_stmt more:(nl instruction_stmt)* <InstructionStatements>
   end
 
 end

data/lib/ceml.rb

@@ -1,22 +1,22 @@
 require 'forwardable'
 require 'treetop'
 
-require 'ceml/casting'
-require 'ceml/instructions'
 require 'ceml/script'
+require 'ceml/casting_statement'
+require 'ceml/instruction_statements'
 require 'ceml/tt/lexer'
 require 'ceml/tt/casting'
 require 'ceml/tt/instructions'
 require 'ceml/tt/scripts'
 
+require 'ceml/delegate'
 require 'ceml/casting_criterion'
 require 'ceml/incident'
 
 module CEML
   extend self
   attr_accessor :delegate
-  @delegate = Class.new{ def method_missing(meth, *args, &blk);end }.new
-  # puts "#{meth}: #{args.to_s.inspect}"
+  @delegate = Delegate.new
 end
 
 module CEML

data/test/helper.rb

@@ -6,31 +6,47 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'ceml'
 
 class Test::Unit::TestCase
-  def play script
-    @e = CEML::Incident.new(script)
+  def play script = nil
+    @e = CEML::Incident.new(script) if script
+    yield
+    CEML::Delegate::PLAYERS.clear
   end
 
   def player id, *roles
-    @e.add id, *roles
-    @e.run
+    @e.run do |script|
+      script.add id, *roles
+    end
   end
 
   def asked id, rx
-    p = @e.players[id]
+    assert g = CEML::Delegate::PLAYERS.values.find{ |game| game[id] }
+    p = g[id]
     assert_equal :ask, p[:said]
     assert_match rx, p[:q]
     p.delete :said
   end
 
+  def silent id
+    if g = CEML::Delegate::PLAYERS.values.find{ |game| game[id] }
+      p = g[id]
+      assert !p[:msg]
+    end
+  end
+
   def told id, rx
-    p = @e.players[id]
+    assert g = CEML::Delegate::PLAYERS.values.find{ |game| game[id] }
+    p = g[id]
     assert_match rx, p[:msg]
     p.delete :said
   end
 
   def says id, str
-    @e.players[id][:received] = str
-    @e.run
-    @e.players[id][:received] = nil
+    @e.run do |incident|
+      incident.players[id][:received] = str
+    end
+
+    CEML.delegate.with_players(@e.id) do |players|
+      players[id][:received] = nil
+    end
   end
 end

data/test/test_incident.rb

@@ -20,36 +20,64 @@ XXX
 
 class TestIncident < Test::Unit::TestCase
 
-  SIGNUP_SCRIPT = "await 1 new signup\ntell signup: thanks"
-  def test_signup_script
-    s = CEML.parse(:script, SIGNUP_SCRIPT)
-    c = CEML::Candidate.new('fred', ['new'], {}, nil, nil)
-    s.post c
-    assert s.launchable_location
+  def test_signup_1
+    s = CEML.parse(:script, "await 1 new signup\ntell signup: thanks")
+    play do
+      s.post CEML::Candidate.new('fred', ['new'], {})
+      told 'fred', /thanks/
+    end
+  end
+
+  def test_signup_2
+    s = CEML.parse(:script, "await 2 new signups\ntell signups: thanks")
+    play do
+      s.post CEML::Candidate.new('fred', ['new'], {})
+      silent 'fred'
+      s.post CEML::Candidate.new('wilma', ['old'], {})
+      silent 'fred'
+      s.post CEML::Candidate.new('betty', ['new'], {})
+      told 'fred', /thanks/
+    end
+  end
+
+  def test_await
+    s = CEML.parse(:script, "await a,b,c\ntell a: foo\ntell b: bar\ntell c: baz")
+    play do
+      s.post CEML::Candidate.new('fred', [], {})
+      silent 'fred'
+      s.post CEML::Candidate.new('wilma', [], {})
+      silent 'fred'
+      silent 'wilma'
+      s.post CEML::Candidate.new('betty', [], {})
+      told 'fred', /foo/
+      told 'betty', /baz/
+    end
   end
 
   def test_incident
-    play COMPLIMENT_SCRIPT
-    player :joe, :organizer, :agent
-    player :bill, :agent
+    play COMPLIMENT_SCRIPT do
+      player :joe, :organizer, :agent
+      player :bill, :agent
 
-    asked :joe, /^Describe/
-    says :joe, 'red people'
+      asked :joe, /^Describe/
+      says :joe, 'red people'
 
-    told :bill, /^Look for red people/
+      told :bill, /^Look for red people/
+    end
   end
 
   def test_askchain
-    play ASKCHAIN_SCRIPT
-    player :joe, :players, :agent
-    player :bill, :players, :agent
-
-    asked :joe,  /favorite color/
-    asked :bill, /favorite color/
-    says :joe, "red"
-    says :bill, "green"
-    asked :joe, /with the color green/
-    asked :bill, /with the color red/
+    play ASKCHAIN_SCRIPT do
+      player :joe, :players, :agent
+      player :bill, :players, :agent
+
+      asked :joe,  /favorite color/
+      asked :bill, /favorite color/
+      says :joe, "red"
+      says :bill, "green"
+      asked :joe, /with the color green/
+      asked :bill, /with the color red/
+    end
   end
 
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 1
-  version: 0.3.1
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Joe Edelman
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-26 00:00:00 -08:00
+date: 2011-01-09 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -53,11 +53,13 @@ files:
 - examples/breakfast-exchange.ceml
 - examples/citizen-investigation.ceml
 - examples/high-fives.ceml
+- examples/sample_delegate.rb
 - lib/ceml.rb
-- lib/ceml/casting.rb
 - lib/ceml/casting_criterion.rb
+- lib/ceml/casting_statement.rb
+- lib/ceml/delegate.rb
 - lib/ceml/incident.rb
-- lib/ceml/instructions.rb
+- lib/ceml/instruction_statements.rb
 - lib/ceml/script.rb
 - lib/ceml/tt/casting.treetop
 - lib/ceml/tt/instructions.treetop