activefacts 0.6.0

data/lib/activefacts/cql.rb

@@ -0,0 +1,31 @@
+#
+# ActiveFacts CQL loader.
+# Copyright (c) 2007 Clifford Heath. Read the LICENSE file.
+#
+require 'rubygems'
+require 'polyglot'
+require 'activefacts/support'
+require 'activefacts/input/cql'
+require 'activefacts/generate/ruby'
+
+module ActiveFacts
+  # Extend the generated parser:
+  class CQLLoader
+    # This load method for Polyglot tells it how to _require_ a CQL file.
+    # The CQL file is parsed to a vocabulary constellation, which is generated
+    # to Ruby code and eval'd, making the generated classes available.
+    def self.load(file)
+      debug "Loading #{file}" do
+        vocabulary = ActiveFacts::Input::CQL.readfile(file)
+
+        ruby = StringIO.new
+        @dumper = ActiveFacts::Generate::RUBY.new(vocabulary.constellation)
+        @dumper.generate(ruby)
+        ruby.rewind
+        eval ruby.read, ::TOPLEVEL_BINDING
+      end
+    end
+  end
+
+  Polyglot.register('cql', CQLLoader)
+end

data/lib/activefacts/cql/CQLParser.treetop

@@ -0,0 +1,104 @@
+module ActiveFacts
+  grammar CQL
+    include LexicalRules
+    include Language        # One of the language modules provides this module
+    include Expressions
+    include Concepts
+    include DataTypes
+    include FactTypes
+
+    rule cql_file
+      s seq:definition*
+      {
+        def definitions
+          seq.elements.map{|e|
+              e.value rescue $stderr.puts "Can't call value() on #{e.inspect}"
+            }
+        end
+      }
+    end
+
+    # Each definition has a value() method that returns an array like
+    # either [name, [kind, definition]] or [name, kind]:
+    rule definition
+      vocabulary_definition
+      / import_definition
+      / constraint
+      / concept
+    end
+
+    rule vocabulary_definition
+      s vocabulary S id s ';' s
+      {
+        def value
+          [ id.text_value, [ :vocabulary ] ]
+        end
+      }
+    end
+
+    rule import_definition
+      s import S id alias_list ';' s
+      {
+        def value
+          puts "import #{id.text_value}: not implemented"
+          [ id.text_value, [ :import ], alias_list.value ]
+        end
+      }
+    end
+
+    # REVISIT: Need a way to define equivalent readings for fact types here (and in the metamodel)
+    rule alias_list
+      ( s ',' s alias S aliase_from:id S as S alias_to:id s )*
+      {
+        def value
+          elements.inject({}){|h, e| h[e.aliase_from.text_value] = e.alias_to; h }
+        end
+      }
+    end
+
+    rule constraint
+      subset_constraint /
+      equality_constraint /
+      set_constraint /
+      presence_constraint
+      # REVISIT: / value_constraint
+    end
+
+    # presence constraint:
+    rule presence_constraint
+      s 'each' s ('combination' S)? role_list s 'occurs' s quantifier s 'time' s 'in' s
+      readings_list s
+      ';' s
+      { def value; [ nil, [ :constraint, :presence, role_list.roles, quantifier.value, readings_list.value ] ]; end }
+    end
+
+    rule subset_constraint
+      s readings s only s if s r2:readings s ';' s
+      { def value; [ nil, [ :constraint, :subset, readings.value, r2.value ] ]; end }
+    end
+
+    # set (exclusion, mandatory exclusion, complex equality) constraint
+    rule set_constraint
+      s 'for' s 'each' s role_list s quantifier s 'of' s 'these' s 'holds' s ':' s
+      readings_list s
+      ';' s
+      { def value; [ nil, [ :constraint, :set, role_list.roles, quantifier.value, *readings_list.value ] ]; end }
+    end
+
+    rule equality_constraint
+      s readings s tail:( if s and s only s if s readings s)+ ';' s
+      { def value; [ nil, [ :constraint, :equality, *([readings.value] + tail.elements.map{|e| e.readings.value }) ] ]; end }
+    end
+
+    rule readings_list
+      readings tail:( ',' s readings )*
+      { def value; [readings.value]+tail.elements.map{|e| e.readings.value }; end }
+    end
+
+    rule readings
+      reading s tail:( and s reading s )*
+      { def value; [reading.value]+tail.elements.map{|e| e.reading.value }; end }
+    end
+
+  end
+end

