activefacts 0.7.2 → 0.7.3

data/lib/activefacts/generate/sql/server.rb

@@ -18,7 +18,6 @@ module ActiveFacts
       # * norma Translate datatypes from NORMA to SQL Server
       class SERVER
       private
-        include Metamodel
         include Persistence
         ColumnNameMax = 40
 

data/lib/activefacts/input/cql.rb

@@ -5,8 +5,6 @@
 require 'activefacts/vocabulary'
 require 'activefacts/cql/parser'
 
-require 'ruby-debug'
-
 module ActiveFacts
   module Input #:nodoc:
     # Compile CQL to an ActiveFacts vocabulary.

data/lib/activefacts/persistence/columns.rb

@@ -20,8 +20,6 @@ module ActiveFacts
   module Persistence    #:nodoc:
 
     class Column
-      include Metamodel
-
       def initialize(reference = nil) #:nodoc:
         references << reference if reference
       end
@@ -58,40 +56,59 @@ 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)
+      # The names to use is derived from the to_names of each Reference,
+      # modified by these rules:
+      # * A reference after the first one which is not a TypeInheritance but where the _from_ object plays the sole role in the preferred identifier of the _to_ entity is ignored,
+      # * A reference (after a name has been retained) which is a TypeInheritance retains the names of the subtype,
+      # * If the names retained so far end in XYZ and the to_names start with XYZ, remove the duplication
+      # * If we have retained the name of an entity, and this reference is the sole identifying role of an entity, and the identifying object has a name that is prefixed by the name of the object it identifies, remove the prefix and use just the suffix.
       def name(joiner = "")
         last_names = []
         names = @references.
-          reject do |ref|
-            # Skip any object after the first which is identified by this reference
-            ref != @references[0] and
-              !ref.fact_type.is_a?(TypeInheritance) and
-              ref.to and
-              ref.to.is_a?(EntityType) and
-              (role_ref = ref.to.preferred_identifier.role_sequence.all_role_ref.single) and
-              role_ref.role == ref.from_role
-          end.
           inject([]) do |a, ref|
+
+            # Skip any object after the first which is identified by this reference
+            if ref != @references[0] and
+                !ref.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) and
+                ref.to and
+                ref.to.is_a?(ActiveFacts::Metamodel::EntityType) and
+                (role_ref = ref.to.preferred_identifier.role_sequence.all_role_ref.single) and
+                role_ref.role == ref.from_role
+              debug :columns, "Skipping #{ref}, identifies non-initial object"
+              next a
+            end
+
             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)
-              next a if ref.to != ref.fact_type.subtype  # Did we already have the subtype?
+            if a.size > 0 && ref.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+              if ref.to != ref.fact_type.subtype  # Did we already have the subtype?
+                debug :columns, "Skipping supertype #{ref}"
+                next a
+              end
+              debug :columns, "Eliding supertype in #{ref}"
               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
+              debug :columns, "truncating repeated #{last_names.last} in #{names[0]}"
               names[0] = names[0][last_names.last.size..-1]
             elsif last_names.last == names[0]
               # Same, but where an underscore split up the words
+              debug :columns, "truncating repeated name in #{names.inspect}"
               names.shift
             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 the reference is to the single identifying role of the concept making the reference,
+            # strip the concept name from the start of the reference role
             if a.size > 0 and
-                (et = ref.from).is_a?(EntityType) and
+                (et = ref.from).is_a?(ActiveFacts::Metamodel::EntityType) and
+                # This instead of the next 2 would apply to all identifying roles, but breaks some examples:
+                # (role_ref = et.preferred_identifier.role_sequence.all_role_ref.detect{|rr| rr.role == ref.to_role}) 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
+
+              debug :columns, "truncating transitive identifying role #{names.inspect}"
               names[0] = names[0][et.name.size..-1]
               names.shift if names[0] == ""
             end
@@ -100,7 +117,13 @@ module ActiveFacts
 
             a += names
             a
-          end
+          end.elide_repeated_subsequences { |a, b|
+            if a.is_a?(Array)
+              a.map{|e| e.downcase} == b.map{|e| e.downcase}
+            else
+              a.downcase == b.downcase
+            end
+          }
 
         name_array = names.map{|n| n.sub(/^[a-z]/){|s| s.upcase}}
         joiner ? name_array * joiner : name_array
@@ -158,7 +181,7 @@ module ActiveFacts
       def columns(excluded_supertypes)  #:nodoc:
         kind = ""
         cols = 
-          if is_unary
+          if is_unary && !(@to && @to.fact_type)
             kind = "unary "
             [Column.new()]
           elsif is_self_value
