activefacts 0.7.1 → 0.7.2

data/lib/activefacts/persistence/columns.rb

@@ -59,7 +59,7 @@ module ActiveFacts
       # A Column name is a sequence of names (derived from the to_roles of the References)
       # joined by a joiner string (pass nil to get the original array of names)
       def name(joiner = "")
-        last_name = ""
+        last_names = []
         names = @references.
           reject do |ref|
             # Skip any object after the first which is identified by this reference
@@ -67,37 +67,41 @@ module ActiveFacts
               !ref.fact_type.is_a?(TypeInheritance) and
               ref.to and
               ref.to.is_a?(EntityType) and
-              (role_refs = ref.to.preferred_identifier.role_sequence.all_role_ref).size == 1 and
-              role_refs.only.role == ref.from_role
+              (role_ref = ref.to.preferred_identifier.role_sequence.all_role_ref.single) and
+              role_ref.role == ref.from_role
           end.
           inject([]) do |a, ref|
             names = ref.to_names
 
             # When traversing type inheritances, keep the subtype name, not the supertype names as well:
             if a.size > 0 && ref.fact_type.is_a?(TypeInheritance)
-              a[-1] = names[0] if ref.to == ref.fact_type.subtype   # Else we already had the subtype
-              next a
+              next a if ref.to != ref.fact_type.subtype  # Did we already have the subtype?
+              last_names.size.times { a.pop }   # Remove the last names added
+            elsif last_names.last && last_names.last == names[0][0...last_names.last.size] 
+              # When Xyz is followed by XyzID, truncate that to just ID
+              names[0] = names[0][last_names.last.size..-1]
+            elsif last_names.last == names[0]
+              # Same, but where an underscore split up the words
+              names.shift
             end
 
-            # When Xyz is followed by XyzID, truncate that to just ID:
-            names[0] = names[0][last_name.size..-1] if last_name == names[0][0...last_name.size] 
-            last_name = names.last
+            # Where the last name is like a reference mode but the preceeding name isn't the identified concept,
+            # strip it down (so turn Driver.PartyID into Driver.ID for example):
+            if a.size > 0 and
+                (et = ref.from).is_a?(EntityType) and
+                (role_ref = et.preferred_identifier.role_sequence.all_role_ref.single) and
+                role_ref.role == ref.to_role and
+                names[0][0...et.name.size].downcase == et.name.downcase
+              names[0] = names[0][et.name.size..-1]
+              names.shift if names[0] == ""
+            end
+
+            last_names = names
 
             a += names
             a
           end
 
-        # Where the last name is like a reference mode but the preceeding name isn't the identified concept,
-        # strip it down (so turn Driver.PartyID into Driver.ID for example):
-        if names.size > 1 and
-            (et = @references.last.from).is_a?(EntityType) and
-            (role_refs = et.preferred_identifier.role_sequence.all_role_ref).size == 1 and
-            role_refs.only.role == @references.last.to_role and
-            names.last[0...et.name.size].downcase == et.name.downcase
-          names[-1] = names.last[et.name.size..-1]
-          names.pop if names.last == ''
-        end
-
         name_array = names.map{|n| n.sub(/^[a-z]/){|s| s.upcase}}
         joiner ? name_array * joiner : name_array
       end
@@ -185,10 +189,13 @@ module ActiveFacts
     # This section shows the features relevant to relational Persistence.
     class Concept
       # The array of columns for this Concept's table
-      def columns; @columns; end
+      def columns
+        @columns
+      end
 
       def populate_columns  #:nodoc:
-        @columns = all_columns({})
+        @columns =
+          all_columns({})
       end
     end
 

data/lib/activefacts/persistence/concept.rb

