activefacts 0.8.9 → 0.8.10

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

@@ -10,15 +10,21 @@ module ActiveFacts
           @value_constraint = value_constraint
           @parameters = parameters
         end
+
+        def to_s
+          "identified by its #{name}" +
+            ((p = @parameters).size > 0 ? '('+p*', '+')' : '') +
+            ((v = @value_constraint) ? v.to_s : '')
+        end
       end
 
-      class EntityType < Concept
-        def initialize name, supertypes, identification, pragmas, readings
+      class EntityType < ObjectType
+        def initialize name, supertypes, identification, pragmas, clauses
           super name
           @supertypes = supertypes
           @identification = identification
           @pragmas = pragmas
-          @readings = readings || []
+          @clauses = clauses || []
         end
 
         def compile
@@ -36,10 +42,12 @@ module ActiveFacts
           # Identification may be via a mode (create it) or by forward-referenced entity types (allow those):
           prepare_identifier context
 
+          context.bind @clauses, @identification.is_a?(Array) ? @identification : []
+
           # Create the fact types that define the identifying roles:
           fact_types = create_identifying_fact_types context
 
-          # At this point, @identification is an array of RoleRefs and/or Readings (for unary fact types)
+          # At this point, @identification is an array of VarRefs and/or Clauses (for unary fact types)
           # Have to do this after creating the necessary fact types
           complete_reference_mode_fact_type fact_types
 
@@ -48,9 +56,9 @@ module ActiveFacts
 
           make_preferred_identifier_over_roles identifying_roles
 
-          @readings.each do |reading|
-            next unless reading.context_note
-            reading.context_note.compile(@constellation, @entity_type)
+          @clauses.each do |clause|
+            next unless clause.context_note
+            clause.context_note.compile(@constellation, @entity_type)
           end
 
           @entity_type
@@ -62,7 +70,7 @@ module ActiveFacts
             if @identification.is_a? ReferenceMode
               make_entity_type_refmode_valuetypes(name, @identification.name, @identification.parameters)
               vt_name = @reference_mode_value_type.name
-              @identification = [Compiler::RoleRef.new(vt_name, nil, nil, nil, nil, nil, @identification.value_constraint, nil)]
+              @identification = [Compiler::VarRef.new(vt_name, nil, nil, nil, nil, nil, @identification.value_constraint, nil)]
             else
               context.allowed_forward_terms = legal_forward_references(@identification)
             end
@@ -70,29 +78,28 @@ module ActiveFacts
         end
 
         # Names used in the identifying roles list may be forward referenced:
-        def legal_forward_references(identification_roles)
-          identification_roles.map do |phrase|
-            phrase.is_a?(RoleRef) ? phrase.term : nil
+        def legal_forward_references(identification_phrases)
+          identification_phrases.map do |phrase|
+            phrase.is_a?(VarRef) ? phrase.term : nil
           end.compact.uniq
         end
 
         def bind_identifying_roles context
           return unless @identification
           @identification.map do |id|
-            if id.is_a?(RoleRef)
-              id.identify_player(context)
-              binding = id.bind(context)
-              roles = binding.refs.map{|r| r.role}.compact.uniq
+            if id.is_a?(VarRef)
+              variable = id.variable
+              roles = variable.refs.map{|r| r.role}.compact.uniq
               raise "Looking for an occurrence of identifying role #{id.inspect}, but found #{roles.size == 0 ? "none" : roles.size}" if roles.size != 1
               roles[0]
             else
-              # id is a reading of a unary fact type.
+              # id is a clause of a unary fact type.
               id.identify_other_players context
-              id.bind_roles context
-              matching_reading =
-                @readings.detect { |reading| reading.phrases_match id.phrases }
-              raise "Unary identifying role 'id.inspect' is not found in the defined fact types" unless matching_reading
-              matching_reading.fact_type.all_role.single
+              id.bind context
+              matching_clause =
+                @clauses.detect { |clause| clause.phrases_match id.phrases }
+              raise "Unary identifying role '#{id.inspect}' is not found in the defined fact types" unless matching_clause
+              matching_clause.fact_type.all_role.single
             end
           end
         end
