activefacts-cql 1.8.3 → 1.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 17b326a796d8f23d4b73ca8af114df35ae8d1cb0
-  data.tar.gz: 9b99bebe1d49eb09878bb3df01302f7649e58fea
+  metadata.gz: 9c904dd901055b4ee41174b3d60a3d16d02c4af0
+  data.tar.gz: 8321e5b02ed21d4132878e5d43e556ecd27460fa
 SHA512:
-  metadata.gz: 15e06b8dea51d28928b9618f0b3903c6db8721a4695f5682a8d0391f5d48a88851d04e6aa7db215f97b64296e97f0a4a4ab660a549634d5632efbbb96101badf
-  data.tar.gz: bff64b710592ac5bf3ff9da9b1a99243da09a6dd8c613af478da0b15e363c5bfb7ef08826e4fa16573d0f23f8b63062fe2ea60287f899c9edf93da465c98add0
+  metadata.gz: 699900788c5a3e09206a553b0751cce243a2b17edd3b7c7bb6ea59b00fb3177dd458674247631bb90af1a282840b64892862dbd8902f8513a1ad324852a6e6bb
+  data.tar.gz: d29b4f20f3fc97a4dfb04366bb2f035f9ae837fcae73d617ce5917903429327be0c1bc2eee0a6b052226cb29949c68b501f8d2412b3bee4bc4488c6ae8c32851

data/.gitignore

@@ -6,6 +6,7 @@
 /doc/
 /pkg/
 /spec/reports/
+/spec/activefacts/cql/actual
 /tmp/
 lib/activefacts/cql/parser/[A-Z]*.rb
 lib/activefacts/cql/parser/Language/[A-Z]*.rb

data/activefacts-cql.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.3"
 
-  spec.add_runtime_dependency "activefacts-metamodel", "~> 1", ">= 1.9.5"
+  spec.add_runtime_dependency "activefacts-metamodel", "~> 1", ">= 1.9.14"
   spec.add_runtime_dependency "treetop", [">= 1.4.14", "~> 1.4"]
 end
 

data/lib/activefacts/cql/compiler.rb

@@ -14,6 +14,7 @@ require 'activefacts/cql/compiler/fact'
 require 'activefacts/cql/compiler/constraint'
 require 'activefacts/cql/compiler/query'
 require 'activefacts/cql/compiler/informal'
+require 'activefacts/cql/compiler/transform_rule'
 
 module ActiveFacts
   module CQL
@@ -23,30 +24,35 @@ module ActiveFacts
         'fr' => 'French',
         'cn' => 'Mandarin'
       }
+      EXTENSIONS = ['fiml', 'fidl', 'fiql', 'cql']
+
       attr_reader :vocabulary
 
-      def initialize *a
-        @filename = a.shift || "stdio"
+      def initialize filepath, *a
+        @filepath = filepath
         super *a
         @constellation = ActiveFacts::API::Constellation.new(ActiveFacts::Metamodel)
         @constellation.loggers << proc{|*k| trace :apilog, k.inspect} if trace(:apilog)
         @language = nil
+        @pending_import_topic = nil
+        @pending_import_role = ''
+        @pending_import_file_name = ''
         trace :file, "Parsing '#{@filename}'"
       end
 
-      def compile_file filename
-        old_filename = @filename
-        @filename = filename
-        File.open(filename) do |f|
+      def compile_file filepath
+        old_filepath = @filepath
+        @filepath = filename
+        File.open(filepath) do |f|
           compile(f.read)
         end
-        @filename = old_filename
+        @filepath = old_filepath
         @vocabulary
       end
 
       # Load the appropriate natural language module
       def detect_language
-        @filename =~ /.*\.(..)\.cql$/i
+        @filepath =~ /.*\.(..)\.cql$/i
         language_code = $1
         @language = LANGUAGES[language_code] || 'English'
       end
@@ -67,6 +73,23 @@ module ActiveFacts
         end
       end
 
