activefacts 1.0.2 → 1.1.0

data/lib/activefacts/generate/helpers/oo.rb

@@ -6,13 +6,15 @@
 #
 require 'activefacts/vocabulary'
 require 'activefacts/generate/helpers/ordered'
+require 'activefacts/generate/traits/oo'
 
 module ActiveFacts
   module Generate
+
     module Helpers
       # Base class for generators of object-oriented class libraries for an ActiveFacts vocabulary.
       class OO < OrderedDumper  #:nodoc:
-        def constraints_dump(constraints_used)
+        def constraints_dump
           # Stub, not needed.
         end
 
@@ -23,7 +25,7 @@ module ActiveFacts
         end
 
         def entity_type_dump(o)
-          @object_types_dumped[o] = true
+          o.ordered_dumped!
           pi = o.preferred_identifier
 
           supers = o.supertypes
@@ -34,7 +36,7 @@ module ActiveFacts
           else
             non_subtype_dump(o, pi)
           end
-          @constraints_used[pi] = true
+          pi.ordered_dumped! if pi
         end
 
         # Dump the roles for an object type (excluding the roles of a fact type which is objectified)
@@ -45,27 +47,29 @@ module ActiveFacts
                 !role.fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
             }.
             sort_by{|role|
-              preferred_role_name(role.fact_type.all_role.select{|r2| r2 != role}[0] || role, o)
+	      other_role = role.fact_type.all_role.select{|r2| r2 != role}[0] || role
+              other_role.preferred_role_name(o) + ':' + role.preferred_role_name(other_role.object_type)
             }.each{|role| 
               role_dump(role)
             }
         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))
+            unary_dump(role, role.preferred_role_name)
             return
-          elsif fact_type.all_role.size != 2
+	  end
+          return if role.fact_type.entity_type
+
+          if fact_type.all_role.size != 2
             # Shouldn't come here, except perhaps for an invalid model
             return  # ternaries and higher are always objectified
           end
 
           # REVISIT: TypeInheritance
           if fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
-            # debug "Ignoring role #{role} in #{fact_type}, subtype fact type"
+            # trace "Ignoring role #{role} in #{fact_type}, subtype fact type"
             # REVISIT: What about secondary subtypes?
             # REVISIT: What about dumping the relational mapping when using separate tables?
             return
@@ -74,68 +78,31 @@ module ActiveFacts
           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_role_name = other_role.preferred_role_name
           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]
+              !other_role.object_type.ordered_dumped
 
           # Find role name:
-          role_method = preferred_role_name(role)
+          role_method = role.preferred_role_name
           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
+          if other_role_name != other_player.oo_default_role_name and
+	      role_method == role.object_type.oo_default_role_name
+	    # debugger
             other_role_method += "_as_#{other_role_name}"
           end
 
           role_name = role_method
-          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
-
-        def preferred_role_name(role, is_for = nil, &b)
-	  b ||= proc {|names| names.map(&:downcase)*'_' }   # Make snake_case by default
-          return b.call([]) 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 b.call(role.object_type.name.gsub(/[- ]/,'_').split(/_/))
-          end
-
-          # debug "Looking for preferred_role_name of #{describe_fact_type(role.fact_type, role)}"
-          reading = role.fact_type.preferred_reading
-          preferred_role_ref = reading.role_sequence.all_role_ref.detect{|reading_rr|
-              reading_rr.role == role
-            }
-
-          # Unaries are a hack, with only one role for what is effectively a binary:
-          if (role.fact_type.all_role.size == 1)
-            return b.call(
-	      ( (role.role_name && role.role_name.snakecase) ||
-		reading.text.gsub(/ *\{0\} */,'').gsub(/[- ]/,'_')
-	      ).split(/_/)
-	    )
-          end
-
-          # 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 == ""
+          role_name = nil if role_name == role.object_type.oo_default_role_name
 
-          # REVISIT: Consider whether NOT to use the adjective if it's a prefix of the role_name
-          la = preferred_role_ref.leading_adjective
-          role_words << la.gsub(/[- ]/,'_') if la && la != "" and !role.role_name
+b = role.ruby_role_definition
+puts b
 