@@ -138,51 +145,47 @@ module ActiveFacts
 
         def create_identifying_fact_types context
           fact_types = []
-          # Categorise the readings into fact types according to the roles they play.
-          @readings.each{ |reading| reading.identify_players_with_role_name(context) }
-          @readings.each{ |reading| reading.identify_other_players(context) }
-          @readings.inject({}) do |hash, reading|
-            players_key = reading.role_refs.map{|rr| rr.key.compact}.sort
-            (hash[players_key] ||= []) << reading
+          # Categorise the clauses into fact types according to the roles they play.
+          @clauses.inject({}) do |hash, clause|
+            players_key = clause.var_refs.map{|vr| vr.key.compact}.sort
+            (hash[players_key] ||= []) << clause
             hash
-          end.each do |players_key, readings|
-            readings.each{ |reading| reading.bind_roles context }  # Create the Compiler::Bindings
-
+          end.each do |players_key, clauses|
             # REVISIT: Loose binding goes here; it might merge some Compiler#Roles
 
-            fact_type = create_identifying_fact_type(context, readings)
+            fact_type = create_identifying_fact_type(context, clauses)
             fact_types << fact_type if fact_type
-            objectify_existing_fact_type(fact_type) unless fact_type.all_role.detect{|r| r.concept == @entity_type}
+            objectify_existing_fact_type(fact_type) unless fact_type.all_role.detect{|r| r.object_type == @entity_type}
           end
           fact_types
         end
 
-        def create_identifying_fact_type context, readings
+        def create_identifying_fact_type context, clauses
           # Remove uninteresting assertions:
-          readings.reject!{|reading| reading.is_existential_type }
-          return nil unless readings.size > 0    # Nothing interesting was said.
+          clauses.reject!{|clause| clause.is_existential_type }
+          return nil unless clauses.size > 0    # Nothing interesting was said.
 
           # See if any fact type already exists (this ET cannot be a player, but might objectify it)
-          existing_readings = readings.select{ |reading| reading.match_existing_fact_type context }
-          any_matched = existing_readings.size > 0
+          existing_clauses = clauses.select{ |clause| clause.match_existing_fact_type context }
+          any_matched = existing_clauses.size > 0
 
           operation = any_matched ? 'Objectifying' : 'Creating'
-          player_names = readings[0].role_refs.map{|rr| rr.key.compact*'-'}
-          debug :matching, "#{operation} fact type for #{readings.size} readings over (#{player_names*', '})" do
+          player_names = clauses[0].var_refs.map{|vr| vr.key.compact*'-'}
+          debug :matching, "#{operation} fact type for #{clauses.size} clauses over (#{player_names*', '})" do
             if any_matched  # There's an existing fact type we must be objectifying
-              fact_type = objectify_existing_fact_type(existing_readings[0].fact_type)
+              fact_type = objectify_existing_fact_type(existing_clauses[0].fact_type)
             end
 
             unless fact_type
-              fact_type = readings[0].make_fact_type(@vocabulary)
-              readings[0].make_reading(@vocabulary, fact_type)
-              readings[0].make_embedded_constraints vocabulary
-              existing_readings = [readings[0]]
+              fact_type = clauses[0].make_fact_type(@vocabulary)
+              clauses[0].make_reading(@vocabulary, fact_type)
+              clauses[0].make_embedded_constraints vocabulary
+              existing_clauses = [clauses[0]]
             end
 
-            (readings - existing_readings).each do |reading|
-              reading.make_reading(@vocabulary, fact_type)
-              reading.make_embedded_constraints vocabulary
+            (clauses - existing_clauses).each do |clause|
+              clause.make_reading(@vocabulary, fact_type)
+              clause.make_embedded_constraints vocabulary
             end
 
             fact_type
@@ -226,24 +229,20 @@ module ActiveFacts
             inheritance_fact.assimilation = assimilations[0]
 
             # Create a reading:
