caruby-tissue 1.5.6 → 2.1.1

data/lib/catissue/helpers/controlled_value.rb

@@ -0,0 +1,35 @@
+require 'caruby/helpers/controlled_value'
+
+module CaTissue
+  class ControlledValue < CaRuby::ControlledValue
+    # @param [String, Symbol] public_id_or_alias the public id value or the
+    #   standard alias +:tissue_site+ or +:clinical_diagnosis+
+    # @return [String] the standard public id value for the given string or alias
+    def self.standard_public_id(public_id_or_alias)
+      PID_ALIAS_HASH[public_id_or_alias.to_sym] or public_id_or_alias.to_s
+    end
+
+    attr_accessor :identifier
+
+    attr_reader :public_id
+
+    # @return [Integer] the identifier of the parent
+    def parent_identifier
+      parent.identifier if parent
+    end
+
+    # @param public_id_or_alias (see ControlledValue.standard_public_id)
+    def public_id=(public_id_or_alias)
+      @public_id = self.class.standard_public_id(public_id_or_alias)
+    end
+
+    def to_s
+      "#{value}"
+    end
+    
+    private
+
+    # The public id symbol => name hash.
+    PID_ALIAS_HASH = {:tissue_site => 'Tissue_Site_PID', :clinical_diagnosis => 'Clinical_Diagnosis_PID'}
+  end
+end

data/lib/catissue/{util → helpers}/location.rb

@@ -1,5 +1,5 @@
-require 'caruby/util/coordinate'
-require 'caruby/util/validation'
+require 'caruby/helpers/coordinate'
+require 'jinx/helpers/validation'
 
 module CaTissue
   # A Location is a non-Resource utility class which represents a Container row and column.
@@ -20,7 +20,7 @@ module CaTissue
       Options.validate(params, INIT_OPTS)
       @container = Options.get(:in, params)
       coord = Options.get(:at, params, Coordinate.new)
-      # turn an :at Array value into a Coordinate
+      # turn an +:at+ Array value into a Coordinate
       if Array === coord and not Coordinate === coord then
         coord = Coordinate.new(*coord) 
       end
@@ -50,13 +50,13 @@ module CaTissue
 
     # @return [Boolean] whether other is a Location and has the same content as this Location
     def ==(other)
-      super rescue false
+      container == other.container and coordinate == other.coordinate
     end
 
     # @return [Location, nil] a new Location at the next slot in this Location's {#container},
     #   or nil if there are no more locations
     def succ
-      self.class.new(:in => container, :at => @coordinate).succ! rescue nil
+      self.class.new(:in => container, :at => @coordinate.dup).succ! rescue nil
     end
 
     # Sets this Location to the next slot in this Location's {#container}.
@@ -89,6 +89,7 @@ module CaTissue
 
     private
     
+    # @private
     INIT_OPTS = [:in, :at].to_set
     
     # @param [CaRuby::Coordinate] coord the coordinate to validate

data/lib/catissue/helpers/log.rb

@@ -0,0 +1,4 @@
+require 'catissue/wustl/logger'
+
+# Set up the caTissue client logger before loading the class definitions.
+Wustl::Logger.configure

data/lib/catissue/{util → helpers}/person.rb

@@ -1,4 +1,4 @@
-require 'caruby/util/person'
+require 'caruby/helpers/person'
 
 module CaTissue
   # Mix-in for domain classes that define the +first_name+, +last_name+ and optional +middle_name+ attributes.

data/lib/catissue/{util → helpers}/position.rb

@@ -1,5 +1,5 @@
-require 'catissue/util/location'
-require 'caruby/util/validation'
+require 'catissue/helpers/location'
+require 'jinx/helpers/validation'
 
 module CaTissue
   # The Position mix-in encapsulates the location of an occupant in a holder.
@@ -15,7 +15,8 @@ module CaTissue
       self.class === other and occupant == other.occupant and location == other.location
     end
 
-    # @return [Coordinate] the read-only coordinate with this AbstractPosition's #row and {#column}.
+    # @return [Coordinate] the read-only coordinate with this AbstractPosition's {Location#row}
+    #   and {Location#column}.
     def coordinate
       location.coordinate
     end
@@ -38,17 +39,18 @@ module CaTissue
       self.column = @location.column
     end
     
-    # @return whether either the column or the row is nil
+    # @return [Boolean] whether either the column or the row is nil
     def unspecified?
       column.nil? or row.nil?
     end
 