@@ -0,0 +1,73 @@
+module ActiveFacts
+  module API
+    module Concept
+      def table
+        @is_table = true
+      end
+
+      def is_table
+        @is_table
+      end
+
+      def columns
+        #puts "Calculating columns for #{basename}"
+        return @columns if @columns
+        @columns = (
+          roles.
+              values.
+              select{|role| role.unique}.
+              inject([]) do |columns, role|
+            rn = role.name.to_s.split(/_/)
+            columns += role.counterpart_concept.__absorb(rn, role.counterpart)
+          end +
+          # REVISIT: Need to use subtypes_transitive here:
+          subtypes.
+            select{|subtype| !subtype.is_table}.    # Don't absorb separate subtypes
+            inject([]) { |columns, subtype|
+              sn = [subtype.basename]
+              columns += subtype.__absorb(sn)
+              # puts "subtype #{subtype.name} contributed #{columns.inspect}"
+              columns
+            }
+          ).map{|col_names| col_names.uniq.map{|name| name.sub(/^[a-z]/){|c| c.upcase}}*"."}
+      end
+
+      # Return an array of the absorbed columns, using prefix for name truncation
+      def __absorb(prefix, except_role = nil)
+        is_entity = respond_to?(:identifying_role_names)
+        absorbed_into = nil
+        if absorbed_into
+          # REVISIT: if this concept is fully absorbed through one of its roles into another table, we absorb that tables identifying_roles
+          absorbed_into.__absorb(prefix)
+        elsif !@is_table
+          # Not a table -> all roles are absorbed
+          if is_entity
+            roles.
+                values.
+                select{|role| role.unique && role.counterpart_concept != except_role }.
+                inject([]) do |columns, role|
+              columns += role.counterpart_concept.__absorb(prefix + role.name.to_s.split(/_/), self)
+            end
+          else
+            [prefix]
+          end
+        else
+        #puts "#{@is_table ? "referencing" : "absorbing"} #{is_entity ? "entity" : "value"} #{basename} using #{prefix.inspect}"
+          if is_entity
+            identifying_role_names.map{|role_name| prefix+role_name.to_s.split(/_/)}
+          else
+            # Reference to value type which is a table
+            [prefix + ["Value"]]
+          end
+        end
+      end
+    end
+
+  end
+end
+
+class TrueClass
+  def self.__absorb(prefix, except_role = nil)
+    [prefix]
+  end
+end

data/lib/activefacts/persistence/foreignkey.rb

@@ -35,7 +35,11 @@ module ActiveFacts
       # Return an Array of Reference paths for such absorbed FKs
       def all_absorbed_foreign_key_reference_path
         references_from.inject([]) do |array, ref|
+
           if ref.is_simple_reference