+      def create_import_if_pending new_topic
+        if @pending_import_topic
+          trace :import, "Topic #{@pending_import_topic.topic_name} imports #{new_topic.topic_name} as #{@pending_import_role} from file #{@pending_import_file_name}"
+
+          @constellation.Import(
+            topic: @pending_import_topic,
+            precursor_topic: new_topic,
+            import_role: @pending_import_role,
+            file_name: @pending_import_file_name
+          )
+
+          @pending_import_topic = nil
+          @pending_import_role = ''
+          @pending_import_file_name = ''
+        end
+      end
+
       def compile input
         include_language
 
@@ -87,10 +110,11 @@ module ActiveFacts
               value = compile_definition ast
               trace :definition, "Compiled to #{value.is_a?(Array) ? value.map{|v| v.verbalise}*', ' : value.verbalise}" if value
               if value.is_a?(ActiveFacts::Metamodel::Topic)
-                topic_flood if @topic
+                topic_flood() if @topic
+                create_import_if_pending(value)
                 @topic = value
               elsif ast.is_a?(Compiler::Vocabulary)
-                topic_flood if @topic
+                topic_flood() if @topic
                 @vocabulary = value
                 @topic = @constellation.Topic(@vocabulary.name)
               end
@@ -104,33 +128,25 @@ module ActiveFacts
               raise ne
             end
           end
-          topic_flood if @topic
+          topic_flood() if @topic
         end
         raise failure_reason unless ok
         vocabulary
       end
 
-      def compile_import file, aliases
+      def compile_import file, import_role, aliases
         saved_index = @index
         saved_block = @block
         saved_string = @string
         saved_input_length = @input_length
-        saved_topic = @topic
-        old_filename = @filename
-        @filename = import_filename(old_filename, file)
+        old_filepath = @filepath
+        @file = file
+        @filepath = import_filepath(old_filepath, file)
 
-        # REVISIT: Save and use another @vocabulary for this file?
-        File.open(@filename) do |f|
-          topic_flood if @topic
-          @topic = @constellation.Topic(File.basename(@filename, '.cql'))
-          trace :import, "Importing #{@filename} as #{@topic.topic_name}" do
-            ok = parse_all(f.read, nil, &@block)
-          end
-          @topic = saved_topic
-        end
+        compile_import_file(@filepath, import_role)
 
       rescue => e
-        ne = StandardError.new("In #{@filename} #{e.message.strip}")
+        ne = StandardError.new("In #{@filepath} #{e.message.strip}")
         ne.set_backtrace(e.backtrace)
         raise ne
       ensure
@@ -138,13 +154,52 @@ module ActiveFacts
         @index = saved_index
         @input_length = saved_input_length
         @string = saved_string
-        @filename = old_filename
+        @filepath = old_filepath
         nil
       end
 
-      # import_filename may be redefined in subclass
-      def import_filename(old_filename, file)
-        File.dirname(old_filename)+'/'+file+'.cql'
+      # redefine in subsclass for different behaviour
+      def import_filepath(old_filepath, file)
+        filepath = ''
+        EXTENSIONS.each do |extension|
+          filepath = File.dirname(old_filepath)+'/'+file+".#{extension}"
+          break if File.exist?(filepath)
+        end
+        filepath
+      end
+
+      # redefine in subsclass for different behaviour
+      def compile_import_file filepath, import_role
+        # REVISIT: Save and use another @vocabulary for this file?
+        File.open(filepath) do |f|
+          compile_import_input(f.read, import_role)
+        end
+      end
+
+      def compile_import_input input, import_role
+        topic_external_name = @file
+
+        if existing_topic = @constellation.Topic[[topic_external_name]]
+          # topic has already been loaded, just build import
+          trace :import, "Topic #{@topic.topic_name} has already been loaded, skip reload"
+          import = @constellation.Import(
+            topic: @topic, precursor_topic: existing_topic, 
+            import_role: import_role, file_name: topic_external_name
+          )
+        else
+          # topic has not been loaded previously, import topic
+          saved_topic = @topic
+          topic_flood() if @topic
+
+          @pending_import_topic = saved_topic
+          @pending_import_role = import_role
+          @pending_import_file_name = topic_external_name
+
+          trace :import, "Importing #{@filepath} into #{@topic.topic_name}" do
+            ok = parse_all(input, nil, &@block)
+          end
+          @topic = saved_topic
+        end
       end
 
       def compile_definition ast

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

