activefacts-cql 1.8.3 → 1.9.1

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

@@ -44,7 +44,7 @@ module ActiveFacts
           unless @conditions.empty? and @returning.empty?
             trace :query, "building query for derived fact type (returning #{@returning}) with #{@conditions.size} conditions: (#{@conditions.map{|c|c.inspect}*', '})" do
               @query = build_variables(@conditions.flatten)
-              @roles_by_binding = build_all_steps(@conditions)
+              @roles_by_binding = build_all_steps(@query, @conditions)
               @query.validate
               @query
             end
@@ -108,7 +108,9 @@ module ActiveFacts
           # Prepare to objectify the fact type (so readings for link fact types can be created)
           if @name
             entity_type = @vocabulary.valid_entity_type_name(@name)
-            raise "You can't objectify #{@name}, it already exists" if entity_type
+
+            # REVISIT disable name check -- GSP 5 Jul 2017
+            raise "You can't objectify #{@name}, it already exists" if entity_type && false
             @entity_type = @constellation.EntityType(@vocabulary, @name, :fact_type => @fact_type, :concept => :new)
           end
 

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

@@ -8,8 +8,11 @@ module ActiveFacts
             query = @constellation.Query(:new)
             all_bindings_in_clauses(clauses_list).
               each do |binding|
-                trace :query, "Creating variable #{query.all_variable.size} for #{binding.inspect}"
-                binding.variable = @constellation.Variable(query, query.all_variable.size, :object_type => binding.player)
+                var_name = (r = binding.refs.select{|r| r.is_a?(Reference)}.first) ? r.var_name : nil
+                trace :query, "Creating variable #{query.all_variable.size} for #{binding.inspect} with role_name #{var_name}"
+                binding.variable = @constellation.Variable(
+                  query, query.all_variable.size, :object_type => binding.player, role_name: var_name
+                )
                 if literal = binding.refs.detect{|r| r.literal}
                   if literal.kind_of?(ActiveFacts::CQL::Compiler::Reference)
                     # REVISIT: Fix this crappy ad-hoc polymorphism hack
@@ -23,21 +26,21 @@ module ActiveFacts
           end
         end
 
-        def build_all_steps(clauses_list)
+        def build_all_steps(query, clauses_list)
           roles_by_binding = {}
           trace :query, "Building steps" do
             clauses_list.each do |clause|
-              build_step(clause, roles_by_binding)
+              build_step(query, clause, roles_by_binding)
             end
           end
           roles_by_binding
         end
 
