activefacts 0.7.1 → 0.7.2

data/lib/activefacts/generate/null.rb

@@ -21,6 +21,7 @@ module ActiveFacts
         @indices = options.include? "indices"
       end
 
+    public
       def generate(out = $>)
         @vocabulary.tables if @tables || @columns || @indices
       end

data/lib/activefacts/generate/ruby.rb

@@ -31,12 +31,13 @@ module ActiveFacts
       end
 
       def vocabulary_start(vocabulary)
+        puts "require 'activefacts/api'\n"
         if @sql
           require 'activefacts/persistence'
+          puts "require 'activefacts/persistence'\n"
           @tables = vocabulary.tables
         end
-        puts "require 'activefacts/api'\n\n"
-        puts "module #{vocabulary.name}\n\n"
+        puts "\nmodule #{vocabulary.name}\n\n"
       end
 
       def vocabulary_end
@@ -63,7 +64,7 @@ module ActiveFacts
 
         puts "  class #{o.name} < #{ruby_type_name}\n" +
              "    value_type #{params}\n"
-        puts "    table" if @sql and @tables.include? o
+        puts "    table" if @sql and o.is_table
         puts "    \# REVISIT: #{o.name} has restricted values\n" if o.value_restriction
         puts "    \# REVISIT: #{o.name} is in units of #{o.unit.name}\n" if o.unit
         roles_dump(o)
@@ -71,9 +72,13 @@ module ActiveFacts
       end
 
       def subtype_dump(o, supertypes, pi = nil)
-        puts "  class #{o.name} < #{ supertypes[0].name }"
+        primary_supertype = o && (o.identifying_supertype || o.supertypes[0])
+        secondary_supertypes = o.supertypes-[primary_supertype]
+
+        puts "  class #{o.name} < #{ primary_supertype.name }"
         puts "    identified_by #{identified_by(o, pi)}" if pi
-        puts "    table" if @sql and @tables.include? o
+        puts "    supertypes "+secondary_supertypes.map(&:name)*", " if secondary_supertypes.size > 0
+        puts "    table" if @sql and o.is_table
         fact_roles_dump(o.fact_type) if o.fact_type
         roles_dump(o)
         puts "  end\n\n"
@@ -83,7 +88,7 @@ module ActiveFacts
       def non_subtype_dump(o, pi)
         puts "  class #{o.name}"
         puts "    identified_by #{identified_by(o, pi)}"
-        puts "    table" if @sql and @tables.include? o
+        puts "    table" if @sql and o.is_table
         fact_roles_dump(o.fact_type) if o.fact_type
         roles_dump(o)
         puts "  end\n\n"
@@ -107,6 +112,7 @@ module ActiveFacts
           "\n" +
           secondary_supertypes.map{|sst| "    supertype :#{sst.name}"}*"\n" +
           (pi ? "    identified_by #{identified_by(o, pi)}" : "")
+        puts "    table" if @sql and o.is_table
         fact_roles_dump(fact_type)
         roles_dump(o)
         puts "  end\n\n"
@@ -120,32 +126,10 @@ module ActiveFacts
           }*", "
       end
 
-      def roles_dump(o)
-        @ar_by_role = nil
-        if @sql and @tables.include?(o)
-          ar = o.absorbed_roles
-          @ar_by_role = ar.all_role_ref.inject({}){|h,rr|
-            input_role = (j=rr.all_join_path).size > 0 ? j[0].input_role : rr.role
-            (h[input_role] ||= []) << rr
-            h
-          }
-          #puts ar.all_role_ref.map{|rr| "\t"+rr.describe}*"\n"
-        end
-        super
-      end
-
       def unary_dump(role, role_name)
         puts "    maybe :"+role_name
       end
 
-      def role_dump(role)
-        other_role = role.fact_type.all_role.select{|r| r != role}[0] || role
-        if @ar_by_role and @ar_by_role[other_role] and @sql
-          puts "    # role #{role.fact_type.describe(role)}: absorbs in through #{preferred_role_name(other_role)}: "+@ar_by_role[other_role].map(&:column_name)*", "
-        end
-        super
-      end
-
       def binary_dump(role, role_name, role_player, one_to_one = nil, readings = nil, other_role_name = nil, other_method_name = nil)
         # Find whether we need the name of the other role player, and whether it's defined yet:
         if role_name.camelcase(true) == role_player.name

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

@@ -116,7 +116,7 @@ module ActiveFacts
           tables_emitted = {}
           delayed_foreign_keys = []
 
