activefacts 0.7.1 → 0.7.2

data/Manifest.txt

@@ -26,8 +26,11 @@ lib/activefacts/api/concept.rb
 lib/activefacts/api/constellation.rb
 lib/activefacts/api/entity.rb
 lib/activefacts/api/instance.rb
+lib/activefacts/api/instance_index.rb
 lib/activefacts/api/numeric.rb
 lib/activefacts/api/role.rb
+lib/activefacts/api/role_proxy.rb
+lib/activefacts/api/role_values.rb
 lib/activefacts/api/standard_types.rb
 lib/activefacts/api/support.rb
 lib/activefacts/api/value.rb
@@ -55,6 +58,7 @@ lib/activefacts/input/cql.rb
 lib/activefacts/input/orm.rb
 lib/activefacts/persistence.rb
 lib/activefacts/persistence/columns.rb
+lib/activefacts/persistence/concept.rb
 lib/activefacts/persistence/foreignkey.rb
 lib/activefacts/persistence/index.rb
 lib/activefacts/persistence/reference.rb

data/examples/CQL/Metamodel.cql

@@ -16,6 +16,7 @@ Length is defined as UnsignedInteger(32);
 Name is defined as VariableLengthText(64);
 Numerator is defined as Decimal();
 Ordinal is defined as UnsignedSmallInteger(32);
+Pronoun is defined as VariableLengthText() restricted to {'feminine', 'masculine', 'personal'};
 RingType is defined as VariableLengthText();
 RoleSequenceId is defined as AutoCounter();
 Scale is defined as UnsignedInteger(32);
@@ -142,8 +143,8 @@ SetExclusionConstraint is mandatory;
 Alias is a kind of Feature;
 
 Concept is a kind of Feature;
+Concept uses at most one Pronoun;
 Concept is independent;
-Concept is personal;
 Instance is of one Concept;
 Role is where
 	FactType has Ordinal role played by Concept,
@@ -165,12 +166,12 @@ RoleRef is where
 	Role has Ordinal place in RoleSequence;
 RoleRef has at most one leading-Adjective;
 RoleRef has at most one trailing-Adjective;
-JoinPath is where
-	RoleRef has Ordinal (as JoinStep) path;
-JoinPath traverses at most one Concept,
-	Concept is traversed by JoinPath;
-JoinPath has one input-Role;
-JoinPath has one output-Role;
+Join is where
+	RoleRef has Ordinal (as JoinStep) join;
+Join traverses at most one Concept,
+	Concept is traversed by Join;
+Join has at most one input-Role;
+Join has at most one output-Role;
 
 EntityType is a kind of Concept;
 EntityType nests at most one FactType,
@@ -227,6 +228,9 @@ each combination EntityType, TypeInheritance occurs at most one time in
 	TypeInheritance provides identification;
 each FactType occurs at least one time in
 	FactType has Ordinal role played by Concept;
+each Join occurs at least one time in
+	Join has input-Role,
+	Join has output-Role;
 each PresenceConstraint occurs at least one time in
 	PresenceConstraint has min-Frequency,
 	PresenceConstraint has max-Frequency,

data/lib/activefacts/api/concept.rb

@@ -121,6 +121,10 @@ module ActiveFacts
         end
       end
 
+      def subtypes
+        @subtypes ||= []
+      end
+
       # Every new role added or inherited comes through here:
       def realise_role(role) #:nodoc:
         #puts "Realising role #{role.counterpart_concept.basename rescue role.counterpart_concept}.#{role.name} in #{basename}"
@@ -137,6 +141,10 @@ module ActiveFacts
 
       # REVISIT: Use method_missing to catch all_some_role_as_other_role_and_third_role, to sort_by those roles?
 
+      def is_a? klass
+        super || supertypes_transitive.include?(klass)
+      end
+
       private
 
       def realise_supertypes(concept, all_supertypes = nil)
@@ -146,6 +154,7 @@ module ActiveFacts
         s.each {|t|
             next if all_supertypes.include? t
             realise_supertypes(t, all_supertypes)
+            t.subtypes << self
             all_supertypes << t
           }
         #puts "Realising roles of #{concept.basename} in #{basename}"
@@ -174,6 +183,7 @@ module ActiveFacts
           else
             target.roles[related_role_name] = role.counterpart = Role.new(target, definer, role, related_role_name, false, false)
           end
+          role.counterpart_concept = target
           #puts "Realising role pair #{definer.basename}.#{role_name} <-> #{target.basename}.#{related_role_name}"
           realise_role(role)
           target.realise_role(role.counterpart)

data/lib/activefacts/api/entity.rb

@@ -219,6 +219,8 @@ module ActiveFacts
 
         def inherited(other) #:nodoc:
           other.identified_by *identifying_role_names
+          subtypes << other unless subtypes.include? other
+          #puts "#{self.name} inherited by #{other.name}"
           vocabulary.add_concept(other)
         end
 

