activefacts 0.8.9 → 0.8.10

data/lib/activefacts/generate/oo.rb

@@ -21,6 +21,7 @@ module ActiveFacts
       def value_type_end
       end
 
+      # Dump the roles for an object type (excluding the roles of a fact type which is objectified)
       def roles_dump(o)
         o.all_role.
           select{|role|
@@ -35,12 +36,14 @@ module ActiveFacts
       end
 
       def role_dump(role)
+        return if role.fact_type.entity_type
+
         fact_type = role.fact_type
         if fact_type.all_role.size == 1
-          unary_dump(role, preferred_role_name(role)) unless fact_type.entity_type
-          # REVISIT: If the objectified fact type has already been dumped, we'll get nothing.
+          unary_dump(role, preferred_role_name(role))
           return
         elsif fact_type.all_role.size != 2
+          # Shouldn't come here, except perhaps for an invalid model
           return  # ternaries and higher are always objectified
         end
 
@@ -50,54 +53,28 @@ module ActiveFacts
           return
         end
 
-        # Find any uniqueness constraint over this role:
-        fact_constraints = @presence_constraints_by_fact[fact_type]
-        #debug "Considering #{fact_constraints.size} fact constraints over fact role #{role.concept.name}"
-        ucs = fact_constraints.select{|c| c.is_a?(ActiveFacts::Metamodel::PresenceConstraint) && c.max_frequency == 1 }
-        # Emit "has_one/one_to_one..." only for functional roles here:
-        #debug "Considering #{ucs.size} unique constraints over role #{role.concept.name}"
-        unless ucs.find {|c|
-              c.role_sequence.all_role_ref.map(&:role) == [role]
-          }
-          #debug "No uniqueness constraint found for #{role} in #{fact_type}"
-          return
-        end
+        return unless role.is_functional
+
+        other_role = fact_type.all_role.select{|r| r != role}[0]
+        other_role_name = preferred_role_name(other_role)
+        other_player = other_role.object_type
+
+        # It's a one_to_one if there's a uniqueness constraint on the other role:
+        one_to_one = other_role.is_functional
+        return if one_to_one &&
+            !@object_types_dumped[other_role.object_type]
 
-        if fact_type.entity_type
-          # other_role is a phantom played by the entity type that objectifies this fact type.
-          # REVISIT: No rolename can be provided for the phantom role, so _as_XYZ doesn't occur
-          other_player = fact_type.entity_type
-          return unless @concept_types_dumped[other_player]
-
-          other_role_name = other_player.name.gsub(/ /,'_').snakecase
-          other_role_method = role.concept.name.gsub(/ /,'_').snakecase
-          one_to_one = true
-        else
-
-          other_role = fact_type.all_role.select{|r| r != role}[0]
-          other_role_name = preferred_role_name(other_role)
-          other_player = other_role.concept
-
-          # It's a one_to_one if there's a uniqueness constraint on the other role:
-          one_to_one = ucs.find {|c| c.role_sequence.all_role_ref.map(&:role) == [other_role] }
-          if one_to_one &&
-              !@concept_types_dumped[other_role.concept]
-            #debug "Will dump 1:1 later for #{role} in #{fact_type}"
-            return
-          end
-
-          # Find role name:
-          role_method = preferred_role_name(role)
-          other_role_method = one_to_one ? role_method : "all_"+role_method
-          # puts "---"+role.role_name if role.role_name
-          if other_role_name != other_player.name.gsub(/ /,'_').snakecase and
-            role_method == role.concept.name.gsub(/ /,'_').snakecase
-            other_role_method += "_as_#{other_role_name}"
-          end
+        # Find role name:
+        role_method = preferred_role_name(role)
+        other_role_method = one_to_one ? role_method : "all_"+role_method
+        # puts "---"+role.role_name if role.role_name
+        if other_role_name != other_player.name.gsub(/ /,'_').snakecase and
+          role_method == role.object_type.name.gsub(/ /,'_').snakecase
+          other_role_method += "_as_#{other_role_name}"
         end
 
         role_name = role_method
-        role_name = nil if role_name == role.concept.name.gsub(/ /,'_').snakecase
+        role_name = nil if role_name == role.object_type.name.gsub(/ /,'_').snakecase
 
         binary_dump(role, other_role_name, other_player, role.is_mandatory, one_to_one, nil, role_name, other_role_method)
       end
@@ -106,7 +83,7 @@ module ActiveFacts
         return "" if role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
 
         if is_for && role.fact_type.entity_type == is_for && role.fact_type.all_role.size == 1
-          return role.concept.name.gsub(/[- ]/,'_').snakecase
+          return role.object_type.name.gsub(/[- ]/,'_').snakecase
         end
 
         # debug "Looking for preferred_role_name of #{describe_fact_type(role.fact_type, role)}"
@@ -121,7 +98,7 @@ module ActiveFacts
             reading.text.gsub(/ *\{0\} */,'').gsub(/[- ]/,'_').downcase
         end
 
-        # debug "\tleading_adjective=#{(p=preferred_role_ref).leading_adjective}, role_name=#{role.role_name}, role player=#{role.concept.name}, trailing_adjective=#{p.trailing_adjective}"
+        # debug "\tleading_adjective=#{(p=preferred_role_ref).leading_adjective}, role_name=#{role.role_name}, role player=#{role.object_type.name}, trailing_adjective=#{p.trailing_adjective}"
         role_words = []
         role_name = role.role_name
         role_name = nil if role_name == ""
@@ -130,7 +107,7 @@ module ActiveFacts
         la = preferred_role_ref.leading_adjective
         role_words << la.gsub(/ /,'_') if la && la != "" and !role.role_name
 
-        role_words << (role_name || role.concept.name.gsub(/ /,'_'))
+        role_words << (role_name || role.object_type.name.gsub(/ /,'_'))
         # REVISIT: Same when trailing_adjective is a suffix of the role_name
         ta = preferred_role_ref.trailing_adjective
         role_words << ta.gsub(/ /,'_') if ta && ta != "" and !role_name
@@ -157,12 +134,12 @@ module ActiveFacts
                 pc.max_frequency == 1
               }
             }