-        def build_step clause, roles_by_binding = {}, parent_variable = nil
+        def build_step query, clause, roles_by_binding = {}, parent_variable = nil
           return unless clause.refs.size > 0  # Empty clause... really?
 
           step = @constellation.Step(
-              :guid => :new,
+              query, query.all_step.size,
               :fact_type => clause.fact_type,
               :alternative_set => nil,
               :is_disallowed => clause.certainty == false,
@@ -56,7 +59,7 @@ module ActiveFacts
               objectification_step = nil
               if ref.nested_clauses
                 ref.nested_clauses.each do |nested_clause|
-                  objectification_step = build_step nested_clause, roles_by_binding
+                  objectification_step = build_step(query, nested_clause, roles_by_binding)
                   if ref.binding.player.is_a?(ActiveFacts::Metamodel::EntityType) and
                       ref.binding.player.fact_type == nested_clause.fact_type
                     objectification_step.objectification_variable = binding.variable
@@ -72,9 +75,10 @@ module ActiveFacts
                 if binding.variable.object_type.common_supertype(role.object_type)
                   # REVISIT: there's an implicit subtyping step here, create it; then always raise the error here.
                   # I don't want to do this for now because the verbaliser will always verbalise all steps.
-                  raise "Disallowing implicit subtyping step from #{role.object_type.name} to #{binding.variable.object_type.name} in #{clause.fact_type.default_reading.inspect}"
+                  # raise "Disallowing implicit subtyping step from #{role.object_type.name} to #{binding.variable.object_type.name} in #{clause.fact_type.default_reading.inspect}"
+                else
+                  raise "A #{role.object_type.name} cannot satisfy #{binding.variable.object_type.name} in #{clause.fact_type.default_reading.inspect}"
                 end
-                raise "A #{role.object_type.name} cannot satisfy #{binding.variable.object_type.name} in #{clause.fact_type.default_reading.inspect}"
               end
 
               trace :query, "Creating Play for #{ref.inspect}"

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

@@ -13,7 +13,7 @@ module ActiveFacts
       class Binding
         attr_reader :player             # The ObjectType (object type)
         attr_reader :refs               # an array of the References
-        attr_reader :role_name
+        attr_accessor :role_name
         attr_accessor :rebound_to       # Loose binding may set this to another binding
         attr_reader :variable
         attr_accessor :instance         # When binding fact instances, the instance goes here
@@ -35,7 +35,7 @@ module ActiveFacts
         def <=>(other)
           key <=> other.key
         end
-        
+
         def variable= v
           @variable = v   # A place for a breakpoint :)
         end
@@ -111,15 +111,17 @@ module ActiveFacts
       end
 
       class Vocabulary < Definition
-        def initialize name
+        def initialize name, is_transform, version_number
           @name = name
+          @is_transform = is_transform
+          @version_number = version_number
         end
 
         def compile
           if @constellation.Vocabulary.size > 0
             @constellation.Topic @name
           else
-            @constellation.Vocabulary @name
+            @constellation.Vocabulary(@name, is_transform: @is_transform, version_number: @version_number)
           end
         end
 
@@ -129,9 +131,11 @@ module ActiveFacts
       end
 
       class Import < Definition
-        def initialize parser, name, alias_hash
+        def initialize parser, name, import_role, version_pattern, alias_hash
           @parser = parser
           @name = name
+          @import_role = import_role
+          @version_pattern = version_pattern
           @alias_hash = alias_hash
         end
 
@@ -140,7 +144,7 @@ module ActiveFacts
         end
 
         def compile
-          @parser.compile_import(@name, @alias_hash)
+          @parser.compile_import(@name, @import_role, @alias_hash)
         end
       end
 

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

@@ -0,0 +1,136 @@
+#
+#       ActiveFacts CQL Parser.
+#       Compiler classes relating to Transform Rules.
+#
+# Copyright (c) 2017 Factil Pty Ltd. Read the LICENSE file.
+#
+module ActiveFacts
+  module CQL
+    class Compiler < ActiveFacts::CQL::Parser
+
+      class TransformRule < Definition
+        attr_accessor :compound_matching
+
+        def initialize compound_matching
+          @compound_matching = compound_matching
+        end
+
+        def compile
+          context = CompilationContext.new(@vocabulary)
+          transform_matching = @compound_matching.compile(context)
+          @constellation.TransformRule(:new, :compound_matching => transform_matching)
+        end
+      end
+
+      def self.build_transform_target_refs context, targ_term_list, transform_rule
+        vocabulary_identifier = context.vocabulary.identifying_role_values
+        constellation = context.vocabulary.constellation
+
+        targ_term_list.flatten!
+        (0 ... targ_term_list.size).each do |idx|
+          ref = targ_term_list[idx]
+          if (target_ot = constellation.ObjectType[[vocabulary_identifier, ref.term]]).nil?
+            raise "Target object '#{ref.term}' of transformation must be a valid object type"
+          end
+          constellation.TransformTargetRef(
+            transform_rule, idx, :object_type => target_ot,
+            :leading_adjective => ref.leading_adjective, :trailing_adjective => ref.trailing_adjective
+          )
+        end
+      end
+
+      class CompoundMatching
+        attr_accessor :targ_term_list, :transform_query, :transform_matchings
+
+        def initialize targ_term_list, transform_query, transform_matchings
+          @targ_term_list = targ_term_list
+          @transform_query = transform_query
+          @transform_matchings = transform_matchings
+        end
+
+        def compile(context)
+          compound_rule = nil
+          vocabulary_identifier = context.vocabulary.identifying_role_values
+          constellation = context.vocabulary.constellation
+
+          source_ot = nil
+          source_query = nil
+          if @transform_query.is_a?(ActiveFacts::CQL::Compiler::Reference)
+            if (source_ot = constellation.ObjectType[[vocabulary_identifier, @transform_query.term]]).nil?
+              raise "Invalid source object '#{@transform_query.term}' for '#{@targ_term.term}' transformation"
+            end
+          elsif @transform_query.is_a?(Array)
+            query = Query.new(nil, @transform_query.flatten)
+            query.constellation = constellation
+            query.vocabulary = context.vocabulary
+            if (source_query = query.compile).nil?
+              raise "Invalid source query for '#{@targ_term.term}' transformation"
+            end
+          end
+
+          compound_rule = constellation.CompoundMatching(
+            :new, :source_object_type => source_ot, :source_query => source_query
+          )
+          ActiveFacts::CQL::Compiler.build_transform_target_refs(context, @targ_term_list, compound_rule)
+
+          @transform_matchings.each do |tr|
+            trule = tr.compile(context)
+            trule.compound_matching = compound_rule
+          end
+
+          compound_rule
+        end
+      end
+
+      class SimpleMatching
+        attr_accessor :targ_term_list, :transform_expr
+
+        def initialize targ_term_list, transform_expr
+          @targ_term_list = targ_term_list
+          @transform_expr = transform_expr
+        end
+
+        def compile(context)
+          vocabulary_identifier = context.vocabulary.identifying_role_values
+          constellation = context.vocabulary.constellation
+
+          expr = transform_expr ? transform_expr.compile(context) : nil
+          simple_rule = constellation.SimpleMatching(:new, :expression => expr)
+          ActiveFacts::CQL::Compiler.build_transform_target_refs(context, @targ_term_list, simple_rule)
+
+          simple_rule
+        end
+      end
+      
+      class ExpressionTermList
+        attr_accessor :term_list
+        
+        def initialize term_list
+          @term_list = term_list
+        end
+        
+        def compile(context)
+          vocabulary_identifier = context.vocabulary.identifying_role_values
+          constellation = context.vocabulary.constellation
+          
+          expression = context.vocabulary.constellation.Expression(:new, :expression_type => 'Role')
+          
+          @term_list.flatten!
+          (0 ... @term_list.size).each do |idx|
+            ref = term_list[idx]
+            if (object_type = constellation.ObjectType[[vocabulary_identifier, ref.term]]).nil?
+              raise "Object '#{ref.term}' of transformation must be a valid object type"
+            end
+            constellation.ExpressionObjectRef(
+              expression, idx, :object_type => object_type,
+              :leading_adjective => ref.leading_adjective, :trailing_adjective => ref.trailing_adjective
+            )
+          end
+          
+          expression
+        end        
+      end
+      
+    end
+  end
+end

data/lib/activefacts/cql/parser.rb

@@ -119,6 +119,8 @@ module ActiveFacts
               @term = @term_part if t[@term_part]
               @global_term = (t = t[@term_part]) == true ? @term_part : t
               trace :context, "saving context #{@term}/#{@global_term}"
+              # trace :context, "@terms =\n\t#{@terms.map{|k,v| "#{k} => #{v}"} * "\n\t"}"
+              # trace :context, "@role_names =\n\t#{@role_names.map{|k,v| "#{k} => #{v}"} * "\n\t"}"
               @context_saver.context = {:term => @term, :global_term => @global_term }
             end
           end
@@ -128,8 +130,49 @@ module ActiveFacts
         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])
