activefacts 0.8.6 → 0.8.8

data/lib/activefacts/cql/compiler/shared.rb

@@ -0,0 +1,109 @@
+module ActiveFacts
+  module CQL
+    class Compiler < ActiveFacts::CQL::Parser
+
+      # In a declaration, a Binding has one or more RoleRef's.
+      # A Binding is for a single Concept, normally related to just one Role,
+      # and the references (RoleRefs) to it will normally be the concept name
+      # with the same adjectives (modulo loose binding),
+      # or a role name or subscript reference.
+      #
+      # In some situations a Binding will have some RoleRefs with the same adjectives,
+      # and one or more RoleRefs with no adjectives - this is called "loose binding".
+      class Binding
+        attr_reader :player   # The Concept (object type)
+        attr_reader :refs     # an array of the RoleRefs
+        attr_reader :role_name
+        attr_accessor :rebound_to   # Loose binding may set this to another binding
+        attr_accessor :join_node
+
+        def initialize player, role_name = nil
+          @player = player
+          @role_name = role_name
+          @refs = []
+        end
+
+        def inspect
+          "#{@player.name}#{@role_name and @role_name.is_a?(Integer) ? " (#{@role_name})" : " (as #{@role_name})"}"
+        end
+
+        def key
+          "#{@player.name}#{@role_name && " (as #{@role_name})"}"
+        end
+
+        def <=>(other)
+          key <=> other.key
+        end
+      end
+
+      class CompilationContext
+        attr_accessor :allowed_forward_terms
+        attr_reader :bindings             # The Bindings in this declaration
+        attr_reader :player_by_role_name
+
+        def initialize vocabulary
+          @vocabulary = vocabulary
+          @vocabulary_identifier = @vocabulary.identifying_role_values
+          @allowed_forward_terms = []
+          @bindings = {}
+          @player_by_role_name = {}
+        end
+
+        # Look up this concept by its name
+        def concept(name)
+          constellation = @vocabulary.constellation
+          player = constellation.Concept[[@vocabulary_identifier, name]]
+
+          # Bind to an existing role which has a role name (that's why we bind those first)
+          player ||= @player_by_role_name[name]
+
+          if !player && @allowed_forward_terms.include?(name)
+            player = constellation.EntityType(@vocabulary, name)
+          end
+
+          player
+        end
+      end
+
+      class Definition
+        attr_accessor :constellation, :vocabulary, :source
+        def compile
+          raise "#{self.class} should implement the compile method"
+        end
+      end
+
+      class Vocabulary < Definition
+        def initialize name
+          @name = name
+        end
+
+        def compile
+          @constellation.Vocabulary @name
+        end
+      end
+
+      class Import < Definition
+        def initialize name, alias_list
+          @name = name
+          @alias_list = alias_list
+        end
+      end
+
+      class Concept < Definition
+        attr_reader :name
+
+        def initialize name
+          @name = name
+        end
+      end
+
+    end
+  end
+end
+
+require 'activefacts/cql/compiler/value_type'
+require 'activefacts/cql/compiler/entity_type'
+require 'activefacts/cql/compiler/reading'
+require 'activefacts/cql/compiler/fact_type'
+require 'activefacts/cql/compiler/fact'
+require 'activefacts/cql/compiler/constraint'

data/lib/activefacts/cql/compiler/value_type.rb

@@ -0,0 +1,104 @@
+module ActiveFacts
+  module CQL
+    class Compiler < ActiveFacts::CQL::Parser
+
+      class Unit < Definition
+        def initialize singular, plural, numerator, denominator, offset, base_units, approximately, ephemera_url
+          @singular = singular
+          @plural = plural
+          @numerator, @denominator = numerator, denominator
+          @offset = offset
+          @base_units = base_units  # An array of pairs, each [unit_name, power]
+          @approximately = approximately
+          @ephemera_url = ephemera_url
+        end
+
+        def compile
+          if (@numerator.to_f / @denominator.to_i != 1.0)
+            coefficient = @constellation.Coefficient(
+                :numerator => @numerator,
+                :denominator => @denominator.to_i,
+                :is_precise => !@approximately
+              )
+          else
+            coefficient = nil
+          end
+          @offset = nil if @offset.to_f == 0
+
+          debug :units, "Defining new unit #{@singular}#{@plural ? "/"+@plural : ""}" do
+            debug :units, "Coefficient is #{coefficient.numerator}#{coefficient.denominator != 1 ? "/#{coefficient.denominator}" : ""} #{coefficient.is_precise ? "exactly" : "approximately"}" if coefficient
+            debug :units, "Offset is #{@offset}" if @offset
+            raise "Redefinition of unit #{@singular}" if @constellation.Unit.values.detect{|u| u.name == @singular}
+            raise "Redefinition of unit #{@plural}" if @constellation.Unit.values.detect{|u| u.name == @plural}
+            unit = @constellation.Unit(:new,
+                :name => @singular,
+                :plural_name => @plural,
+                :coefficient => coefficient,
+                :offset => @offset,
+                :is_fundamental => @base_units.empty?,
+                :ephemera_url => @ephemera_url,
+                :vocabulary => @vocabulary
+              )
+            @base_units.each do |base_unit, exponent|
+              base = @constellation.Unit.values.detect{|u| u.name == base_unit || u.plural_name == base_unit }
+              debug :units, "Base unit #{base_unit}^#{exponent} #{base ? "" : "(implicitly fundamental)"}"
+              base ||= @constellation.Unit(:new, :name => base_unit, :is_fundamental => true, :vocabulary => @vocabulary)
+              @constellation.Derivation(:derived_unit => unit, :base_unit => base, :exponent => exponent)
+            end
+=begin
+            if @plural
+              plural_unit = @constellation.Unit(:new,
+                  :name => @plural,
+                  :is_fundamental => false,
+                  :vocabulary => @vocabulary
+                )
+              @constellation.Derivation(:derived_unit => plural_unit, :base_unit => unit, :exponent => 1)
+            end
+=end
+            unit
+          end
+        end
+      end
+
+      class ValueType < Concept
+        def initialize name, base, parameters, unit, value_constraint, pragmas
+          super name
+          @base_type_name = base
+          @parameters = parameters
+          @unit = unit
+          @value_constraint = value_constraint
+          @pragmas = pragmas
+        end
+
+        def compile
+          length, scale = *@parameters
+
+          # Create the base type:
+          base_type = nil
+          if (@base_type_name != @name)
+            unless base_type = @constellation.ValueType[[@vocabulary.identifying_role_values, @constellation.Name(@base_type_name)]]
+              base_type = @constellation.ValueType(@vocabulary, @base_type_name)
+              return base_type if @base_type_name == @name
+            end
+          end
+
+          # Create and initialise the ValueType:
+          vt = @constellation.ValueType(@vocabulary, @name)
+          vt.is_independent = true if (@pragmas.include? 'independent')
+          vt.supertype = base_type if base_type
+          vt.length = length if length
+          vt.scale = scale if scale
+
+          raise "REVISIT: ValueType units are recognised but not yet compiled" unless @unit.empty?
+
+          if @value_constraint
+            @value_constraint.constellation = @constellation
+            vt.value_constraint = @value_constraint.compile
+          end
+
+          vt
+        end
+      end
+    end
+  end
+end

data/lib/activefacts/cql/parser.rb

@@ -7,7 +7,7 @@
 require 'rubygems'
 require 'treetop'
 
-# These are Treetop files, which it will compile on the fly if precompiled ones aren't found:
+# These are Treetop files, which Polyglot will compile on the fly if precompiled ones aren't found:
 require 'activefacts/cql/LexicalRules'
 require 'activefacts/cql/Language/English'
 require 'activefacts/cql/Expressions'
@@ -20,17 +20,136 @@ require 'activefacts/cql/CQLParser'
 
 module ActiveFacts
   module CQL
+    module Terms
+      class SavedContext < Treetop::Runtime::SyntaxNode
+        attr_accessor :context
+      end
+    end
+
     # Extend the generated parser:
     class Parser < CQLParser
       include ActiveFacts
 
-      class BlackHole
-        def method_missing(m, *p, &b)
-          self    # Make all calls vanish
+      # The Context manages some key information revealed or needed during parsing
+      # These methods are semantic predicates; if they return false this parse rule will fail.
+      class Context
+        attr_reader :term, :global_term
+
+        def initialize(parser)
+          @parser = parser
+          @terms = {}
+          @role_names = {}
+          @allowed_forward_terms = []
+        end
+
+        def object_type(name, kind)
+          index_name(@terms, name) && debug(:context, "new #{kind} '#{name}'")
+          true
+        end
+
+        def reset_role_names
+          debug :context, "\tresetting role names #{@role_names.keys.sort*", "}" if @role_names && @role_names.size > 0
+          @role_names = {}
+        end
+
+        def allowed_forward_terms(terms)
+          @allowed_forward_terms = terms
+        end
+
+        def new_leading_adjective_term(adj, term)
+          index_name(@role_names, "#{adj} #{term}", term) && debug(:context, "new role '#{adj}- #{term}'")
+          true
+        end
+
+        def new_trailing_adjective_term(adj, term)
+          index_name(@role_names, n = "#{term} #{adj}", term) && debug(:context, "new role '#{term} -#{adj}'")
+          true
+        end
+
+        def role_name(name)
+          index_name(@role_names, name) && debug(:context, "new role '#{name}'")
+          true
+        end
+
+        def term_starts?(s, context_saver)
+          @term = @global_term = nil
+
+          @term_part = s
+          @context_saver = context_saver
+          t = @terms[s] || @role_names[s] || system_term(s)
+          if t
+            # s is a prefix of the keys of t.
+            if t[s]
+              @global_term = @term = @term_part
+              @context_saver.context = {:term => @term, :global_term => @global_term }
+            end
+            debug :context, "Term #{t[s] ? "is" : "starts"} '#{@term_part}'"
+          elsif @allowed_forward_terms.include?(@term_part)
+            @term = @term_part
+            @context_saver.context = {:term => @term, :global_term => @term }
+            debug :context, "Term #{s} is an allowed forward"
+            return true
+          end
+          t
+        end
+
+        def term_continues?(s)
+          @term_part = "#{@term_part} #{s}"
+          t = @terms[@term_part]
+          r = @role_names[@term_part]
+          if t && (!r || !r[@term_part])    # Part of a term and not a complete role name
+            w = "term"
+          else
+            t = r
+            w = "role_name"
+          end
+          if t
+            debug :context, "Multi-word #{w} #{t[@term_part] ? 'ends at' : 'continues to'} #{@term_part.inspect}"
+
+            # Record the name of the full term and the underlying global term:
+            if t[@term_part]
+              @term = @term_part if t[@term_part]
+              @global_term = (t = t[@term_part]) == true ? @term_part : t
+              debug :context, "saving context #{@term}/#{@global_term}"
+              @context_saver.context = {:term => @term, :global_term => @global_term }
+            end
+          end
+          t
+        end
+
+        def term_complete?
+          return true if @allowed_forward_terms.include?(@term)
+          return true if system_term(@term)
+          (t = @terms[@term] and t[@term]) or
+            (t = @role_names[@term] and t[@term])
+        end
+
+        def system_term(s)
+          false
+        end
+
+        def unit? s
+          @parser.unit? s
+        end
+
+      private
+        # Index the name by all prefixes
+        def index_name(index, name, value = true)
+          added = false
+          words = name.scan(/\w+/)
+          words.inject("") do |n, w|
+            # Index all prefixes up to the full term
+            n = n.empty? ? w : "#{n} #{w}"
+            index[n] ||= {}
+            added = true unless index[n][name]
+            index[n][name] = value    # Save all possible completions of this prefix
+            n
+          end
+          added
         end
       end
 
-      class InputProxy < Object
+      class InputProxy
         attr_reader :context
 
         def initialize(input, context)
@@ -64,7 +183,12 @@ module ActiveFacts
       end
 
       def context
-        @context ||= BlackHole.new
+        @context ||= Context.new(self)
+      end
+
+      def unit?(s)
+        # puts "Asking whether #{s.inspect} is a unit"
+        true
       end
 
       def parse(input, options = {})
@@ -72,91 +196,18 @@ module ActiveFacts
         super(input, options)
       end
 
-      # Repeatedly parse rule_name until all input is consumed,
-      # returning an array of syntax trees for each definition.
       def parse_all(input, rule_name = nil, &block)
         self.root = rule_name if rule_name
 
         @index = 0  # Byte offset to start next parse
         self.consume_all_input = false
-        results = []
         begin
           node = parse(InputProxy.new(input, context), :index => @index)
           return nil unless node
-          node = block.call(node) if block
-          results << node if node
+          block.call(node) if block
         end until self.index == @input_length
-        results
-      end
-
-      def definition(node)
-        name, ast = *node.value
-        kind, *value = *ast
-
-        begin
-          debug "CQL: Processing definition #{[kind, name].compact*" "}" do
-            case kind
-            when :vocabulary
-              [kind, name]
-            when :value_type
-              value_type_ast(name, value)
-            when :entity_type
-              supertypes = value.shift
-              entity_type_ast(name, supertypes, value)
-            when :fact_type
-              f = fact_type_ast(name, value)
-            when :unit
-              ast
-            when :constraint
-              ast
-            else
-              raise "CQL: internal error, unknown definition kind"
-            end
-          end
-        end
-      rescue => e
-        raise "in #{kind.to_s.camelcase(true)} definition, #{e.message}:\n\t#{node.text_value}" +
-          (ENV['DEBUG'] =~ /\bexception\b/ ? "\nfrom\t"+e.backtrace*"\n\t" : "")
+        true
       end
-
-      def value_type_ast(name, value)
-        # REVISIT: Massage/check value type here?
-        [:value_type, name, *value]
-      end
-
-      def entity_type_ast(name, supertypes, value)
-        #print "entity_type parameters for #{name}: "; p value
-        identification, mapping_pragmas, clauses = *value
-        clauses ||= []
-
-        # raise "Entity type clauses must all be fact types" if clauses.detect{|c| c[0] != :fact_clause }
-
-        [:entity_type, name, supertypes, identification, mapping_pragmas, clauses]
-      end
-
-      def fact_type_ast(name, value)
-        clauses, conditions = value
-
-        if conditions.empty? && includes_literals(clauses)
-          [:fact, nil, clauses]
-        elsif clauses.size == 1 &&
-            (popname = clauses[0][2]).size == 1 &&
-            popname[0].keys == [:word] &&
-            includes_literals(conditions)
-          [:fact, popname[0][:word], conditions]
-        else
-          [:fact_type, name, clauses, conditions]
-        end
-      end
-
-      def includes_literals(clauses)
-        clauses.detect do |clause|
-          raise "alternate clauses are not yet supported" if clause[0] == :"||"
-          fc, qualifiers, phrases, context_note = *clause
-          phrases.detect{|w| w[:literal]}
-        end
-      end
-
     end
 
   end