activefacts 1.3.0 → 1.5.0

data/lib/activefacts/persistence/columns.rb

@@ -177,17 +177,7 @@ module ActiveFacts
       # The comment is the readings from the References expressed as a series of steps (not a full verbalisation)
       def comment
         @references.map do |ref|
-	  # REVISIT: Some contraction would be nice here
-          objectification = ref.fact_type && ref.fact_type.entity_type
-	  involves = ''
-	  if objectification && ref == @references.last
-	    objectification = nil if ref.fact_type.all_role.size == 1	# Disregard the objectification of a trailing unary
-	    involves = ref.to_role.link_fact_type.default_reading[ref.fact_type.entity_type.name.size..-1]
-	  end
-	  (objectification ? objectification.name + ' (in which ' : '') +
-          (ref.is_mandatory || ref.is_unary ? '' : 'maybe ') +
-          ref.reading +
-	  (objectification ? ')'+involves : '')
+	  ref.verbalised_path
         end.compact * " and "
       end
 

data/lib/activefacts/persistence/foreignkey.rb

@@ -31,12 +31,11 @@ module ActiveFacts
 	"foreign key from #{from.name}(#{from_columns.map{|c| c.name}*', '}) to #{to.name}(#{to_columns.map{|c| c.name}*', '})"
       end
 
-      def verbalised_path
+      def verbalised_path reverse = false
 	# REVISIT: This should be a proper join path verbalisation:
-	references.map do |r|
-	  (r.fact_type.entity_type ? r.fact_type.entity_type.name + ' (in which ' : '') +
-	    r.fact_type.default_reading +
-	    (r.fact_type.entity_type ? ')' : '')
+	refs = reverse ? references.reverse : references
+	refs.map do |r|
+	  r.verbalised_path reverse
 	end * ' and '
       end
 
@@ -125,7 +124,7 @@ module ActiveFacts
       def foreign_keys
 
         # Get the ForeignKey object for each absorbed reference path
-	@foreign_keys ||= 
+	@foreign_keys ||=
 	  begin
 	    fk_ref_paths = all_absorbed_foreign_key_reference_path
 	    fk_ref_paths.map do |fk_ref_path|

data/lib/activefacts/persistence/reference.rb

@@ -92,7 +92,7 @@ module ActiveFacts
 
       # If this Reference is from an objectified FactType, there is no *from_role*
       def is_from_objectified_fact
-        @to && @to_role && !@from_role
+        @to && !@from_role && @to_role
       end
 
       # Is this reference an injected role as a result a ValueType being a table?
@@ -211,6 +211,26 @@ module ActiveFacts
         is_self_value ? "#{from.name} has value" : @fact_type.reading_preferably_starting_with_role(@from_role).expand
       end
 
+      def verbalised_path reverse = false
+	return "#{from.name} Value" if is_self_value
+	objectified = fact_type.entity_type 
+	f =	# Switch to the Link Fact Type if we're traversing an objectification
+	  (to_role && to_role.link_fact_type) ||
+	  (from_role && from_role.link_fact_type) ||
+	  fact_type
+
+	start_role =
+	  if objectified
+	    target = reverse ? to : from
+	    [to_role, from_role, f.all_role[0]].compact.detect{|role| role.object_type == target}
+	  else
+	    reverse ? to_role : from_role
+	  end
+	reading = f.reading_preferably_starting_with_role(start_role)
+	(is_mandatory || is_unary ? '' : 'maybe ') +
+	  reading.expand
+      end
+
       def inspect #:nodoc:
         to_s
       end

data/lib/activefacts/version.rb

@@ -7,7 +7,7 @@
 module ActiveFacts
   module Version
     MAJOR = 1
-    MINOR = 3
+    MINOR = 5
     PATCH = 0
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')

data/lib/activefacts/vocabulary/extensions.rb

@@ -66,6 +66,128 @@ module ActiveFacts
       end
     end
 
