caruby-core 1.4.9 → 1.5.1

data/lib/caruby/domain.rb

@@ -0,0 +1,340 @@
+require 'fileutils'
+require 'caruby/util/collection'
+require 'caruby/util/log'
+require 'caruby/domain/importer'
+
+module CaRuby
+  class JavaImportError < StandardError; end;
+
+  # The application and database connection access command line options.
+  ACCESS_OPTS = [
+      [:user, "--user USER", "the application login user"],
+      [:password, "--password PSWD", "the application login password"],
+      [:host, "--host HOST", "the application host name"],
+      [:port, "--port PORT", "the application port number"],
+      [:classpath, "--classpath PATH", "the application client classpath"],
+      [:database_host, "--database_host HOST", "the database host name"],
+      [:database_type, "--database_type TYPE", "the database type (mysql or oracle)"],
+      [:database_driver, "--database_driver DRIVER", "the database driver string"],
+      [:database_driver_class, "--database_driver_class CLASS", "the database driver class name"],
+      [:database_port, "--database_port PORT", Integer, "the database port number"],
+      [:database, "--database NAME", "the database name"],
+      [:database_user, "--database_user USER", "the database login user"],
+      [:database_password, "--database_password PSWD", "the database login password"]
+    ]
+
+  # Domain extends a Module with Java class {Metadata} support.
+  #
+  # A Java class is imported into Ruby either by including the given Resource module
+  # or by referenceing the class name for the first time. For example, the
+  # +ClinicalTrials+ wrapper for Java package +org.nci.ctms+ classes and
+  # Ruby class definitions in the +domain+ subdirectory is enabled as follows:
+  #   module ClinicalTrials
+  #     PKG = 'org.nci.ctms'
+  #     SRC_DIR = File.join(File.dirname(__FILE__), 'domain')
+  #     CaRuby::Domain.extend_module(self, :package => PKG, :directory => SRC_DIR)
+  #
+  # The first reference by name to +ClinicalTrials::Subject+ imports the Java class
+  # +org.nci.ctms.Subject+ into +ClinicalTrials+. The +Subject+ Java property meta-data
+  # is introspected and the {Resource} module is included.
+  module Domain
+    # Extends the given module with importable Java class {Metadata} support.
+    #
+    # @param [Module] mod the module to extend
+    # @param [{Symbol => Object}] opts the extension options
+    # @option opts [Module] :metadata the optional {Metadata} extension (default {Metadata})
+    # @option opts [Module] :mixin the optional mix-in module (default {Resource})
+    # @option opts [String] :package the required Java package name
+    # @option opts [String] :directory the optional directory of source class definitions to load
+    def self.extend_module(mod, opts)
+      mod.extend(self)
+      Importer.extend_module(mod, opts)
+    end
+    
+    # Loads the {#access_properties} and adds the +path+ property items to the Java classpath.
+    #
+    # @param [Module] mod the module to extend
+    def self.extended(mod)
+      super
+      mod.ensure_classpath_defined
+    end
+    
+    # Loads the application start-up properties on demand. The properties are defined in the properties
+    # file or as environment variables.
+    # The properties file path is a period followed by the lower-case application name in the home directory,
+    # e.g. +~/.clincaltrials+ for the +ClinicalTrials+ application.
+    #
+    # The property file format is a series of property definitions in the form _property_: _value_.
+    # The supported properties include the following:
+    # * +host+ - the application server host (default +localhost+)
+    # * +port+ - the application server port (default +8080+)
+    # * +user+ - the application server login
+    # * +password+ - the application service password
+    # * +path+ or +classpath+ - the application client Java directories
+    # * +database+ - the application database name
+    # * +database_user+ - the application database connection userid
+    # * +database_password+ - the application database connection password
+    # * +database_host+ - the application database connection host (default +localhost+)
+    # * +database_type+ - the application database type, + mysql+ or +oracle+ (default +mysql+)
+    # * +database_driver+ - the application database connection driver (default is the database type default)
+    # * +database_port+ - the application database connection port (default is the database type default)
+    #
+    # The +path+ value is one or more directories separated by a semi-colon(;) or colon (:)
+    # Each path directory and all jar files within the directory are added to the caRuby execution
+    # Java classpath.
+    #
+    # Each property has an environment variable counterpart given by 
+    #
+    # @return [{Symbol => Object}] the caBIG application access properties
+    def access_properties
+      @rsc_props ||= load_access_properties
+    end
+    
+    # Ensures that the application client classpath is defined. The classpath is defined
+    # in the {#access_properties}. This method is called when a module extends this
+    # Domain, before any application Java domain class is imported into JRuby.
+    def ensure_classpath_defined
+      # Loading the access properties on demand sets the classpath.
+      access_properties
+    end
+    
+#    # @param [Class, String] class_or_name the class to import into this module
+#    # @return [Class] the imported {Resource} class
+#    def resource_import(class_or_name)
+#      java_import(class_or_name)
+#      klass = Class.to_ruby(class_or_name)
+#      add_class(klass)
+#      klass
+#    end
+#
+#    # @param [String] the class name to check
+#    # @eturn [Class, nil] the domain class for the class name, or nil if none in this module
+#    def domain_type_with_name(name)
+#      pkg, base = Java.split_class_name(name)
+#      return unless pkg.nil? or pkg == @java_package
+#      begin
+#        type = const_get(base)
+#      rescue JavaImportError => e
+#        # no such domain type; not an error.
+#        # other exceptions indicate that there was a domain type but could not be loaded; these exceptions propagate up the call stack
+#        logger.debug { "#{$!}" }
+#        return
+#      end
+#      type if type < Resource
+#    end
+
+    private
+    
+#    # Adds the given class to this domain module. The class is extended with {Metadata} methods.
+#    #
+#    # @param [Class] the {Resource} class to add
+#    def add_class(klass)
+#      # This domain module's known Resource classes.
+#      @rsc_classes ||= Set.new
+#      # Bail if already added.
+#      return if @rsc_classes.include?(klass)
+#
+#      logger.debug { "Adding #{klass.java_class.name} to #{qp}..." }
+#      # Add metadata to the class. This is done before adding the superclass and
+#      # referenced metadata, since they in turn might reference the current class
+#      # metadata.
+#      Metadata.extend_class(klass, self)
+#      # Add the class to the known Resource class set.
+#      @rsc_classes << klass
+#      
+#      # Make the superclass a Resource, if necessary.
+#      sc = klass.superclass
+#      unless @rsc_classes.include?(sc) then
+#        # the domain module includes the superclass on demand
+#        pkg, sym = Java.split_class_name(sc)
+#        if pkg == @java_package then
+#          # Load the superclass on demand; don't need to make this class a Resource,
+#          # but do need to import the class.
+#          const_get(sym)
+#        else
+#          # Superclass is not a member of the domain package; make this class a Resource.
+#          mod = @mixin
+#          klass.class_eval { include mod }
+#        end
+#      end
+#
+#      # Add referenced domain classes as necessary.
+#      klass.each_attribute_metadata do |attr_md|
+#        ref = attr_md.type
+#        next if @rsc_classes.include?(ref)
+#        pkg, sym = Java.split_class_name(ref)
+#        # This domain module adds a referenced Domain class on demand.
+#        if pkg == @java_package then
+#          puts "rm ac1 #{klass} #{attr_md} -> #{ref}..."
+#          logger.debug { "Loading #{klass.qp} #{attr_md} reference #{ref.qp}" }
+#          const_get(sym)
+#        end
+#      end
+#      
+#      # Invoke the callback.
+#      class_added(klass)
+#      logger.debug { "#{klass.java_class.name} added to #{qp}." }
+#      # print the class structure to the log
+#      logger.info(klass.pp_s)
+#    end
+#    
+#    # Callback invoked after the given domain class is added to this domain module.
+#    #
+#    # @param [Class] klass the class that was added
+#    def class_added(klass); end
+   
+    # Loads the application start-up properties in the given file path.
+    #
+    # @return (see #access_properties)
+    def load_access_properties
+      # the properties file
+      file = default_properties_file
+      # the access properties
+      props = file && File.exists?(file) ? load_properties_file(file) : {}
+      # Look for environment overrides preceded by the uppercase module name,
+      # e.g. CATISSUE_USER for the CaTissue module.
+      load_environment_properties(props)
+      
+      # load the Java application jar path
+      path = props[:classpath] || props[:path]
+      if path then
+        logger.info("Defining application classpath #{path}...")
+        Java.add_path(path)
+      end
+      
+      props
+    end
+    
+    def load_properties_file(file)
+      props = {}
+      logger.info("Loading application properties from #{file}...")
+      File.open(file).map 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
+        name = pname == :path ? :classpath : pname
+        value = tokens.last
+        # capture the property
+        props[name] = value
+      end
+      props
+    end
+    
+    def load_environment_properties(props)
+      ACCESS_OPTS.each do |spec|
+        # the access option symbol is the first specification item
+        opt = spec[0]
+        # the envvar value
+        value = environment_property(opt) || next
+        # override the file property with the envar value
+        props[opt] = value
+        logger.info("Set application property #{opt} from environment variable #{ev}.")
+      end
+    end 
+    
+    # @param [Symbol] opt the property symbol, e.g. :user
+    # @return [String, nil] the value of the corresponding environment variable, e.g. +CATISSUE_USER+
+    def environment_property(opt)
+      @env_prefix ||= name.gsub('::', '_').upcase
+      ev = "#{@env_prefix}_#{opt.to_s.upcase}"
+      value = ENV[ev]
+      # If no classpath envvar, then try the deprecated path envvar.
+      if value.nil? and opt == :classpath then
+        environment_property(:path)
+      else
+        value
+      end
+    end
+#    
+#    # Imports the domain Java class with specified class name_or_sym.
+#    # This method enables the domain class extensions for storing and retrieving domain objects.
+#    # The class is added to this module.
+#    #
+#    # The optional block overrides the native Java property access wrappers.
+#    # For example:
+#    #   ClinicalTrials.java_import Java::edu.wustl.catissuecore.domain.Study do
+#    #     def study_code=(value)
+#    #       value = value.to_s if Integer === value
+#    #       setStudyCode(value)
+#    #     end
+#    #   end
+#    # imports the ClinicalTrials Study class as ClinicalTrials::Study and overrides the
+#    # +study_code+ setter method.
+#    #
+#    # Convenience aliases are added to the imported class, e.g. attribute +studyParticipantCollection+
+#    # is aliased as +study_participants+. Specifically, each attribute reader and writer is aliased with
+#    # the lower-case, underscore equivalent and a name ending in 'Collection' is changed to plural.
+#    # Pluralization is smart, e.g. +studyCollection+ is aliased to +studies+ rather than +studys+.
+#    #
+#    # The optional aliases argument consists of additional alias => standard attribute associations.
+#    # The optional owner_attr argument is a non-Java annotation owner attribute.
+#    #
+#    # @param [Symbol] symbol the class symbol
+#    # @param [String, nil] pkg the Java class package name, or nil for the default module package
+#    # @return [Class] the imported domain class
+#    def import_domain_class(symbol, pkg=nil)
+#      # import the Java class
+#      pkg ||= @java_package
+#      name = [pkg, symbol.to_s].join('.')
+#      logger.debug { "Detecting whether #{symbol} is a #{pkg} Java class..." }
+#      # Push each imported class onto a stack. When all referenced classes are imported,
+#      # each class on the stack is post-initialized and the class structure is printed to
+#      # the log.
+#      @import_stack ||= []
+#      @import_stack.push(symbol)
+#      begin
+#        resource_import(name)
+#      ensure
+#        @import_stack.pop
+#      end
+#      
+#      # the imported Java class is registered as a constant in this module
+#      klass = const_get(symbol)
+#      add_class(klass)
+#      
+#      # if we are back to top of the stack, then print the imported Resources
+#      if symbol == @import_stack.first then
+#        # a referenced class could be imported on demand in the course of printing a referencing class;
+#        # the referenced class is then pushed onto the stack. thus, the stack can grow during the
+#        # course of printing, but each imported class is consumed and printed in the end.
+#        until @import_stack.empty? do
+#          # the class constant
+#          sym = @import_stack.pop
+#          # the imported class
+#          kls = const_get(sym)
+#          # print the class structure to the log
+#          logger.info(kls.pp_s)
+#        end
+#      end
+#      
+#      klass
+#    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("#{home}/.#{name[/\w+$/].downcase}")
+      if File.exists?(file) then
+        file
+      else
+        logger.warn("The default #{name} application property file was not found: #{file}.")
+        nil
+      end
+    end
+  end
+end