+          result = ((t = @terms[@term] and t[@term]) or (t = @role_names[@term] and t[@term]))
+          trace :context, "term #{@term} is #{result ? '' : 'in'}complete"
+          result
+        end
+
+        def global_term_starts?(s, context_saver)
+          @term = @global_term = nil
+
+          @term_part = s
+          @context_saver = context_saver
+          t = @terms[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
+            trace :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 }
+            trace :context, "Term #{s} is an allowed forward"
+            return true
+          end
+          t
+        end
+
+        def global_term_continues?(s)
+          @term_part = "#{@term_part} #{s}"
+          t = @terms[@term_part]
+          if t
+            trace :context, "Multi-word term #{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
+              trace :context, "saving context #{@term}/#{@global_term}"
+              # trace :context, "@terms =\n\t#{@terms.map{|k,v| "#{k} => #{v}"} * "\n\t"}"
+              @context_saver.context = {:term => @term, :global_term => @global_term }
+            end
+          end
+          t
         end
 
         def system_term(s)

data/lib/activefacts/cql/parser/CQLParser.treetop

@@ -11,6 +11,7 @@ require 'activefacts/cql/parser/Terms'
 require 'activefacts/cql/parser/ObjectTypes'
 require 'activefacts/cql/parser/ValueTypes'
 require 'activefacts/cql/parser/FactTypes'