+            # This catches references that would be created to secondary supertypes, when absorption is through primary.
+            # There might be other cases where an exclusion like this is needed, but I can't reason it out.
+            next array if TypeInheritance === ref.fact_type && absorbed_via && TypeInheritance === absorbed_via.fact_type
             array << [ref]
           elsif ref.is_absorbing
             ref.to.all_absorbed_foreign_key_reference_path.each{|aref|
@@ -102,8 +106,20 @@ module ActiveFacts
             end
             debug :fk, "to_columns in #{to.name}: #{to_columns.map { |column| column ? column.name : "OOPS!" }*", "}"
 
-            ActiveFacts::Persistence::ForeignKey.new(self, to, fk_ref_path[-1], from_columns, to_columns)
+            # Put the column pairs in a defined order, sorting key pairs by to-name:
+            froms, tos = from_columns.zip(to_columns).sort_by { |pair|
+              pair[1].name(nil)
+            }.transpose
+
+            ActiveFacts::Persistence::ForeignKey.new(self, to, fk_ref_path[-1], froms, tos)
           end
+        end.
+        sort_by do |fk|
+          # Put the foreign keys in a defined order:
+          [ fk.to.name,
+            fk.to_columns.map{|col| col.name(nil).sort},
+            fk.from_columns.map{|col| col.name(nil).sort}
+          ]
         end
       end
     end

data/lib/activefacts/persistence/index.rb

@@ -94,10 +94,14 @@ module ActiveFacts
         # The reference path is the set of absorption references and one past it.
         # Stopping here means we don't dig into the definitions of FK column counterparts.
         # Note that many columns of an object may have the same ref_path.
+        #
+        # REVISIT:
+        # Note also that this produces columns ordered for each refpath the same as the
+        # order of the columns, not the same as the columns in the PK for which they might be an FK.
         all_column_by_ref_path =
           debug :index2, "Indexing columns by ref_path" do
-            columns.inject({}) do |hash, column|
-              debug :index2, "References in column #{name}#{column.name}" do
+            @columns.inject({}) do |hash, column|
+              debug :index2, "References in column #{name}.#{column.name}" do
                 ref_path = column.absorption_references
                 raise "No absorption_references for #{column.name} from #{column.references.map(&:to_s)*" and "}" if !ref_path || ref_path.empty?
                 (hash[ref_path] ||= []) << column
@@ -114,15 +118,17 @@ module ActiveFacts
             inject({}) do |hash, ref_path|
               ref_path.each do |ref|
                 next unless ref.to_role
+                #debug :index2, "Considering #{ref_path.map(&:to_s)*" and "} yielding columns #{all_column_by_ref_path[ref_path].map{|c| c.name(".")}*", "}"
+                #debugger if name == 'VehicleIncident' && ref.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
                 ref.to_role.all_role_ref.each do |role_ref|
-                  pcs = role_ref.role_sequence.all_presence_constraint.
+                  all_pcs = role_ref.role_sequence.all_presence_constraint
+    #puts "pcs over #{ref_path.map{|r| r.to_names}.flatten*"."}: #{role_ref.role_sequence.all_presence_constraint.map(&:describe)*"; "}" if all_pcs.size > 0
+                  pcs = all_pcs.
                     reject do |pc|
                       !pc.max_frequency or      # No maximum freq; cannot be a uniqueness constraint
                       pc.max_frequency != 1 or  # maximum is not 1
-                      pc.role_sequence.all_role_ref.size == 1 &&        # UniquenessConstraint is over one role
-                        ((fact_type = pc.role_sequence.all_role_ref.only.role.fact_type).is_a?(TypeInheritance) ||      # Inheritance
-                        fact_type.all_role.size == 1)             # Unary
-                        # The preceeeding two restrictions exclude the internal UCs created within NORMA.
+                                                # Constraint is not over a unary fact type role (NORMA does this)
+                      pc.role_sequence.all_role_ref.size == 1 && ref_path[-1].to_role.fact_type.all_role.size == 1
                     end
                   next unless pcs.size > 0
                   # The columns for this ref_path support the UCs in "pcs".
@@ -151,8 +157,8 @@ module ActiveFacts
             # Absorption through a one-to-one forms a UC that we don't need to enforce using an index:
             next nil if over != self and
               over.absorbed_via == columns[0].references[absorption_level-1] and
-              (rrs = uc.role_sequence.all_role_ref).size == 1 and
-              over.absorbed_via.fact_type.all_role.include?(rrs.only.role)
+              (rr = uc.role_sequence.all_role_ref.single) and
+              over.absorbed_via.fact_type.all_role.include?(rr.role)
 
             index = ActiveFacts::Persistence::Index.new(
               uc,
@@ -163,7 +169,12 @@ module ActiveFacts
             )
             debug :index, index
             index
-          end.compact
+          end.
+          compact.
+          sort_by do |index|
+            # Put the indices in a defined order:
+            index.columns.map(&:name)
+          end
         end
       end
 

data/lib/activefacts/persistence/reference.rb

@@ -114,16 +114,16 @@ module ActiveFacts
       def to_names
         case
         when is_unary
-          @to_role.fact_type.preferred_reading.reading_text.gsub(/\{[0-9]\}/,'').strip.split(/\s/)
+          @to_role.fact_type.preferred_reading.reading_text.gsub(/\{[0-9]\}/,'').strip.split(/[_\s]/)
         when @to && !@to_role           # @to is an objectified fact type so @to_role is a phantom
-          [@to.name]
+          @to.name.split(/[_\s]/)
         when !@to_role                  # Self-value role of an independent ValueType
-          ["#{@from.name}Value"]
+          ["#{@from.name}", "Value"]
         when @to_role.role_name         # Named role
-          [@to_role.role_name]
+          @to_role.role_name.split(/[_\s]/)
         else                            # Use the name from the preferred reading
           role_ref = @to_role.preferred_reference
-          [role_ref.leading_adjective, @to_role.concept.name, role_ref.trailing_adjective].compact.map{|w| w.split(/\s/)}.flatten.reject{|s| s == ''}
+          [role_ref.leading_adjective, @to_role.concept.name, role_ref.trailing_adjective].compact.map{|w| w.split(/[_\s]/)}.flatten.reject{|s| s == ''}
         end
       end
 
@@ -315,7 +315,7 @@ module ActiveFacts
       end
     end
 
-    class EntityType
+    class EntityType < Concept
       def populate_references          #:nodoc:
         if fact_type && fact_type.all_role.size > 1
           # NOT: fact_type.all_role.each do |role|  # Place roles in the preferred order instead:

data/lib/activefacts/persistence/tables.rb

@@ -17,7 +17,7 @@ require 'activefacts/persistence/reference'
 module ActiveFacts
   module Metamodel
 
-    class ValueType
+    class ValueType < Concept
       def absorbed_via  #:nodoc:
         # ValueTypes aren't absorbed in the way EntityTypes are
         nil
@@ -55,7 +55,7 @@ module ActiveFacts
       end
     end
 
-    class EntityType
+    class EntityType < Concept
       # A Reference from an entity type that fully absorbs this one
       def absorbed_via; @absorbed_via; end
       def absorbed_via=(r) #:nodoc:
@@ -133,8 +133,8 @@ module ActiveFacts
         to_1 =
           all_uniqueness_constraints.
             detect do |c|
-                c.role_sequence.all_role_ref.size == 1 and
-                c.role_sequence.all_role_ref.only.role == self
+                (rr = c.role_sequence.all_role_ref.single) and
+                rr.role == self
             end
 
         if fact_type.entity_type
@@ -310,7 +310,10 @@ module ActiveFacts
         populate_all_columns
         populate_all_indices
 
-        @tables = all_feature.select { |f| f.is_table }
+        @tables =
+          all_feature.
+          select { |f| f.is_table }.
+          sort_by { |table| table.name }
       end
     end
 

data/lib/activefacts/version.rb

@@ -5,5 +5,5 @@
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
 module ActiveFacts
-  VERSION = '0.7.1'
+  VERSION = '0.7.2'
 end

data/lib/activefacts/vocabulary/extensions.rb

@@ -58,7 +58,7 @@ module ActiveFacts
       end
     end
 
-    class JoinPath
+    class Join
       def column_name(joiner = '-')
         concept == input_role.concept ? input_role.preferred_reference.role_name(joiner) : Array(concept.name)
       end
@@ -72,8 +72,8 @@ module ActiveFacts
 
     class RoleRef
       def describe
-        # The reference traverses the JoinPaths in sequence to the final role:
-        all_join_path.sort_by{|jp| jp.join_step}.map{ |jp| jp.describe + "." }*"" + role_name
+        # The reference traverses the Joins in sequence to the final role:
+        all_join.sort_by{|jp| jp.join_step}.map{ |jp| jp.describe + "." }*"" + role_name
       end
 
       def role_name(joiner = "-")
@@ -86,13 +86,13 @@ module ActiveFacts
         return joiner ? Array(name_array)*joiner : Array(name_array)
       end
 
-      # Two RoleRefs are equal if they have the same role and JoinPaths with matching roles
+      # Two RoleRefs are equal if they have the same role and Joins with matching roles
       def ==(role_ref)
         RoleRef === role_ref &&
         role_ref.role == role &&
-        all_join_path.size == role_ref.all_join_path.size &&
-        !all_join_path.sort_by{|j|j.join_step}.
-          zip(role_ref.all_join_path.sort_by{|j|j.join_step}).
+        all_join.size == role_ref.all_join.size &&
+        !all_join.sort_by{|j|j.join_step}.
+          zip(role_ref.all_join.sort_by{|j|j.join_step}).
           detect{|j1,j2|
             j1.input_role != j2.input_role ||
             j1.output_role != j2.output_role
@@ -376,6 +376,16 @@ module ActiveFacts
             ((max && min == max) ? "#{max == 1 ? "one" : max.to_s}" : nil)
         ].compact * " and"
       end
+
+      def describe
+        role_sequence.describe + " occurs " + frequency + " time"
+      end
+    end
+
+    class TypeInheritance
+      def describe(role = nil)
+        "#{subtype.name} is a kind of #{supertype.name}"
+      end
     end
 
   end

data/lib/activefacts/vocabulary/metamodel.rb

@@ -55,6 +55,11 @@ module ActiveFacts
       value_type :length => 32
     end
 
+    class Pronoun < String
+      value_type 
+      # REVISIT: Pronoun has restricted values
+    end
+
     class ReadingText < String
       value_type :length => 256
     end
@@ -90,7 +95,7 @@ module ActiveFacts
     end
 
     class Coefficient
-      identified_by :numerator, :denominator
+      identified_by :numerator, :denominator, :is_precise
       has_one :denominator                        # See Denominator.all_coefficient
       maybe :is_precise
       has_one :numerator                          # See Numerator.all_coefficient
@@ -175,11 +180,11 @@ module ActiveFacts
       one_to_one :unit_id                         # See UnitId.unit
     end
 
-    class UnitBasis
-      identified_by :base_unit, :derived_unit
-      has_one :base_unit, Unit                    # See Unit.all_unit_basis_as_base_unit
-      has_one :derived_unit, Unit                 # See Unit.all_unit_basis_as_derived_unit
-      has_one :exponent                           # See Exponent.all_unit_basis
+    class Derivation
+      identified_by :derived_unit, :base_unit
+      has_one :base_unit, Unit                    # See Unit.all_derivation_as_base_unit
+      has_one :derived_unit, Unit                 # See Unit.all_derivation_as_derived_unit
+      has_one :exponent                           # See Exponent.all_derivation
     end
 
     class ValueRange
@@ -194,7 +199,7 @@ module ActiveFacts
     end
 
     class AllowedRange
-      identified_by :value_range, :value_restriction
+      identified_by :value_restriction, :value_range
       has_one :value_range                        # See ValueRange.all_allowed_range
       has_one :value_restriction                  # See ValueRestriction.all_allowed_range
     end
@@ -205,19 +210,19 @@ module ActiveFacts
     end
 
     class Import
-      identified_by :imported_vocabulary, :vocabulary
+      identified_by :vocabulary, :imported_vocabulary
       has_one :imported_vocabulary, Vocabulary    # See Vocabulary.all_import_as_imported_vocabulary
       has_one :vocabulary                         # See Vocabulary.all_import
     end
 
     class Feature
-      identified_by :name, :vocabulary
+      identified_by :vocabulary, :name
       has_one :name                               # See Name.all_feature
       has_one :vocabulary                         # See Vocabulary.all_feature
     end
 
     class Correspondence
-      identified_by :imported_feature, :import
+      identified_by :import, :imported_feature
       has_one :import                             # See Import.all_correspondence
       has_one :imported_feature, Feature          # See Feature.all_correspondence_as_imported_feature
       has_one :local_feature, Feature             # See Feature.all_correspondence_as_local_feature
@@ -251,7 +256,7 @@ module ActiveFacts
 
     class Concept < Feature
       maybe :is_independent
-      maybe :is_personal
+      has_one :pronoun                            # See Pronoun.all_concept
     end
 
     class Role
@@ -272,13 +277,13 @@ module ActiveFacts
       has_one :trailing_adjective, Adjective      # See Adjective.all_role_ref_as_trailing_adjective
     end
 
-    class JoinPath
+    class Join
       identified_by :role_ref, :join_step
-      has_one :join_step, Ordinal                 # See Ordinal.all_join_path_as_join_step
-      has_one :role_ref                           # See RoleRef.all_join_path
-      has_one :concept                            # See Concept.all_join_path
-      has_one :input_role, Role                   # See Role.all_join_path_as_input_role
-      has_one :output_role, Role                  # See Role.all_join_path_as_output_role
+      has_one :join_step, Ordinal                 # See Ordinal.all_join_as_join_step
+      has_one :role_ref                           # See RoleRef.all_join
+      has_one :concept                            # See Concept.all_join
+      has_one :input_role, Role                   # See Role.all_join_as_input_role
+      has_one :output_role, Role                  # See Role.all_join_as_output_role
     end
 
     class EntityType < Concept