+    class Concept
+      def describe
+	case
+	when object_type; "#{object_type.class.basename} #{object_type.name.inspect}"
+	when fact_type; "FactType #{fact_type.default_reading.inspect}"
+	when role; "Role in #{role.fact_type.describe(role)}"
+	when constraint; constraint.describe
+	when instance; "Instance #{instance.verbalise}"
+	when fact; "Fact #{fact.verbalise}"
+	when query; query.describe
+	when context_note; "ContextNote#{context_note.verbalise}"
+	when unit; "Unit #{unit.describe}"
+	when population; "Population: #{population.name}"
+	else
+	  raise "ROGUE CONCEPT OF NO TYPE"
+	end
+      end
+
+      def embodied_as
+	case
+	when object_type; object_type
+	when fact_type; fact_type
+	when role; role
+	when constraint; constraint
+	when instance; instance
+	when fact; fact
+	when query; query
+	when context_note; context_note
+	when unit; unit
+	when population; population
+	else
+	  raise "ROGUE CONCEPT OF NO TYPE"
+	end
+      end
+
+      # Return an array of all Concepts that must be defined before this concept can be defined:
+      def precursors
+	case body = embodied_as
+	when ActiveFacts::Metamodel::ValueType
+	  [ body.supertype, body.unit ] +
+	  body.all_facet.map{|f| f.facet_value_type } +
+	  body.all_facet_restriction.map{|vr| vr.value.unit}
+	when ActiveFacts::Metamodel::EntityType
+	  # You can't define the preferred_identifier fact types until you define the entity type,
+	  # but the objects which play the identifying roles must be defined:
+	  body.preferred_identifier.role_sequence.all_role_ref.map {|rr| rr.role.object_type } +
+	  # You can't define the objectified fact type until you define the entity type:
+	  # [ body.fact_type ]	# If it's an objectification
+	  body.all_type_inheritance_as_subtype.map{|ti| ti.supertype}	# If it's a subtype
+	when FactType
+	  body.all_role.map(&:object_type)
+	when Role   # We don't consider roles as they cannot be separately defined
+	  []
+	when ActiveFacts::Metamodel::PresenceConstraint
+	  body.role_sequence.all_role_ref.map do |rr|
+	    rr.role.fact_type
+	  end
+	when ActiveFacts::Metamodel::ValueConstraint
+	  [ body.role ? body.role.fact_type : nil, body.value_type ] +
+	  body.all_allowed_range.map do |ar|
+	    [ ar.value_range.minimum_bound, ar.value_range.maximum_bound ].compact.map{|b| b.value.unit}
+	  end
+	when ActiveFacts::Metamodel::SubsetConstraint
+	  body.subset_role_sequence.all_role_ref.map{|rr| rr.role.fact_type } +
+	  body.superset_role_sequence.all_role_ref.map{|rr| rr.role.fact_type }
+	when ActiveFacts::Metamodel::SetComparisonConstraint
+	  body.all_set_comparison_roles.map{|scr| scr.role_sequence.all_role_ref.map{|rr| rr.role.fact_type } }
+	when ActiveFacts::Metamodel::RingConstraint
+	  [ body.role.fact_type, body.other_role.fact_type ]
+	when Instance
+	  [ body.population, body.object_type, body.value ? body.value.unit : nil ]
+	when Fact
+	  [ body.population, body.fact_type ]
+	when Query
+	  body.all_variable.map do |v|
+	    [ v.object_type,
+	      v.value ? v.value.unit : nil,
+	      v.step ? v.step.fact_type : nil
+	    ] +
+	    v.all_play.map{|p| p.role.fact_type }
+	  end
+	when ContextNote
+	  []
+	when Unit
+	  body.all_derivation_as_derived_unit.map{|d| d.base_unit }
+	when Population
+	  []
+	else
+	  raise "ROGUE CONCEPT OF NO TYPE"
+	end.flatten.compact.uniq.map{|c| c.concept }
+      end
+    end
+
+    class Topic
+      def precursors
+	# Precursors of a topic are the topics of all precursors of items in this topic
+	all_concept.map{|c| c.precursors }.flatten.uniq.map{|c| c.topic}.uniq-[self]
+      end
+    end
+
+    class Unit
+      def describe
+	'Unit' +
+	name +
+	(plural_name ? '/'+plural_name : '') +
+	'=' +
+	coefficient.to_s+'*' +
+	all_derivation_as_derived_unit.map do |derivation|
+	  derivation.base_unit.name +
+	  (derivation.exponent != 1 ? derivation.exponent.to_s : '')
+	end.join('') +
+	(offset ? ' + '+offset.to_s : '')
+      end
+    end
+
+    class Coefficient
+      def to_s
+	numerator.to_s +
+	(denominator != 1 ? '/' + denominator.to_s : '')
+      end
+    end
+
     class FactType
       attr_accessor :check_and_add_spanning_uniqueness_constraint
 
@@ -111,8 +233,8 @@ module ActiveFacts
       end
 
       def implicit_boolean_type vocabulary