@@ -275,10 +298,14 @@ module ActiveFacts
         debug :columns, "Reference Columns for #{name}" do
 
           if absorbed_via and
-            # If this is a subtype that has its own identification, use that.
+            # If this is not a subtype, or is a subtype that has its own identification, use the id.
             (all_type_inheritance_as_subtype.size == 0 ||
               all_type_inheritance_as_subtype.detect{|ti| ti.provides_identification })
-            return absorbed_via.from.reference_columns(excluded_supertypes)
+            rc = absorbed_via.from.reference_columns(excluded_supertypes)
+            # The absorbed_via reference gets skipped here, ans also in concept.rb
+            debug :columns, "Skipping #{absorbed_via}"
+            #rc.each{|col| col.prepend(absorbed_via)}
+            return rc
           end
 
           # REVISIT: Should have built preferred_identifier_references
@@ -302,7 +329,7 @@ module ActiveFacts
           references_from.sort_by do |ref|
             # Put supertypes first, in order, then non-subtype references, then subtypes, otherwise retaining their order:
             sups.index(ref.to) ||
-              (!ref.fact_type.is_a?(TypeInheritance) && references_from.size+references_from.index(ref)) ||
+              (!ref.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) && references_from.size+references_from.index(ref)) ||
               references_from.size*2+references_from.index(ref)
           end.each do |ref|
             debug :columns, "Columns absorbed via #{ref}" do
@@ -332,7 +359,7 @@ module ActiveFacts
       # Override this method to change the transformations
       def finish_schema
         all_feature.each do |feature|
-          feature.self_value_reference if feature.is_a?(ValueType) && feature.is_table
+          feature.self_value_reference if feature.is_a?(ActiveFacts::Metamodel::ValueType) && feature.is_table
         end
       end
 
@@ -342,7 +369,7 @@ module ActiveFacts
 
         debug :columns, "Populating all columns" do
           all_feature.each do |feature|
-            next if !feature.is_a?(Concept) || !feature.is_table
+            next if !feature.is_a?(ActiveFacts::Metamodel::Concept) || !feature.is_table
             debug :columns, "Populating columns for table #{feature.name}" do
               feature.populate_columns
             end
@@ -350,7 +377,7 @@ module ActiveFacts
         end
         debug :columns, "Finished columns" do
           all_feature.each do |feature|
-            next if !feature.is_a?(Concept) || !feature.is_table
+            next if !feature.is_a?(ActiveFacts::Metamodel::Concept) || !feature.is_table
             debug :columns, "Finished columns for table #{feature.name}" do
               feature.columns.each do |column|
                 debug :columns, "#{column}"

data/lib/activefacts/persistence/concept.rb

@@ -1,3 +1,5 @@
+require 'activefacts/support'
+
 module ActiveFacts
   module API
     module Concept
@@ -10,57 +12,169 @@ module ActiveFacts
       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}}*"."}
+        debug :persistence, "Calculating columns for #{basename}" do
+          @columns = (
+            if superclass.is_entity_type
+              # REVISIT: Need keys to secondary supertypes as well, but no duplicates.
+              debug :persistence, "Separate subtype has a foreign key to its supertype" do
+                superclass.__absorb([[superclass.basename]], self)
+              end
+            else
+              []
+            end +
+            # Then absorb all normal roles:
+            roles.values.select do |role|
+              role.unique && !role.counterpart_unary_has_precedence
+            end.inject([]) do |columns, role|
+              rn = role.name.to_s.split(/_/)
+              debug :persistence, "Role #{rn*'.'}" do
+                columns += role.counterpart_concept.__absorb([rn], role.counterpart)
+              end
+            end +
+            # And finally all absorbed subtypes:
+            subtypes.
+              select{|subtype| !subtype.is_table}.    # Don't absorb separate subtypes
+              inject([]) do |columns, subtype|
+                # Pass self as 2nd param here, not a role, standing for the supertype role
+                subtype_name = subtype.basename
+                debug :persistence, "Absorbing subtype #{subtype_name}" do
+                  columns += subtype.__absorb([[subtype_name]], self)
+                end
+              end
+            ).map do |col_names|
+              last = nil
+              col_names.flatten.map do |name|
+                name.downcase.sub(/^[a-z]/){|c| c.upcase}
+              end.
+              reject do |n|
+                # Remove sequential duplicates:
+                dup = last == n
+                last = n
+                dup
+              end*"."
+            end
+        end
       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)