data/lib/caruby/import/java.rb

@@ -168,27 +168,21 @@ module Java
     end
 
     class Date
-      # millisecond-to-day conversion factor
-      MILLIS_PER_HR = 60 * 60 * 1000
-      MILLIS_PER_DAY = MILLIS_PER_HR * 24
+      # The millisecond-to-day conversion factor.
+      MILLIS_PER_DAY = (60 * 60 * 1000) * 24
 
       # Converts this Java Date to a Ruby DateTime.
       #
-      # caTissue alert - Bug #165: API CPR create date validation is time zone dependent.
-      # Since Java Date accounts for DST and Ruby DateTime doesn't,
-      # this method makes the DST adjustment by subtracting a compensatory
-      # one-hour DST offset from the Java Date time zone offset and using
-      # that to set the DateTime offset. This ensures that Date
-      # conversion is idempotent, i.e.
-      #   date.to_ruby_date().to_java_date == date
+      # @quirk caTissue Bug #165: API CPR create date validation is time zone dependent.
+      #   Since Java Date accounts for DST and Ruby DateTime doesn't, this method makes the
+      #   DST adjustment by subtracting a compensatory one-hour DST offset from the
+      #   Java Date time zone offset and using that to set the DateTime offset.
+      #   This ensures that Date conversion is idempotent, i.e.
+      #     date.to_ruby_date().to_java_date == date
       #