-          @vocabulary.tables.sort_by{|table| table.name}.each do |table|
+          @vocabulary.tables.each do |table|
             puts "CREATE TABLE #{escape table.name} ("
 
             pk = table.identifier_columns
@@ -127,9 +127,9 @@ module ActiveFacts
               column.references[0].is_simple_reference
             end
 
-            columns = table.columns.sort_by do |column|
-              column.name(nil)
-            end.map do |column|
+            # We sort the columns here, not in the persistence layer, because it affects
+            # the ordering of columns in an index :-(.
+            columns = table.columns.sort_by { |column| column.name(nil) }.map do |column|
               name = escape column.name("")
               padding = " "*(name.size >= ColumnNameMax ? 1 : ColumnNameMax-name.size)
               type, params, restrictions = column.type
@@ -158,22 +158,11 @@ module ActiveFacts
                 ")"
 
             inline_fks = []
-            table.foreign_keys.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.each do |fk|
-              # Put the column pairs in a defined order, sorting key pairs by to-name:
-              froms, tos = fk.from_columns.zip(fk.to_columns).sort_by { |pair|
-                pair[1].name(nil)
-              }.transpose
-
+            table.foreign_keys.each do |fk|
               fk_text = "FOREIGN KEY (" +
-                froms.map{|column| column.name}*", " +
+                fk.from_columns.map{|column| column.name}*", " +
                 ") REFERENCES #{escape fk.to.name} (" +
-                tos.map{|column| column.name}*", " +
+                fk.to_columns.map{|column| column.name}*", " +
                 ")"
               if !@delay_fks and              # We don't want to delay all Fks
                 (tables_emitted[fk.to] or     # The target table has been emitted
@@ -187,10 +176,7 @@ module ActiveFacts
             indices = table.indices
             inline_indices = []
             delayed_indices = []
-            indices.sort_by do |index|
-              # Put the indices in a defined order:
-              index.columns.map(&:name)
-            end.each do |index|
+            indices.each do |index|
               next if index.over == table && index.is_primary   # Already did the primary keys
               abbreviated_column_names = index.abbreviated_column_names*""
               column_names = index.column_names

data/lib/activefacts/generate/text.rb

@@ -16,6 +16,7 @@ module ActiveFacts
         @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
       end
 
+    public
       def generate(out = $>)
         out.puts @vocabulary.constellation.verbalise
       end

data/lib/activefacts/input/cql.rb

@@ -1,5 +1,3 @@
-#
-#       ActiveFacts Vocabulary Input.
 #       Compile a CQL file into an ActiveFacts vocabulary.
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
@@ -97,15 +95,15 @@ module ActiveFacts
         # Create the base type:
         base_type = nil
         if (base_type_name != name)
-          unless base_type = @constellation.ValueType[[@constellation.Name(base_type_name), @vocabulary]]
+          unless base_type = @constellation.ValueType[[@vocabulary, @constellation.Name(base_type_name)]]
             #puts "REVISIT: Creating base ValueType #{base_type_name} in #{@vocabulary.inspect}"
-            base_type = @constellation.ValueType(base_type_name, @vocabulary)
+            base_type = @constellation.ValueType(@vocabulary, base_type_name)
             return if base_type_name == name
           end
         end
 
         # Create and initialise the ValueType:
-        vt = @constellation.ValueType(name, @vocabulary)
+        vt = @constellation.ValueType(@vocabulary, name)
         vt.supertype = base_type if base_type
         vt.length = length if length
         vt.scale = scale if scale
@@ -120,7 +118,7 @@ module ActiveFacts
               min ? [min.to_s, true] : nil,
               max ? [max.to_s, true] : nil
               )
-            ar = @constellation.AllowedRange(v_range, vt.value_restriction)
+            ar = @constellation.AllowedRange(vt.value_restriction, v_range)
           end
         end
       end
@@ -130,7 +128,7 @@ module ActiveFacts
         debug :entity, "Defining Entity Type #{name}" do
           # Assert the entity:
           # If this entity was forward referenced, this won't be a new object, and will subsume its roles
-          entity_type = @constellation.EntityType(name, @vocabulary)
+          entity_type = @constellation.EntityType(@vocabulary, name)
 
           # Set up its supertypes:
           supertypes.each do |supertype_name|