+        # also considered a table if the superclass isn't excluded and is (transitively) a table
+        if !@is_table && (except_role == superclass || !is_table_subtype)
+          if is_entity_type
+            if (role = fully_absorbed) && role != except_role
+              # If this non-table is fully absorbed into another table (not our caller!)
+              # (another table plays its single identifying role), then absorb that role only.
+              # counterpart_concept = role.counterpart_concept
+              # This omission matches the one in columns.rb, see EntityType#reference_columns
+              # new_prefix = prefix + [role.name.to_s.split(/_/)]
+              debug :persistence, "Reference to #{role.name} (absorbed elsewhere)" do
+                role.counterpart_concept.__absorb(prefix, role.counterpart)
+              end
+            else
+              # Not a table -> all roles are absorbed
+              roles.
+                  values.
+                  select do |role|
+                    role.unique && role != except_role && !role.counterpart_unary_has_precedence
+                  end.
+                  inject([]) do |columns, role|
+                columns += __absorb_role(prefix, role)
+              end +
+              subtypes.          # Absorb subtype roles too!
+                select{|subtype| !subtype.is_table}.    # Don't absorb separate subtypes
+                inject([]) do |columns, subtype|
+                  # Pass self as 2nd param here, not a role, standing for the supertype role
+                  new_prefix = prefix[0..-2] + [[subtype.basename]]
+                  debug :persistence, "Absorbed subtype #{subtype.basename}" do
+                    columns += subtype.__absorb(new_prefix, self)
+                  end
+                end
             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(/_/)}
+          # Create a foreign key to the table
+          if is_entity_type
+            ir = identifying_role_names.map{|role_name| roles(role_name) }
+            debug :persistence, "Reference to #{basename} with #{prefix.inspect}" do
+              ic = identifying_role_names.map{|role_name| role_name.to_s.split(/_/)}
+              ir.inject([]) do |columns, role|
+                columns += __absorb_role(prefix, role)
+              end
+            end
           else
             # Reference to value type which is a table
-            [prefix + ["Value"]]
+            col = prefix.clone
+            debug :persistence, "Self-value #{col[-1]}.Value"
+            col[-1] += ["Value"]
+            col
           end
         end
       end
+
+      def __absorb_role(prefix, role)
+        if prefix.size > 0 and
+            (c = role.owner).is_entity_type and
+            c.identifying_roles == [role] and
+            (irn = c.identifying_role_names).size == 1 and
+            (n = irn[0].to_s.split(/_/)).size > 1 and
+            (owner = role.owner.basename.snakecase.split(/_/)) and
+            n[0...owner.size] == owner
+          debug :persistence, "truncating transitive identifying role #{n.inspect}"
+          owner.size.times { n.shift }
+          new_prefix = prefix + [n]
+        elsif (c = role.counterpart_concept).is_entity_type and
+            (irn = c.identifying_role_names).size == 1 and
+            #irn[0].to_s.split(/_/)[0] == role.owner.basename.downcase
+            irn[0] == role.counterpart.name
+          #debug :persistence, "=== #{irn[0].to_s.split(/_/)[0]} elided ==="
+          new_prefix = prefix
+        elsif (fa_role = fully_absorbed) && fa_role == role
+          new_prefix = prefix
+        else
+          new_prefix = prefix + [role.name.to_s.split(/_/)]
+        end
+        #debug :persistence, "new_prefix is #{new_prefix*"."}"
+
+        debug :persistence, "Absorbing role #{role.name} as #{new_prefix[prefix.size..-1]*"."}" do
+          role.counterpart_concept.__absorb(new_prefix, role.counterpart)
+        end
+      end
+
+      def is_table_subtype
+        return true if is_table
+        klass = superclass
+        while klass.is_entity_type
+          return true if klass.is_table
+          klass = klass.superclass
+        end
+        return false
+      end
+    end
+
+    module Entity
+      module ClassMethods
+        def fully_absorbed
+          return false unless (ir = identifying_role_names) && ir.size == 1
+          role = roles(ir[0])
+          return role if ((cp = role.counterpart_concept).is_table ||
+              (cp.is_entity_type && cp.fully_absorbed))
+          return superclass if superclass.is_entity_type  # Absorbed subtype
+          nil
+        end
+      end
+    end
+
+    # A one-to-one can be absorbed into either table. We decide which by comparing
+    # the names, just as happens in Concept.populate_reference (see reference.rb)
+    class Role
+      def counterpart_unary_has_precedence
+        counterpart_concept.is_table_subtype and
+          counterpart.unique and
+          owner.name.downcase < counterpart.owner.name.downcase
+      end
     end
 
   end
@@ -70,4 +184,12 @@ class TrueClass
   def self.__absorb(prefix, except_role = nil)
     [prefix]
   end
+
+  def self.is_table
+    false
+  end
+
+  def self.is_table_subtype
+    false
+  end
 end

data/lib/activefacts/persistence/reference.rb