-          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
-          n = role_words.map{|w| w.gsub(/([a-z])([A-Z]+)/,'\1_\2').downcase}*"_"
-          # debug "\tresult=#{n}"
-          return b.call(n.gsub(' ','_').split(/_/))
+          # binary_dump(role, other_role_name, other_player, role.is_mandatory, one_to_one, nil, role_name, other_role_method)
         end
 
         def skip_fact_type(f)
@@ -147,19 +114,15 @@ module ActiveFacts
         # An objectified fact type has internal roles that are always "has_one":
         def fact_roles_dump(fact_type)
           fact_type.all_role.sort_by{|role|
-              preferred_role_name(role, fact_type.entity_type)
+              role.preferred_role_name(fact_type.entity_type)
             }.each{|role| 
-              role_name = preferred_role_name(role, fact_type.entity_type)
-              one_to_one = role.all_role_ref.detect{|rr|
-                rr.role_sequence.all_role_ref.size == 1 &&
-                rr.role_sequence.all_presence_constraint.detect{|pc|
-                  pc.max_frequency == 1
-                }
-              }
-              as = role_name != role.object_type.name.gsub(/ /,'_').snakecase ? "_as_#{role_name}" : ""
+              role_name = role.preferred_role_name(fact_type.entity_type)
+              one_to_one = role.is_unique
+              as = role_name != role.object_type.oo_default_role_name ? "_as_#{role_name}" : ""
+#	      debugger if as != ''
               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 +
+                fact_type.entity_type.oo_default_role_name +
                 as
               binary_dump(role, role_name, role.object_type, true, one_to_one, nil, nil, other_role_method)
             }
@@ -172,7 +135,7 @@ module ActiveFacts
         end
 
         def append_ring_to_reading(reading, ring)
-          # REVISIT: debug "Should override append_ring_to_reading"
+          # REVISIT: trace "Should override append_ring_to_reading"
         end
 
         def fact_type_banner
@@ -182,15 +145,15 @@ module ActiveFacts
         end
 
         def constraint_banner
-          # debug "Should override constraint_banner"
+          # trace "Should override constraint_banner"
         end
 
         def constraint_end
-          # debug "Should override constraint_end"
+          # trace "Should override constraint_end"
         end
 
         def constraint_dump(c)
-          # debug "Should override constraint_dump"
+          # trace "Should override constraint_dump"
         end
 
       end

data/lib/activefacts/generate/helpers/ordered.rb

@@ -5,6 +5,8 @@
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
 require 'activefacts/api'
+require 'activefacts/generate/helpers/inject'
+require 'activefacts/generate/traits/ordered'
 
 module ActiveFacts
   module Generate #:nodoc:
@@ -30,40 +32,15 @@ module ActiveFacts
 
         def generate(out = $>)
           @out = out
-          vocabulary_start(@vocabulary)
-
-          build_indices
-          @object_types_dumped = {}
-          @fact_types_dumped = {}
-          units_dump()
-          value_types_dump()
-          entity_types_dump()
-          fact_types_dump()
-          constraints_dump(@constraints_used)
+          vocabulary_start
+          units_dump
+          value_types_dump
+          entity_types_dump
+          fact_types_dump
+          constraints_dump
           vocabulary_end
         end
 
-        def build_indices
-          @presence_constraints_by_fact = Hash.new{ |h, k| h[k] = [] }
-          @ring_constraints_by_fact = Hash.new{ |h, k| h[k] = [] }
-
-          @vocabulary.all_constraint.each { |c|
-              case c
-              when ActiveFacts::Metamodel::PresenceConstraint
-                fact_types = c.role_sequence.all_role_ref.map{|rr| rr.role.fact_type}.uniq  # All fact types spanned by this constraint
-                if fact_types.size == 1     # There's only one, save it:
-                  # debug "Single-fact constraint on #{fact_types[0].concept.guid}: #{c.name}"
-                  (@presence_constraints_by_fact[fact_types[0]] ||= []) << c
-                end
-              when ActiveFacts::Metamodel::RingConstraint
-                (@ring_constraints_by_fact[c.role.fact_type] ||= []) << c
-              else
-                # debug "Found unhandled constraint #{c.class} #{c.name}"
-              end
-            }
-          @constraints_used = {}
-        end
-
         def units_dump
           done_banner = false
           units = @vocabulary.all_unit.to_a.sort_by{|u| u.name.gsub(/ /,'')}