@@ -162,9 +160,9 @@ module ActiveFacts
 
             # Find or Create an appropriate ValueType called "#{name}#{mode}", of the supertype "#{mode}"
             vt_name = "#{name}#{mode}"
-            unless vt = @constellation.ValueType[[vt_name, @vocabulary]]
-              base_vt = @constellation.ValueType(mode, @vocabulary)
-              vt = @constellation.ValueType(vt_name, @vocabulary, :supertype => base_vt)
+            unless vt = @constellation.ValueType[[@vocabulary, vt_name]]
+              base_vt = @constellation.ValueType(@vocabulary, mode)
+              vt = @constellation.ValueType(@vocabulary, vt_name, :supertype => base_vt)
             end
           end
 
@@ -373,7 +371,7 @@ module ActiveFacts
 
       def add_supertype(entity_type, supertype_name, identifying_supertype)
         debug :supertype, "Supertype #{supertype_name}"
-        supertype = @constellation.EntityType(supertype_name, @vocabulary)
+        supertype = @constellation.EntityType(@vocabulary, supertype_name)
         inheritance_fact = @constellation.TypeInheritance(entity_type, supertype, :fact_type_id => :new)
 
         # Create a reading:
@@ -459,7 +457,7 @@ module ActiveFacts
 
           # The fact type has a name iff it's objectified as an entity type
           #puts "============= Creating entity #{name} to nominalize fact type #{fact_type.default_reading} ======================" if name
-          fact_type.entity_type = @constellation.EntityType(name, @vocabulary) if name
+          fact_type.entity_type = @constellation.EntityType(@vocabulary, name) if name
 
           # Add the identifying PresenceConstraint for this fact type:
           if fact_type.all_role.size == 1 && !fact_type.entity_type
@@ -496,7 +494,7 @@ module ActiveFacts
       # sequences. Each binding that isn't common at this top level
       # must occur more than once in each group of fact types where
       # it appears, and it forms a join between those fact types.
-      def bind_join_paths_as_role_sequences(readings_list)
+      def bind_joins_as_role_sequences(readings_list)
         @symbols = SymbolTable.new(@constellation, @vocabulary)
         fact_roles_list = []
         bindings_list = []
@@ -520,8 +518,8 @@ module ActiveFacts
         end
 
         # Each set of binding arrays in the list must share at least one common binding
-        bindings_by_join_path = bindings_list.map{|join_path| join_path.flatten}
-        common_bindings = bindings_by_join_path[1..-1].inject(bindings_by_join_path[0]) { |c, b| c & b }
+        bindings_by_join = bindings_list.map{|join| join.flatten}
+        common_bindings = bindings_by_join[1..-1].inject(bindings_by_join[0]) { |c, b| c & b }
         # Was:
         # common_bindings = bindings_list.inject(bindings_list[0]) { |common, bindings| common & bindings }
         raise "Set constraints must have at least one common role between the sets" unless common_bindings.size > 0
@@ -533,9 +531,9 @@ module ActiveFacts
         # Each element of a join path is the array of bindings for a fact type invocation.
         # Each invocation must share a binding (not one of the globally common ones) with
         # another invocation in that join path.
-        bindings_list.each_with_index do |join_path, jpnum|
+        bindings_list.each_with_index do |join, jpnum|
           # Check that this bindings array creates a complete join path:
-          join_path.each_with_index do |bindings, i|
+          join.each_with_index do |bindings, i|
             fact_type_roles = fact_roles_list[jpnum][i]
             fact_type = fact_type_roles[0].fact_type
 
@@ -543,10 +541,10 @@ module ActiveFacts
             # These bindings must be joined to some later fact type by a common binding that isn't a globally-common one:
             local_bindings = bindings-common_bindings
             next if local_bindings.size == 0  # No join path is required, as only one fact type is invoked.
-            next if i == join_path.size-1   # We already checked that the last fact type invocation is joined
+            next if i == join.size-1   # We already checked that the last fact type invocation is joined
             ok = local_bindings.detect do |local_binding|
               j = i+1
-              join_path[j..-1].detect do |other_bindings|
+              join[j..-1].detect do |other_bindings|
                 other_fact_type_roles = fact_roles_list[jpnum][j]
                 other_fact_type = other_fact_type_roles[0].fact_type
                 j += 1
@@ -568,10 +566,10 @@ module ActiveFacts
         role_sequences = readings_list.map{|r| @constellation.RoleSequence(:new) }
         common_bindings.each_with_index do |binding, index|
           role_sequences.each_with_index do |rs, rsi|