-        @constellation.ImplicitBooleanValueType[[vocabulary.identifying_role_values, "_ImplicitBooleanValueType"]] ||
-        @constellation.ImplicitBooleanValueType(vocabulary.identifying_role_values, "_ImplicitBooleanValueType", :concept => :new)
+        @constellation.ImplicitBooleanValueType[[vocabulary.identifying_role_values, "_ImplicitBooleanValueType"]] or
+        @constellation.ImplicitBooleanValueType(vocabulary.identifying_role_values, "_ImplicitBooleanValueType", :concept => [:new, :implication_rule => 'unary'])
       end
 
       # This entity type has just objectified a fact type. Create the necessary ImplicitFactTypes with phantom roles
@@ -122,6 +244,7 @@ module ActiveFacts
         # NORMA doesn't create an implicit fact type here, rather the fact type has an implicit extra role, so looks like a binary
         # We only do it when the unary fact type is not objectified
         link_fact_type = @constellation.LinkFactType(:new, :implying_role => role)
+	link_fact_type.concept.implication_rule = 'unary'
         entity_type = @entity_type || implicit_boolean_type(role.object_type.vocabulary)
         phantom_role = @constellation.Role(link_fact_type, 0, :object_type => entity_type, :concept => :new)
       end
@@ -166,6 +289,7 @@ module ActiveFacts
       end
 
       def is_mandatory
+	return fact_type.implying_role.is_mandatory if fact_type.is_a?(LinkFactType)
         all_role_ref.detect{|rr|
           rs = rr.role_sequence
           rs.all_role_ref.size == 1 and
@@ -196,6 +320,10 @@ module ActiveFacts
 	end
       end
 
+      def name
+	role_name || object_type.name
+      end
+
     end
 
     class RoleRef
@@ -222,6 +350,38 @@ module ActiveFacts
         return separator ? Array(name_array)*separator : Array(name_array)
       end
 
+      def cql_leading_adjective
+	if leading_adjective
+	  # 'foo' => "foo-"
+	  # 'foo bar' => "foo- bar "
+	  # 'foo-bar' => "foo-- bar "
+	  # 'foo-bar baz' => "foo-- bar baz "
+	  # 'bat foo-bar baz' => "bat- foo-bar baz "
+	  leading_adjective.strip.
+	    sub(/[- ]|$/, '-\0 ').sub(/  /, ' ').sub(/[^-]$/, '\0 ').sub(/-  $/,'-')
+	else
+	  ''
+	end
+      end
+
+      def cql_trailing_adjective
+	if trailing_adjective
+	  # 'foo' => "-foo"
+	  # 'foo bar' => " foo -bar"
+	  # 'foo-bar' => " foo --bar"
+	  # 'foo-bar baz' => " foo-bar -baz"
+	  # 'bat foo-bar baz' => " bat foo-bar -baz"
+	  trailing_adjective.
+	    strip.
+	    sub(/(?<a>.*) (?<b>[^- ]+$)|(?<a>.*)(?<b>-[^- ]*)$|(?<a>)(?<b>.*)/) {
+	      " #{$~[:a]} -#{$~[:b]}"
+	    }.
+	    sub(/^ *-/, '-')  # A leading space is not needed if the hyphen is at the start
+	else
+	  ''
+	end
+      end
+
       def cql_name
         if role.fact_type.all_role.size == 1
           role_name
@@ -229,9 +389,9 @@ module ActiveFacts
           role.role_name
         else
           # Where an adjective has multiple words, the hyphen is inserted outside the outermost space, leaving the space
-          (leading_adjective ? leading_adjective.strip.sub(/ |$/, '-\0').sub(/[^-]$/,'\0 ') : '') +
+	  cql_leading_adjective +
             role.object_type.name+
-            (trailing_adjective ? ' '+trailing_adjective.strip.sub(/.* |^/, '\0-').sub(/^[^-]/,' \0') : '')
+	    cql_trailing_adjective
         end
       end
     end
@@ -497,6 +657,7 @@ module ActiveFacts
         fact_type.all_role.map do |role|
           next if role.link_fact_type     # Already exists
           link_fact_type = @constellation.LinkFactType(:new, :implying_role => role)
+	  link_fact_type.concept.implication_rule = 'objectification'
           phantom_role = @constellation.Role(link_fact_type, 0, :object_type => self, :concept => :new)
           # We could create a copy of the visible external role here, but there's no need yet...
           # Nor is there a need for a presence constraint, readings, etc.
@@ -619,6 +780,10 @@ module ActiveFacts
 
     class ValueConstraint
       def describe
+	as_cql
+      end
+
+      def as_cql
         "restricted to "+
 	  ( if regular_expression
 	      '/' + regular_expression + '/'
@@ -712,7 +877,38 @@ module ActiveFacts
       def describe
         min = min_frequency
         max = max_frequency
-        role_sequence.describe + " occurs " + frequency + " time#{(min&&min>1)||(max&&max>1) ? 's' : ''}"
+        'PresenceConstraint over '+role_sequence.describe + " occurs " + frequency + " time#{(min&&min>1)||(max&&max>1) ? 's' : ''}"
+      end
+    end
+
+    class SubsetConstraint
+      def describe
+	'SubsetConstraint(' +
+	subset_role_sequence.describe 
+	' < ' +
+	superset_role_sequence.describe +
+	')'
+      end
+    end
+
+    class SetComparisonConstraint
+      def describe
+	self.class.basename+'(' +
+	all_set_comparison_roles.map do |scr|
+	  scr.role_sequence.describe
+	end*',' +
+	')'
+      end
+    end
+
+    class RingConstraint
+      def describe
+	'RingConstraint(' +
+	ring_type.to_s+': ' +
+	role.describe+', ' +
+	other_role.describe+' in ' +
+	role.fact_type.default_reading +
+	')'
       end
     end
 
@@ -784,6 +980,20 @@ module ActiveFacts
     end
 
     class Query
+      def describe
+        steps_shown = {}
+	'Query(' +
+          all_variable.sort_by{|var| var.ordinal}.map do |variable|
+	    variable.describe + ': ' +
+	    variable.all_step.map do |step|
+	      next if steps_shown[step]
+	      steps_shown[step] = true
+	      step.describe
+	    end.compact.join(',')
+	  end.join('; ') +
+	')'
+      end
+
       def show
         steps_shown = {}
         trace :query, "Displaying full contents of Query #{concept.guid}" do
@@ -862,7 +1072,12 @@ module ActiveFacts
 	      self,
 	      implying_role.fact_type.entity_type ? "{0} involves {1}" : implying_role.fact_type.default_reading+" Boolean"
 	    )
-	  ]
+	  ] +
+	  Array(implying_role.fact_type.entity_type ? ImplicitReading.new(self, "{1} is involved in {0}") : nil)
+      end
+
+      def reading_preferably_starting_with_role role, negated = false
+        all_reading[role == implying_role ? 1 : 0]
       end
 
       # This is only used for debugging, from RoleRef#describe