-            sub_role = @constellation.Role(inheritance_fact, 0, :concept => @entity_type)
-            super_role = @constellation.Role(inheritance_fact, 1, :concept => supertype)
+            sub_role = @constellation.Role(inheritance_fact, 0, :object_type => @entity_type)
+            super_role = @constellation.Role(inheritance_fact, 1, :object_type => supertype)
 
             rs = @constellation.RoleSequence(:new)
             @constellation.RoleRef(rs, 0, :role => sub_role)
             @constellation.RoleRef(rs, 1, :role => super_role)
             @constellation.Reading(inheritance_fact, 0, :role_sequence => rs, :text => "{0} is a kind of {1}")
-            # REVISIT: Can we get away with adding "{0} is a/n {1}" here?
-            # REVISIT: Can we deprecate the "is a subtype of" reading?
-            @constellation.Reading(inheritance_fact, 1, :role_sequence => rs, :text => "{0} is a subtype of {1}")
 
             rs2 = @constellation.RoleSequence(:new)
             @constellation.RoleRef(rs2, 0, :role => super_role)
             @constellation.RoleRef(rs2, 1, :role => sub_role)
             # Decide in which order to include is a/is an. Provide both, but in order.
-            n = 'aeiouh'.include?(sub_role.concept.name.downcase[0]) ? 1 : 0
-            @constellation.Reading(inheritance_fact, 2+n, :role_sequence => rs2, :text => "{0} is a {1}")
-            @constellation.Reading(inheritance_fact, 3-n, :role_sequence => rs2, :text => "{0} is an {1}")
+            n = 'aeiouh'.include?(sub_role.object_type.name.downcase[0]) ? 'n' : ''
+            @constellation.Reading(inheritance_fact, 2, :role_sequence => rs2, :text => "{0} is a#{n} {1}")
 
             if is_identifying_supertype
               inheritance_fact.provides_identification = true
@@ -278,8 +277,8 @@ module ActiveFacts
           vt = nil
           debug :entity, "Preparing value type #{vt_name} for reference mode" do
             # Find or Create an appropriate ValueType called '#{vt_name}', of the supertype '#{mode}'
-            unless vt = @constellation.Concept[[@vocabulary.identifying_role_values, vt_name]] or
-                   vt = @constellation.Concept[[@vocabulary.identifying_role_values, vt_name = "#{name} #{mode}"]]
+            unless vt = @constellation.ObjectType[[@vocabulary.identifying_role_values, vt_name]] or
+                   vt = @constellation.ObjectType[[@vocabulary.identifying_role_values, vt_name = "#{name} #{mode}"]]
               base_vt = @constellation.ValueType(@vocabulary, mode)
               vt = @constellation.ValueType(@vocabulary, vt_name, :supertype => base_vt)
               if parameters
@@ -306,16 +305,16 @@ module ActiveFacts
           # Find an existing fact type, if any:
           entity_role = identifying_role = nil
           fact_type = fact_types.detect do |ft|
-            identifying_role = ft.all_role.detect{|r| r.concept == identifying_type } and
-            entity_role = ft.all_role.detect{|r| r.concept == @entity_type }
+            identifying_role = ft.all_role.detect{|r| r.object_type == identifying_type } and
+            entity_role = ft.all_role.detect{|r| r.object_type == @entity_type }
           end
 
           # Create an identifying fact type if needed:
           unless fact_type
             fact_type = @constellation.FactType(:new)
             fact_types << fact_type
-            entity_role = @constellation.Role(fact_type, 0, :concept => @entity_type)
-            identifying_role = @constellation.Role(fact_type, 1, :concept => identifying_type)
+            entity_role = @constellation.Role(fact_type, 0, :object_type => @entity_type)
+            identifying_role = @constellation.Role(fact_type, 1, :object_type => identifying_type)
           end
           @identification[0].role = identifying_role
 
@@ -342,7 +341,7 @@ module ActiveFacts
           end
           if rs01.all_reading.empty?
             @constellation.Reading(fact_type, fact_type.all_reading.size, :role_sequence => rs01, :text => "{0} has {1}")
