activefacts 0.8.9 → 0.8.10

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

@@ -2,19 +2,19 @@ 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
+      # In a declaration, a Variable has one or more VarRef's.
+      # A Variable is for a single ObjectType, normally related to just one Role,
+      # and the references (VarRefs) to it will normally be the object_type 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
+      # In some situations a Variable will have some VarRefs with the same adjectives,
+      # and one or more VarRefs with no adjectives - this is called "loose binding".
+      class Variable
+        attr_reader :player             # The ObjectType (object type)
+        attr_reader :refs               # an array of the VarRefs
         attr_reader :role_name
-        attr_accessor :rebound_to       # Loose binding may set this to another binding
+        attr_accessor :rebound_to       # Loose binding may set this to another variable
         attr_accessor :join_node
         attr_accessor :instance         # When binding fact instances, the instance goes here
 
@@ -38,22 +38,27 @@ module ActiveFacts
       end
 
       class CompilationContext
+        attr_accessor :vocabulary
         attr_accessor :allowed_forward_terms
-        attr_reader :bindings             # The Bindings in this declaration
+        attr_accessor :left_contraction_allowed
+        attr_accessor :left_contractable_clause
+        attr_accessor :left_contraction_conjunction
+        attr_reader :variables             # The Variables in this declaration
         attr_reader :player_by_role_name
 
         def initialize vocabulary
           @vocabulary = vocabulary
           @vocabulary_identifier = @vocabulary.identifying_role_values
           @allowed_forward_terms = []
-          @bindings = {}
+          @variables = {}
           @player_by_role_name = {}
+          @left_contraction_allowed = false
         end
 
-        # Look up this concept by its name
-        def concept(name)
+        # Look up this object_type by its name
+        def object_type(name)
           constellation = @vocabulary.constellation
-          player = constellation.Concept[[@vocabulary_identifier, name]]
+          player = constellation.ObjectType[[@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]
@@ -64,13 +69,31 @@ module ActiveFacts
 
           player
         end
+
+        # Pass in an array of clauses or VarRefs for player identification and binding (creating the Variables)
+        # It's necessary to identify all players that define a role name first,
+        # so those names exist in the context for where they're used.
+        def bind *clauses
+          cl = clauses.flatten
+          cl.each { |clause| clause.identify_players_with_role_name(self) }
+          cl.each { |clause| clause.identify_other_players(self) }
+          cl.each { |clause| clause.bind(self) }
+        end
       end
 
       class Definition
-        attr_accessor :constellation, :vocabulary, :source
+        attr_accessor :constellation, :vocabulary, :tree
         def compile
           raise "#{self.class} should implement the compile method"
         end
+
+        def to_s
+          @vocabulary ? "#{vocabulary.to_s}::" : ''
+        end
+
+        def source
+          @tree.text_value
+        end
       end
 
       class Vocabulary < Definition
@@ -81,6 +104,10 @@ module ActiveFacts
         def compile
           @constellation.Vocabulary @name
         end
+
+        def to_s
+          @name
+        end
       end
 
       class Import < Definition
@@ -88,23 +115,24 @@ module ActiveFacts
           @name = name
           @alias_list = alias_list
         end
+
+        def to_s
+          "#{@vocabulary.to_s} imports #{alias_list*', '};"
+        end
       end
 
-      class Concept < Definition
+      class ObjectType < Definition
         attr_reader :name
 
         def initialize name
           @name = name
         end
+
+        def to_s
+          "#{super}#{@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

@@ -58,9 +58,31 @@ module ActiveFacts
             unit
           end
         end
+
+        def inspect
+          to_s
+        end
+
+        def to_s
+          super + "Unit(#{
+            @singular
+          }#{
+            @plural ? '/'+@plural : ''
+          }) is #{
+            @numerator
+          }/#{
+            @denominator
+          }+#{
+            @offset
+          } #{
+            @base_units.map{|b,e|
+              b+'^'+e.to_s
+            }*'*'
+          }"
+        end
       end
 