@@ -899,6 +1114,9 @@ module ActiveFacts
           def all_role_ref
             @role_refs
           end
+          def all_role_ref_in_order
+	    @role_refs
+	  end
           def describe
             '('+@role_refs.map(&:describe)*', '+')'
           end
@@ -914,7 +1132,13 @@ module ActiveFacts
         def ordinal; 0; end
 
         def expand
-          @fact_type.default_reading
+	  text.gsub(/\{([01])\}/) do
+	    if $1 == '0'
+	      fact_type.all_role[0].object_type.name
+	    else
+	      fact_type.implying_role.object_type.name
+	    end
+	  end
         end
       end
     end
@@ -1085,6 +1309,10 @@ module ActiveFacts
 
     class ContextNote
       def verbalise(context=nil)
+	as_cql
+      end
+
+      def as_cql
 	' (' +
 	( if all_context_according_to
 	    'according to '
@@ -1098,7 +1326,7 @@ module ActiveFacts
 	discussion +
 	( if agreement
 	    ', as agreed ' +
-	    (agreement.date ? ' on '+agreement.date+' ' : '') +
+	    (agreement.date ? ' on '+agreement.date.iso8601.inspect+' ' : '') +
 	    'by '
 	    agreement.all_context_agreed_by.map do |acab|
 	      acab.agent.agent_name+', '

data/lib/activefacts/vocabulary/metamodel.rb

@@ -131,6 +131,11 @@ module ActiveFacts
       value_type :length => 256
     end
 
+    class TopicName < Name
+      value_type 
+      one_to_one :topic                           # See Topic.topic_name
+    end
+
     class TransactionPhase < String
       value_type 
       restrict 'assert', 'commit'
@@ -171,6 +176,7 @@ module ActiveFacts
       identified_by :guid
       one_to_one :guid, :mandatory => true        # See Guid.concept
       has_one :implication_rule                   # See ImplicationRule.all_concept
+      has_one :topic                              # See Topic.all_concept
     end
 
     class Constraint
@@ -307,6 +313,11 @@ module ActiveFacts
       has_one :superset_role_sequence, :class => RoleSequence, :mandatory => true  # See RoleSequence.all_subset_constraint_as_superset_role_sequence
     end
 
+    class Topic
+      identified_by :topic_name
+      one_to_one :topic_name, :mandatory => true  # See TopicName.topic
+    end
+
     class Unit
       identified_by :concept
       has_one :coefficient                        # See Coefficient.all_unit