-            debug :mode, "Creating new forward reading '#{entity_role.concept.name} has #{identifying_type.name}'"
+            debug :mode, "Creating new forward reading '#{entity_role.object_type.name} has #{identifying_type.name}'"
           else
             debug :mode, "Using existing forward reading"
           end
@@ -356,7 +355,7 @@ module ActiveFacts
           end
           if rs10.all_reading.empty?
             @constellation.Reading(fact_type, fact_type.all_reading.size, :role_sequence => rs10, :text => "{0} is of {1}")
-            debug :mode, "Creating new reverse reading '#{identifying_type.name} is of #{entity_role.concept.name}'"
+            debug :mode, "Creating new reverse reading '#{identifying_type.name} is of #{entity_role.object_type.name}'"
           else
             debug :mode, "Using existing reverse reading"
           end
@@ -417,9 +416,19 @@ module ActiveFacts
           end
         end
 
+        def to_s
+          "EntityType: #{super} #{
+            @supertypes.size > 0 ? "< #{@supertypes*','} " : ''
+          }#{
+            @identification.is_a?(ReferenceMode) ? @identification.to_s : @identification.inspect
+          }#{
+            @clauses.size > 0 ? " where #{@clauses.inspect}" : ''
+          }#{
+            @pragmas.size > 0 ? ", pragmas [#{@pragmas*','}]" : ''
+          };"
+        end
       end
 
     end
   end
 end
-

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