-      class ValueType < Concept
+      class ValueType < ObjectType
         def initialize name, base, parameters, unit, value_constraint, pragmas
           super name
           @base_type_name = base
@@ -89,7 +111,25 @@ module ActiveFacts
           vt.length = length if length
           vt.scale = scale if scale
 
-          raise "REVISIT: ValueType units are recognised but not yet compiled" unless @unit.empty?
+          unless @unit.empty?
+            unit_name, exponent = *@unit[0]
+            unit = @constellation.Unit.detect{|k,v| v.name == unit_name }
+            raise "Unit #{unit_name} for value type #{@name} is not defined" unless unit
+            if exponent != 1
+              base_unit = unit
+              unit_name = base_unit.name+"^#{exponent}"
+              unless unit = @constellation.Unit.detect{|k,v| v.name == unit_name } 
+                # Define a derived unit (these are skipped on output)
+                unit = @constellation.Unit(:new,
+                      :vocabulary => @vocabulary,
+                      :name => unit_name,
+                      :is_fundamental => false
+                    )
+                @constellation.Derivation(unit, base_unit).exponent = exponent
+              end
+            end
+            vt.unit = unit
+          end
 
           if @value_constraint
             @value_constraint.constellation = @constellation
@@ -98,6 +138,20 @@ module ActiveFacts
 
           vt
         end
+
+        def to_s
+          "ValueType: #{super} is written as #{
+              @base_type_name
+            }#{
+              @parameters.size > 0 ? "(#{ @parameters.map{|p|p.to_s}*', ' })" : ''
+            }#{
+              @unit && @unit.length > 0 ? " in #{@unit.inspect}" : ''
+            }#{
+              @value_constraint ? " "+@value_constraint.to_s : ''
+            }#{
+              @pragmas.size > 0 ? ", pragmas [#{@pragmas*','}]" : ''
+            };"
+        end
       end
     end
   end

data/lib/activefacts/cql/parser.rb

@@ -12,12 +12,18 @@ require 'activefacts/cql/LexicalRules'
 require 'activefacts/cql/Language/English'
 require 'activefacts/cql/Expressions'
 require 'activefacts/cql/Terms'
-require 'activefacts/cql/Concepts'
+require 'activefacts/cql/ObjectTypes'
 require 'activefacts/cql/ValueTypes'
 require 'activefacts/cql/FactTypes'
 require 'activefacts/cql/Context'
 require 'activefacts/cql/CQLParser'
 
+class Treetop::Runtime::SyntaxNode
+  def node_type
+    terminal? ? :keyword : :composite
+  end
+end
+
 module ActiveFacts
   module CQL
     module Terms
@@ -62,7 +68,7 @@ module ActiveFacts
         end
 
         def new_trailing_adjective_term(adj, term)
-          index_name(@role_names, n = "#{term} #{adj}", term) && debug(:context, "new role '#{term} -#{adj}'")
+          index_name(@role_names, "#{term} #{adj}", term) && debug(:context, "new role '#{term} -#{adj}'")
           true
         end
 
@@ -201,12 +207,17 @@ module ActiveFacts
 
         @index = 0  # Byte offset to start next parse
         self.consume_all_input = false
+        nodes = []
         begin
           node = parse(InputProxy.new(input, context), :index => @index)
           return nil unless node
-          block.call(node) if block
+          if block
+            block.call(node)
+          else
+            nodes << node
+          end
         end until self.index == @input_length
-        true
+        block ? true : nodes
       end
     end
 

data/lib/activefacts/generate/absorption.rb

@@ -14,7 +14,7 @@ module ActiveFacts
     #   afgen --absorption[=options] <file>.cql"
     # Options are comma or space separated:
     # * no_columns Don't emit the columns
-    # * all Show Concepts that are not tables as well
+    # * all Show ObjectTypes that are not tables as well
     # * paths Show the references paths through which each column was defined
     # * no_identifier Don't show the identified_by columns for an EntityType
 
@@ -34,21 +34,21 @@ module ActiveFacts
         multi_absorption_vts = 0
         multi_absorption_ets = 0
         @vocabulary.tables