@@ -22,7 +22,7 @@ module ActiveFacts
         end
 
         def refs
-          @phrases.select{|r| r.respond_to?(:player)}
+          @phrases.select{|r| r.is_a?(ActiveFacts::CQL::Compiler::Reference)}
         end
 
         # A clause that contains only the name of a ObjectType and no literal or reading text
@@ -142,7 +142,7 @@ module ActiveFacts
         # no change is made to this Clause object - those will be done later.
         #
         def match_existing_fact_type context, options = {}
-          raise "Cannot match a clause that contains no object types" if refs.size == 0
+          raise "Cannot match a clause that contains no object types for #{self.inspect}" if refs.size == 0
           raise "Internal error, clause already matched, should not match again" if @fact_type
 
           if is_naked_object_type
@@ -184,7 +184,12 @@ module ActiveFacts
           contract_left = proc do
             contracted_from = left_contract_this_onto.refs[0]
             contraction_player = contracted_from.player
-            contracted_role = Reference.new(contraction_player.name)
+            contracted_role = Reference.new(
+              term: contraction_player.name,
+              leading_adjective: contracted_from.leading_adjective,
+              trailing_adjective: contracted_from.trailing_adjective,
+              role_name: contracted_from.role_name
+            )
             supposed_roles << contracted_role
             left_insertion = contracted_role.inspect+' '
             contracted_role.player = contracted_from.player
@@ -199,7 +204,12 @@ module ActiveFacts
           contract_right = proc do
             contracted_from = left_contract_this_onto.refs[-1]
             contraction_player = contracted_from.player
-            contracted_role = Reference.new(contraction_player.name)
+            contracted_role = Reference.new(
+              term: contraction_player.name,
+              leading_adjective: contracted_from.leading_adjective,
+              trailing_adjective: contracted_from.trailing_adjective,
+              role_name: contracted_from.role_name
+            )
             supposed_roles << contracted_role
             right_insertion = ' '+contracted_role.inspect
             contracted_role.player = contracted_from.player
@@ -306,7 +316,7 @@ module ActiveFacts
 
                   if equal_best.size > 1 and equal_best.detect{|k,m| !m.fact_type.is_a?(Metamodel::TypeInheritance)}
                     # Complain if there's more than one equivalent cost match (unless all are TypeInheritance):
-                    raise "#{@phrases.inspect} could match any of the following:\n\t"+
+                    trace :matching_fails, "#{@phrases.inspect} could match any of the following:\n\t"+
                       best_matches.map { |reading| reading.expand + " with " + matches[reading].describe } * "\n\t"
                   end
                 end
@@ -317,7 +327,14 @@ module ActiveFacts
                   @fact_type = @side_effects.fact_type
                   trace :matching, "Matched '#{@fact_type.default_reading}'"
                   @phrases = phrases
-                  apply_side_effects(context, @side_effects)
+
+                  # REVISIT: Drop handling side-effects because roles are still required for processing conditions in transformation logic
+                  # apply_side_effects(context, @side_effects)
+                  @side_effects.role_side_effects.each do |side_effect|
+                    phrase = side_effect.phrase
+                    phrase.role_ref = side_effect.role_ref
+                  end
+
                   return @fact_type
                 end
 
@@ -757,7 +774,7 @@ module ActiveFacts
 
           if @qualifiers && @qualifiers.size > 0
             # We shouldn't make a new ring constraint if there's already one over this ring.
-            existing_rcs = 
+            existing_rcs =
               @role_sequence.all_role_ref.map{|rr| rr.role.all_ring_constraint.to_a }.flatten.uniq
             unless existing_rcs[0]
               rc = RingConstraint.new(@role_sequence, @qualifiers)