+require 'activefacts/cql/parser/TransformRules'
 require 'activefacts/cql/parser/Context'
 
 module ActiveFacts
@@ -22,6 +23,7 @@ module ActiveFacts
       include ObjectTypes
       include ValueTypes
       include FactTypes
+      include TransformRules
       include Context
 
       rule cql_file
@@ -58,20 +60,35 @@ module ActiveFacts
         / object_type
         / informal_description
         / query
+        / transform_rule
         / s ';' s { def ast; nil; end }
       end
 
       rule vocabulary_definition
-        s vocabulary S vocabulary_name s ';'
+        schema_definition /
+        transform_definition
+      end
+
+      rule schema_definition
+        s ( schema / topic / vocabulary ) S vocabulary_name vn:version_number? s ';'
+        {
+          def ast
+            Compiler::Vocabulary.new(vocabulary_name.value, false, vn.empty? ? nil : vn.value)
+          end
+        }
+      end
+
+      rule transform_definition
+        s transform S vocabulary_name vn:version_number? s ';'
         {
           def ast
-            Compiler::Vocabulary.new(vocabulary_name.value)
+            Compiler::Vocabulary.new(vocabulary_name.value, true, vn.empty? ? nil : vn.value)
           end
         }
       end
 
       rule vocabulary_name
-        id tail:(S id)*
+        id tail:(S !version id)*
         {
 	  def node_type; :vocabulary; end
 	  def value
@@ -81,10 +98,47 @@ module ActiveFacts
       end
 
       rule import_definition
-        s import S vocabulary_name alias_list ';'
+        s import i:import_role? S vocabulary_name vp:version_pattern? alias_list ';'
         {
           def ast
-            Compiler::Import.new(import.input.parser, vocabulary_name.value, alias_list.value)
+            Compiler::Import.new(
+              import.input.parser, vocabulary_name.value, i.empty? ? "topic" : i.value, vp.empty? ? nil : vp.value, alias_list.value
+            )
+          end
+        }
+      end
+
+      rule version_number
+        S version S version_number_string
+        {
+          def value
+            version_number_string.text_value
+          end
+        }
+      end
+
+      rule version_pattern
+        S version S version_pattern_string
+        {
+          def value
+            version_pattern_string.text_value
+          end
+        }
+      end
+
+      rule version_number_string
+        [0-9]+ '.' [0-9]+ '.' [0-9]+ ('-' [0-9A-Za-z-]+ ('.' [0-9A-Za-z-]+ )* )?
+      end
+
+      rule version_pattern_string
+        [0-9]+ ('.' [0-9]+ ('.' [0-9]+ ('-' [0-9A-Za-z-]+ ('.' [0-9A-Za-z-]+ )* )? )? )?
+      end
+
+      rule import_role
+        S id
+        {
+          def value
+            id.text_value
           end
         }
       end

data/lib/activefacts/cql/parser/Language/English.treetop

@@ -295,6 +295,7 @@ module ActiveFacts
       rule radix_point '.' end
       rule reflexive 'reflexive' !alphanumeric end
       rule returning 'returning' !alphanumeric end
+      rule schema 'schema' !alphanumeric end
       rule separate 'separate' !alphanumeric end
       rule so_that 'so' S that end
       rule static 'static' !alphanumeric end
@@ -304,10 +305,13 @@ module ActiveFacts
       rule then 'then' !alphanumeric end
       rule to 'to' !alphanumeric end
       rule to_avoid to s 'avoid' !alphanumeric end
+      rule topic 'topic' !alphanumeric end
+      rule transform 'transform' !alphanumeric end
       rule transient 'transient' !alphanumeric end
       rule transitive 'transitive' !alphanumeric end
       rule true 'true' !alphanumeric end
-      rule vocabulary ('vocabulary' / 'schema') !alphanumeric end
+      rule version 'version' !alphanumeric end
+      rule vocabulary 'vocabulary' !alphanumeric end
       rule when 'when' !alphanumeric end
       rule where 'where' !alphanumeric end
       rule which 'which' !alphanumeric end