-        @vocabulary.all_concept.sort_by{|c| c.name}.each do |o|
+        @vocabulary.all_object_type.sort_by{|c| c.name}.each do |o|
           next if !o.is_table
           show(o)
         end
       end
 
-      def show concept        #:nodoc:
-        indices = concept.indices
+      def show object_type        #:nodoc:
+        indices = object_type.indices
         pk = indices.select(&:is_primary)[0]
         indices = indices.clone
         indices.delete pk
-        puts "#{concept.name}: #{
-#            "[#{concept.indices.size} indices] "
+        puts "#{object_type.name}: #{
+#            "[#{object_type.indices.size} indices] "
 #          } #{
-            concept.columns.sort_by do |column|
+            object_type.columns.sort_by do |column|
               column.name(nil)
             end.map do |column|
               index_nrs =

data/lib/activefacts/generate/cql.rb

@@ -57,6 +57,10 @@ module ActiveFacts
         puts ";"
       end
 
+      def units_end
+        puts "\n"
+      end
+
       def value_type_banner
         puts "/*\n * Value Types\n */"
       end
@@ -84,8 +88,8 @@ module ActiveFacts
           !o.all_role.
             detect do |role|
               (other_roles = role.fact_type.all_role.to_a-[role]).size != 1 ||      # Not a role in a binary FT
-              !(concept = other_roles[0].concept).is_a?(ActiveFacts::Metamodel::EntityType) ||  # Counterpart is not an ET
-              (pi = concept.preferred_identifier).role_sequence.all_role_ref.size != 1 ||   # Entity PI has > 1 roles
+              !(object_type = other_roles[0].object_type).is_a?(ActiveFacts::Metamodel::EntityType) ||  # Counterpart is not an ET
+              (pi = object_type.preferred_identifier).role_sequence.all_role_ref.size != 1 ||   # Entity PI has > 1 roles
               pi.role_sequence.all_role_ref.single.role != role                     # This isn't the identifying role
             end
           puts "About to skip #{o.name}"
@@ -106,9 +110,17 @@ module ActiveFacts
           ].compact
         parameters = parameters.length > 0 ? "("+parameters.join(",")+")" : ""
 
-        puts "#{o.name} is written as #{(o.supertype || o).name}#{ parameters }#{
+        puts "#{o.name
+          } #{
+            (o.is_independent ? '[independent] ' : '')
+          }is written as #{
+            (o.supertype || o).name
+          }#{
+            parameters
+          }#{
+            o.unit && " "+o.unit.name
+          }#{
             o.value_constraint && " "+o.value_constraint.describe
-          }#{o.is_independent ? ' [independent]' : ''
           };"
       end
 
@@ -116,13 +128,13 @@ module ActiveFacts
         reading << " [#{(ring.ring_type.scan(/[A-Z][a-z]*/)*", ").downcase}]"
       end
 
-      def mapping_pragma(entity_type)
+      def mapping_pragma(entity_type, ignore_independence = false)
         ti = entity_type.all_type_inheritance_as_subtype
         assimilation = ti.map{|t| t.assimilation }.compact[0]
-        return "" unless entity_type.is_independent || assimilation
+        return "" unless (entity_type.is_independent && !ignore_independence) || assimilation
         " [" +
           [
-            entity_type.is_independent ? "independent" : nil,
+            entity_type.is_independent && !ignore_independence ? "independent" : nil,
             assimilation || nil
           ].compact*", " +
         "]"
@@ -134,12 +146,12 @@ module ActiveFacts
         fact_type = external_identifying_facts[0]
         ftr = fact_type && fact_type.all_role.sort_by{|role| role.ordinal}
         if external_identifying_facts.size == 1 and
-            entity_role = ftr[n = (ftr[0].concept == entity_type ? 0 : 1)] and
+            entity_role = ftr[n = (ftr[0].object_type == entity_type ? 0 : 1)] and
             value_role = ftr[1-n] and