-      # However, there can be adverse consequences for an application that assumes
-      # that the client time zone is the same as the server time zone, as described
-      # in caTissue Bug #165.
-      #
-      # TODO: Revisit {CaRuby::Resource.value_equal?} which must resort to a 
-      # date-as-string comparison, always a bad idea. If that can be fixed, then
-      # increment/decrement the hour field rather than the offset field.
+      #   However, there can be adverse consequences for an application that assumes that the
+      #   client time zone is the same as the server time zone, as described in caTissue
+      #   Bug #165.
       #
       # @return [DateTime] the Ruby date
       def to_ruby_date
@@ -199,9 +193,13 @@ module Java
         time = Time.at(secs)
         # convert UTC timezone millisecond offset to Rational fraction of a day
         offset_millis = calendar.timeZone.getOffset(calendar.timeInMillis).to_f
-        offset_days = offset_millis / MILLIS_PER_DAY
-        offset_fraction = 1 / offset_days
-        offset = Rational(1, offset_fraction)
+        if offset_millis.zero? then
+          offset = 0
+        else
+          offset_days = offset_millis / MILLIS_PER_DAY
+          offset_fraction = 1 / offset_days
+          offset = Rational(1, offset_fraction)
+        end
         # convert to DateTime
         DateTime.civil(time.year, time.mon, time.day, time.hour, time.min, time.sec, offset)
       end