data/lib/activefacts/api/instance_index.rb

@@ -0,0 +1,71 @@
+#
+#       ActiveFacts Runtime API
+#       InstanceIndex class
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+module ActiveFacts
+  module API
+    #
+    # Each Constellation maintains an InstanceIndex for each Concept in its Vocabulary.
+    # The InstanceIndex object is returned when you call @constellation.Concept with no
+    # arguments (where Concept is the concept name you're interested in)
+    #
+    class InstanceIndex
+      def []=(key, value)   #:nodoc:
+        raise "Adding RoleProxy to InstanceIndex" if value && RoleProxy === value
+        h[key] = value
+      end
+
+      def [](*args)
+        a = args
+        #a = naked(args)
+#        p "vvvv",
+#          args,
+#          a,
+#          keys.map{|k| v=super(k); (RoleProxy === k ? "*" : "")+k.to_s+"=>"+(RoleProxy === v ? "*" : "")+v.to_s}*",",
+#          "^^^^"
+        h[*a]
+        #super(*a)
+      end
+
+      def size
+        h.size
+      end
+
+      def map &b
+        h.map &b
+      end
+
+      # Return an array of all the instances of this concept
+      def values
+        h.values
+      end
+
+      # Return an array of the identifying role values arrays for all the instances of this concept
+      def keys
+        h.keys
+      end
+
+      def delete_if(&b)   #:nodoc:
+        h.delete_if &b
+      end
+
+    private
+      def h
+        @hash ||= {}
+      end
+
+      def naked(o)
+        case o
+        when Array
+          o.map{|e| naked(e) }
+        when RoleProxy
+          o.__getobj__
+        else
+          o
+        end
+      end
+    end
+  end
+end

data/lib/activefacts/api/role_proxy.rb

@@ -0,0 +1,70 @@
+#
+#       ActiveFacts Runtime API
+#       RoleProxy class, still somewhat experimental
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'delegate'
+
+module ActiveFacts
+  module API
+    #
+    # When you use the accessor method created by has_one, one_to_one, or maybe, you get a RoleProxy for the actual value.
+    # This behaves almost exactly as the value, but it knows through which role you fetched it.
+    # That will allow it to verbalise itself using the correct reading for that role.
+    #
+    # Don't use "SomeClass === role_value" to test the type, use "role_value.is_a?(SomeClass)" instead.
+    #
+    # In future, retrieving a value by indexing into a RoleValues array will do the same thing.
+    #
+    class RoleProxy < SimpleDelegator
+      def initialize(role, o = nil)     #:nodoc:
+        @role = role                    # REVISIT: Use this to implement verbalise()
+        __setobj__(o)
+      end
+
+      def method_missing(m, *a, &b)     #:nodoc:
+        begin
+          super                         # Delegate first
+        rescue NoMethodError => e
+          __getobj__.method_missing(m, *a, &b)
+        rescue => e
+          raise
+        end
+      end
+
+      def class                         #:nodoc:
+        __getobj__.class
+      end
+
+      def is_a? klass                   #:nodoc:
+        __getobj__.is_a? klass
+      end
+
+      def to_s                          #:nodoc:
+        __getobj__.to_s
+      end
+
+      def object_id                     #:nodoc:
+        __getobj__.object_id
+      end
+
+      # REVISIT: Should Proxies hash and eql? the same as their wards?
+      def hash                          #:nodoc:
+        __getobj__.hash ^ self.class.hash
+      end
+
+      def eql?(o)                       #:nodoc:
+        self.class == o.class and __getobj__.eql?(o)
+      end
+
+      def ==(o)                         #:nodoc:
+        __getobj__.==(o)
+      end
+
+      def inspect                       #:nodoc:
+        "Proxy:#{__getobj__.inspect}"
+      end
+    end
+  end
+end

data/lib/activefacts/api/role_values.rb

