activefacts-api 0.8.9 → 0.8.10

data/lib/activefacts/api/role.rb

@@ -11,26 +11,40 @@ module ActiveFacts
 
     # A Role represents the relationship of one object to another (or to a boolean condition).
     # Relationships (or binary fact types) have a Role at each end; one is declared using _has_one_
-    # or _one_to_one_, and the other is created on the counterpart class. Each ObjectType class maintains
-    # an array of the roles it plays.
+    # or _one_to_one_, and the other is created on the counterpart class.
+    # Each ObjectType class maintains a RoleCollection hash of the roles it plays.
     class Role
-      attr_accessor :owner            # The ObjectType to which this role belongs
-      attr_accessor :name             # The name of the role (a Symbol)
-      attr_accessor :counterpart_object_type  # A ObjectType Class (may be temporarily a Symbol before the class is defined)
-      attr_accessor :counterpart      # All roles except unaries have a binary counterpart
-      attr_accessor :unique           # Is this role played by at most one instance, or more?
-      attr_accessor :mandatory        # In a valid fact population, is this role required to be played?
-      attr_accessor :value_constraint  # Counterpart Instances playing this role must meet this constraint
-      attr_reader :is_identifying     # Is this an identifying role for owner?
+      attr_reader   :object_type      # The ObjectType to which this role belongs
+      attr_reader   :name             # The name of the role (a Symbol)
+      attr_accessor :counterpart      # All roles except unaries have a counterpart Role
+      attr_reader   :unique           # Is this role played by at most one instance, or more?
+      attr_reader   :mandatory        # In a valid fact population, is this role required to be played?
+      attr_reader   :value_constraint # Counterpart Instances playing this role must meet this constraint
+      attr_reader   :is_identifying   # Is this an identifying role for object_type?
 
-      def initialize(owner, counterpart_object_type, counterpart, name, mandatory = false, unique = true)
-        @owner = owner
-        @counterpart_object_type = counterpart_object_type
+      def initialize(object_type, counterpart, name, mandatory = false, unique = true)
+        @object_type = object_type
         @counterpart = counterpart
         @name = name
         @mandatory = mandatory
         @unique = unique
-        @is_identifying = @owner.is_entity_type && @owner.identifying_role_names.include?(@name)
+        @is_identifying = @object_type.is_entity_type && @object_type.identifying_role_names.include?(@name)
+        associate_role(@object_type)
+      end
+
+      # Return the name of the getter method
+      def getter
+        @getter ||= @name.to_sym
+      end
+
+      # Return the name of the setter method
+      def setter
+        @setter ||= :"#{@name}="
+      end
+
+      # Return the name of the instance variable
+      def variable
+        @variable ||= "@#{@name}"
       end
 
       # Is this role a unary (created by maybe)? If so, it has no counterpart
@@ -39,34 +53,57 @@ module ActiveFacts
         counterpart == nil
       end
 
-      def resolve_counterpart(vocabulary)  #:nodoc:
-        return @counterpart_object_type if @counterpart_object_type.is_a?(Class)   # Done already
-        klass = vocabulary.object_type(@counterpart_object_type)   # Trigger the binding
-        raise "Cannot resolve role counterpart_object_type #{@counterpart_object_type.inspect} for role #{name} in vocabulary #{vocabulary.basename}; still forward-declared?" unless klass
-        @counterpart_object_type = klass                       # Memoize a successful result
+      def counterpart_object_type
+        # This method is sometimes used when unaries are used in an entity's identifier.
+        counterpart == nil ? TrueClass : counterpart.object_type
+      end
+
+      def inspect
+        "<Role #{object_type.name}.#{name}>"
       end
 
       def adapt(constellation, value) #:nodoc:
         # If the value is a compatible class, use it (if in another constellation, clone it),
         # else create a compatible object using the value as constructor parameters.
-        if value.is_a?(@counterpart_object_type)  # REVISIT: may be a non-primary subtype of counterpart_object_type
-          value = value.__getobj__ if RoleProxy === value
+        if value.is_a?(counterpart.object_type)
           # Check that the value is in a compatible constellation, clone if not:
           if constellation && (vc = value.constellation) && vc != constellation
-            value = value.clone   # REVISIT: There's sure to be things we should reset/clone here, like non-identifying roles
+            # Cross-constellation assignment!
+            # Just take the identifying_role_values to make a new object
+            value = constellation.send(value.class.basename, value.identifying_role_values)
           end
           value.constellation = constellation if constellation
         else
           value = [value] unless Array === value
