activefacts 0.7.3 → 0.8.5

data/lib/activefacts/persistence/columns.rb

@@ -92,6 +92,7 @@ module ActiveFacts
               # 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]
+              names.shift if names[0] == ''
             elsif last_names.last == names[0]
               # Same, but where an underscore split up the words
               debug :columns, "truncating repeated name in #{names.inspect}"
@@ -358,8 +359,8 @@ module ActiveFacts
       # Make schema transformations like adding ValueType self-value columns (and later, Rails-friendly ID fields).
       # Override this method to change the transformations
       def finish_schema
-        all_feature.each do |feature|
-          feature.self_value_reference if feature.is_a?(ActiveFacts::Metamodel::ValueType) && feature.is_table
+        all_concept.each do |concept|
+          concept.self_value_reference if concept.is_a?(ActiveFacts::Metamodel::ValueType) && concept.is_table
         end
       end
 
@@ -368,18 +369,18 @@ module ActiveFacts
         finish_schema
 
         debug :columns, "Populating all columns" do
-          all_feature.each do |feature|
-            next if !feature.is_a?(ActiveFacts::Metamodel::Concept) || !feature.is_table
-            debug :columns, "Populating columns for table #{feature.name}" do
-              feature.populate_columns
+          all_concept.each do |concept|
+            next if !concept.is_table
+            debug :columns, "Populating columns for table #{concept.name}" do
+              concept.populate_columns
             end
           end
         end
         debug :columns, "Finished columns" do
-          all_feature.each do |feature|
-            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|
+          all_concept.each do |concept|
+            next if !concept.is_table
+            debug :columns, "Finished columns for table #{concept.name}" do
+              concept.columns.each do |column|
                 debug :columns, "#{column}"
               end
             end

data/lib/activefacts/persistence/index.rb

@@ -54,13 +54,13 @@ module ActiveFacts
       end
 
       # An array of the names of the columns this index covers
-      def column_names
-        columns.map{|column| column.name}
+      def column_names(joiner = "")
+        columns.map{|column| column.name(joiner)}
       end
 
       # An array of the names of the columns this index covers, with some lexical truncations.