@@ -904,6 +921,22 @@ module ActiveFacts
           }}"
         end
 
+        def var_name
+          if @role_name && !@role_name.is_a?(Integer)
+            @role_name
+          else
+            "#{
+              @leading_adjective && @leading_adjective.split.map(&:capitalize).join(' ') + ' '
+            }#{
+              @term
+            }#{
+              @trailing_adjective && ' ' + @trailing_adjective.split.map(&:capitalize).join(' ')
+            }#{
+              @role_name && "(#{@role_name})"
+            }"
+          end
+        end
+
         def <=>(other)
           ( 4*(@term <=> other.term) +
             2*((@leading_adjective||'') <=> (other.leading_adjective||'')) +
@@ -1038,7 +1071,7 @@ module ActiveFacts
         end
 
         def find_pc_over_roles(roles)
-          return nil if roles.size == 0 # Safeguard; this would chuck an exception otherwise
+          raise "No Role for embedded_presence_constraint" if roles.size == 0 # Safeguard; this would chuck an exception otherwise
           roles[0].all_role_ref.each do |role_ref|
             next if role_ref.role_sequence.all_role_ref.map(&:role) != roles
             pc = role_ref.role_sequence.all_presence_constraint.single  # Will return nil if there's more than one.
@@ -1049,7 +1082,7 @@ module ActiveFacts
         end
 
         def make_embedded_presence_constraint vocabulary
-          raise "No Role for embedded_presence_constraint" unless @role_ref
+          return unless @role_ref
           fact_type = @role_ref.role.fact_type
           constellation = vocabulary.constellation
 
@@ -1098,6 +1131,15 @@ module ActiveFacts
         def result(context = nil)
           self
         end
+
+        def compile(context)
+          identify_player(context)
+          constellation = context.vocabulary.constellation
+          constellation.Expression(
+              :new, :expression_type => 'Role', :object_type => @player,
+              :leading_adjective => leading_adjective, :trailing_adjective => trailing_adjective
+          )
+        end
       end
 
       # REVISIT: This needs to handle annotations for some/that/which, etc.

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

@@ -297,7 +297,7 @@ module ActiveFacts
 
                 # Create a query with a variable for every binding and all steps:
                 query = build_variables(clauses_list)
-                roles_by_binding = build_all_steps(clauses_list)
+                roles_by_binding = build_all_steps(query, clauses_list)
                 query.validate
 
                 # Create the projected RoleSequence for the constraint:

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

@@ -195,14 +195,6 @@ module ActiveFacts
           end
         end
 
-=begin
-        def project lr
-          @projection = lr
-          projected_rr = lr == :left ? @e2 : @e1
-          true
-        end
-=end
-
         def inspect; to_s; end
 
         def to_s
@@ -222,6 +214,15 @@ module ActiveFacts
             @qualifiers.empty? ? '' : ', ['+@qualifiers*', '+']'
           })"
         end
+
+        def compile(context)
+          op1 = e1.compile(context)
+          op2 = e2.compile(context)
+          context.vocabulary.constellation.Expression(
+              :new, :expression_type => 'Binary', :operator => operator,
+              :first_operand_expression => op1, :second_operand_expression => op2
+          )
+        end
       end
 
       class Sum < Operation
@@ -254,19 +255,29 @@ module ActiveFacts
           "SUM_OF<#{ @terms.map{|f| f.player.name}*', ' }>"
         end
 
-=begin
-        def result_value_type(context, name)
-          # REVISIT: If there are units involved, check compatibility
-          vt = super
-          vt
-        end
-=end
-
         def inspect; to_s; end
 
         def to_s
           'SUM(' + @terms.map{|term| "#{term.to_s}" } * ' PLUS ' + ')'
         end