-            as = role_name != role.concept.name.gsub(/ /,'_').snakecase ? "_as_#{role_name}" : ""
+            as = role_name != role.object_type.name.gsub(/ /,'_').snakecase ? "_as_#{role_name}" : ""
             raise "Fact #{fact_type.describe} type is not objectified" unless fact_type.entity_type
             other_role_method = (one_to_one ? "" : "all_") + 
               fact_type.entity_type.name.gsub(/ /,'_').snakecase +
               as
-            binary_dump(role, role_name, role.concept, true, one_to_one, nil, nil, other_role_method)
+            binary_dump(role, role_name, role.object_type, true, one_to_one, nil, nil, other_role_method)
           }
       end
 

data/lib/activefacts/generate/ordered.rb

@@ -32,7 +32,7 @@ module ActiveFacts
         vocabulary_start(@vocabulary)
 
         build_indices
-        @concept_types_dumped = {}
+        @object_types_dumped = {}
         @fact_types_dumped = {}
         units_dump()
         value_types_dump()
@@ -67,35 +67,46 @@ module ActiveFacts
         done_banner = false
         units = @vocabulary.all_unit.to_a.sort_by{|u| u.name.gsub(/ /,'')}
         while units.size > 0
-          if !done_banner
-            done_banner = true
-            units_banner
-          end
           i = 0
           while i < units.size
             unit = units[i]
             i += 1
+
             # Skip this one if the precursors haven't yet been dumped:
             next if unit.all_derivation_as_derived_unit.detect{|d| units.include?(d.base_unit) }
 
-            unit_dump(unit)
+            # Even if we skip, we're done with this unit
             units.delete(unit)
             i -= 1
+
+            # Skip value-type derived units
+            next if unit.name =~ /\^/
+
+            # Don't dump fundamental units which have normal derived units, they are implied:
+            next if unit.is_fundamental &&
+              unit.all_derivation_as_base_unit.detect{|d| d.derived_unit.name !~ /\^/}
+
+            if !done_banner
+              done_banner = true
+              units_banner
+            end
+            unit_dump(unit)
           end
         end
+        units_end if done_banner
       end
 
       def value_types_dump
         done_banner = false
         @value_type_dumped = {}