-      def abbreviated_column_names
-        columns.map{|column| column.name.sub(/^#{over.name}/,'')}
+      def abbreviated_column_names(joiner = "")
+        columns.map{|column| column.name(joiner).sub(/^#{over.name}/,'')}
       end
 
       # The name of a view that can be created to enforce uniqueness over non-null key values
@@ -183,25 +183,22 @@ module ActiveFacts
     class Vocabulary
       def populate_all_indices  #:nodoc:
         debug :index, "Populating all concept indices" do
-          all_feature.each do |feature|
-            next unless feature.is_a? Concept
-            feature.clear_indices
+          all_concept.each do |concept|
+            concept.clear_indices
           end
-          all_feature.each do |feature|
-            next unless feature.is_a? Concept
-            next unless feature.is_table
-            debug :index, "Populating indices for #{feature.name}" do
-              feature.populate_indices
+          all_concept.each do |concept|
+            next unless concept.is_table
+            debug :index, "Populating indices for #{concept.name}" do
+              concept.populate_indices
             end
           end
         end
         debug :index, "Finished concept indices" do
-          all_feature.each do |feature|
-            next unless feature.is_a? Concept
-            next unless feature.is_table
-            next unless feature.indices.size > 0
-            debug :index, "#{feature.name}:" do
-              feature.indices.each do |index|
+          all_concept.each do |concept|
+            next unless concept.is_table
+            next unless concept.indices.size > 0
+            debug :index, "#{concept.name}:" do
+              concept.indices.each do |index|
                 debug :index, index
               end
             end

data/lib/activefacts/persistence/reference.rb

@@ -117,7 +117,7 @@ module ActiveFacts
           if @to && @to.fact_type
             @to.name.camelwords
           else
-            @to_role.fact_type.preferred_reading.reading_text.gsub(/\{[0-9]\}/,'').strip.camelwords
+            @to_role.fact_type.preferred_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.camelwords
@@ -260,7 +260,8 @@ module ActiveFacts
 
         when :supertype   # A subtype absorbs a reference to its supertype when separate, or all when partitioned
           # REVISIT: Or when partitioned
-          if role.fact_type.subtype.is_independent
+          raise hell unless role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+          if role.fact_type.assimilation  # assimilation == 'separate' or assimilation == 'partitioned'
             debug :references, "supertype #{name} doesn't absorb a reference to separate subtype #{role.fact_type.subtype.name}"
           else
             r = ActiveFacts::Persistence::Reference.new(self, role)
@@ -270,7 +271,8 @@ module ActiveFacts
           end
 
         when :subtype    # This object is a supertype, which can absorb the subtype unless that's independent
-          if is_independent    # REVISIT: Or when partitioned
+          raise hell unless role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+          if role.fact_type.assimilation
             ActiveFacts::Persistence::Reference.new(self, role).tabulate
             # If partitioned, the supertype is absorbed into *each* subtype; a reference to the supertype needs to know which
           else
@@ -282,6 +284,7 @@ module ActiveFacts
 
           # Decide which way the one-to-one is likely to go; it will be flipped later if necessary.
           # Force the decision if just one is independent:
+          # REVISIT: Decide whether supertype assimilation can affect this
           r.tabulate and return if is_independent and !r.to.is_independent
           return if !is_independent and r.to.is_independent
 
@@ -335,25 +338,22 @@ module ActiveFacts
     class Vocabulary
       def populate_all_references #:nodoc:
         debug :references, "Populating all concept references" do
-          all_feature.each do |feature|
-            next unless feature.is_a? Concept
-            feature.clear_references
-            feature.is_table = nil      # Undecided; force an attempt to decide
-            feature.tentative = true    # Uncertain
+          all_concept.each do |concept|
+            concept.clear_references
+            concept.is_table = nil      # Undecided; force an attempt to decide
+            concept.tentative = true    # Uncertain
           end
-          all_feature.each do |feature|
-            next unless feature.is_a? Concept
-            debug :references, "Populating references for #{feature.name}" do
-              feature.populate_references
+          all_concept.each do |concept|
+            debug :references, "Populating references for #{concept.name}" do
+              concept.populate_references
             end
           end
         end
         debug :references, "Finished concept references" do
-          all_feature.each do |feature|
-            next unless feature.is_a? Concept
-            next unless feature.references_from.size > 0
-            debug :references, "#{feature.name}:" do
-              feature.references_from.each do |ref|
+          all_concept.each do |concept|
+            next unless concept.references_from.size > 0
+            debug :references, "#{concept.name}:" do
+              concept.references_from.each do |ref|
                 debug :references, "#{ref}"
               end
             end

data/lib/activefacts/persistence/tables.rb

@@ -88,8 +88,7 @@ module ActiveFacts
         # Subtypes are not a table unless partitioned or separate
         # REVISIT: Support partitioned subtypes here
         if (!supertypes.empty?)
-          av = all_supertype_inheritance[0]
-          return @is_table = false
+          return @is_table = all_supertype_inheritance.detect{|ti| ti.assimilation} != nil
         end
 
         # If the preferred_identifier includes an auto_assigned ValueType
@@ -169,7 +168,7 @@ module ActiveFacts
         # 2) Decide which Concepts must be and must not be tables
         #  a. Concepts labelled is_independent are tables (See the is_table methods above)
         #  b. Entity types having no references to them must be tables
-        #  c. subtypes are not tables unless marked is_independent (separate) or partitioned (not yet impl)
+        #  c. subtypes are not tables unless marked with assimilation = separate or partitioned
         #  d. ValueTypes are never tables unless they can have references (to other ValueTypes)
         #  e. An EntityType having an identifying AutoInc field must be a table unless it has exactly one reference
         #  f. An EntityType whose only reference is through its single preferred_identifier role gets absorbed
@@ -182,19 +181,18 @@ module ActiveFacts
         populate_all_references
 
         debug :absorption, "Calculating relational composition" do
-          # Evaluate the possible independence of each concept, building an array of features of indeterminate status:
+          # Evaluate the possible independence of each concept, building an array of concepts of indeterminate status:
           undecided =
-            all_feature.select do |feature|
-              next unless feature.is_a? Concept
-              feature.is_table          # Ask it whether it thinks it should be a table
-              feature.tentative         # Selection criterion
+            all_concept.select do |concept|
+              concept.is_table          # Ask it whether it thinks it should be a table
+              concept.tentative         # Selection criterion
             end
 
           if debug :absorption, "Generating tables, #{undecided.size} undecided"
-            (all_feature-undecided).each {|feature|
-              next if ValueType === feature && !feature.is_table  # Skip unremarkable cases
+            (all_concept-undecided).each {|concept|
+              next if ValueType === concept && !concept.is_table  # Skip unremarkable cases
               debug :absorption do
-                debug :absorption, "#{feature.name} is #{feature.is_table ? "" : "not "}a table#{feature.tentative ? ", tentatively" : ""}"
+                debug :absorption, "#{concept.name} is #{concept.is_table ? "" : "not "}a table#{concept.tentative ? ", tentatively" : ""}"
               end
             }
           end
@@ -205,80 +203,81 @@ module ActiveFacts
             debug :absorption, "Starting composition pass #{pass} with #{undecided.size} undecided tables"
             possible_flips = {}         # A hash by table containing an array of references that can be flipped
             finalised =                 # Make an array of things we finalised during this pass
-              undecided.select do |feature|
-                debug :absorption, "Considering #{feature.name}:" do
-                  debug :absorption, "refs to #{feature.name} are from #{feature.references_to.map{|ref| ref.from.name}*", "}" if feature.references_to.size > 0
-                  debug :absorption, "refs from #{feature.name} are to #{feature.references_from.map{|ref| ref.to.name rescue ref.fact_type.default_reading}*", "}" if feature.references_from.size > 0
+              undecided.select do |concept|
+                debug :absorption, "Considering #{concept.name}:" do
+                  debug :absorption, "refs to #{concept.name} are from #{concept.references_to.map{|ref| ref.from.name}*", "}" if concept.references_to.size > 0
+                  debug :absorption, "refs from #{concept.name} are to #{concept.references_from.map{|ref| ref.to.name rescue ref.fact_type.default_reading}*", "}" if concept.references_from.size > 0
 
                   # Always absorb an objectified unary into its role player:
-                  if feature.fact_type && feature.fact_type.all_role.size == 1
-                    debug :absorption, "Absorb objectified unary #{feature.name} into #{feature.fact_type.entity_type.name}"
-                    feature.definitely_not_table
-                    next feature
+                  if concept.fact_type && concept.fact_type.all_role.size == 1
+                    debug :absorption, "Absorb objectified unary #{concept.name} into #{concept.fact_type.entity_type.name}"
+                    concept.definitely_not_table
+                    next concept
                   end
 
                   # If the PI contains one role only, played by an entity type that can absorb us, do that.
-                  pi_roles = feature.preferred_identifier.role_sequence.all_role_ref.map(&:role)
+                  pi_roles = concept.preferred_identifier.role_sequence.all_role_ref.map(&:role)
                   debug :absorption, "pi_roles are played by #{pi_roles.map{|role| role.concept.name}*", "}"
                   first_pi_role = pi_roles[0]
                   pi_ref = nil
                   if pi_roles.size == 1 and
-                    feature.references_to.detect{|ref| pi_ref = ref if ref.from_role == first_pi_role && ref.from.is_a?(EntityType)}
+                    concept.references_to.detect{|ref| pi_ref = ref if ref.from_role == first_pi_role && ref.from.is_a?(EntityType)}
 
-                    debug :absorption, "#{feature.name} is fully absorbed along its sole reference path into entity type #{pi_ref.from.name}"
-                    feature.definitely_not_table
-                    next feature
+                    debug :absorption, "#{concept.name} is fully absorbed along its sole reference path into entity type #{pi_ref.from.name}"
+                    concept.definitely_not_table
+                    next concept
                   end
 
                   # If there's more than one absorption path and any functional dependencies that can't absorb us, it's a table
                   non_identifying_refs_from =
-                    feature.references_from.reject{|ref|
+                    concept.references_from.reject{|ref|
                       pi_roles.include?(ref.to_role)
                     }
-                  debug :absorption, "#{feature.name} has #{non_identifying_refs_from.size} non-identifying functional roles"
+                  debug :absorption, "#{concept.name} has #{non_identifying_refs_from.size} non-identifying functional roles"
 
-                  if feature.references_to.size > 1 and
+                  if concept.references_to.size > 1 and
                       non_identifying_refs_from.size > 0
-                    debug :absorption, "#{feature.name} has non-identifying functional dependencies so 3NF requires it be a table"
-                    feature.definitely_table
-                    next feature
+                    debug :absorption, "#{concept.name} has non-identifying functional dependencies so 3NF requires it be a table"
+                    concept.definitely_table
+                    next concept
                   end
 
                   absorption_paths =
                     (
                       non_identifying_refs_from.reject do |ref|
                         !ref.to or ref.to.absorbed_via == ref
-                      end+feature.references_to
+                      end+concept.references_to
                     ).reject do |ref|
                       next true if !ref.to.is_table or
                         ![:one_one, :supertype, :subtype].include?(ref.role_type)
 
-                      # If one side is mandatory but not the other, don't absorb the mandatory side into the non-mandatory one
+                      # Don't absorb an object along a non-mandatory role (otherwise if it doesn't play that role, it can't exist either)
                       from_is_mandatory = !!ref.is_mandatory
                       to_is_mandatory = !ref.to_role || !!ref.to_role.is_mandatory
-                      bad = (to_is_mandatory != from_is_mandatory and (ref.from == feature ? from_is_mandatory : to_is_mandatory))
-                      debug :absorption, "Not absorbing mandatory #{feature.name} through #{ref}" if bad
+
+                      bad = !(ref.from == concept ? from_is_mandatory : to_is_mandatory)
+                      debug :absorption, "Not absorbing #{concept.name} through non-mandatory #{ref}" if bad
                       bad
                     end
 
                   # If this object can be fully absorbed, do that (might require flipping some references)
                   if absorption_paths.size > 0
-                    debug :absorption, "#{feature.name} is fully absorbed through #{absorption_paths.inspect}"
+                    debug :absorption, "#{concept.name} is fully absorbed through #{absorption_paths.inspect}"
                     absorption_paths.each do |ref|
-                      debug :absorption, "flip #{ref} so #{feature.name} can be absorbed"
-                      ref.flip if feature == ref.from
+                      debug :absorption, "flip #{ref} so #{concept.name} can be absorbed"
+                      ref.flip if concept == ref.from
                     end
-                    feature.definitely_not_table
-                    next feature
+                    concept.definitely_not_table
+                    next concept
                   end
 
                   if non_identifying_refs_from.size == 0
-#                    and (!feature.is_a?(EntityType) ||
+#                    and (!concept.is_a?(EntityType) ||
 #                      # REVISIT: The roles may be collectively but not individually mandatory.
-#                      feature.references_to.detect { |ref| !ref.from_role || ref.from_role.is_mandatory })
-                    debug :absorption, "#{feature.name} is fully absorbed in #{feature.references_to.size} places: #{feature.references_to.map{|ref| ref.from.name}*", "}"
-                    feature.definitely_not_table
-                    next feature
+#                      concept.references_to.detect { |ref| !ref.from_role || ref.from_role.is_mandatory })
+                    debug :absorption, "#{concept.name} is fully absorbed in #{concept.references_to.size} places: #{concept.references_to.map{|ref| ref.from.name}*", "}"
+                    concept.definitely_not_table
+                    next concept
                   end
 
                   false   # Failed to decide about this entity_type this time around
@@ -291,18 +290,18 @@ module ActiveFacts
 
           # A ValueType that isn't explicitly a table and isn't needed anywhere doesn't matter,
           # unless it should absorb something else (another ValueType is all it could be):
-          all_feature.each do |feature|
-            if (!feature.is_table and feature.references_to.size == 0 and feature.references_from.size > 0)
-              debug :absorption, "Making #{feature.name} a table; it has nowhere else to go and needs to absorb things"
-              feature.probably_table
+          all_concept.each do |concept|
+            if (!concept.is_table and concept.references_to.size == 0 and concept.references_from.size > 0)
+              debug :absorption, "Making #{concept.name} a table; it has nowhere else to go and needs to absorb things"
+              concept.probably_table
             end
           end
 
           # Now, evaluate all possibilities of the tentative assignments
           # Incomplete. Apparently unnecessary as well... so far. We'll see.
           if debug :absorption
-            undecided.each do |feature|
-              debug :absorption, "Unable to decide independence of #{feature.name}, going with #{feature.show_tabular}"
+            undecided.each do |concept|
+              debug :absorption, "Unable to decide independence of #{concept.name}, going with #{concept.show_tabular}"
             end
           end
         end
@@ -311,7 +310,7 @@ module ActiveFacts
         populate_all_indices
 
         @tables =
-          all_feature.
+          all_concept.
           select { |f| f.is_table }.
           sort_by { |table| table.name }
       end

data/lib/activefacts/version.rb

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

data/lib/activefacts/vocabulary/extensions.rb

@@ -13,7 +13,9 @@ module ActiveFacts
       end
 
       def preferred_reading
-        all_reading_by_ordinal[0]
+        p = all_reading_by_ordinal[0]
+        raise "No reading for (#{all_role.map{|r| r.concept.name}*", "})" unless p
+        p
       end
 
       def describe(highlight = nil)
@@ -39,7 +41,7 @@ module ActiveFacts
           rs.all_presence_constraint.detect{|pc|
             pc.max_frequency == 1
           }
-        }
+        } ? true : false
       end
 
       def is_mandatory
@@ -49,7 +51,7 @@ module ActiveFacts
           rs.all_presence_constraint.detect{|pc|
             pc.min_frequency and pc.min_frequency >= 1 and pc.is_mandatory
           }
-        }
+        } ? true : false
       end
 
       # Return the RoleRef to this role from its fact type's preferred_reading
@@ -79,7 +81,7 @@ module ActiveFacts
       def role_name(joiner = "-")
         name_array =
           if role.fact_type.all_role.size == 1
-            role.fact_type.preferred_reading.reading_text.gsub(/\{[0-9]\}/,'').strip.split(/\s/)
+            role.fact_type.preferred_reading.text.gsub(/\{[0-9]\}/,'').strip.split(/\s/)
           else
             role.role_name || [leading_adjective, role.concept.name, trailing_adjective].compact.map{|w| w.split(/\s/)}.flatten
           end
@@ -310,8 +312,8 @@ module ActiveFacts
       # REVISIT: This should probably be changed to be the fact role sequence.
       #
       # define_role_names here is false (use defined names), true (define names) or nil (neither)
-      def expand(frequency_constraints = [], define_role_names = false)
-        expanded = "#{reading_text}"
+      def expand(frequency_constraints = [], define_role_names = false, literals = [])
+        expanded = "#{text}"
         role_refs = role_sequence.all_role_ref.sort_by{|role_ref| role_ref.ordinal}
         (0...role_refs.size).each{|i|
             role_ref = role_refs[i]
@@ -337,12 +339,15 @@ module ActiveFacts
                 else
                   player_name = player.name
                 end
+                literal = literals[i]
                 [
                   fc ? fc : nil,
                   la,
                   define_role_names == false && role_name ? role_name : player_name,
                   ta,
-                  define_role_names && role_name && player.name != role_name ? "(as #{role_name})" : nil
+                  define_role_names && role_name && player.name != role_name ? "(as #{role_name})" : nil,
+                  # Can't have both a literal and a restriction, but we don't enforce that here:
+                  literal ? literal : nil
                 ].compact*" "
             }
         }
@@ -352,7 +357,7 @@ module ActiveFacts
       end
 
       def words_and_role_refs
-        reading_text.
+        text.
         scan(/(?: |\{[0-9]+\}|[^{} ]+)/).   # split up the text into words
         reject{|s| s==' '}.                 # Remove white space
         map do |frag|                       # and go through the bits
@@ -365,6 +370,72 @@ module ActiveFacts
       end
     end
 
+    class ValueRestriction
+      def describe
+        "restricted to {"+
+          all_allowed_range_sorted.map{|ar| ar.to_s(false) }*", "+
+          "}"
+      end
+
+      def all_allowed_range_sorted
+        all_allowed_range.sort_by{|ar|
+            ((min = ar.value_range.minimum_bound) && min.value.literal) ||
+              ((max = ar.value_range.maximum_bound) && max.value.literal)
+          }
+      end
+
+      def to_s
+        if all_allowed_range.size > 1
+        "[" +
+          all_allowed_range.sorted.map { |ar| ar.to_s(true) }*", " +
+        "]"
+        else
+          all_allowed_range.single.to_s
+        end
+      end
+    end
+
+    class AllowedRange
+      def to_s(infinity = true)
+        min = value_range.minimum_bound
+        max = value_range.maximum_bound
+        # Open-ended string ranges will fail in Ruby
+
+        if min = value_range.minimum_bound
+          min = min.value
+          if min.is_a_string
+            min_literal = min.literal.inspect.gsub(/\A"|"\Z/,"'")   # Escape string characters
+          else
+            min_literal = min.literal
+          end
+        else
+          min_literal = infinity ? "INFINITY" : ""
+        end
+        if max = value_range.maximum_bound
+          max = max.value
+          if max.is_a_string
+            max_literal = max.literal.inspect.gsub(/\A"|"\Z/,"'")   # Escape string characters
+          else
+            max_literal = max.literal
+          end
+        else
+          max_literal = infinity ? "INFINITY" : ""
+        end
+
+        min_literal +
+          (min_literal != (max&&max_literal) ? (".." + max_literal) : "")
+      end
+    end
+
+    class Value
+      def to_s
+        (is_a_string ? literal.inspect.gsub(/\A"|"\Z/,"'") : literal) + (unit ? " " + unit.name : "")
+      end
+      def inspect
+        to_s
+      end
+    end
+
     class PresenceConstraint
       def frequency
         min = min_frequency