-    # @return [(Integer, Integer)] this Position's zero-based ({#column}, {#row}) tuple.
+    # @return [(Integer, Integer)] this Position's zero-based ({Location#column}, {Location#row})
+    #   tuple
     def to_a
       [column, row]
     end
     
-    # @raise [ValidationError] if the holder cannot hold the occupant type
+    # @raise [Jinx::ValidationError] if the holder cannot hold the occupant type
     def validate
       super
       logger.debug { "Validating that #{holder} can hold #{occupant}..." }
@@ -56,10 +58,10 @@ module CaTissue
       if curr_occ.nil? then
         unless holder.can_hold_child?(occupant) then
           reason = holder.full? ? "it is full" : "the occupant type is not among the supported types #{holder.container_type.child_types.qp}"
-          raise ValidationError.new("#{holder} cannot hold #{occupant} since #{reason}")
+          raise Jinx::ValidationError.new("#{holder} cannot hold #{occupant} since #{reason}")
         end
       elsif curr_occ != occupant
-        raise ValidationError.new("#{holder} cannot hold #{occupant} since the location #{[colum, row]} is already occupied by #{curr_occ}")
+        raise Jinx::ValidationError.new("#{holder} cannot hold #{occupant} since the location #{[colum, row]} is already occupied by #{curr_occ}")
       end
     end
   end

data/lib/catissue/helpers/properties_loader.rb