+
+        def compile(context)
+          compile_terms(context, @terms)
+        end
+
+        def compile_terms(context, terms)
+          if terms.size == 1
+            terms[0].compile(context)
+          else
+            lhs = terms.shift
+            lhs_expr = lhs.compile(context)
+            rhs_expr = compile_terms(context, terms)
+            context.vocabulary.constellation.Expression(
+                :new, :expression_type => 'Binary', :operator => operator,
+                :first_operand_expression => lhs_expr, :second_operand_expression => rhs_expr
+            )
+          end
+        end
       end
 
       class Product < Operation
@@ -298,19 +309,29 @@ module ActiveFacts
           "PRODUCT_OF<#{ @factors.map{|f| f.player.name}*' ' }>"
         end
 
-=begin
-        def result_value_type(context, name)
-          vt = super
-          # REVISIT: If there are units involved, create the result units
-          vt
-        end
-=end
-
         def inspect; to_s; end
 
         def to_s
           'PRODUCT(' + @factors.map{|factor| "#{factor.to_s}" } * ' TIMES ' + ')'
         end
+
+        def compile(context)
+          compile_factors(context, @factors)
+        end
+
+        def compile_factors(context, factors)
+          if factors.size == 1
+            factors[0].compile(context)
+          else
+            lhs = factors.shift
+            lhs_expr = lhs.compile(context)
+            rhs_expr = compile_factors(context, factors)
+            context.vocabulary.constellation.Expression(
+                :new, :expression_type => 'Binary', :operator => operator,
+                :first_operand_expression => lhs_expr, :second_operand_expression => rhs_expr
+            )
+          end
+        end
       end
 
       class Reciprocal < Operation
@@ -337,17 +358,19 @@ module ActiveFacts
           end
         end
 
-=begin
-        def result_type_name(context)
-          raise hell
-        end
-=end
-
         def inspect; to_s; end
 
         def to_s
           "RECIPROCAL(#{factor.to_s})"
         end
+
+        def compile(context)
+          op1 = @divisor.compile(context)
+          context.vocabulary.constellation.Expression(
+              :new, :expression_type => 'Unary', :operator => operator,
+              :first_operand_expression => op1
+          )
+        end
       end
 
       class Negate
@@ -368,16 +391,227 @@ module ActiveFacts
           end
         end
 
-=begin
+        def inspect; to_s; end
+
+        def to_s
+          "NEGATIVE(#{term.to_s})"
+        end
+
+        def compile(context)
+          op1 = @term.compile(context)
+          context.vocabulary.constellation.Expression(
+              :new, :expression_type => 'Unary', :operator => operator,
+              :first_operand_expression => op1
+          )
+        end
+      end
+
+      class Negation
+        attr_accessor :term
+        def initialize term
+          @term = term
+        end
+
+        def operator
+          'not'
+        end
+
+        def identify_player context
+          @player || begin
+            # The player in @term have already been identified
+            v = context.vocabulary
+            @player = @term.player
+          end
+        end
+
+        def inspect; to_s; end
+
+        def to_s
+          "NEGATION(#{term.to_s})"
+        end
+
+        def compile(context)
+          op1 = @term.compile(context)
+          context.vocabulary.constellation.Expression(
+              :new, :expression_type => 'Unary', :operator => operator,
+              :first_operand_expression => op1
+          )
+        end
+      end
+
+      class LogicalAnd < Operation
+        attr_accessor :factors
+        def initialize *factors
+          @factors = factors
+        end
+
+        def refs
+          @factors
+        end
+
+        def operator
+          'and'
+        end
+
+        def identify_player context
+          @player || begin
+            v = context.vocabulary
+            @player = @factors[0].player
+          end
+        end
+
         def result_type_name(context)
-          raise hell
+          "CONJUNCTION_OF<#{ @factors.map{|f| f.player.name}*' ' }>"
         end
-=end
 
         def inspect; to_s; end
 
         def to_s