data/lib/activefacts/cql/Concepts.treetop

@@ -0,0 +1,112 @@
+module ActiveFacts
+  module CQL
+    grammar Concepts
+      rule concept
+        entity_type
+        / data_type
+        / named_fact_type
+        / anonymous_fact_type
+      end
+
+      rule entity_type
+        s name:id s
+        sup:(basetype / subtype)
+        ec:entity_conditions?
+        ';' s
+        {
+          def value
+            [ name.text_value, [ :entity_type, sup.supers, sup.identifier, ec.empty? ? nil : ec.conditions ] ]
+          end
+        }
+      end
+
+      rule subtype
+        subtype_prefix supertype_list ident:identification?
+        {
+          def supers; supertype_list.value; end
+          def identifier; ident.empty? ? nil : ident.value; end
+        }
+      end
+
+      rule supertype_list
+        primary:id s
+        alternate_supertypes:( ',' s !identified_by name:id s )*
+        { def value
+            [primary.text_value]+alternate_supertypes.elements.map{|sup| sup.name.text_value}
+          end
+        }
+      end
+
+      rule basetype
+        is s identification
+        { def supers; [] end
+          def identifier; identification.value; end
+        }
+      end
+
+      rule identification
+	# REVISIT: Consider distinguishing "-Id" from just "Id", and not prepending the entity type name if no "-"
+        identified_by its s id s	  # Reference Mode
+	  { def value; {:mode => id.text_value }; end }
+	/
+        identified_by role_list
+	  { def value; {:roles => role_list.roles }; end }
+      end
+
+      # Identified by roles... also used for constraints, beware
+      rule role_list 
+        head:role_player s tail:( ( and S / ',' s ) role:role_player s )*
+        {
+          def roles
+            [head.value] + tail.elements.map{|i| i.role.value}
+          end
+        }
+      end
+
+          # We can't tell which word is an adjective and which is a concept here.
+          # The concept might be forward-referenced, but not if adjectives are used.
+          # REVISIT: This accepts double-adjective expressions (three words) but they don't work elsewhere
+	  rule lead_adj
+	    role_player_id '-'
+	  end
+
+	  rule trail_adj
+	    '-' role_player_id
+	  end
+
+	  rule role_player
+	    l:lead_adj? tail:(s role_player_id)+ s t:trail_adj?
+	    {
+	      def value
+		(l.empty? ? [] : [l.role_player_id.text_value]) +
+		tail.elements.map{|e| e.role_player_id.text_value } +
+		(t.empty? ? [] : [t.role_player_id.text_value])
+	      end
+	    }
+	  end
+
+          rule role_player_id
+            !(role_list_sep / quantifier) id
+          end
+
+          rule role_list_sep
+            (where / and / 'occurs')
+          end
+
+          rule reference_mode
+            # REVISIT: Adopt ORM2-style reference mode patterns here
+            '(' s '.' s mode_name:id s ')' s
+          end
+
+      rule entity_conditions
+        (':' / where) s c:conditions?
+        {
+          def conditions
+            c.empty? ? [] : c.condition_list
+          end
+        }
+      end
+
+    end
+  end
+end

data/lib/activefacts/cql/DataTypes.treetop

@@ -0,0 +1,66 @@
+module ActiveFacts
+  module CQL
+    grammar DataTypes
+      rule data_type
+        s name:id
+        ( s '=' s / defined_as )
+        base:id s
+        '(' s tpl:type_parameter_list? ')' s
+        u0:(!restricted u1:unit s)?
+        r:restriction?
+        s ';' s
+        {
+          def defined_type
+            [
+              :data_type,
+              base.text_value,
+              tpl.empty? ? [] : tpl.value,
+              !u0.empty? ? u0.u1.text_value : nil,
+              !r.empty? ? r.ranges : [],
+            ]
+          end
+
+          def value
+            [ name.text_value,
+              defined_type
+            ]
+          end
+        }
+      end
+
+      rule type_parameter_list
+        head:number s tail:( ',' s number s )*
+        {
+          def value
+            [head.value] + tail.elements.map{|i| i.number.value}
+          end
+        }
+      end
+
+      rule unit
+        unit_name:id ('^' '-'? [0-9])?
+      end
+
+      rule restriction
+        restricted s to s range_list s unit?
+        {
+          def ranges
+            range_list.ranges
+          end
+        }
+      end
+
+      rule range_list
+        '{' s
+          head:range s tail:( ',' s range )*
+        '}' s
+        {
+          def ranges
+            [head.value] + tail.elements.map{|e| e.range.value }
+          end
+        }
+      end
+
+    end
+  end
+end