@@ -0,0 +1,418 @@
+module ActiveFacts
+  module CQL
+    class Compiler
+
+      # An Operation is a binary or ternary fact type involving an operator,
+      # a result, and one or two operands.
+      # Viewed as a result, it behaves like a VarRef with a nested Clause.
+      # Viewed as a fact type, it behaves like a Clause.
+      #
+      # The only exception here is an equality comparison, where it may
+      # turn out that the equality is merely a projection. In this case
+      # the Operation is dropped from the clauses and is replaced by the
+      # projected operand.
+      #
+      # Each operand may be a Literal, a VarRef, or another Operation,
+      # so we need to recurse down the tree to build the join.
+      #
+      class Operation
+        # VarRef (in)compatibility:
+        [ :term, :leading_adjective, :trailing_adjective, :role_name, :quantifier,
+          :value_constraint, :embedded_presence_constraint, :literal
+        ].each do |s|
+          define_method(s) { raise "Unexpected call to Operation\##{s}" }
+          define_method(:"#{s}=") { raise "Unexpected call to Operation\##{s}=" }
+        end
+        def role_name; nil; end
+        def leading_adjective; nil; end
+        def trailing_adjective; nil; end
+        def value_constraint; nil; end
+        def literal; nil; end
+        attr_accessor :player     # What ObjectType does the Variable denote
+        attr_accessor :variable   # What Variable for that ObjectType
+        attr_accessor :clause     # What clause does the result participate in?
+        attr_accessor :role       # Which Role of this ObjectType
+        attr_accessor :role_ref   # Which RoleRef to that Role
+        def nested_clauses; @nested_clauses ||= [self]; end
+        def clause; self; end
+        def objectification_of; @fact_type; end
+
+        # Clause (in)compatibility:
+        [ :phrases, :qualifiers, :context_note, :reading, :role_sequence, :fact
+        ].each do |s|
+          define_method(s) { raise "Unexpected call to Operation\##{s}" }
+          define_method(:"#{s}=") { raise "Unexpected call to Operation\##{s}=" }
+        end
+        def conjunction; nil; end
+        attr_reader :fact_type
+        def objectified_as; self; end   # The VarRef which objectified this fact type
+
+        def operands context = nil
+          raise "REVISIT: Implement operand enumeration in the operator subclass #{self.class.name}"
+        end
+
+        def identify_players_with_role_name context
+          # Just recurse, there's no way (yet: REVISIT?) to add a role name to the result of an expression
+          var_refs.each { |o|
+            o.identify_players_with_role_name(context)
+          }
+          # As yet, an operation cannot have a role name:
+          # identify_player context if role_name
+        end
+
+        def identify_other_players context
+          # Just recurse, there's no way (yet: REVISIT?) to add a role name to the result of an expression
+          var_refs.each { |o|
+            o.identify_other_players(context)
+          }
+          identify_player context
+        end
+
+        def bind context
+          var_refs.each do |o|
+            o.bind context
+          end
+          name = result_type_name(context)
+          @player = result_value_type(context, name)
+          key = "#{name} #{object_id}"  # Every Operation result is a unique Variable
+          @variable = (context.variables[key] ||= Variable.new(@player))
+          @variable.refs << self
+          @variable
+        end
+
+        def result_type_name(context)
+          raise "REVISIT: Implement result_type_name in the #{self.class.name} subclass"
+        end
+
+        def result_value_type(context, name)
+          vocabulary = context.vocabulary
+          constellation = vocabulary.constellation
+          constellation.ValueType(vocabulary, name)
+        end
+
+        def is_naked_object_type
+          false # All Operations are non-naked
+        end
+
+        def match_existing_fact_type context
+          opnds = var_refs
+          result_var_ref = VarRef.new(@variable.player.name)
+          result_var_ref.player = @variable.player
+          result_var_ref.variable = @variable
+          @variable.refs << result_var_ref
+          clause_ast = Clause.new(
+            [result_var_ref, '='] +
+              (opnds.size > 1 ? [opnds[0]] : []) +
+              [operator, opnds[-1]]
+          )
+
+          # REVISIT: All operands must be value-types or simply-identified Entity Types.
+
+          # REVISIT: We should auto-create joins from Entity Types to an identifying ValueType
+          # REVISIT: We should traverse up the supertype of ValueTypes to find a DataType
+          @fact_type = clause_ast.match_existing_fact_type(context, :exact_type => true)
+          return @fact_type if @fact_type
+
+          @fact_type = clause_ast.make_fact_type context.vocabulary
+          reading = clause_ast.make_reading context.vocabulary, @fact_type
+          rrs = reading.role_sequence.all_role_ref_in_order
+          opnds[0].role_ref = rrs[0]
+          opnds[-1].role_ref = rrs[-1]
+          opnds.each do |opnd|
+            next unless opnd.is_a?(Operation)
+            opnd.match_existing_fact_type context
+          end
+          @fact_type
+        end
+
+        def is_existential_type
+          false
+        end
+
+        def is_equality_comparison
+          false
+        end
+
+        def operator
+          raise "REVISIT: Implement operator access in the operator subclass #{self.class.name}"
+        end
+
+      end
+
+      class Comparison < Operation
+        attr_accessor :operator, :e1, :e2, :qualifiers, :conjunction
+
+        def initialize operator, e1, e2, qualifiers = []
+          @operator, @e1, @e2, @qualifiers = operator, e1, e2, qualifiers
+        end
+
+        def var_refs
+          [@e1, @e2]
+        end
+
+        def bind context
+          var_refs.each do |o|
+            o.bind context
+          end
+
+          # REVISIT: Return the projected binding instead:
+          return @result = nil if @projection
+
+          name = 'Boolean'
+          @player = result_value_type(context, name)
+          key = "#{name} #{object_id}"  # Every Comparison result is a unique Variable
+          @variable = (context.variables[key] ||= Variable.new(@player))
+          @variable.refs << self
+          @variable
+        end
+
+        def result_type_name(context)
+          "compare#{operator}(#{[@e1,@e2].map{|e| e.player.name}*', '}))"
+        end
+
+        def is_equality_comparison
+          @operator == '='
+        end
+
+        def identify_player context
+          @player || begin
+            if @projection
+              raise "REVISIT: The player is the projected expression"
+            end
+            v = context.vocabulary
+            @player = v.constellation.ValueType(v, 'Boolean')
+          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
+          "compare#{operator}(#{e1.to_s} #{e2.to_s}#{@qualifiers.empty? ? '' : ', ['+@qualifiers*', '+']'})"
+        end
+      end
+
+      class Sum < Operation
+        attr_accessor :terms
+        def initialize *terms
+          @terms = terms
+        end
+
+        def var_refs
+          @terms
+        end
+
+        def operator
+          '+'
+        end
+
+        def identify_player context
+          @player || begin
+            # The players in the @terms have already been identified
+            # REVISIT: Check compliance of all units in @terms, and apply conversions where necessary
+            # REVISIT: The type of this result should be derived from type promotion rules. Here, we take the left-most.
+            # REVISIT: We should define a subtype of the result type here, and apply the units to it.
+            v = context.vocabulary
+            @player = @terms[0].player
+            @player
+          end
+        end
+
+        def result_type_name(context)
+          "sum(#{ @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}" } * ' ' + ')'
+        end
+      end
+
+      class Product < Operation
+        attr_accessor :factors
+        def initialize *factors
+          @factors = factors
+        end
+
+        def var_refs
+          @factors
+        end
+
+        def operator
+          '*'
+        end
+
+        def identify_player context
+          @player || begin
+            # The players in the @factors have already been identified
+            # REVISIT: Calculate the units of the result from the units in @factors
+            # REVISIT: The type of this result should be derived from type promotion rules. Here, we take the left-most.
+            # REVISIT: We should define a subtype of the result type here, and apply the units to it.
+            v = context.vocabulary
+            @player = @factors[0].player
+          end
+        end
+
+        def result_type_name(context)
+          "product(#{ @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}" } * ' ' + ')'
+        end
+      end
+
+      class Reciprocal < Operation
+        attr_accessor :divisor
+        def initialize divisor
+          @divisor = divisor
+        end
+
+        def operator
+          '1/'
+        end
+
+        def var_refs
+          [@divisor]
+        end
+
+        def identify_player context
+          @player || begin
+            # The player in @divisor has already been identified
+            # REVISIT: Calculate the units of the result from the units in @divisor
+            # REVISIT: Do we want integer division?
+            v = context.vocabulary
+            @player = v.constellation.ValueType(v, 'Real')
+          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
+      end
+
+      class Negate
+        attr_accessor :term
+        def initialize term
+          @term = term
+        end
+
+        def operator
+          '0-'
+        end
+
+        def identify_player context
+          @player || begin
+            # The player in @term have already been identified
+            v = context.vocabulary
+            @player = @term.player
+          end
+        end
+
+=begin
+        def result_type_name(context)
+          raise hell
+        end
+=end
+
+        def inspect; to_s; end
+
+        def to_s
+          "negate(#{term.to_s})"
+        end
+      end
+
+      class Literal
+        attr_accessor :literal, :unit, :role, :role_ref, :clause
+        attr_reader :objectification_of, :leading_adjective, :trailing_adjective, :value_constraint
+
+        def initialize literal, unit
+          @literal, @unit = literal, unit
+        end
+
+        # Stubs:
+        def role_name; nil; end
+        def nested_clauses; nil; end
+
+        def inspect; to_s; end
+
+        def to_s
+          unit ? "(#{@literal.to_s} in #{unit.to_s})" : @literal.to_s
+        end
+
+        def player
+          @player
+        end
+
+        def identify_players_with_role_name(context)
+          # Nothing to do here, move along
+        end
+
+        def identify_other_players(context)
+          identify_player context
+        end
+
+        def identify_player context
+          @player || begin
+            player_name =
+              case @literal
+              when String; 'String'
+              when Float; 'Real'
+              when Numeric; 'Integer'
+              when TrueClass, FalseClass; 'Boolean'
+              end
+            v = context.vocabulary
+            @player = v.constellation.ValueType(v, player_name)
+          end
+        end
+
+        def bind context
+          @variable || begin
+            key = "#{@player.name} #{@literal}"
+            @variable = (context.variables[key] ||= Variable.new(@player))
+            @variable.refs << self
+          end
+        end
+
+        def variable
+          @variable
+        end
+      end
+
+    end
+  end
+end