-          raise "No parameters were provided to identify an #{@counterpart_object_type.basename} instance" if value == []
+          raise "No parameters were provided to identify an #{counterpart.object_type.basename} instance" if value == []
           if constellation
-            value = constellation.send(@counterpart_object_type.basename.to_sym, *value)
+            value = constellation.send(counterpart.object_type.basename.to_sym, *value)
           else
-            value = @counterpart_object_type.new(*value)
+            #trace :assert, "Constructing new #{counterpart.object_type} with #{value.inspect}" do
+              value = counterpart.object_type.new(*value)
+            #end
           end
         end
         value
       end
+
+    private
+      # Create a class method to access the Role object.
+      # This seems to add *significantly* to the runtime of the tests,
+      # but it's load-time, not execution-time, so it's staying!
+      def associate_role(klass)
+        role = self
+        klass.class_eval do
+          role_accessor_name = "#{role.name}_role"
+          unless (method(role_accessor_name) rescue nil)
+            (class << self; self; end).
+              send(:define_method, role_accessor_name) do
+                role
+              end
+          # else we can't create such a method without creating mayhem, so don't.
+          end
+        end
+      end
     end
 
     # Every ObjectType has a Role collection

data/lib/activefacts/api/role_values.rb

@@ -14,7 +14,6 @@ module ActiveFacts
     class RoleValues  #:nodoc:
       include Enumerable
 
-#=begin
       def initialize
         @a = []
       end
@@ -48,68 +47,11 @@ module ActiveFacts
       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
 

data/lib/activefacts/api/standard_types.rb

@@ -15,8 +15,7 @@ module ActiveFacts
     module ValueClass #:nodoc:
       def value_type *args, &block #:nodoc:
         include ActiveFacts::API::Value
-        # the included method adds the Value::ClassMethods
-        initialise_value_type(*args, &block)
+        value_type(*args, &block)
       end
     end
   end