-          "NEGATIVE(#{term.to_s})"
+          'CONJUNCTION(' + @factors.map{|factor| "#{factor.to_s}" } * ' AND ' + ')'
+        end
+
+        def compile(context)
+          compile_factors(context, @factors)
+        end
+
+        def compile_factors(context, factors)
+          if factors.size == 1
+            factors[0].compile(context)
+          else
+            lhs = factors.shift
+            lhs_expr = lhs.compile(context)
+            rhs_expr = compile_factors(context, factors)
+            context.vocabulary.constellation.Expression(
+                :new, :expression_type => 'Binary', :operator => operator,
+                :first_operand_expression => lhs_expr, :second_operand_expression => rhs_expr
+            )
+          end
+        end
+      end
+
+      class LogicalOr < Operation
+        attr_accessor :factors
+        def initialize *factors
+          @factors = factors
+        end
+
+        def refs
+          @factors
+        end
+
+        def operator
+          'or'
+        end
+
+        def identify_player context
+          @player || begin
+            v = context.vocabulary
+            @player = @factors[0].player
+          end
+        end
+
+        def result_type_name(context)
+          "DISJUNCTION_OF<#{ @factors.map{|f| f.player.name}*' ' }>"
+        end
+
+        def inspect; to_s; end
+
+        def to_s
+          'DISJUNCTION(' + @factors.map{|factor| "#{factor.to_s}" } * ' OR ' + ')'
+        end
+
+        def compile(context)
+          compile_factors(context, @factors)
+        end
+
+        def compile_factors(context, factors)
+          if factors.size == 1
+            factors[0].compile(context)
+          else
+            lhs = factors.shift
+            lhs_expr = lhs.compile(context)
+            rhs_expr = compile_factors(context, factors)
+            context.vocabulary.constellation.Expression(
+                :new, :expression_type => 'Binary', :operator => operator,
+                :first_operand_expression => lhs_expr, :second_operand_expression => rhs_expr
+            )
+          end
+        end
+      end
+
+      class Ternary < Operation
+        attr_accessor :condition, :true_value, :false_value
+        def initialize condition, true_value, false_value
+          @condition = condition
+          @true_value = true_value
+          @false_value = false_value
+        end
+
+        def refs
+          [@condition, @true_value, @false_value]
+        end
+
+        def operator
+          '?'
+        end
+
+        def identify_player context
+          @player || begin
+            v = context.vocabulary
+            @player = @true_value.player
+          end
+        end
+
+        def inspect; to_s; end
+
+        def to_s
+          "TERNARY(#{@condition.to_s}, #{@true_value.to_s}, #{@false_value.to_s})"
+        end
+
+        def compile(context)
+          op1 = @condition.compile(context)
+          op2 = @true_value.compile(context)
+          op3 = @false_value.compile(context)
+          context.vocabulary.constellation.Expression(
+              :new, :expression_type => 'Ternary', :operator => operator,
+              :first_operand_expression => op1, :second_operand_expression => op2, :third_operand_expression => op3
+          )
+        end
+      end
+
+      class Aggregate < Operation
+        attr_accessor :operation, :aggregand
+        def initialize operation, aggregand
+          @operation = operation
+          @aggregand = aggregand
+        end
+
+        def refs
+          [@operation, @aggregand]
+        end
+
+        def operator
+          operation
+        end
+
+        def identify_player context
+          @player || begin
+            @player = @aggregand.player
+          end
+        end
+
+        def inspect; to_s; end
+
+        def to_s
+          "AGGREGATE(#{@operation.to_s}, #{@aggregand.to_s})"
+        end
+
+        def compile(context)
+          op1 = @aggregand.compile(context)
+          context.vocabulary.constellation.Expression(
+              :new, :expression_type => 'Unary', :operator => operator,
+              :first_operand_expression => op1
+          )
         end
       end
 
@@ -436,8 +670,19 @@ module ActiveFacts
         def binding
           @binding
         end
+
+        def compile(context)
+          literal_string = case @literal
+            when String; "'#{@literal.to_s}'"
+            else @literal.to_s
+            end
+          context.vocabulary.constellation.Expression(
+              :new, :expression_type => 'Literal', :literal_string => literal_string
+          )
+        end
       end
 
     end
+
   end
 end