@@ -79,7 +79,7 @@ module ActiveFacts
 
       # Is this Reference from a unary Role?
       def is_unary
-        !@to && @to_role && @to_role.fact_type.all_role.size == 1
+        @to_role && @to_role.fact_type.all_role.size == 1
       end
 
       # If this Reference is to an objectified FactType, there is no *to_role*
@@ -114,16 +114,20 @@ module ActiveFacts
       def to_names
         case
         when is_unary
-          @to_role.fact_type.preferred_reading.reading_text.gsub(/\{[0-9]\}/,'').strip.split(/[_\s]/)
+          if @to && @to.fact_type
+            @to.name.camelwords
+          else
+            @to_role.fact_type.preferred_reading.reading_text.gsub(/\{[0-9]\}/,'').strip.camelwords
+          end
         when @to && !@to_role           # @to is an objectified fact type so @to_role is a phantom
-          @to.name.split(/[_\s]/)
+          @to.name.camelwords
         when !@to_role                  # Self-value role of an independent ValueType
-          ["#{@from.name}", "Value"]
+          @from.name.camelwords + ["Value"]
         when @to_role.role_name         # Named role
-          @to_role.role_name.split(/[_\s]/)
+          @to_role.role_name.camelwords
         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.camelwords}.flatten.reject{|s| s == ''}
         end
       end
 
@@ -304,8 +308,9 @@ module ActiveFacts
           end
 
           # Either both EntityTypes, or both ValueTypes.
-          # Make an arbitrary (but stable) decision which way to go. We might flip it later.
-          unless r.from.name < r.to.name or
+          # Make an arbitrary (but stable) decision which way to go. We might flip it later,
+          # but not frivolously; the Ruby API column name generation duplicates this logic.
+          unless r.from.name.downcase < r.to.name.downcase or
             (r.from == r.to && references_to.detect{|ref| ref.to_role == role}) # one-to-one self reference, done already
             r.tabulate
           end

data/lib/activefacts/support.rb

@@ -9,6 +9,7 @@
   $debug_indent = nil
   $debug_nested = false
   $debug_keys = nil
+  $debug_available = {}
   def debug(*args, &block)
     unless $debug_indent
       # First time, initialise the tracing environment
@@ -16,13 +17,19 @@
       $debug_keys = {}
       if (e = ENV["DEBUG"])
         e.split(/[^a-zA-Z0-9]/).each{|k| $debug_keys[k.to_sym] = true }
+        if $debug_keys[:help]
+          at_exit {
+            $stderr.puts "---\nDebugging keys available: #{$debug_available.keys.map{|s| s.to_s}.sort*", "}"
+          }
+        end
       end
     end
 
     # Figure out whether this trace is enabled and nests:
     control = (!args.empty? && Symbol === args[0]) ? args.shift : :all
-    key = control.to_s.sub(/_\Z/, '')
-    enabled = $debug_nested || $debug_keys[key.to_sym]
+    key = control.to_s.sub(/_\Z/, '').to_sym
+    $debug_available[key] ||= key
+    enabled = $debug_nested || $debug_keys[key]
     nesting = control.to_s =~ /_\Z/
     old_nested = $debug_nested
     $debug_nested = nesting
@@ -56,4 +63,35 @@ class Array
       v == 1
     end.keys
   end
+
+  # Allow indexing using a custom comparator:
+  def index value, &compare_block
+    compare_block ||= lambda{|a,b| a == b}
+    (0...size).detect{|i| compare_block[value, self[i]] }
+  end
+
+  # If any element, or sequence of elements, repeats immediately, delete the repetition.
+  # Note that this doesn't remove all re-occurrences of a subsequence, only consecutive ones.
+  # The compare_block allows a custom equality comparison.
+  def elide_repeated_subsequences &compare_block
+    compare_block ||= lambda{|a,b| a == b}
+    i = 0
+    while i < size  # Need to re-evaluate size on each loop - the array shrinks.
+      j = i
+      #puts "Looking for repetitions of #{self[i]}@[#{i}]"
+      while tail = self[j+1..-1] and k = tail.index(self[i], &compare_block)
+        length = j+1+k-i
+        #puts "Found at #{j+1+k} (subsequence of length #{j+1+k-i}), will need to repeat to #{j+k+length}"
+        if j+k+1+length <= size && compare_block[self[i, length], self[j+k+1, length]]
+          #puts "Subsequence from #{i}..#{j+k} repeats immediately at #{j+k+1}..#{j+k+length}"
+          slice!(j+k+1, length)
+          j = i
+        else
+          j += k+1
+        end
+      end
+      i += 1
+    end
+    self
+  end
 end