@@ -115,7 +92,6 @@ module ActiveFacts
 
         def value_types_dump
           done_banner = false
-          @value_type_dumped = {}
           @vocabulary.all_object_type.sort_by{|o| o.name.gsub(/ /,'')}.each{|o|
               next unless o.is_a?(ActiveFacts::Metamodel::ValueType)
 
@@ -123,17 +99,18 @@ module ActiveFacts
               done_banner = true
 
               value_type_chain_dump(o)
-              @object_types_dumped[o] = true
+#              @object_types_dumped[o] = true
+	      o.ordered_dumped!
             }
           value_type_end if done_banner
         end
 
         # Ensure that supertype gets dumped first
         def value_type_chain_dump(o)
-          return if @value_type_dumped[o]
-          value_type_chain_dump(o.supertype) if (o.supertype && !@value_type_dumped[o.supertype])
+          return if o.ordered_dumped
+          value_type_chain_dump(o.supertype) if (o.supertype && !o.supertype.ordered_dumped)
           value_type_fork(o)
-          @value_type_dumped[o] = true
+          o.ordered_dumped!
         end
 
         # Try to dump entity types in order of name, but we need
@@ -152,11 +129,11 @@ module ActiveFacts
             count_this_pass = 0
             skipped_this_pass = 0
             sorted.each{|o|
-                next if @object_types_dumped[o]    # Already done
+		next if o.ordered_dumped	    # Already done
 
                 # Can we do this yet?
                 if (o != panic and                  # We don't *have* to do it (panic mode)
-                    (p = @precursors[o]) and         # There might be...
+                    (p = @precursors[o]) and        # There might be...
                     p.size > 0)                     # precursors - still blocked
                   skipped_this_pass += 1
                   next
@@ -188,7 +165,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 && !@object_types_dumped[o]}).map{|o| o.name }.inspect +
+                    (bad = sorted.select{|o| EntityType === o && !o.ordered_dumped}).map{|o| o.name }.inspect +
                     ":\n\t" + bad.map{|o|
                       o.name +
                       ": " +
@@ -198,12 +175,12 @@ 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| !@object_types_dumped[o] }.
+                    select{|o| o.ordered_dumped }.
                     sort_by{|o|
                         f = @followers[o] || []; 
-                        o.supertypes.detect{|s| !@object_types_dumped[s] } ? 0 : -f.size
+                        o.supertypes.detect{|s| !s.ordered_dumped } ? 0 : -f.size
                       }[0]
-                  # debug "Panic mode, selected #{panic.name} next"
+                  # trace "Panic mode, selected #{panic.name} next"
                 end
               end
 