@@ -33,19 +32,29 @@ ValueClasses.each{|c|
 
 class TrueClass #:nodoc:
   def verbalise(role_name = nil); role_name ? "#{role_name}: true" : "true"; end
+  def identifying_role_values; self; end
+  def self.identifying_role_values(*a); true; end
+end
+
+class FalseClass #:nodoc:
+  def verbalise(role_name = nil); role_name ? "#{role_name}: false" : "false"; end
+  def identifying_role_values; self; end
+  def self.identifying_role_values(*a); false; end
 end
 
 class NilClass #:nodoc:
   def verbalise; "nil"; end
+  def identifying_role_values; self; end
+  def self.identifying_role_values(*a); nil; end
 end
 
 class Class
   # Make this Class into a ObjectType and if necessary its module into a Vocabulary.
   # The parameters are the names (Symbols) of the identifying roles.
-  def identified_by *args
+  def identified_by *args, &b
     raise "#{basename} is not an entity type" if respond_to? :value_type  # Don't make a ValueType into an EntityType
     include ActiveFacts::API::Entity
-    initialise_entity_type(*args)
+    identified_by(*args, &b)
   end
 
   def is_entity_type
@@ -58,7 +67,7 @@ class Decimal < BigDecimal #:nodoc:
   extend ActiveFacts::API::ValueClass
   # The problem here is you can't pass a BigDecimal to BigDecimal.new. Fix it.
   def self.new(v)
-    if v.is_a?(BigDecimal)
+    if v.is_a?(BigDecimal) || v.is_a?(Bignum)
       super(v.to_s)
     else
       super

data/lib/activefacts/api/value.rb

@@ -15,8 +15,14 @@ module ActiveFacts
 
       # Value instance methods:
       def initialize(*args) #:nodoc:
-        args[0] = args[0].__getobj__ if RoleProxy === args[0]
+        hash = args[-1].is_a?(Hash) ? args.pop.clone : nil
+
         super(args)
+
+        (hash ? hash.entries : []).each do |role_name, value|
+          role = self.class.roles(role_name)
+          send(role.setter, value)
+        end
       end
 
       # verbalise this Value
@@ -24,18 +30,22 @@ module ActiveFacts
         "#{role_name || self.class.basename} '#{to_s}'"
       end
 
-      # A value is its own key
+      # A value is its own key, unless it's a delegate for a raw value
       def identifying_role_values #:nodoc:
-        self
+        __getobj__ rescue self
       end
 
       # All ValueType classes include the methods defined here
       module ClassMethods
         include Instance::ClassMethods
 
-        def initialise_value_type *args, &block #:nodoc:
+        def value_type *args, &block #:nodoc:
           # REVISIT: args could be a hash, with keys :length, :scale, :unit, :allow
-          #raise "value_type args unexpected" if args.size > 0
+          options = (args[-1].is_a?(Hash) ? args.pop : {})
+          options.each do |key, value|
+            raise "unknown value type option #{key}" unless respond_to?(key)
+            send(key, value)
+          end
         end
 
         class_eval do
@@ -67,12 +77,10 @@ module ActiveFacts
 
         def identifying_role_values(*args)  #:nodoc:
           # If the single arg is the correct class or a subclass, use it directly
-          #puts "#{basename}.identifying_role_values#{args.inspect}"
-          if (args.size == 1 and (arg = args[0]).is_a?(self.class))   # No secondary supertypes allowed for value types
-            arg = arg.__getobj__ if RoleProxy === arg
-            return arg
+          if (args.size == 1 and (arg = args[0]).is_a?(self))   # No secondary supertypes allowed for value types
+            return arg.identifying_role_values
           end
-          new(*args)
+          new(*args).identifying_role_values
         end
 
         def assert_instance(constellation, args)  #:nodoc:
@@ -80,25 +88,24 @@ module ActiveFacts
           # The key of an instance is the value or array of keys of the identifying values.
           # The key values aren't necessarily present in the constellation, even after this.
           key = identifying_role_values(*args)
-          #puts "#{klass} key is #{key.inspect}"
 
           # Find and return an existing instance matching this key
           instances = constellation.instances[self]   # All instances of this class in this constellation
           instance = instances[key]
-          # DEBUG: puts "assert #{self.basename} #{key.inspect} #{instance ? "exists" : "new"}"
           return instance, key if instance      # A matching instance of this class
 
-          instance = new(*args)
+          #trace :assert, "Constructing new #{self} with #{args.inspect}" do
+            instance = new(*args)
+          #end
 
           instance.constellation = constellation
           return *index_instance(instance)
         end
 
-        def index_instance(instance, key = nil) #:nodoc:
+        def index_instance(instance, key = nil, key_roles = nil) #:nodoc:
           instances = instance.constellation.instances[self]
           key = instance.identifying_role_values
           instances[key] = instance
-          # DEBUG: puts "indexing value #{basename} using #{key.inspect} in #{constellation.object_id}"
 
           # Index the instance for each supertype:
           supertypes.each do |supertype|
@@ -109,7 +116,6 @@ module ActiveFacts
         end
 
         def inherited(other)  #:nodoc:
-          #puts "REVISIT: ValueType #{self} < #{self.superclass} was inherited by #{other}; not implemented" #+"from #{caller*"\n\t"}"
           # Copy the type parameters here, etc?
           other.send :realise_supertypes, self
           vocabulary.__add_object_type(other)
@@ -120,11 +126,8 @@ module ActiveFacts
       def self.included other #:nodoc:
         other.send :extend, ClassMethods
 
-        #puts "ValueType included in #{other.basename} from #{caller*"\n\t"}"
-
         # Register ourselves with the parent module, which has become a Vocabulary:
         vocabulary = other.modspace
-        # puts "ValueType.included(#{other.inspect})"
         unless vocabulary.respond_to? :object_type  # Extend module with Vocabulary if necessary
           vocabulary.send :extend, Vocabulary
         end

data/lib/activefacts/api/vocabulary.rb

@@ -14,21 +14,28 @@ module ActiveFacts
     # and can resolve the forward references when the class is finally defined.
     # Construction of a Constellation requires a Vocabuary as argument.
     module Vocabulary
-      # With a parameter, look up a object_type class by name.
+      # With a parameter, look up an object type by name.
       # Without, return the hash (keyed by the class' basename) of all object_types in this vocabulary
       def object_type(name = nil)
         @object_type ||= {}
         return @object_type unless name
 
-        return name if name.is_a? Class
+        if name.is_a? Class
+          raise "#{name} must be an object type in #{self.name}" unless name.vocabulary == self
+          return name
+        end
 
-        # puts "Looking up object_type #{name} in #{self.name}"
         camel = name.to_s.camelcase
         if (c = @object_type[camel])
           __bind(camel)
-          return c
+          c
+        else
+          begin
+            const_get("#{self.name}::#{camel}")
+          rescue NameError
+            nil
+          end
         end
-        return (const_get("#{name}::#{camel}") rescue nil)
       end
 
       # Create a new constellation over this vocabulary
@@ -52,13 +59,11 @@ module ActiveFacts
       def __add_object_type(klass)  #:nodoc:
         name = klass.basename
         __bind(name)
-        # puts "Adding object_type #{name} to #{self.name}"
         @object_type ||= {}
         @object_type[klass.basename] = klass
       end
 
       def __delay(object_type_name, args, &block) #:nodoc:
-        # puts "Arranging for delayed binding on #{object_type_name.inspect}"
         @delayed ||= Hash.new { |h,k| h[k] = [] }
         @delayed[object_type_name] << [args, block]
       end
@@ -66,9 +71,7 @@ module ActiveFacts
       # __bind raises an error if the named class doesn't exist yet.
       def __bind(object_type_name)  #:nodoc:
         object_type = const_get(object_type_name)
-        # puts "#{name}.__bind #{object_type_name} -> #{object_type.name}" if object_type
         if (@delayed && @delayed.include?(object_type_name))
-          # $stderr.puts "#{object_type_name} was delayed, binding now"
           d = @delayed[object_type_name]
           d.each{|(a,b)|
               b.call(object_type, *a)

data/lib/activefacts/tracer.rb

@@ -0,0 +1,109 @@
+#
+#       ActiveFacts Support code.
+#       The trace method supports indented tracing.
+#       Set the TRACE environment variable to enable it. Search the code to find the TRACE keywords, or use "all".
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+module ActiveFacts
+  (class << self; self; end).class_eval do
+    attr_accessor :tracer
+  end
+
+  class Tracer
+    def initialize
+      @nested = false   # Set when a block enables all enclosed tracing
+      @available = {}
+
+      # First time, initialise the tracing environment
+      @indent = 0
+      @keys = {}
+      if (e = ENV["TRACE"])
+        e.split(/[^_a-zA-Z0-9]/).each{|k| enable(k) }
+        if @keys[:help]
+          at_exit {
+            @stderr.puts "---\nDebugging keys available: #{@available.keys.map{|s| s.to_s}.sort*", "}"
+          }
+        end
+        require 'ruby-debug' if @keys[:debug]
+      end
+    end
+
+    def keys
+      @available.keys
+    end
+
+    def enabled key
+      !key.empty? && @keys[key.to_sym]
+    end
+
+    def enable key
+      !key.to_s.empty? && @keys[key.to_sym] = true
+    end
+
+    def disable key
+      !key.to_s.empty? && @keys.delete(key.to_sym)
+    end
+
+    def toggle key
+      !key.to_s.empty? and enabled(key) ? (disable(key); false) : (enable(key); true)
+    end
+
+    def selected(args)
+      # Figure out whether this trace is enabled (itself or by :all), if it nests, and if we should print the key:
+      key =
+        if Symbol === args[0]
+          control = args.shift
+          if (s = control.to_s) =~ /_\Z/
+            nested = true
+            s.sub(/_\Z/, '').to_sym     # Avoid creating new strings willy-nilly
+          else
+            control
+          end
+        else
+          :all
+        end
+
+      @available[key] ||= key   # Remember that this trace was requested, for help
+      enabled = @nested ||      # This trace is enabled because it's in a nested block
+                @keys[key] ||   # This trace is enabled in its own right
+                @keys[:all]     # This trace is enabled because all are
+      @nested = nested
+      [
+        (enabled ? 1 : 0),
+        @keys[:all] ? " %-15s"%control : nil
+      ]
+    end
+
+    def show(*args)
+      enabled, key_to_show = selected(args)
+
+      # Emit the message if enabled or a parent is:
+      if args.size > 0 && enabled == 1
+        puts "\##{key_to_show} " +
+          '  '*@indent +
+          args.
+#            A laudable aim, certainly, but in practise the Procs leak and slow things down:
+#            map{|a| a.respond_to?(:call) ? a.call : a}.
+            join(' ')
+      end
+      @indent += enabled
+      enabled
+    end
+
+    def trace(*args, &block)
+      begin
+        old_indent, old_nested, enabled  = @indent, @nested, show(*args)
+        return (block || proc { enabled == 1 }).call
+      ensure
+        @indent, @nested = old_indent, old_nested
+      end
+    end
+  end
+end
+
+class Object
+  def trace *args, &block
+    (ActiveFacts.tracer ||= ActiveFacts::Tracer.new).trace(*args, &block)
+  end
+end