data/lib/activefacts/cql/Expressions.treetop

@@ -0,0 +1,113 @@
+module ActiveFacts
+  module CQL
+    grammar Expressions
+      rule comparison
+        e1:expression s comparator s e2:expression
+        {
+          def body
+            [ comparator.text_value,
+              e1.value,
+              e2.value
+            ]
+          end
+        }
+      end
+
+      rule comparator
+        '<=' / '<' / '=' / '>=' / '>'
+        # REVISIT: These words occur in readings, find alternates:
+        # / matches / includes
+      end
+
+      rule expression
+        sum
+      end
+
+      rule sum
+        t0:term s tail:( o:add_op s t1:term s )*
+        {
+          def value
+            return t0.value if tail.empty?
+            [ :"+",
+              *([t0.value] +
+                tail.elements.map{|e|
+                    e.o.text_value == '-' ? [ :"-", e.t1.value ] : e.t1.value
+                  }
+              )
+            ]
+          end
+        }
+      end
+
+      rule add_op
+        '+' / '-'
+      end
+
+      rule term
+        f0:factor s tail:( o:mul_op s f1:factor s )*
+        {
+          def value
+            return f0.value if tail.empty?
+            [ :"*",
+              *([f0.value] +
+                tail.elements.map{|e|
+                    e.o.text_value != '*' ? [ :"-", e.f1.value ] : e.f1.value
+                  }
+              )
+            ]
+          end
+        }
+      end
+
+      rule factor
+        literal u:unit? s
+            { def value
+                u.empty? ? literal.value : [ literal.value, u.text_value ]
+              end
+            }
+        / derived_variable
+        / '(' s sum s ')' s                   { def value; sum.value; end }
+      end
+
+      rule derived_variable
+        variable s p:function_call*
+        {
+          def value
+            r = variable.value
+            # Apply the function_call operators in order:
+            p.elements.each{|p| r = [ p.value, r ] }
+            r
+          end
+        }
+      end
+
+      rule variable
+        id0:id o0:( !defined_as s id1:id )?
+        {
+          def value
+            # Variable names may consist of one or two words (optional adjective and a noun):
+            r = [ :variable, id0.text_value ]
+            r += [ o0.id1.text_value ] unless o0.empty?
+            r
+          end
+        }
+      end
+
+      rule function_call
+        '.' s func:id s param_list:( '(' s params:( p0:expression s tail:( ',' s p1:expression s )* )? ')' s )?
+        {
+          def value
+            r = [ :"(", func.text_value ]
+            return r if param_list.empty? || param_list.params.empty?
+            r += [ param_list.params.p0.value ]
+            param_list.params.tail.elements.each{|e|
+                r += [ e.p1.value ]
+              }
+            r
+          end
+        }
+      end
+
+    end
+  end
+end

data/lib/activefacts/cql/FactTypes.treetop