@@ -0,0 +1,143 @@
+module CaTissue
+  # The caTissue classpath and connection parameters properties loader mix-in.
+  module PropertiesLoader
+    class ConfigurationError < StandardError; end
+    
+    # @return [{Symbol => [String, <String>]}] the application properties
+    def properties
+      @properties ||= load_properties
+    end
+    
+    private
+
+    # Loads the caTissue classpath and connection properties.
+    #
+    # @quirk caTissue The classpath remoteServices.xml stream is corrupted, e.g. with a line:
+    #     at top level in <value>http://cabig4 at line 8080
+    #   instead of the expected:
+    #     <property name="serviceUrl">http://cabig4:8080<\/property>
+    #   This might be a classpath order side-effect or an install jar corruption, e.g. as
+    #   occurs when building the caCORE API with a custom DE jar.
+    def load_properties
+      # the properties file
+      file = default_properties_file
+      # the access properties
+      props = file && File.exists?(file) ? load_properties_file(file) : {}
+      # Load the Java application jar path.
+      path = props[:classpath] || props[:path] || infer_classpath
+      if path then
+        Java.expand_to_class_path(path)
+      end
+      # TODO - below doesn't work because of caTissue bug described in the method rubydoc.
+      # Augment the application login properties with the remoteService.xml url property.
+      # path[:url] ||= remote_service_url
+      # def remote_service_url
+      #   is = Java::edu.wustl.catissuecore.domain.Specimen.java_class.class_loader.getResourceAsStream('remoteService.xml')
+      #   xml = Java::java.util.Scanner.new(is).useDelimiter("\\A").next
+      #   /<property.+serviceUrl['"]?>(.+)<\/property>/.match(xml).captures.first
+      # end
+      props
+    end
+    
+    def load_properties_file(file)
+      props = {}
+      logger.info("Loading application properties from #{file}...")
+      File.open(file).each do |line|
+        # match the tolerant property definition
+        match = PROP_DEF_REGEX.match(line.chomp.strip) || next
+        # the property [name, value] tokens
+        tokens = match.captures
+        pname = tokens.first.to_sym
+        # :path is deprecated; if there is a :path entry, then
+        # set :classpath with the :path value instead.
+        name = pname == :path ? :classpath : pname
+        value = tokens.last
+        # capture the property
+        props[name] = value
+      end
+      props
+    end
+
+    # The property/value matcher, e.g.:
+    #   host: jacardi
+    #   host = jacardi
+    #   host=jacardi
+    #   name: J. Edgar Hoover
+    # but not:
+    #   # host: jacardi
+    # The captures are the trimmed property and value.
+    PROP_DEF_REGEX = /^(\w+)(?:\s*[:=]\s*)([^#]+)/
+  
+    # @return [String] the default application properties file, given by +~/.+_name_,
+    #   where _name_ is the underscore unqualified module name, e.g. +~/.catissue+
+    #   for module +CaTissue+
+    def default_properties_file
+      home = ENV['HOME'] || ENV['USERPROFILE'] || '~'
+      file = File.expand_path('.catissue', home)
+      file if File.exists?(file)
+    end
+  
+    # @quirk caTissue 1.2 the caTissue API class path is sensitive to order in subtle ways that
+    #   caTissue 1.1.2 is not. The caTissue client +build.xml+ defines a +cp+ classpath 
+    #   property which was used to run a caTissue 1.1.1 example.
+    #
+    #   However, the example was removed in caTissue 1.1.2. As of 1.1.2, the +cp+ property is no
+    #   longer referenced in the client +build.xml+. Rather, the classpath is defined inline
+    #   in the task with a small but important change: +cp+ placed the config directories
+    #   before the jar files, whereas the inline definition placed the configs after the jars.
+    #
+    #   This difference does not present a problem in caTissue 1.1.2, but the confusion was
+    #   carried over to caTissue 1.2 where it does cause a problem. Unlike caTissue 1.1.2,
+    #   in 1.2 the +DynamicExtension.jar+ is redundantly included in both the client and the
+    #   declient lib. Furthermore, +DynamicExtension.jar+ contains an invalid and unnecessary
+    #   +remoteServices.xml+, which references a non-existent +RemoteSDKApplicationService+.
+    #
+    #   If the caTissue path is defined with the jars preceding the configs, then in 1.2 an
+    #   obscure +PropertyAccessExceptionsException+ exception is raised indicating that
+    #   +RemoteSDKApplicationService+ is an invalid class name. The cause is the classpath
+    #   precedence of jars prior to configs.
+    #
+    #   The caRuby FAQ shows an example +~/.catissue+ +path+ property that was originally
+    #   borrowed from the caTissue 1.1.1 client example. This incorrect precedence was a time
+    #   bomb that exploded in 1.2. This 1.2 regression is now noted in the FAQ.
+    #
+    # @quirk caTissue 1.2 per the caTissue API client Ant build file, the +catissuecore.jar+
+    #   should not be included in the client class path, even though it is in the client lib
+    #   directory.
+    def infer_classpath
+      dir = ENV['CATISSUE_CLIENT_HOME'] || '.'
+      logger.info("Inferring the class path from directory #{dir}...")
+      # Hunt for the client directories
+      clt_dir = client_directory(dir, 'caTissueSuite_Client')
+      de_dir = client_directory(dir, 'catissue_de_integration_client')
+      dirs = [client_subdirectory(clt_dir, 'conf'),
+        client_subdirectory(de_dir, 'conf'),
+        client_subdirectory(clt_dir, 'lib'),
+        client_subdirectory(de_dir, 'lib')
+      ]
+      # caTissue 1.1.2 has an extra directory.
+      clt_lib = File.expand_path('lib', dir)
+      dirs << clt_lib if File.directory?(clt_lib)
+      # Make a semi-colon separated path string.
+      path = dirs.join(';')
+      logger.info("Inferred the class path #{path}.")
+      path
+    end
+    
+    def client_directory(dir, subdir)
+      clt_dir = File.expand_path(subdir, dir)
+      unless File.directory?(clt_dir) then
+        raise ConfigurationError.new("caTissue installation client directory not found: #{clt_dir}")
+      end
+      clt_dir
+    end
+    
+    def client_subdirectory(dir, subdir)
+      clt_subdir = File.expand_path(subdir, dir)
+      unless File.directory?(clt_subdir) then
+        raise ConfigurationError.new("caTissue client directory #{dir} does not include the #{subdir} subdirectory.")
+      end
+      clt_subdir
+    end
+  end
+end

data/lib/catissue/{util → helpers}/storable.rb

@@ -1,4 +1,5 @@
-require 'caruby/util/collection'
+require 'jinx/helpers/collections'
+
 
 module CaTissue
   # The Storable mix-in adds methods for a domain class which can be stored and implements

data/lib/catissue/{util → helpers}/storage_type_holder.rb

@@ -1,9 +1,9 @@
-require 'caruby/util/collection'
+require 'jinx/helpers/partial_order'
 
 module CaTissue
   # The StorageTypeHolder mix-in adds common methods for the StorageType or StorageContainer child type accessors.
   module StorageTypeHolder
-    include PartialOrder
+    include Jinx::PartialOrder
     
     # @return [StorageType] the allowable child storage types
     def child_storage_types
@@ -20,10 +20,16 @@ module CaTissue
       holds_specimen_array_types
     end
 
+    # Returns the {CaTissue::SpecimenArrayType} or {CaTissue::StorageType} children which this StorageTypeHolder
+    # can hold.
+    def child_container_types
+      child_storage_types.union(child_specimen_array_types)
+    end
+
     # Returns the {CaTissue::SpecimenArrayType}, {CaTissue::AbstractSpecimen#specimen_class} or {CaTissue::StorageType}
     # children which this StorageTypeHolder can hold.
     def child_types
-      child_storage_types.union(child_specimen_classes).union(child_specimen_array_types)
+      child_container_types.union(child_specimen_classes)
     end
     
     # Adds the given subtype to the list of subtypes which this StorageType can hold.

data/lib/catissue/{annotation/annotatable_class.rb → metadata.rb}

@@ -1,41 +1,20 @@
-require 'caruby/util/inflector'
-require 'caruby/domain/metadata'
-require 'catissue/annotation/annotation_module'
+require 'caruby/metadata'
+require 'catissue/annotation/importer'
 require 'catissue/annotation/de_integration'
 
 module CaTissue
-  # Mix-in for extending a caTissue domain class with annotations.
-  module AnnotatableClass
+  # Mix-in for extending a caTissue domain class with +Jinx::Metadata+ introspection and annotations.
+  module Metadata
+    include CaRuby::Metadata
     
     # @return [Integer, nil] the the hook class designator that is used by caTissue to persist primary
     #   annotation objects, or nil if this is not a primary annotation class
     attr_reader :entity_id
-      
-    # @return [Class] the {DEIntegration} proxy class (nil for 1.1 caTissue)
+    
+    # @return [Class] the {Annotation::DEIntegration} proxy class (nil for 1.1 caTissue)
     def de_integration_proxy_class
       @de_integration_proxy_class or (superclass.de_integration_proxy_class if superclass < Annotatable)
     end
-    
-    # Adds {CaRuby::Domain::Metadata} and {AnnotatableClass} functionality to the given class.
-    #
-    # @param [Class] the domain class to extend
-    def self.extend_class(klass)
-      # Enable the class meta-data.
-      klass.extend(CaRuby::Domain::Metadata)
-      klass.extend(self)
-    end
-    
-    def self.extended(klass)
-      super
-      # Initialize the class annotation hashes.
-      klass.class_eval do
-        # Enable the class meta-data.
-        # the annotation name => spec hash
-        @ann_spec_hash = {}
-        # the annotation module => proxy hash
-        @ann_mod_pxy_hash = {}
-      end
-    end
 
     # @return [Integer, nil] this class's entity id, if it exists, otherwise the superclass effective entity id
     #   if the superclass is an annotation class
@@ -61,21 +40,21 @@ module CaTissue
       annotation_defined?(symbol)
     end
 
-    # Refines the {CaRuby::Domain::Attributes#toxic_attributes} to exclude annotation attributes.
+    # Refines the +CaRuby::Propertied.toxic_attributes+ to exclude annotation attributes.
     #
     # @return [<Symbol>] the non-annotation unfetched attributes
     def toxic_attributes
-      @anntbl_toxic_attrs ||= unfetched_attributes.compose { |attr_md| not attr_md.type < Annotation } 
+      @anbl_toxic_attrs ||= unfetched_attributes.compose { |prop| not prop.type < Annotation } 
     end
 
     # @param [AnnotationModule] mod the annotation module
     # @return [Symbol] the corresponding annotation proxy reference attribute
     def annotation_proxy_attribute(mod)
-      @ann_mod_pxy_hash[mod] or
+      (@ann_mod_pxy_hash and @ann_mod_pxy_hash[mod]) or
         (superclass.annotation_proxy_attribute(mod) if superclass < Annotatable) or
         raise AnnotationError.new("#{qp} #{mod} proxy attribute not found.")
     end
-    
+  
     # Loads the annotations, if necessary, and tries to get the constant again.
     #
     # @param [Symbol] symbol the missing constant
@@ -90,60 +69,58 @@ module CaTissue
       end
     end
 
-    # Filters {CaRuby::Domain::Attributes#loadable_attributes} to exclude the {#annotation_attributes}
+    # Filters +CaRuby::Propertied#loadable_attributes} to exclude the {.annotation_attributes+
     # since annotation lazy-loading is not supported.
     #
-    # @return (see CaRuby::Domain::Attributes#loadable_attributes)
+    # @return (see CaRuby::Propertied#loadable_attributes)
     def loadable_attributes
-      @antbl_ld_attrs ||= super.compose { |attr_md| not attr_md.type < Annotation }
+      @antbl_ld_attrs ||= unfetched_attributes.compose do |prop|
+        # JRuby bug - Copied super body to avoid infinite loop. See const_missing.
+        prop.java_property? and not prop.type.abstract? and not prop.type < Annotation
+      end
     end
-    
+  
     def printable_attributes
-      @prbl_attrs ||= super.union(annotation_attributes)
-    end
-    
-    def attribute_metadata(attribute)
-      begin
-        super
-      rescue
-        if annotation_attribute?(attribute) then
-          attribute_metadata(attribute)
-        else
-          raise
-        end
-      end
+      # JRuby bug - Copied super body to avoid infinite loop. See const_missing.
+      @prbl_attrs ||= java_attributes.union(annotation_attributes)
     end
-    
+  
     def annotation_attributes
+      @ann_mod_pxy_hash ||= {}
       @ann_attrs ||= append_ancestor_enum(@ann_mod_pxy_hash.enum_values) do |sc|
         sc.annotation_attributes if sc < Annotatable
       end
     end
-    
+  
     protected
-    
+  
     # @return [<AnnotationModule>] the annotation modules in the class hierarchy
     def annotation_modules
       @ann_mods ||= load_annotations
     end
-    
+  
     private
-    
+  
+    # @return [Boolean] whenter this class's annotations are loaded
+    def annotations_loaded?
+      !!@ann_mods
+    end
+  
     # @param [String] name the proxy record entry class name
     def annotation_proxy_class_name=(name)
       @de_integration_proxy_class = Annotation::DEIntegration.proxy(name)
       if @de_integration_proxy_class then
         # hide the internal caTissue proxy collection attribute
-        attr = detect_attribute_with_type(@de_integration_proxy_class)
-        if attr then
-          remove_attribute(attr)
-          logger.debug { "Hid the internal caTissue #{qp} annotation record-keeping attribute #{attr}." }
+        pa = detect_attribute_with_type(@de_integration_proxy_class)
+        if pa then
+          remove_attribute(pa)
+          logger.debug { "Hid the internal caTissue #{qp} annotation record-keeping attribute #{pa}." }
         end
       else
         logger.debug { "Ignored the missing caTissue #{qp} proxy class name #{name}, presumably unsupported in this caTissue release." }
       end
     end
-    
+  
     # Loads the annotation modules in the class hierarchy.
     #
     # @return [<AnnotationModule>] an Enumerable on the loaded annotation modules
@@ -151,15 +128,15 @@ module CaTissue
       @local_ann_mods = load_local_annotations
       superclass < Annotatable ? @local_ann_mods.union(superclass.annotation_modules) : @local_ann_mods
     end
-    
+  
     def parent_entity_id
       superclass.entity_id if superclass < Annotatable
     end
-    
+  
     def annotatable_class_hierarchy
       class_hierarchy.filter { |klass| klass < Annotatable }
     end
-    
+  
     # Declares an annotation scoped by this class.
     #
     # @param [String] name the name of the annotation module
@@ -167,6 +144,7 @@ module CaTissue
     # @option opts [String] :package the package name (default is the lower-case underscore name)
     # @option opts [String] :service the service name (default is the lower-case underscore name)
     # @option opts [String] :group the DE group short name (default is the package)
+    # @option opts [String] :proxy_name the DE proxy class name (default is the class name followed by +RecordEntry+)
     def add_annotation(name, opts={})
       # the module symbol
       mod_sym = name.camelize.to_sym
@@ -174,35 +152,39 @@ module CaTissue
       pkg = opts[:package] ||= name.underscore
       svc = opts[:service] ||= name.underscore
       grp = opts[:group] ||= pkg
+      pxy_nm = opts[:proxy_name] || "#{self.name.demodulize}RecordEntry"
+      self.annotation_proxy_class_name = pxy_nm
       # add the annotation entry
+      @ann_spec_hash ||= {}
       @ann_spec_hash[mod_sym] = opts
       logger.info("Added #{qp} annotation #{name} with module #{mod_sym}, package #{pkg}, service #{svc} and group #{grp}.")
     end
-    
+  
     # @return [Boolean] whether this annotatable class's annotations are loaded
     def annotations_loaded?
-      not @ann_mods.nil?
+      !!@ann_mods
     end
-    
+  
     # Loads this class's annotations.
     #
     # @return [<AnnotationModule>] the loaded annotation modules
     def load_local_annotations
+      return Array::EMPTY_ARRAY if @ann_spec_hash.nil?
       # an annotated class has a hook entity id
-      unless @ann_spec_hash.empty? then initialize_annotation_holder end
+      initialize_annotation_holder
       # build the annotations
       @ann_spec_hash.map { |name, opts| import_annotation(name, opts) }
-    end    
-    
+    end
+  
     # Determines this annotated class's {#entity_id} and {#de_integration_proxy_class}.
     def initialize_annotation_holder
       @entity_id = Annotation::EntityFacade.instance.hook_entity_id(self)
     end
-    
+  
     # @param [Symbol] attribute the annotation accessor
     # @return [Module] the annotation module which implements the attribute
     def annotation_attribute_module(attribute)
-      annotation_modules.detect { |mod| mod.proxy.attribute_defined?(attribute) }
+      annotation_modules.detect { |mod| mod.proxy.property_defined?(attribute) }
     end
 
     # Builds a new annotation module for the given module name and options.
@@ -213,19 +195,14 @@ module CaTissue
     # @raise [AnnotationError] if there is no annotation proxy class
     def import_annotation(name, opts)
       logger.debug { "Importing #{qp} annotation #{name}..." }
-      # Make the annotation module scoped by this Annotatable class.
-      class_eval("class #{name}; end")
-      klass = const_get(name)
+      # Make the annotation module class scoped by this Annotatable class.
+      class_eval("module #{name}; end")
+      mod = const_get(name)
       # Append the AnnotationModule methods.
-      AnnotationModule.extend_module(klass, self, opts)
-      # Make the proxy attribute.
-      attr = create_proxy_attribute(klass)
-      # The proxy is a logical dependent.
-      add_dependent_attribute(attr, :logical)
-      logger.debug { "Created #{qp} annotation proxy logical dependent reference attribute #{attr}." }
-      # Fill out the dependency hierarchy.
-      klass.proxy.build_annotation_dependency_hierarchy
-      klass
+      mod.extend(Annotation::Importer)
+      # Build the annnotation module.
+      mod.initialize_annotation(self, opts) { |pxy| create_proxy_attribute(mod, pxy) }
+      mod
     end
 
     # Returns whether this class has an annotation whose proxy accessor is the
@@ -235,28 +212,29 @@ module CaTissue
     # @return (see #annotation?)
     # @see #annotation?
     def annotation_defined?(symbol)
-      attribute_defined?(symbol) and attribute_metadata(symbol).type < Annotation
+      property_defined?(symbol) and property(symbol).type < Annotation
     end
-    
+  
     # Makes an attribute whose name is the demodulized underscored given module name.
     # The attribute reader creates an {Annotation::Proxy} instance of the method
     # receiver {Annotatable} instance on demand.
     # 
-    # @param [AnnotationModule] klass the subject annotation
-    # @return [Symbol] the proxy attribute
-    def create_proxy_attribute(klass)
-      # the proxy class
-      pxy = klass.proxy
+    # @param [AnnotationModule] mod the subject annotation
+    # @return [ProxyClass] proxy the proxy class
+    def create_proxy_attribute(mod, proxy)
       # the proxy attribute symbol
-      attr = klass.name.demodulize.underscore.to_sym
+      pa = mod.name.demodulize.underscore.to_sym
       # Define the proxy attribute.
-      attr_create_on_demand_accessor(attr) { Set.new }
+      attr_create_on_demand_accessor(pa) { Set.new }
       # Register the attribute.
-      add_attribute(attr, pxy, :collection, :saved)
-      logger.debug { "Added #{qp} #{klass.qp} annotation proxy attribute #{attr} of type #{pxy}." }
+      add_attribute(pa, proxy, :collection, :saved, :nosync)
       # the annotation module => proxy attribute association
-      @ann_mod_pxy_hash[klass] = attr
-      attr
+      @ann_mod_pxy_hash ||= {}
+      @ann_mod_pxy_hash[mod] = pa
+      # The proxy is a logical dependent.
+      add_dependent_attribute(pa, :logical)
+      logger.debug { "Created #{qp} #{mod.qp} annotation proxy logical dependent reference attribute #{pa} to #{proxy}." }
+      pa
     end
   end
 end