ceml 0.3.0 → 0.3.1

data/.gitignore

@@ -1,3 +1,5 @@
+lib/ceml/tt/*.rb
+
 ## MAC OS
 .DS_Store
 

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.3.1

data/beginners-guide.md

@@ -6,11 +6,11 @@ Thanks for taking an interest in CEML, the Coordinated Event Modeling Language.
 A CEML _script_ is a recipe for action.  Just like a recipe, it has three parts: a title, a list of ingredients, and then a section that says what to do with the ingredients.  Here's an example:
 
     "Trade favorite colors"
-    gather 1 answerer and 1 listener within 50 feet
-    ask answerer re favorite_color:
+    gather 1 guy and 1 girl within 50 feet
+    ask guy re favorite_color:
         What's your favorite color?
-    tell listener:
-        Someone nearby likes the color |answerer.favorite_color|.  Find them.
+    tell girl:
+        Someone nearby likes the color |guy.favorite_color|.  Find them.
 
 In the example, the first line is the title, which is written in double quotes.  The second line is the ingredients and how they are obtained.  In CEML, the ingredients are usually people (although sometimes they can be places, things, or notes).  The remaining lines are the instructions.
 
@@ -26,7 +26,7 @@ Whether you write a script compactly with short names for roles and answers or l
 Commands
 --------
 
-The above script only uses three CEML commands—*gather*, *ask*, and *tell*—but there aren't many more commands to learn.  Only four more, actually: besides *gather*, the other ingredients commands are *await* and *nab*.  Besides *ask* and *tell*, the other instructions commands are *assign* and *certify*.
+The above script only uses three CEML commands--*gather*, *ask*, and *tell*--but there aren't many more commands to learn.  Only four more, actually: besides *gather*, the other ingredients commands are *await* and *nab*.  Besides *ask* and *tell*, the other instructions commands are *assign* and *certify*.
 
 As a sneak preview, here's an example that uses the other commands:
 
@@ -65,7 +65,7 @@ Texts may also contain hyperlinks, which if the player has a smartphone with a w
 Roles
 -----
 
-In the examples so far, the words like 'enemy', 'reporter', 'answerer', 'listener', 'a', 'b', 'signup', 'patient', and 'doctor' are *role names*.  Most of the time, a role name can be any word you like.  They are just a placeholder to connect *casting commands* like *gather* and *await*, with *coordination commands* like *tell*.
+In the examples so far, the words like 'enemy', 'reporter', 'guy', 'girl', 'a', 'b', 'signup', 'patient', and 'doctor' are *role names*.  Most of the time, a role name can be any word you like.  They are just a placeholder to connect *casting commands* like *gather* and *await*, with *coordination commands* like *tell*.
 
 Squads on Groundcrew, however, can define special meanings for certain roles.  So on a particular squad, a 'doctor' might mean someone who's been tagged/certified with the tag 'doctor', and a patient might mean anyone else.
 
@@ -120,7 +120,7 @@ Choosing Players: Await, Gather, and Nab.
 
 So what is really the difference between *await*, *gather*, and *nab*, you may be asking?  Or perhaps you have already figured it out.
 
-*Await* defines a kind of trigger—as soon as the conditions awaited for are met, the script will run.
+*Await* defines a kind of trigger--as soon as the conditions awaited for are met, the script will run.
 
     await 2-5 level1 players within 50ft
     assign: shout out "woo-hoo!"

data/ceml.gemspec

@@ -0,0 +1,78 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ceml}
+  s.version = "0.3.1"
+
+  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.description = %q{a language for coordinating real world events}
+  s.email = %q{joe@citizenlogistics.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "Makefile",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "beginners-guide.md",
+     "ceml.gemspec",
+     "editors/CEML.tmbundle/Syntaxes/ceml.tmLanguage",
+     "editors/CEML.tmbundle/info.plist",
+     "examples/breakfast-exchange.ceml",
+     "examples/citizen-investigation.ceml",
+     "examples/high-fives.ceml",
+     "lib/ceml.rb",
+     "lib/ceml/casting.rb",
+     "lib/ceml/casting_criterion.rb",
+     "lib/ceml/incident.rb",
+     "lib/ceml/instructions.rb",
+     "lib/ceml/script.rb",
+     "lib/ceml/tt/casting.treetop",
+     "lib/ceml/tt/instructions.treetop",
+     "lib/ceml/tt/lexer.treetop",
+     "lib/ceml/tt/scripts.treetop",
+     "test/helper.rb",
+     "test/test_casting.rb",
+     "test/test_incident.rb",
+     "test/test_instructions.rb",
+     "test/test_scripts.rb",
+     "try"
+  ]
+  s.homepage = %q{http://github.com/citizenlogistics/ceml}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{a language for coordinating real world events}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_casting.rb",
+     "test/test_incident.rb",
+     "test/test_instructions.rb",
+     "test/test_scripts.rb",
+     "examples/sample_delegate.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<treetop>, [">= 0"])
+    else
+      s.add_dependency(%q<treetop>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<treetop>, [">= 0"])
+  end
+end
+

data/examples/sample_delegate.rb

@@ -0,0 +1,4 @@
+class CEMLDelegate
+  def locations(script)
+  end
+end

data/lib/ceml/casting.rb

@@ -1,52 +1,34 @@
 module CEML
   module CastingStatement
     extend Forwardable
-    def_delegators :roles_phrase, :roles, :[], :min
+    def_delegators :roles, :names, :[], :min
+    alias_method :rolenames, :names
+
+    def criteria(script)
+      return [] unless type == :await
+      group_by = if radius then [:city] else [] end
+      criteria_by_qualifiers = Hash.new do |h,k|
+        h[k] = CastingCriterion.new(script, k, [], group_by, radius, {})
+      end
+
+      roles.list.each{ |r| criteria_by_qualifiers[r.qualifiers].role_counts[r.name] = r.min }
+      criteria_by_qualifiers.values
+    end
 
     def type
       elements.first.text_value.split.first.to_sym
     end
 
     def max
-      in_teams? ? 10000 : roles_phrase.max
+      roles.max
     end
 
     def radius
-      within.empty? ? 1600 * 50 : within.distance.meters
-    end
-
-    def in_teams?
-      type == :teams
+      within_phrase.empty? ? 1600 * 50 : within_phrase.distance.meters
     end
 
     def nab?
       type == :nab
     end
   end
-
-
-  module CastingRoles
-    def role_nodes
-      return [role] if more_roles.empty?
-      return [role] + more_roles.roles_phrase.role_nodes
-    end
-
-    def roles
-      role_nodes.map{ |r| r.name.to_sym }
-    end
-
-    def [](x)
-      role_nodes.detect{ |r| r.name.to_sym == x }
-    end
-
-    def min
-      role_nodes.map(&:min).inject(0, &:+)
-    end
-
-    def max
-      role_nodes.map(&:max).inject(0, &:+)
-    end
-  end
-
-
 end

data/lib/ceml/casting_criterion.rb

@@ -0,0 +1,39 @@
+require 'geokit'
+require "forwardable"
+
+module CEML
+  class Candidate < Struct.new :uid, :tags, :matchables, :lat, :lng
+    include Geokit::Mappable
+  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
+
+    def =~(candidate)
+      (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 }
+    end
+  end
+end

data/lib/ceml/instructions.rb

@@ -1,29 +1,30 @@
 module CEML
   module Instructions
-    def validate!(allowed_roles)
+    def list
+        [instruction_stmt] + more.elements.map(&:instruction_stmt)
+    end
+
+    def validate_instructions!(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
+      list.map{ |s| s.role.to_sym }.uniq
     end
 
     def for(roles)
-      elements.select{ |s| roles.include?(s.role.to_sym) }
+      list.select{ |s| roles.include?(s.role.to_sym) }
     end
 
-    def asks(roles)
-      elements.select do |s|
+    def i_asks(roles)
+      list.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) }
+    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

data/lib/ceml/script.rb

@@ -1,41 +1,100 @@
 module CEML
   module Script
+    extend Forwardable
+    attr_writer :delegate
+    def delegate; @delegate || CEML.delegate; end
 
-    def to_hash *fields
-      fields.inject({}){ |h, s| x = send(s); h[s] = x if x; h }
+    # ===========
+    # = casting =
+    # ===========
+
+    def locations
+      @locations ||= (delegate.locations(self) || [])
     end
 
-    def script
-      text_value
+    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
 
-    def title
-      super && !super.empty? && super.value
+    # public
+    def post candidate
+      criteria = awaited_criteria.select{ |c| c =~ candidate }
+      criteria.each{ |c| c.list_candidate(candidate) }
+      not criteria.empty?
     end
 
-    def name
-      title || label
+    def awaited_criteria
+      return [] unless cast.type == :await
+      return cast.criteria(self)
     end
 
-    def radius
-      casting_statement.empty? ? nil : casting_statement.radius
+
+    # ===============
+    # = likelihoods =
+    # ===============
+
+    def color(odds)
+      return :red    if odds < 0.1
+      return :yellow if odds < 0.4
+      return :green
     end
 
-    def roles
-      return [:agents] if casting_statement.empty?
-      return casting_statement.roles
+    def likelihood(yesprob, needed, psize)
+      return 1 if needed <= 0
+      return 0 if psize < needed
+      return (needed..psize).inject(0) do |memo, yes_count|
+        memo + begin
+          no_count = psize - yes_count
+          ways_it_could_happen = psize.choose(yes_count)
+          prob_of_each = (yesprob ** yes_count) * ((1 - yesprob) ** no_count)
+          ways_it_could_happen * prob_of_each
+        end
+      end
     end
 
-    def dramatis_personae
-      casting_statement.empty? ? nil : casting_statement
+    def availabilities(potential_count, committed_count = 0)
+      return {} unless script.dramatis_personae
+      min        = script.dramatis_personae.min
+      needed     = min - committed_count
+      possible   = potential_count + committed_count
+      yesprob    = 0.7  # just make this up for now
+      odds       = likelihood(yesprob, needed, potential_count)
+
+      {
+        :odds => odds, :color => color(odds),
+        :availability_counts => {
+          :total => possible,
+          :unknown => potential_count
+        },
+        :estimated_size => yesprob * potential_count + committed_count,
+        :needed => min
+      }
     end
 
-    def max_to_invite
-      dramatis_personae ? dramatis_personae.max : 0
+
+    # ========
+    # = cast =
+    # ========
+
+    DefaultDP = Struct.new :radius, :rolenames, :max, :type
+
+    def cast
+      return casting_statement if respond_to? :casting_statement
+      return DefaultDP.new nil, [:agents], 0, :nab
     end
 
+    def_delegators :cast, :radius
+    def_delegator :cast, :max, :max_to_invite
+    def_delegator :cast, :rolenames, :roles
+    alias_method :dramatis_personae, :cast
     alias_method :dp, :dramatis_personae
 
+    # casting_statement.roles.names
+
     def simple?
       (roles - [:agents, :organizer]).empty?
     end
@@ -44,14 +103,71 @@ module CEML
       roles.map{ |r| r == :agent ? [:agent, :agents] : r }.flatten.concat([:both, :all, :everyone])
     end
 
+    def allowed_roles
+      allowed_roles = [:organizer, :agents]
+      allowed_roles += cast.rolenames
+      allowed_roles.uniq
+    end
+
+
+    # ================
+    # = instructions =
+    # ================
+
+    def instructions
+      return super if defined?(super)
+      return self if Instructions === self
+      nil
+    end
+
     def instructions_for(roles)
-      return [] if !instructions or instructions.empty?
+      return [] unless instructions
       return instructions.for(expand_roles(roles))
     end
 
     def asks(roles)
-      return [] if instructions.empty?
-      instructions.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)
+    end
+
+    def concludes_immediately?
+      !title and instructions.asks([:agents]).empty?
+    end
+
+
+    # =======
+    # = etc =
+    # =======
+
+    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
+      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
@@ -60,11 +176,6 @@ module CEML
       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?
@@ -89,58 +200,5 @@ module CEML
         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
-
-    def color(odds)
-      return :red    if odds < 0.1
-      return :yellow if odds < 0.4
-      return :green
-    end
-
-    def likelihood(yesprob, needed, psize)
-      return 1 if needed <= 0
-      return 0 if psize < needed
-      return (needed..psize).inject(0) do |memo, yes_count|
-        memo + begin
-          no_count = psize - yes_count
-          ways_it_could_happen = psize.choose(yes_count)
-          prob_of_each = (yesprob ** yes_count) * ((1 - yesprob) ** no_count)
-          ways_it_could_happen * prob_of_each
-        end
-      end
-    end
-
-    def availabilities(potential_count, committed_count = 0)
-      return {} unless script.dramatis_personae
-      min        = script.dramatis_personae.min
-      needed     = min - committed_count
-      possible   = potential_count + committed_count
-      yesprob    = 0.7  # just make this up for now
-      odds       = likelihood(yesprob, needed, potential_count)
-
-      {
-        :odds => odds, :color => color(odds),
-        :availability_counts => {
-          :total => possible,
-          :unknown => potential_count
-        },
-        :estimated_size => yesprob * potential_count + committed_count,
-        :needed => min
-      }
-    end
-
   end
 end

data/lib/ceml/tt/casting.treetop

@@ -3,45 +3,42 @@ grammar Casting
     include Lexer
 
     rule casting_statement
-      casting_method ws roles_phrase within:(ws 'within' ws distance)? nl <CastingStatement>
+      ('gather' / 'await' / 'nab') ws roles within_phrase:within_phrase? <CastingStatement>
     end
 
-    rule casting_method
-        'gather' / 'teams of' / 'nab'
+    rule within_phrase
+        ws 'within' ws distance
     end
 
-    rule roles_phrase
-        role more_roles:(ws 'and' ws roles_phrase)? <CastingRoles>
+    rule roles
+        role more:(and role)* {
+            def list
+                [role] + more.elements.map{ |e| e.role }
+            end
+
+            def names; list.map{ |r| r.name.to_sym };         end
+            def [](x); list.detect{ |r| r.name.to_sym == x }; end
+            def min;   list.map(&:min).inject(0, &:+);        end
+            def max;   list.map(&:max).inject(0, &:+);        end
+        }
     end
 
-    rule distance
-      number ws? distance_unit:('miles' / 'mile' / 'mi' / 'km' / 'kilometers' / 'k' / 'meters' / 'm' / 'ft' / 'feet' / 'f' / 'blocks' / 'block')
-      {
-        def meters
-          number.text_value.to_f * case distance_unit.text_value
-          when /^mi/; 1600; when /^k/;  1000; when /^m/;  1;
-          when /^f/;  0.35; when /^b/;  200; else 1; end
-        end
-      }
+    rule qualifier
+        id
     end
 
-    rule role
-      range:range? ws? id
-      {
-        def name; id.text_value; end
-        def min;  range.empty? ? 2 : range.min; end
-        def max;  range.empty? ? 10000 : range.max; end
-      }
+    rule rolename
+        id
     end
 
-    rule range
-      min:number max:('+' / '-' number)?
-      {
-        def min; super.text_value.to_i; end
-        def max
-            return min if super.empty?
-            return 10000 if super.text_value == '+'
-            return super.number.text_value.to_i
+    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 qualifiers
+            return [qualifier.text_value] if respond_to? :qualifier
+            return []
         end
       }
     end

data/lib/ceml/tt/instructions.treetop

@@ -2,11 +2,7 @@ module CEML
 grammar Instructions
     include Lexer
 
-    rule instructions
-        instruction+ <Instructions>
-    end
-
-    rule instruction
+    rule instruction_stmt
         (ask_stmt / tell_stmt / assign_stmt) {
 
             INTERPOLATE_REGEX = /\|(\w+)\.?(\w+)?\|/
@@ -31,15 +27,15 @@ grammar Instructions
     end
 
     rule tell_stmt
-        'tell' ws id ':' ws? text nl
+        'tell' ws id ':' ws? text
     end
 
     rule assign_stmt
-        'assign' ws id ':' ws? text nl
+        'assign' ws id ':' ws? text
     end
 
     rule ask_stmt
-        'ask' ws id about:(ws 're' ws varname:id)? ':' ws? text nl
+        'ask' ws id about:(ws 're' ws varname:id)? ':' ws? text
     end
 
 end