@@ -0,0 +1,185 @@
+module ActiveFacts
+  module CQL
+    grammar FactTypes
+      rule named_fact_type
+        s name:id ( s '=' s / defined_as / s is s where )
+        anonymous_fact_type
+        {
+          def value
+            f = anonymous_fact_type.value
+            f[0] = name.text_value
+            f
+          end
+        }
+      end
+
+      rule anonymous_fact_type
+        f0:fact_clause
+          ftail:( (',' / and ) s f1:fact_clause s )*
+          ctail:( (':' / where) s c:conditions s)?
+          returning_clause?
+        s ';' s
+        {
+          def value
+            [
+              nil,    # Anonymous fact type
+              [
+                :fact_type,
+                [ f0.body, *ftail.elements.map{|e| e.f1.body } ],
+                !ctail.empty? ? ctail.c.condition_list : []
+              ]
+            ]
+          end
+        }
+      end
+
+      rule returning_clause
+        returning return (',' return)*
+      end
+
+      rule return
+        by order 'REVISIT: return'
+      end
+
+      rule conditions
+        head:condition s tail:( (',' s / and S) next:condition s )*
+        {
+          def condition_list
+            [head.value] + tail.elements.map{|i| i.next.value}
+          end
+        }
+      end
+
+      rule condition
+        head:clause s
+#        tail:(or S alternate:clause s )*
+        {
+          def value
+#            if tail.elements.size == 0
+              head.clause
+#            else
+#              [:"||", head.clause] + tail.elements.map{|i| i.alternate.clause}
+#            end
+          end
+        }
+      end
+
+      rule clause
+        (comparison / fact_clause)
+        {
+          def clause
+            self.body
+          end
+        }
+      end
+
+      rule fact_clause
+        s q:qualifier? s reading s p:post_qualifiers? s
+        {
+          def body
+            [ :fact_clause,
+              (q.empty? ? [] : [ q.text_value ]) +
+                (p.empty? ? [] : p.list),
+              reading.value
+            ]
+          end
+        }
+      end
+
+      rule qualifier
+        maybe / definitely
+      end
+
+      rule post_qualifiers
+        '[' s q0:post_qualifier tail:( s ',' s q1:post_qualifier )* s ']' s
+        {
+          def list
+            [q0.text_value] + tail.elements.map{|e| e.q1.text_value}
+          end
+        }
+      end
+
+      rule post_qualifier
+        static / transient / intransitive / transitive / acyclic / symmetric
+      end
+
+      rule reading
+        subtype_invocation
+        /
+        role+
+        {
+          def value
+            elements.map{|r| r.value}
+          end
+        }
+      end
+
+      # REVISIT: This allows invocation from subtype to supertype. We need the reverse as well (Employee is a Manager).
+      # Now that subtyping fact types have readings created during compilation, perhaps these custom rules can be removed?
+      rule subtype_invocation
+        (('some'/'that') S)? subtype:id s subtype_prefix (('some'/'that') S)? supertype:id
+        {
+          def value
+            [{:subtype => subtype.text_value, :supertype => supertype.text_value }]
+            # [subtype.text_value, "is", "a", "subtype", "of", supertype.text_value].map{|w| {:word => w}}
+          end
+        }
+      end
+
+      # This is the rule that causes most back-tracking. I think you can see why.
+      # When we have an expression, we will come down here perhaps multiple times,
+      # but find no way out as soon as we hit the trailing non_role.
+      rule role
+        q:quantifier?
+        adj0:(a:role_word '-' s)?
+        player:role_word !'-' s?
+        adj1:( '-' a:(a:role_word s)? )?
+        func:function_call?
+        role_name:( '(' s as S r:id s ')' s )?
+        lr:( literal / restriction )?
+        !non_role
+        {
+          def value
+            r = {}
+            quantifier = !q.empty? && q.value   # "some" quantifier has nil value
+
+            r[:quantifier] = quantifier if quantifier
+            r[:leading_adjective] = adj0.a.text_value unless adj0.empty?
+
+            r[:word] = player.text_value
+
+            r[:trailing_adjective] = adj1.a.a.text_value unless adj1.empty?
+            r[:function] = func.value if !func.empty?
+            r[:role_name] = role_name.r.text_value unless role_name.empty?
+            r[:restriction] = lr.ranges if !lr.empty? && lr.respond_to?(:ranges)
+            r[:literal] = lr.value if !lr.empty? && lr.respond_to?(:value)
+
+            r
+          end
+        }
+      end
+
+      rule non_role
+        # Any of these is illegal in or following a reading:
+        comparator
+        / add_op
+        / mul_op
+      end
+
+      rule role_word
+        !non_role_word id
+      end
+
+      rule non_role_word
+        # These words are illegal in (but maybe ok following) a reading where a role word is expected:
+        and
+        / if
+        / only
+        / or
+        / quantifier
+        / restriction
+      end
+
+    end
+  end
+end