-            join_path = bindings_list[rsi]
+            join = bindings_list[rsi]
             fact_pos = nil
-            join_pos = (0...join_path.size).detect do |i|
-              fact_pos = join_path[i].index(binding)
+            join_pos = (0...join.size).detect do |i|
+              fact_pos = join[i].index(binding)
             end
             @constellation.RoleRef(rs, index).role = fact_roles_list[rsi][join_pos][fact_pos]
           end
@@ -581,7 +579,7 @@ module ActiveFacts
       end
 
       def subset_constraint(subset_readings, superset_readings)
-        role_sequences = bind_join_paths_as_role_sequences([subset_readings, superset_readings])
+        role_sequences = bind_joins_as_role_sequences([subset_readings, superset_readings])
 
         #puts "subset_constraint:\n\t#{subset_readings.inspect}\n\t#{superset_readings.inspect}"
         #puts "\t#{role_sequences.map{|rs| rs.describe}.inspect}"
@@ -601,7 +599,7 @@ module ActiveFacts
         # Exactly one or at most one, nothing else will do
         raise "Set comparison constraint must use 'at most' or 'exactly' one" if quantifier[1] != 1
 
-        role_sequences = bind_join_paths_as_role_sequences(readings_list)
+        role_sequences = bind_joins_as_role_sequences(readings_list)
 
         # Create the constraint:
         constraint = @constellation.SetExclusionConstraint(:new)
@@ -615,7 +613,7 @@ module ActiveFacts
       def equality_constraint(*readings_list)
         #puts "REVISIT: equality\n\t#{readings_list.map{|rl| rl.inspect}*"\n\tif and only if\n\t"}"
 
-        role_sequences = bind_join_paths_as_role_sequences(readings_list)
+        role_sequences = bind_joins_as_role_sequences(readings_list)
 
         # Create the constraint:
         constraint = @constellation.SetEqualityConstraint(:new)
@@ -994,7 +992,7 @@ module ActiveFacts
         return nil if roles.size == 0 # Safeguard; this would chuck an exception otherwise
         roles[0].all_role_ref.each do |role_ref|
           next if role_ref.role_sequence.all_role_ref.map(&:role) != roles
-          pc = role_ref.role_sequence.all_presence_constraint.only  # Will throw an exception if there's more than one.
+          pc = role_ref.role_sequence.all_presence_constraint.single  # Will return nil if there's more than one.
           #puts "Existing PresenceConstraint matches those roles!" if pc
           return pc if pc
         end
@@ -1018,15 +1016,15 @@ module ActiveFacts
       end
 
       def concept_by_name(name)
-        player = @constellation.Concept[[name, @vocabulary.identifying_role_values]]
+        player = @constellation.Concept[[@vocabulary.identifying_role_values, name]]
 
         # REVISIT: Hack to allow facts to refer to standard types that will be imported from standard vocabulary:
         if !player && %w{Date DateAndTime Time}.include?(name)
-          player = @constellation.ValueType(name, @vocabulary.identifying_role_values)
+          player = @constellation.ValueType(@vocabulary.identifying_role_values, name)
         end
 
         if (!player && @symbols.allowed_forward[name])
-          player = @constellation.EntityType(name, @vocabulary)
+          player = @constellation.EntityType(@vocabulary, name)
         end
         player
       end
@@ -1173,15 +1171,15 @@ module ActiveFacts
         # return the EntityType or ValueType this name refers to:
         def concept(name, allowed_forward = false)
           # See if the name is a defined concept in this vocabulary:
-          player = @constellation.Concept[[name, virv = @vocabulary.identifying_role_values]]
+          player = @constellation.Concept[[virv = @vocabulary.identifying_role_values, name]]
 
           # REVISIT: Hack to allow facts to refer to standard types that will be imported from standard vocabulary:
           if !player && %w{Date DateAndTime Time}.include?(name)
-            player = @constellation.ValueType(name, virv)
+            player = @constellation.ValueType(virv, name)
           end
 
           if !player && allowed_forward
-            player = @constellation.EntityType(name, @vocabulary)
+            player = @constellation.EntityType(@vocabulary, name)
           end
 
           player

data/lib/activefacts/input/orm.rb

@@ -101,11 +101,11 @@ module ActiveFacts
           entity_types <<
             @by_id[id] =
               entity_type =