@@ -276,7 +253,7 @@ module ActiveFacts
                 subtyping = o.all_type_inheritance_as_supertype
                 next a if subtyping.size == 0
                 subtyping.each{|ti|
-                    # debug ti.class.roles.verbalise; debug "all_type_inheritance_as_supertype"; exit
+                    # debug ti.class.roles.verbalise; trace "all_type_inheritance_as_supertype"; exit
                     s = ti.subtype
                     (precursor[s] ||= []) << o
                     (follower[o] ||= []) << s
@@ -299,9 +276,9 @@ module ActiveFacts
             progress = false
             roles.map(&:fact_type).uniq.select{|fact_type|
                 # The fact type hasn't already been dumped but all its role players have
-                !@fact_types_dumped[fact_type] &&
+                !fact_type.ordered_dumped &&
                   !fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType) &&
-                  !fact_type.all_role.detect{|r| !@object_types_dumped[r.object_type] } &&
+                  !fact_type.all_role.detect{|r| !r.object_type.ordered_dumped } &&
                   !fact_type.entity_type &&
                   derivation_precursors_complete(fact_type)
                 # REVISIT: A derived fact type must not be dumped before its dependent fact types have
@@ -320,43 +297,39 @@ module ActiveFacts
           pr = fact_type.preferred_reading
           return true unless jr = pr.role_sequence.all_role_ref.to_a[0].play
           query = jr.variable.query
-          return false if query.all_step.detect{|js| !@fact_types_dumped[js.fact_type] }
-          return false if query.all_variable.detect{|jn| !@object_types_dumped[jn.object_type] }
+          return false if query.all_step.detect{|js| !js.fact_type.ordered_dumped }
+          return false if query.all_variable.detect{|jn| !jn.object_type.ordered_dumped }
           true
         end
 
         def skip_fact_type(f)
           return true if f.is_a?(ActiveFacts::Metamodel::TypeInheritance)
-          return false if f.entity_type && !@object_types_dumped[f.entity_type]
+          return false if f.entity_type && !f.entity_type.ordered_dumped
 
           # REVISIT: There might be constraints we have to merge into the nested entity or subtype. 
           # These will come up as un-handled constraints:
 	  # Dump this fact type only if it contains a presence constraint we've missed:
           pcs = @presence_constraints_by_fact[f]
-          pcs && pcs.size > 0 && !pcs.detect{|c| !@constraints_used[c] }
+          pcs && pcs.size > 0 && !pcs.detect{|c| !c.ordered_dumped }
         end
 
         # Dump one fact type.
         # Include as many as possible internal constraints in the fact type readings.
         def fact_type_dump_with_dependents(fact_type)
-          @fact_types_dumped[fact_type] = true
-          # debug "Trying to dump FT again" if @fact_types_dumped[fact_type]
+          fact_type.ordered_dumped!
           return if skip_fact_type(fact_type)
 
           if (et = fact_type.entity_type) &&
               (pi = et.preferred_identifier) &&
               pi.role_sequence.all_role_ref.detect{|rr| rr.role.fact_type != fact_type }
-            # debug "Dumping objectified FT #{et.name} as an entity, non-fact PI"
+            # trace "Dumping objectified FT #{et.name} as an entity, non-fact PI"
             entity_type_dump(et)
             released_fact_types_dump(et)
             return
           end
 
-          fact_constraints = @presence_constraints_by_fact[fact_type]
-
-          # debug "for fact type #{fact_type.to_s}, considering\n\t#{fact_constraints.map(&:to_s)*",\n\t"}"
-          # debug "#{fact_type.name} has readings:\n\t#{fact_type.readings.map(&:name)*"\n\t"}"
-          # debug "Dumping #{fact_type.concept.guid} as a fact type"
+          # trace "#{fact_type.name} has readings:\n\t#{fact_type.readings.map(&:name)*"\n\t"}"
+          # trace "Dumping #{fact_type.concept.guid} as a fact type"
 
           # Fact types that aren't nested have no names
           name = fact_type.entity_type && fact_type.entity_type.name
@@ -365,8 +338,9 @@ module ActiveFacts
 
           # REVISIT: Go through the residual constraints and re-process appropriate readings to show them
 
-          @fact_types_dumped[fact_type] = true
-          @object_types_dumped[fact_type.entity_type] = true if fact_type.entity_type
+#CJH: Necessary?
+          fact_type.ordered_dumped!
+          fact_type.entity_type.ordered_dumped! if fact_type.entity_type
         end
 
         # Dump fact types.
@@ -383,7 +357,7 @@ module ActiveFacts
                   fact_type = fact_collection[fact_id] and
                   !fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) and
                   !fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType) and