-            value_player = value_role.concept and
+            value_player = value_role.object_type and
             value_player.is_a?(ActiveFacts::Metamodel::ValueType) and
             value_name = value_player.name and
-            value_residual = value_name.sub(%r{^#{entity_role.concept.name} ?},'') and
+            value_residual = value_name.sub(%r{^#{entity_role.object_type.name} ?},'') and
             value_residual != '' and
             value_residual != value_name
           [fact_type, entity_role, value_role, value_residual]
@@ -189,7 +201,7 @@ module ActiveFacts
         # We can't subscript reference modes.
         # If an objectified fact type has a role played by its identifying player, go long-hand.
         return nil if entity_type.fact_type and
-          entity_type.fact_type.all_role.detect{|role| role.concept == value_role.concept }
+          entity_type.fact_type.all_role.detect{|role| role.object_type == value_role.object_type }
 
         @fact_types_dumped[fact_type] = true  # We've covered this fact type
 
@@ -212,7 +224,7 @@ module ActiveFacts
 
         # The verbaliser needs to have a Player for the roles of entity_type, so it doesn't get subscripted.
         entity_roles =
-          nonstandard_readings.map{|r| r.role_sequence.all_role_ref.detect{|rr| rr.role.concept == entity_type}}.compact
+          nonstandard_readings.map{|r| r.role_sequence.all_role_ref.detect{|rr| rr.role.object_type == entity_type}}.compact
         verbaliser.role_refs_have_same_player entity_roles
 
         verbaliser.alternate_readings nonstandard_readings
@@ -220,7 +232,7 @@ module ActiveFacts
           verbaliser.alternate_readings entity_type.fact_type.all_reading
         end
 
-        verbaliser.create_subscripts      # Ok, the Verbaliser is ready to fly
+        verbaliser.create_subscripts(:rolenames)      # Ok, the Verbaliser is ready to fly
 
         fact_readings =
           nonstandard_readings.map { |reading| expanded_reading(verbaliser, reading, fact_constraints, true) }
@@ -231,7 +243,8 @@ module ActiveFacts
         if nonstandard_readings.size == 0 and c = value_role.role_value_constraint
           constraint_text = " "+c.describe
         end
-        return " identified by its #{value_residual}#{constraint_text}#{mapping_pragma(entity_type)}" +
+        (entity_type.is_independent ? ' independent' : '') +
+          " identified by its #{value_residual}#{constraint_text}#{mapping_pragma(entity_type, true)}" +
           (fact_readings.size > 0 ? " where\n\t" : "") +
           fact_readings*",\n\t"
       end
@@ -247,14 +260,14 @@ module ActiveFacts
         # Announce all the identifying fact roles to the verbaliser so it can decide on any necessary subscripting.
         # The verbaliser needs to have a Player for the roles of entity_type, so it doesn't get subscripted.
         entity_roles =
-          identifying_facts.map{|ft| ft.preferred_reading.role_sequence.all_role_ref.detect{|rr| rr.role.concept == entity_type}}.compact
+          identifying_facts.map{|ft| ft.preferred_reading.role_sequence.all_role_ref.detect{|rr| rr.role.object_type == entity_type}}.compact
         verbaliser.role_refs_have_same_player entity_roles
         identifying_facts.each do |fact_type|
           # The RoleRefs for corresponding roles across all readings are for the same player.
           verbaliser.alternate_readings fact_type.all_reading
-          @fact_types_dumped[fact_type] = true
+          @fact_types_dumped[fact_type] = true unless fact_type.entity_type # Must dump objectification still!
         end
-        verbaliser.create_subscripts
+        verbaliser.create_subscripts(:rolenames)
 
         irn = verbaliser.identifying_role_names identifying_role_refs
 
@@ -263,8 +276,9 @@ module ActiveFacts
                 fact_readings_with_constraints(verbaliser, f)
             }.flatten*",\n\t"
 
-        " identified by #{ irn*" and " }" +
-          mapping_pragma(entity_type) +
+        (entity_type.is_independent ? ' independent' : '') +
+          " identified by #{ irn*" and " }" +
+          mapping_pragma(entity_type, true) +
           " where\n\t"+identifying_fact_text
       end
 
@@ -277,20 +291,22 @@ module ActiveFacts
       end
 
       def subtype_dump(o, supertypes, pi)
-        print "#{o.name} is a kind of #{ o.supertypes.map(&:name)*", " }"
+        print "#{o.name} is a kind of #{
+            o.is_independent ? 'independent ' : ''
+          }#{ o.supertypes.map(&:name)*", " }"
         if pi
           puts identified_by(o, pi)+';'
           return
         end
 
-        print mapping_pragma(o)
+        print mapping_pragma(o, true)
 
         if o.fact_type
           verbaliser = ActiveFacts::Metamodel::Verbaliser.new
           # Announce all the objectified fact roles to the verbaliser so it can decide on any necessary subscripting.
           # The RoleRefs for corresponding roles across all readings are for the same player.
           verbaliser.alternate_readings o.fact_type.all_reading
-          verbaliser.create_subscripts
+          verbaliser.create_subscripts(:rolenames)
 
           print " where\n\t" + fact_readings_with_constraints(verbaliser, o.fact_type)*",\n\t"
         end
@@ -301,12 +317,25 @@ module ActiveFacts
         puts "#{o.name} is" + identified_by(o, pi) + ';'
       end
 
+      def naiive_expand(reading)
+        role_refs = reading.role_sequence.all_role_ref_in_order
+        reading.text.gsub(/\{(\d+)\}/) do
+          role_refs[$1.to_i].role.object_type.name
+        end
+      end
+
       def fact_type_dump(fact_type, name)
 
         if (o = fact_type.entity_type)
           print "#{o.name} is"
           supertypes = o.supertypes
-          print " a kind of #{ supertypes.map(&:name)*", " }" unless supertypes.empty?
+          if supertypes.empty?
+            print ' independent' if o.is_independent
+          else
+            print " a kind of#{
+                o.is_independent ? ' independent' : ''
+              } #{ supertypes.map(&:name)*', ' }"
+          end
 
           # Alternate identification of objectified fact type?
           primary_supertype = supertypes[0]
@@ -318,12 +347,36 @@ module ActiveFacts
           print " where\n\t"
         end
 
+        # Check whether this fact type has readings which could be confused for a previously-dumped one:
+        reading_texts = fact_type.all_reading.map{|r| naiive_expand(r)}
+        if reading_texts.size > 1
+          ambiguity =
+            fact_type.all_role.to_a[0].object_type.all_role.map{|r| r.fact_type}.
+              select{|f| f != fact_type && @fact_types_dumped.include?(f) }.
+              detect do |dft|
+                ambiguous_readings =
+                  reading_texts & dft.all_reading.map{|r| naiive_expand(r)}
+                ambiguous_readings.size > 0
+              end
+          if ambiguity
+            puts fact_type.default_reading([], true)+';  // Avoid ambiguity; this is a new fact type'
+          end
+        end
+
         # There can be no roles of the objectified fact type in the readings, so no need to tell the Verbaliser anything special
         verbaliser = ActiveFacts::Metamodel::Verbaliser.new
         verbaliser.alternate_readings fact_type.all_reading
-        verbaliser.create_subscripts
+        pr = fact_type.preferred_reading
+        if (pr.role_sequence.all_role_ref.to_a[0].join_role)
+          verbaliser.prepare_role_sequence pr.role_sequence
+        end
+        verbaliser.create_subscripts(:rolenames)
 
-        puts(fact_readings_with_constraints(verbaliser, fact_type)*",\n\t"+";")
+        print(fact_readings_with_constraints(verbaliser, fact_type)*",\n\t")
+        if (pr.role_sequence.all_role_ref.to_a[0].join_role)
+          print ":\n\t"+verbaliser.verbalise_over_role_sequence(pr.role_sequence)
+        end
+        puts(';')
       end
 
       def fact_type_banner
@@ -344,9 +397,9 @@ module ActiveFacts
 
       # Of the players of a set of roles, return the one that's a subclass of (or same as) all others, else nil
       def roleplayer_subclass(roles)
-        roles[1..-1].inject(roles[0].concept){|subclass, role|
-          next nil unless subclass and EntityType === role.concept
-          role.concept.supertypes_transitive.include?(subclass) ? role.concept : nil
+        roles[1..-1].inject(roles[0].object_type){|subclass, role|
+          next nil unless subclass and EntityType === role.object_type
+          role.object_type.supertypes_transitive.include?(subclass) ? role.object_type : nil
         }
       end
 
@@ -366,6 +419,8 @@ module ActiveFacts
         end
 
         verbaliser.prepare_role_sequence(c.role_sequence, join_over)
+        # REVISIT: Need to discount role_adjuncts in here, since this constraint uses loose binding:
+        verbaliser.create_subscripts :loose
 
         expanded_readings = verbaliser.verbalise_over_role_sequence(c.role_sequence, nil, role_proximity)
         if c.min_frequency == 1 && c.max_frequency == nil and c.role_sequence.all_role_ref.size == 2
@@ -404,7 +459,7 @@ module ActiveFacts
             end
           end
         end
-        verbaliser.create_subscripts
+        verbaliser.create_subscripts :normal
 
         if role_sequences.detect{|scr| scr.all_role_ref.detect{|rr| rr.join_role}}
           # This set constraint has an explicit join. Verbalise it.
@@ -421,6 +476,14 @@ module ActiveFacts
             puts "either " + readings_list.join(" or ") + " but not both;"
             return
           end
+
+          # Internal check: We must have located the players here
+          if i = players.index(nil)
+            rrs = transposed_role_refs[i]
+            raise "Internal error detecting constrained object types in join involving #{rrs.map{|rr| rr.role.fact_type.default_reading}.uniq*', '}"
+          end
+
+          # Loose binding will apply only to the constrained roles, not to all roles. Not handled here.
           mode = c.is_mandatory ? "exactly one" : "at most one"
           puts "for each #{players.map{|p| p.name}*", "} #{mode} of these holds:\n\t" +
             readings_list.join(",\n\t") +
@@ -437,7 +500,7 @@ module ActiveFacts
         end
 
         # A constrained role may involve a subtyping join. We substitute the name of the supertype for all occurrences.
-        players = transposed_role_refs.map{|role_refs| common_supertype(role_refs.map{|rr| rr.role.concept})}
+        players = transposed_role_refs.map{|role_refs| common_supertype(role_refs.map{|rr| rr.role.object_type})}
         raise "Constraint must cover matching roles" if players.compact.size < players.size
 
         readings_expanded = scrs.
@@ -480,7 +543,7 @@ module ActiveFacts
         transposed_role_refs.each { |role_refs| verbaliser.role_refs_are_subtype_joined role_refs }
         verbaliser.prepare_role_sequence c.subset_role_sequence
         verbaliser.prepare_role_sequence c.superset_role_sequence
-        verbaliser.create_subscripts
+        verbaliser.create_subscripts :normal
 
         puts \
           verbaliser.verbalise_over_role_sequence(c.subset_role_sequence) +
@@ -509,11 +572,11 @@ module ActiveFacts
           end
       end
 
-      # Find the common supertype of these concepts.
-      def common_supertype(concepts)
-        common = concepts[0].supertypes_transitive
-        concepts[1..-1].each do |concept|
-          common &= concept.supertypes_transitive
+      # Find the common supertype of these object_types.
+      def common_supertype(object_types)
+        common = object_types[0].supertypes_transitive
+        object_types[1..-1].each do |object_type|
+          common &= object_type.supertypes_transitive
         end
         common[0]
       end
@@ -581,7 +644,7 @@ module ActiveFacts
         # Make sure that we refer to the constrained players by their common supertype (as passed in)
         frequency_constraints = reading.role_sequence.all_role_ref.
           map do |role_ref|
-            player = role_ref.role.concept
+            player = role_ref.role.object_type
             i = constrained_roles.index(role_ref.role)
             player = players[i] if i
             [ nil, player.name ]