@@ -261,9 +259,13 @@ class Class
     method_defined?(:java_class)
   end
 
-  # Returns a Ruby class for the given klass. If klass is already a Ruby Class, then returns klass.
-  # If klass is a String, then returns the Ruby wrapper class for the corresponding Java class name.
-  # Otherwise, this method returns the Ruby class for the name of the presumed Java klass.
+  # Returns the Ruby class for the given class, as follows:
+  # * If the given class is already a Ruby class, then return the class.
+  # * If the class argument is a Java class or a Java class name, then
+  #   the Ruby class is the JRuby wrapper for the Java class.
+  #
+  # @param [Class, String] the class or class name
+  # @return [Class] the corresponding Ruby class
   def self.to_ruby(klass)
     case klass
       when Class then klass
@@ -347,10 +349,12 @@ class Class
     newsym
   end
 
-  # Returns the property descriptor pd introspected or discovered Java read Method.
+  # @quirk caCORE java.lang.Boolean is<name> is not introspected as a read method, since the type
+  # must be primitive, i.e. `boolean is`<name>.
+  #
+  # @return [Symbol] the property descriptor pd introspected or discovered Java read Method
   def property_read_method(pd)
     return pd.read_method if pd.read_method
-    # caCORE alert - java.lang.Boolean is<name> is not introspected as a read method, since type must be primitive boolean is<name>
     return unless pd.get_property_type == Java::JavaLang::Boolean.java_class
     rdr = java_class.java_method("is#{pd.name.capitalize_first}") rescue nil
     logger.debug { "Discovered #{qp} #{pd.name} property non-introspected reader method #{rdr.name}." } if rdr