-                  !@fact_types_dumped[fact_type] and
+                  !fact_type.ordered_dumped and
                   !skip_fact_type(fact_type) and
                   !fact_type.all_role.detect{|r| r.object_type.is_a?(ActiveFacts::Metamodel::EntityType) }
               }.sort_by{|fact_id|
@@ -404,18 +378,14 @@ module ActiveFacts
             }.sort_by{|fact_type|
               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.object_type.name}*", "})"
+              next if fact_type.ordered_dumped
+              # trace "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)
             }
 
           fact_type_end if done_banner
-          # unused = constraints - @constraints_used.keys
-          # debug "residual constraints are\n\t#{unused.map(&:to_s)*",\n\t"}"
-
-          @constraints_used
         end
 
         def fact_instances_dump
@@ -423,7 +393,7 @@ module ActiveFacts
               # Dump the instances:
               f.facts.each{|i|
                 raise "REVISIT: Not dumping fact instances"
-                debug "\t\t"+i.to_s
+                trace "\t\t"+i.to_s
               }
           }
         end
@@ -498,9 +468,13 @@ module ActiveFacts
           end
         end
 
-        def constraints_dump(except = {})
+        def constraints_dump
           heading = false
-          @vocabulary.all_constraint.reject{|c| except[c]}.sort_by{ |c| constraint_sort_key(c) }.each do|c|
+          @vocabulary.
+	      all_constraint.
+	      reject{|c| c.ordered_dumped}.
+	      sort_by{ |c| constraint_sort_key(c) }.
+	      each do |c|
             # Skip some PresenceConstraints:
             if c.is_a?(ActiveFacts::Metamodel::PresenceConstraint)
               # Skip uniqueness constraints that cover all roles of a fact type, they're implicit
@@ -528,12 +502,12 @@ module ActiveFacts
           constraint_end if heading
         end
 
-        def vocabulary_start(vocabulary)
-          debug "Should override vocabulary_start"
+        def vocabulary_start
+          trace "Should override vocabulary_start"
         end
 
         def vocabulary_end
-          debug "Should override vocabulary_end"
+          trace "Should override vocabulary_end"
         end
 
         def units_banner
@@ -546,63 +520,63 @@ module ActiveFacts
         end
 
         def value_type_banner
-          debug "Should override value_type_banner"
+          trace "Should override value_type_banner"
         end
 
         def value_type_end
-          debug "Should override value_type_end"
+          trace "Should override value_type_end"
         end
 
         def data_type_dump(o)
-          debug "Should override data_type_dump"
+          trace "Should override data_type_dump"
         end
 
 	def value_type_dump(o, super_type_name, facets)
-          debug "Should override value_type_dump"
+          trace "Should override value_type_dump"
         end
 
         def entity_type_banner
-          debug "Should override entity_type_banner"
+          trace "Should override entity_type_banner"
         end
 
         def entity_type_group_end
-          debug "Should override entity_type_group_end"
+          trace "Should override entity_type_group_end"
         end
 
         def non_subtype_dump(o, pi)
-          debug "Should override non_subtype_dump"
+          trace "Should override non_subtype_dump"
         end
 
         def subtype_dump(o, supertypes, pi = nil)
-          debug "Should override subtype_dump"
+          trace "Should override subtype_dump"
         end
 
         def append_ring_to_reading(reading, ring)
-          debug "Should override append_ring_to_reading"
+          trace "Should override append_ring_to_reading"
         end
 
         def fact_type_banner
-          debug "Should override fact_type_banner"
+          trace "Should override fact_type_banner"
         end
 
         def fact_type_end
-          debug "Should override fact_type_end"
+          trace "Should override fact_type_end"
         end
 
         def fact_type_dump(fact_type, name)
-          debug "Should override fact_type_dump"
+          trace "Should override fact_type_dump"
         end
 
         def constraint_banner
-          debug "Should override constraint_banner"
+          trace "Should override constraint_banner"
         end
 
         def constraint_end
-          debug "Should override constraint_end"
+          trace "Should override constraint_end"
         end
 
         def constraint_dump(c)
-          debug "Should override constraint_dump"
+          trace "Should override constraint_dump"
         end
 
       end