ceml 0.7.13 → 0.8.0

data/lib/ceml/{tt → lang/tt}/lexer.treetop

@@ -13,14 +13,21 @@ grammar Lexer
       [ \t\f]+
     end
 
-    rule comment
-      '//' text
+    rule linebreak
+      ("\r" "\n"?) / "\n"
     end
 
     rule eol
-      ("\r" "\n"?) / "\n"
+        linebreak !ws
+    end
+
+    rule comment
+      '//' text
     end
 
+
+
+
     rule number
       ([1-9]+ [0-9]* / '0') {
           def value
@@ -45,8 +52,7 @@ grammar Lexer
       number ws? time_unit:('seconds' / 'second' / 's' / 'minutes' / 'minute' / 'min' / 'hours' / 'hour' / 'hr' / 'h')
       {
           def seconds
-              number.text_value.to_f * case time_unit.text_value
-              when /^h/; 60*60; when /^mi/; 60; else 1; end
+            CEML.dur(number.text_value.to_f, time_unit.text_value)
           end
       }
     end
@@ -65,12 +71,12 @@ grammar Lexer
     rule range
       (
           min:number '-' max:number / floor:number '+'? /
-          'an' / 'a' / 'one' / 'the' / 'some' / 'several' / 'many'
+          'an' / 'a' / 'one' / 'the' / 'some' / 'several' / 'many' / 'all'
       ) {
           def value
             case text_value
             when 'an', 'a', 'one', 'the' then (1..1)
-            when 'some'                  then (1..10000)
+            when 'some', 'all'           then (1..10000)
             when 'several'               then (3..10000)
             when 'many'                  then (5..10000)
             when /^\d+\+$/               then (floor.value..10000)
@@ -82,5 +88,62 @@ grammar Lexer
       }
     end
 
+    rule rolemap
+        mapped_role more:(and mapped_role)* {
+            def all; [mapped_role] + more.elements.map(&:mapped_role); end
+            def value; all.map(&:value); end
+        }
+    end
+
+    rule mapped_role
+        (rolename ws 'as' ws target_role:rolename / rolename '') {
+            def value
+                {
+                    :from => rolename.text_value,
+                    :to => respond_to?(:target_role) && target_role.text_value || '*'
+                }
+            end
+        }
+    end
+
+    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 qualifier
+        id
+    end
+
+    rule rolename
+        id
+    end
+
+    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
+            return range.value.min if respond_to? :range
+            name =~ /s$/ ? 2 : 1
+        end
+        def max
+            return range.value.max if respond_to? :range
+            name =~ /s$/ ? 10000 : 1
+        end
+        def qualifiers
+            return [qualifier.text_value] if respond_to? :qualifier
+            return []
+        end
+      }
+    end
+
 end
 end