data/lib/caruby/migration/migratable.rb

@@ -64,7 +64,7 @@ module CaRuby
   #    collection attributes mentioned above, or to fill in missing values.
   #
   #    Note that there is an extensive set of attribute defaults defined in
-  #    the CaRuby::ResourceMetadata application domain classes. These defaults
+  #    the CaRuby::Metadata application domain classes. These defaults
   #    are applied in a migration database save action and need not be set in
   #    a migration shim. For example, if an acceptable default for a +Study+
   #    +active?+ flag is defined in the +Study+ meta-data, then the flag does not
@@ -102,8 +102,8 @@ module CaRuby
     # for the _attribute_ to modify.
     #
     # The migratable reference attributes consist of the non-collection
-    # {ResourceAttributes#saved_independent_attributes} and 
-    # {ResourceAttributes#unidirectional_dependent_attributes} which don't already have a value.
+    # {Attributes#saved_independent_attributes} and 
+    # {Attributes#unidirectional_dependent_attributes} which don't already have a value.
     # For each such migratable attribute, if there is a single instance of the attribute
     # type in the given migrated domain objects, then the attribute is set to that
     # migrated instance.
@@ -146,7 +146,7 @@ module CaRuby
       end
     end
     
-    # @param [AttributeMetadata::Filter] the attributes to set
+    # @param [Attribute::Filter] the attributes to set
     # @param row (see #migrate_references)
     # @param migrated (see #migrate_references)
     # @param mth_hash (see #migrate_references)
@@ -168,7 +168,7 @@ module CaRuby
       end
     end
     
-    # @param [AttributeMetadata] attr_md the reference attribute
+    # @param [Attribute] attr_md the reference attribute
     # @param row (see #migrate_references)
     # @param migrated (see #migrate_references)
     # @param mth_hash (see #migrate_references)

data/lib/caruby/migration/migrator.rb

@@ -38,6 +38,7 @@ module CaRuby
     # @option opts [String] :bad optional invalid record file
     # @option opts [Integer] :offset zero-based starting source record number to process (default 0)
     # @option opts [Boolean] :quiet suppress output messages
+    # @option opts [Boolean] :verbose print progress
     def initialize(opts)
       @rec_cnt = 0
       parse_options(opts)
@@ -120,7 +121,7 @@ module CaRuby
       @create = opts[:create]
       logger.info("Migration options: #{printable_options(opts).pp_s}.")
       # flag indicating whether to print a progress monitor
-      @print_progress = !opts[:quiet]
+      @print_progress = opts[:verbose]
     end
     
     def printable_options(opts)
@@ -209,7 +210,7 @@ module CaRuby
     def add_owners(klass)
       klass.owners.each do |owner|
         next if @cls_paths_hash.detect_key { |other| other <= owner } or owner.abstract?
-        logger.debug { "Migrator adding #{klass.qp} owner #{owner.qp}" }
+        logger.debug { "Migrator adding #{klass.qp} owner #{owner}" }
         @cls_paths_hash[owner] = Array::EMPTY_ARRAY
         add_owners(owner)
       end
@@ -297,7 +298,7 @@ module CaRuby
       attr_mds.each do |attr_md|
         # the attribute migration method
         mth = attr_mth_hash[attr_md.to_sym]
-        # associate the AttributeMetadata => method
+        # associate the Attribute => method
         @attr_md_mgt_mth_map[attr_md] ||= mth if mth
       end
       @mgt_mth_hash[klass] = attr_mth_hash
@@ -319,7 +320,9 @@ module CaRuby
     end
 
     # Migrates all rows in the input.
-    # The required block to this method is described in {#migrate}.
+    #
+    # @yield (see #migrate)
+    # @yieldparam (see #migrate)
     def migrate_rows # :yields: target
       # open an CSV output for bad records if the option is set
       if @bad_rec_file then