@@ -0,0 +1,117 @@
+#
+#       ActiveFacts Runtime API
+#       RoleValues, manages the set of instances involved in a many_to_one relationship.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+# There are two implementations here, one using an array and one using a hash.
+# The hash one has problems with keys being changed during object deletion, so
+# cannot be used yet; a fix is upcoming and will improve performance of large sets.
+#
+module ActiveFacts
+  module API
+
+    class RoleValues  #:nodoc:
+      include Enumerable
+
+#=begin
+      def initialize
+        @a = []
+      end
+
+      def each &b
+        # REVISIT: Provide a configuration variable to enable this heckling during testing:
+        #@a.sort_by{rand}.each &b
+        @a.each &b
+      end
+
+      def size
+        @a.size
+      end
+
+      def empty?
+        @a.size == 0
+      end
+
+      def +(a)
+        @a.+(a.is_a?(RoleValues) ? Array(a) : a)
+      end
+
+      def -(a)
+        @a - a
+      end
+
+      def single
+        @a.size > 1 ? nil : @a[0]
+      end
+
+      def update(old, value)
+        @a.delete(old) if old
+        @a << value if value
+        raise "Adding RoleProxy to RoleValues collection" if value && RoleProxy === value
+      end
+
+      def verbalise
+        "["+@a.to_a.map{|e| e.verbalise}*", "+"]"
+      end
+#=end
+
+=begin
+      def initialize
+        @h = {}
+      end
+
+      def each &b
+        @h.keys.each &b
+      end
+
+      def size
+        @h.size
+      end
+
+      def empty?
+        @h.size == 0
+      end
+
+      def +(a)
+        @h.keys.+(a.is_a?(RoleValues) ? Array(a) : a)
+      end
+
+      def -(a)
+        @h.keys - a
+      end
+
+      def single
+        @h.size > 1 ? nil : @h.keys[0]
+      end
+
+      def update(old, value)
+        if old
+          unless @h.delete(old)
+            @h.each { |k, v|
+              next if k != old
+              puts "#{@h.object_id}: Didn't delete #{k.verbalise} (hash=#{k.hash}) matching #{old.verbalise} (hash=#{old.hash})"
+              puts "They are #{k.eql?(old) ? "" : "not "}eql?"
+              found = @h[k]
+              puts "found #{found.inspect}" if found
+              debugger
+              x = k.eql?(old)
+              y = old.eql?(k)
+              p y
+            }
+            raise "failed to delete #{old.verbalise}, have #{map{|e| e.verbalise}.inspect}"
+          end
+        end
+        puts "#{@h.object_id}: Adding #{value.inspect}" if value && (value.name == 'Meetingisboardmeeting' rescue false)
+        @h[value] = true if value
+      end
+
+      def verbalise
+        "["+@h.keys.map{|e| e.verbalise}*", "+"]"
+      end
+=end
+
+    end
+
+  end
+end

data/lib/activefacts/generate/absorption.rb

@@ -14,7 +14,7 @@ module ActiveFacts
     #   afgen --absorption[=options] <file>.cql"
     # Options are comma or space separated:
     # * no_columns Don't emit the columns
-    # * dependent Show Concepts that are not tables as well
+    # * all Show Concepts that are not tables as well
     # * paths Show the references paths through which each column was defined
     # * no_identifier Don't show the identified_by columns for an EntityType
 
@@ -25,7 +25,6 @@ module ActiveFacts
         @vocabulary = vocabulary
         @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
         @no_columns = options.include? "no_columns"
-        @dependent = options.include? "dependent"
         @paths = options.include? "paths"
         @no_identifier = options.include? "no_identifier"
       end
@@ -38,39 +37,30 @@ module ActiveFacts
         multi_absorption_ets = 0
         @vocabulary.tables
         @vocabulary.all_feature.sort_by{|c| c.name}.each do |o|
-          # Don't dump imported (base) ValueTypes:
-          next if ValueType === o && !o.supertype
+          next if !o.is_table
           show(o)
         end
       end
 
       def show concept        #:nodoc:
-        return unless concept.is_table || @dependent
-
-        print "#{concept.name}"
-        print " (#{concept.tentative ? "tentatively " : ""}#{concept.is_table ? "in" : ""}dependent)" if @dependent
-
-        if !@no_identifier && concept.is_a?(EntityType)
-          print " is identified by:\n\t#{
-"REVISIT" #              concept.references_from.to_s
-            }"
-        end
-        print "\n"
-
-        unless @no_columns
-          puts "#{ concept.references_from.map do |role_ref|
-              "\t#{role_ref.column_name(".")}\n"
-            end*"" }"
-        end
-
-        if (@paths)
-          ap = concept.absorption_paths
-          puts "#{ ap.map {|role|
-            prr = role.preferred_reference.describe
-            player = role.fact_type.entity_type == concept ? role.concept : (role.fact_type.all_role-[role])[0].concept
-            "\tcan absorb #{prr != role.concept.name ? "(via #{prr}) " : "" }into #{player.name}\n"
-          }*"" }"
-        end
+        indices = concept.indices
+        pk = indices.select(&:is_primary)[0]
+        indices = indices.clone
+        indices.delete pk
+        puts "#{concept.name}: #{
+#            "[#{concept.indices.size} indices] "
+#          } #{
+            concept.columns.sort_by do |column|
+              column.name(nil)
+            end.map do |column|
+              index_nrs =
+                [pk && pk.columns.include?(column) ? "*" : nil] +
+                (0...indices.size).select{|i| indices[i].columns.include?(column)}.map{|i| (i+1).to_i }
+              index_nrs.compact!
+              (@paths ? column.references.map{|r| r.to_names}.flatten : column.name(nil)) * "." +
+                (index_nrs.empty? ? "" : "["+index_nrs*""+"]")
+            end*", "
+          }"
 
       end
     end