-              @constellation.EntityType(name, @vocabulary)
+              @constellation.EntityType(@vocabulary, name)
             independent = x.attributes['IsIndependent']
             entity_type.is_independent = true if independent && independent == 'true'
             personal = x.attributes['IsPersonal']
-            entity_type.is_personal = true if personal && personal == 'true'
+            entity_type.pronoun = 'personal' if personal && personal == 'true'
   #       x_pref = x.elements.to_a("orm:PreferredIdentifier")[0]
   #       if x_pref
   #         pi_id = x_pref.attributes['ref']
@@ -139,26 +139,26 @@ module ActiveFacts
           length = 32 if type_name =~ /Integer\Z/ && length.to_i == 0 # Set default integer length
 
           # REVISIT: Need to handle standard types better here:
-          data_type = type_name != name ? @constellation.ValueType(type_name, @vocabulary) : nil
+          data_type = type_name != name ? @constellation.ValueType(@vocabulary, type_name) : nil
 
           # puts "ValueType #{name} is #{id}"
           value_types <<
             @by_id[id] =
-            vt = @constellation.ValueType(name, @vocabulary)
+            vt = @constellation.ValueType(@vocabulary, name)
           vt.supertype = data_type
           vt.length = length if length
           vt.scale = scale if scale
           independent = x.attributes['IsIndependent']
           vt.is_independent = true if independent && independent == 'true'
           personal = x.attributes['IsPersonal']
-          vt.is_personal = true if personal && personal == 'true'
+          vt.pronoun = 'personal' if personal && personal == 'true'
 
           x_ranges = x.elements.to_a("orm:ValueRestriction/orm:ValueConstraint/orm:ValueRanges/orm:ValueRange")
           next if x_ranges.size == 0
           vt.value_restriction = @constellation.ValueRestriction(:new)
           x_ranges.each{|x_range|
             v_range = value_range(x_range)
-            ar = @constellation.AllowedRange(v_range, vt.value_restriction)
+            ar = @constellation.AllowedRange(vt.value_restriction, v_range)
           }
         }
       end
@@ -317,7 +317,7 @@ module ActiveFacts
             #puts "NestedType #{name} is #{id}, nests #{fact_type.fact_type_id}"
             nested_types <<
               @by_id[id] =
-              nested_type = @constellation.EntityType(name, @vocabulary)
+              nested_type = @constellation.EntityType(@vocabulary, name)
             nested_type.fact_type = fact_type
           end
         }
@@ -390,7 +390,7 @@ module ActiveFacts
               role.role_value_restriction = @constellation.ValueRestriction(:new)
               x_ranges.each{|x_range|
                 v_range = value_range(x_range)
-                ar = @constellation.AllowedRange(v_range, role.role_value_restriction)
+                ar = @constellation.AllowedRange(role.role_value_restriction, v_range)
               }
             }
 
@@ -632,8 +632,8 @@ module ActiveFacts
           # A TypeInheritance fact type has a uniqueness constraint on each role.
           # If this UC is on the supertype and identifies the subtype, it's preferred:
           is_supertype_constraint =
-            roles.all_role_ref.size == 1 &&
-            (role = roles.all_role_ref.only.role) &&
+            (rr = roles.all_role_ref.single) &&
+            (role = rr.role) &&
             (fact_type = role.fact_type) &&
             fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) &&
             role.concept == fact_type.supertype &&
@@ -649,8 +649,7 @@ module ActiveFacts
           pc.is_preferred_identifier = true if pi || unary_identifier || is_supertype_constraint
           #puts "#{name} covers #{roles.describe} has min=#{pc.min_frequency}, max=1, preferred=#{pc.is_preferred_identifier.inspect}" if emit_special_debug
 
-          #puts roles.verbalise
-          #puts pc.verbalise
+          #puts roles.all_role_ref.to_a[0].role.fact_type.describe + " is subject to " + pc.describe if roles.all_role_ref.all?{|r| r.role.fact_type.is_a? ActiveFacts::Metamodel::TypeInheritance }
 
           (@constraints_by_rs[roles] ||= []) << pc
         }

data/lib/activefacts/persistence.rb

@@ -3,8 +3,13 @@
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
+
+# These files are concerned with calculating a relational schema for a vocabulary:
 require 'activefacts/persistence/reference'
 require 'activefacts/persistence/tables'
 require 'activefacts/persistence/columns'
 require 'activefacts/persistence/foreignkey'
 require 'activefacts/persistence/index'
+
+# These extend the API classes with relational awareness:
+require 'activefacts/persistence/concept'