@@ -357,8 +360,7 @@ module CaRuby
           # clear the migration state
           clear(target)
        else
-          # If there is a bad file then warn, reject and continue.
-          # Otherwise, bail.
+          # If there is a bad file then warn, reject and continue. Otherwise, bail.
           if @bad_rec_file then
             logger.warn("Migration not performed on record #{rec_no}.")
             @loader.reject(row)
@@ -366,16 +368,18 @@ module CaRuby
             raise MigrationError.new("Migration not performed on record #{rec_no}")
           end
         end
+        # Bump the record count.
         @rec_cnt += 1
       end
       logger.info("Migrated #{mgt_cnt} of #{@rec_cnt} records.")
     end
     
-    # Prints a +\++ progress indicator to stdout.
+    # Prints a +\++ progress indicator to stdout if the count parameter is divisible by ten.
     #
     # @param [Integer] count the progress step count
     def print_progress(count)
-      if count % 72 == 0 then puts "+" else print "+" end
+      if count % 720 then puts end
+      if count % 10 == 0 then puts "+" else print "+" end
     end
 
     # Clears references to objects allocated for migration of a single row into the given target.
@@ -481,7 +485,7 @@ module CaRuby
       end
     end
 
-    # Fills the given reference AttributeMetadata path starting at obj.
+    # Fills the given reference Attribute path starting at obj.
     #
     # @param row (see #create)
     # @param created (see #create)
@@ -497,7 +501,7 @@ module CaRuby
     # Sets the given migrated object's reference attribute to a new referenced domain object.
     #
     # @param [Resource] obj the domain object being migrated
-    # @param [AttributeMetadata] attr_md the attribute being migrated
+    # @param [Attribute] attr_md the attribute being migrated
     # @param row (see #create)
     # @param created (see #create)
     # @return the new object
@@ -513,7 +517,7 @@ module CaRuby
       ref
     end
 
-    # Sets the obj migratable AttributeMetadata attr_md to value from the given input row.
+    # Sets the obj migratable Attribute attr_md to value from the given input row.
     def migrate_attribute(obj, attr_md, value, row)
       # a single value can be used for both a Numeric and a String attribute; coerce the value if necessary
       # if there is a shim migrate_<attribute> method, then call it on the input value
@@ -554,7 +558,7 @@ module CaRuby
     end
 
     # @param [String] file the migration fields configuration file
-    # @return [{Class => {AttributeMetadata => Symbol}}] the class => path => header hash
+    # @return [{Class => {Attribute => Symbol}}] the class => path => header hash
     #   loaded from the configuration file
     def load_field_map(file)
       # load the field mapping config file
@@ -621,7 +625,7 @@ module CaRuby
     end
 
     # @param [String] path_s a period-delimited path string path_s in the form _class_(._attribute_)+
-    # @return [<AttributeMetadata>] the corresponding attribute metadata path
+    # @return [<Attribute>] the corresponding attribute metadata path
     # @raise [MigrationError] if the path string is malformed or an attribute is not found
     def create_attribute_path(path_s)
       names = path_s.split('.')
@@ -632,7 +636,7 @@ module CaRuby
       if names.empty? then
         raise MigrationError.new("Attribute entry in migration configuration is not in <class>.<attribute> format: #{value}")
       end
-      # build the AttributeMetadata path
+      # build the Attribute path
       path = []
       names.inject(klass) do |parent, name|
         attr = name.to_sym
@@ -647,7 +651,7 @@ module CaRuby
         path << attr_md
         attr_md.type
       end
-      # return the starting class and AttributeMetadata path.
+      # return the starting class and Attribute path.
       # note that the starting class is not necessarily the first path attribute declarer, since the
       # starting class could be the concrete target class rather than an abstract declarer. this is
       # important, since the class must be instantiated.

data/lib/caruby/migration/resource_module.rb

@@ -1,5 +1,5 @@
 module CaRuby
-  module ResourceModule
+  module Domain
     # Declares the given classes which will be dynamically modified for migration.
     # The Java caBIG classes are auto-loaded and wrapped as a CaRuby::Resource, if necessary, and enhanced in the migration shim.
     def shims(*classes)