-        @vocabulary.all_concept.sort_by{|o| o.name.gsub(/ /,'')}.each{|o|
+        @vocabulary.all_object_type.sort_by{|o| o.name.gsub(/ /,'')}.each{|o|
             next unless o.is_a?(ActiveFacts::Metamodel::ValueType)
 
             value_type_banner unless done_banner
             done_banner = true
 
             value_type_chain_dump(o)
-            @concept_types_dumped[o] = true
+            @object_types_dumped[o] = true
           }
         value_type_end if done_banner
       end
@@ -116,7 +127,7 @@ module ActiveFacts
         @precursors, @followers = *build_entity_dependencies
 
         done_banner = false
-        sorted = @vocabulary.all_concept.select{|o|
+        sorted = @vocabulary.all_object_type.select{|o|
           o.is_a?(ActiveFacts::Metamodel::EntityType) # and !o.fact_type
         }.sort_by{|o| o.name.gsub(/ /,'')}
         panic = nil
@@ -124,7 +135,7 @@ module ActiveFacts
           count_this_pass = 0
           skipped_this_pass = 0
           sorted.each{|o|
-              next if @concept_types_dumped[o]    # Already done
+              next if @object_types_dumped[o]    # Already done
 
               # Can we do this yet?
               if (o != panic and                  # We don't *have* to do it (panic mode)
@@ -160,7 +171,7 @@ module ActiveFacts
               if panic        # We were already panicing... what to do now?
                 # This won't happen again unless the above code is changed to decide it can't dump "panic".
                 raise "Unresolvable cycle of forward references: " +
-                  (bad = sorted.select{|o| EntityType === o && !@concept_types_dumped[o]}).map{|o| o.name }.inspect +
+                  (bad = sorted.select{|o| EntityType === o && !@object_types_dumped[o]}).map{|o| o.name }.inspect +
                   ":\n\t" + bad.map{|o|
                     o.name +
                     ": " +
@@ -170,10 +181,10 @@ module ActiveFacts
                 # Find the object that has the most followers and no fwd-ref'd supertypes:
                 # This selection might be better if we allow PI roles to be fwd-ref'd...
                 panic = sorted.
-                  select{|o| !@concept_types_dumped[o] }.
+                  select{|o| !@object_types_dumped[o] }.
                   sort_by{|o|
                       f = @followers[o] || []; 
-                      o.supertypes.detect{|s| !@concept_types_dumped[s] } ? 0 : -f.size
+                      o.supertypes.detect{|s| !@object_types_dumped[s] } ? 0 : -f.size
                     }[0]
                 # debug "Panic mode, selected #{panic.name} next"
               end
@@ -185,7 +196,7 @@ module ActiveFacts
       end
 
       def entity_type_dump(o)
-        @concept_types_dumped[o] = true
+        @object_types_dumped[o] = true
         pi = o.preferred_identifier
 
         supers = o.supertypes
@@ -210,7 +221,6 @@ module ActiveFacts
         identifying_facts = ([o.fact_type]+identifying_role_refs.map{|rr| rr.role.fact_type }).compact.uniq
 
         identification = identified_by_roles_and_facts(o, identifying_role_refs, identifying_facts)
-        #identifying_facts.each{|f| @fact_types_dumped[f] = true }
 
         identification
       end
@@ -222,20 +232,20 @@ module ActiveFacts
 
       def describe_roles(roles, highlight = nil)
         "("+
-        roles.map{|role| role.concept.name + (role == highlight ? "*" : "")}*", "+
+        roles.map{|role| role.object_type.name + (role == highlight ? "*" : "")}*", "+
         ")"
       end
 
       def describe_role_sequence(role_sequence)
         "("+
-        role_sequence.all_role_ref.map{|role_ref| role_ref.role.concept.name }*", "+
+        role_sequence.all_role_ref.map{|role_ref| role_ref.role.object_type.name }*", "+
         ")"
       end
 
       # This returns an array of two hash tables each keyed by an EntityType.
       # The values of each hash entry are the precursors and followers (respectively) of that entity.
       def build_entity_dependencies
-        @vocabulary.all_concept.inject([{},{}]) { |a, o|
+        @vocabulary.all_object_type.inject([{},{}]) { |a, o|
             if o.is_a?(ActiveFacts::Metamodel::EntityType)
               precursor = a[0]
               follower = a[1]
@@ -244,7 +254,7 @@ module ActiveFacts
               if pi
                 pi.role_sequence.all_role_ref.each{|rr|
                     role = rr.role
-                    player = role.concept
+                    player = role.object_type
                     # REVISIT: If we decide to emit value types on demand, need to remove this:
                     next unless player.is_a?(ActiveFacts::Metamodel::EntityType)
                     # player is a precursor of o
@@ -254,9 +264,9 @@ module ActiveFacts
               end
               if o.fact_type
                 o.fact_type.all_role.each do |role|
-                  next unless role.concept.is_a?(ActiveFacts::Metamodel::EntityType)
-                  (precursor[o] ||= []) << role.concept
-                  (follower[role.concept] ||= []) << o
+                  next unless role.object_type.is_a?(ActiveFacts::Metamodel::EntityType)
+                  (precursor[o] ||= []) << role.object_type
+                  (follower[role.object_type] ||= []) << o
                 end
               end
 
@@ -289,9 +299,10 @@ module ActiveFacts
               # The fact type hasn't already been dumped but all its role players have
               !@fact_types_dumped[fact_type] &&
                 !fact_type.is_a?(ActiveFacts::Metamodel::ImplicitFactType) &&
-                !fact_type.all_role.detect{|r| !@concept_types_dumped[r.concept] } &&
-                !fact_type.entity_type
-#                !(fact_type.entity_type && (p = @precursors[fact_type.entity_type]) && p.size > 0)
+                !fact_type.all_role.detect{|r| !@object_types_dumped[r.object_type] } &&
+                !fact_type.entity_type &&
+                derivation_precursors_complete(fact_type)
+              # REVISIT: A derived fact type must not be dumped before its joined fact types have
             }.sort_by{|fact_type|
               fact_type_key(fact_type)
             }.each{|fact_type|
@@ -303,12 +314,22 @@ module ActiveFacts
         end while progress
       end
 
+      def derivation_precursors_complete(fact_type)
+        pr = fact_type.preferred_reading
+        return true unless jr = pr.role_sequence.all_role_ref.to_a[0].join_role
+        join = jr.join_node.join
+        return false if join.all_join_step.detect{|js| !@fact_types_dumped[js.fact_type] }
+        return false if join.all_join_node.detect{|jn| !@object_types_dumped[jn.object_type] }
+        true
+      end
+
       def skip_fact_type(f)
         # REVISIT: There might be constraints we have to merge into the nested entity or subtype. 
         # These will come up as un-handled constraints:
         pcs = @presence_constraints_by_fact[f]
-        f.is_a?(ActiveFacts::Metamodel::TypeInheritance) ||
-          (pcs && pcs.size > 0 && !pcs.detect{|c| !@constraints_used[c] })
+        return true if f.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+        return false if f.entity_type && !@object_types_dumped[f.entity_type]
+        pcs && pcs.size > 0 && !pcs.detect{|c| !@constraints_used[c] }
       end
 
       # Dump one fact type.
@@ -341,7 +362,7 @@ module ActiveFacts
         # REVISIT: Go through the residual constraints and re-process appropriate readings to show them
 
         @fact_types_dumped[fact_type] = true
-        @concept_types_dumped[fact_type.entity_type] = true if fact_type.entity_type
+        @object_types_dumped[fact_type.entity_type] = true if fact_type.entity_type
       end
 
       # Dump fact types.
@@ -360,7 +381,7 @@ module ActiveFacts
                 !fact_type.is_a?(ActiveFacts::Metamodel::ImplicitFactType) and
                 !@fact_types_dumped[fact_type] and
                 !skip_fact_type(fact_type) and
-                !fact_type.all_role.detect{|r| r.concept.is_a?(ActiveFacts::Metamodel::EntityType) }
+                !fact_type.all_role.detect{|r| r.object_type.is_a?(ActiveFacts::Metamodel::EntityType) }
             }.sort_by{|fact_id|
                 fact_type = fact_collection[fact_id]
                 fact_type_key(fact_type)
@@ -380,7 +401,7 @@ module ActiveFacts
             fact_type_key(fact_type)
           }.each{|fact_type|
             next if @fact_types_dumped[fact_type]
-            # debug "Not dumped #{fact_type.verbalise}(#{fact_type.all_role.map{|r| r.concept.name}*", "})"
+            # debug "Not dumped #{fact_type.verbalise}(#{fact_type.all_role.map{|r| r.object_type.name}*", "})"
             fact_type_banner unless done_banner
             done_banner = true
             fact_type_dump_with_dependents(fact_type)
@@ -412,17 +433,17 @@ module ActiveFacts
             pr.role_sequence.
               all_role_ref.
               sort_by{|role_ref| role_ref.ordinal}.
-              map{|role_ref| [ role_ref.leading_adjective, role_ref.role.concept.name, role_ref.trailing_adjective ].compact*"-" } +
+              map{|role_ref| [ role_ref.leading_adjective, role_ref.role.object_type.name, role_ref.trailing_adjective ].compact*"-" } +
               [pr.text]
           else
-            fact_type.all_role.map{|role| role.concept.name }
+            fact_type.all_role.map{|role| role.object_type.name }
           end
 
         (fact_type.entity_type ? [fact_type.entity_type.name] : [""]) + role_names
       end
 
       def role_ref_key(role_ref)
-        [ role_ref.leading_adjective, role_ref.role.concept.name, role_ref.trailing_adjective ].compact*"-" +
+        [ role_ref.leading_adjective, role_ref.role.object_type.name, role_ref.trailing_adjective ].compact*"-" +
         " in " +
         role_ref.role.fact_type.preferred_reading.expand
       end
@@ -432,8 +453,8 @@ module ActiveFacts
         when ActiveFacts::Metamodel::RingConstraint
           [ 1,
             c.ring_type,
-            c.role.concept.name,
-            c.other_role.concept.name,
+            c.role.object_type.name,
+            c.other_role.object_type.name,
             c.name||""
           ]
         when ActiveFacts::Metamodel::SetExclusionConstraint
@@ -499,7 +520,7 @@ module ActiveFacts
 
           # Skip presence constraints on value types:
           # next if ActiveFacts::PresenceConstraint === c &&
-          #     ActiveFacts::ValueType === c.concept
+          #     ActiveFacts::ValueType === c.object_type
           constraint_dump(c)
         end
         constraint_end if heading
@@ -516,6 +537,9 @@ module ActiveFacts
       def units_banner
       end
 
+      def units_end
+      end
+
       def unit_dump unit
       end
 

data/lib/activefacts/generate/ruby.rb

@@ -145,11 +145,11 @@ module ActiveFacts
 
       def binary_dump(role, role_name, role_player, mandatory = nil, 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.gsub(/ /,'').sub(/^[a-z]/) {|i| i.upcase}
+        if role_name.camelcase == role_player.name.gsub(/ /,'').sub(/^[a-z]/) {|i| i.upcase}
           # Don't use Class name if implied by rolename
           role_reference = nil
         else
-          role_reference = ":class => "+concept_reference(role_player)
+          role_reference = ":class => "+object_type_reference(role_player)
         end
         other_role_name = ":counterpart => :"+other_role_name.gsub(/ /,'_') if other_role_name
 
@@ -167,11 +167,11 @@ module ActiveFacts
         #puts "    \# REVISIT: #{other_role_name} has values restricted to #{role.role_value_constraint}\n" if role.role_value_constraint
       end
 
-      def concept_reference concept
-        if !@concept_types_dumped[concept]
-          '"'+concept.name.gsub(/ /,'')+'"'
+      def object_type_reference object_type
+        if !@object_types_dumped[object_type]
+          '"'+object_type.name.gsub(/ /,'')+'"'
         else
-          role_reference = concept.name.gsub(/ /,'')
+          role_reference = object_type.name.gsub(/ /,'')
         end
       end
 

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

@@ -134,7 +134,7 @@ module ActiveFacts
           delayed_foreign_keys = []
 
           @vocabulary.tables.each do |table|
-            puts "CREATE TABLE #{escape table.name(@underscore).gsub(' ',@underscore)} ("
+            puts "CREATE TABLE #{escape table.name.gsub(' ',@underscore)} ("
 
             pk = table.identifier_columns
             identity_column = pk[0] if pk.size == 1 && pk[0].is_auto_assigned
@@ -178,7 +178,7 @@ module ActiveFacts
             table.foreign_keys.each do |fk|
               fk_text = "FOREIGN KEY (" +
                 fk.from_columns.map{|column| column.name(@underscore)}*", " +
-                ") REFERENCES #{escape fk.to.name(@underscore).gsub(' ',@underscore)} (" +
+                ") REFERENCES #{escape fk.to.name.gsub(' ',@underscore)} (" +
                 fk.to_columns.map{|column| column.name(@underscore)}*", " +
                 ")"
               if !@delay_fks and              # We don't want to delay all Fks
@@ -186,7 +186,7 @@ module ActiveFacts
                 fk.to == table && !fk.to_columns.detect{|column| !column.is_mandatory})   # The reference columns already have the required indexes
                 inline_fks << fk_text
               else
-                delayed_foreign_keys << ("ALTER TABLE #{escape fk.from.name(@underscore).gsub(' ',@underscore)}\n\tADD " + fk_text)
+                delayed_foreign_keys << ("ALTER TABLE #{escape fk.from.name.gsub(' ',@underscore)}\n\tADD " + fk_text)
               end
             end
 
@@ -204,7 +204,7 @@ module ActiveFacts
                 view_name = escape "#{index.view_name}_#{abbreviated_column_names}"
                 delayed_indices <<
 %Q{CREATE VIEW dbo.#{view_name} (#{column_name_list}) WITH SCHEMABINDING AS
-\tSELECT #{column_name_list} FROM dbo.#{escape index.on.name(@underscore).gsub(' ',@underscore)}
+\tSELECT #{column_name_list} FROM dbo.#{escape index.on.name.gsub(' ',@underscore)}
 \tWHERE\t#{
   index.columns.
     select{|column| !column.is_mandatory }.