caruby-core 1.4.7 → 1.4.9

data/lib/caruby/import/java.rb

@@ -8,17 +8,30 @@ require 'ftools'
 require 'date'
 
 require 'caruby/util/class'
+require 'caruby/util/log'
 require 'caruby/util/inflector'
 require 'caruby/util/collection'
 
 module Java
+  private
+  
+  # The Windows semi-colon path separator.
+  WINDOWS_PATH_SEP = ';'
+  
+  # The Unix colon path separator.
+  UNIX_PATH_SEP = ':'
+  
+  public
+  
   # Adds the directories in the given path and all Java jar files contained in the directories
   # to the execution classpath.
   #
   # @param [String] path the colon or semi-colon separated directories
   def self.add_path(path)
+    # the path separator
+    sep = path[WINDOWS_PATH_SEP] ? WINDOWS_PATH_SEP : UNIX_PATH_SEP
     # the path directories
-    dirs = path.split(/[:;]/).map { |dir| File.expand_path(dir) }
+    dirs = path.split(sep).map { |dir| File.expand_path(dir) }
     # Add all jars found anywhere within the directories to the the classpath.
     add_jars(*dirs)
     # Add the directories to the the classpath.
@@ -38,6 +51,10 @@ module Java
   #
   # @param [String] file the jar file or directory to add
   def self.add_to_classpath(file)
+    unless File.exist?(file) then
+      logger.warn("File to place on Java classpath does not exist: #{file}")
+      return
+    end
     if file =~ /.jar$/ then
       # require is preferred to classpath append for a jar file
       require file
@@ -182,10 +199,6 @@ 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
-        # adjust for DST
-        if calendar.timeZone.useDaylightTime and time.isdst then
-          offset_millis -= MILLIS_PER_HR
-        end
         offset_days = offset_millis / MILLIS_PER_DAY
         offset_fraction = 1 / offset_days
         offset = Rational(1, offset_fraction)
@@ -206,15 +219,19 @@ module Java
           hour = min = sec = 0
         end
         # the Ruby time
-        time = Time.mktime(date.year, date.mon, date.day, hour, min, sec)
+        rtime = Time.local(sec, min, hour, date.day, date.mon, date.year, nil, nil, nil, nil)
         # millis since epoch
-        millis = (time.to_f * 1000).truncate
+        millis = (rtime.to_f * 1000).truncate
         # the Java date factory
         calendar = java.util.Calendar.instance
-        # adjust for DST
-        if calendar.timeZone.useDaylightTime and Time.at(time).isdst then
-          millis += MILLIS_PER_HR
-        end
+        calendar.setTimeInMillis(millis)
+        jtime = calendar.getTime
+        # the daylight time flag
+        isdt = calendar.timeZone.inDaylightTime(jtime)
+        return jtime unless isdt
+        # adjust the Ruby time for DST
+        rtime = Time.local(sec, min, hour, date.day, date.mon, date.year, nil, nil, isdt, nil)
+        millis = (rtime.to_f * 1000).truncate
         calendar.setTimeInMillis(millis)
         calendar.getTime
       end
@@ -224,15 +241,18 @@ module Java
   def self.now
     JavaUtil::Date.from_ruby_date(DateTime.now)
   end
-
-  # Returns the Java package name for the full class_name, or nil if
-  # class_name is unqualified.
-  def self.java_package_name(class_name)
-    prefix = class_name[/(\w+\.)+/]
-    # remove the trailing period
-    prefix.chop! if prefix
-    prefix
+  
+  # @param [Class, String] the JRuby class or the full Java class name
+  # @return (String, String] the package and base for the given name
+  def self.split_class_name(name_or_class)
+    name = Class === name_or_class ? name_or_class.java_class.name : name_or_class
+    match = NAME_SPLITTER_REGEX.match(name)
+    match ? match.captures : [nil, name]
   end
+  
+  private
+  
+  NAME_SPLITTER_REGEX = /^([\w.]+)\.(\w+)$/
 end
 
 class Class

data/lib/caruby/migration/migratable.rb

@@ -118,28 +118,52 @@ module CaRuby
     # @param [{Symbol => String}] mth_hash a hash that associates this domain object's
     #   attributes to migration method names
     def migrate_references(row, migrated, mth_hash=nil)
-      migratable__set_references(self.class.saved_independent_attributes, row, migrated, mth_hash)
-      migratable__set_references(self.class.unidirectional_dependent_attributes, row, migrated, mth_hash)
+      # migrate the owner
+      migratable__migrate_owner(row, migrated, mth_hash)
+      # migrate the remaining attributes
+      migratable__set_nonowner_references(self.class.saved_independent_attributes, row, migrated, mth_hash)
+      migratable__set_nonowner_references(self.class.unidirectional_dependent_attributes, row, migrated, mth_hash)
     end
     
     private
     
+    # Migrates the owner, if there is a unique owner in the migrated set.
+    #
+    # @param row (see #migrate_references)
+    # @param migrated (see #migrate_references)
+    # @param mth_hash (see #migrate_references)
+    def migratable__migrate_owner(row, migrated, mth_hash=nil)
+      # the owner attributes=> migrated reference hash
+      ovh = self.class.owner_attributes.to_compact_hash do |attr|
+        attr_md = self.class.attribute_metadata(attr)
+        migratable__target_value(attr_md, row, migrated, mth_hash=nil)
+      end
+      if ovh.size > 1 then
+        logger.debug { "The migrated dependent #{qp} has ambiguous migrated owner references #{ovh.qp}." }
+      elsif ovh.size == 1 then
+        attr, ref = ovh.first
+        set_attribute(attr, ref)
+      end
+    end
+    
     # @param [AttributeMetadata::Filter] the attributes to set
     # @param row (see #migrate_references)
     # @param migrated (see #migrate_references)
     # @param mth_hash (see #migrate_references)
-     def migratable__set_references(attr_filter, row, migrated, mth_hash=nil)
+    def migratable__set_nonowner_references(attr_filter, row, migrated, mth_hash=nil)
       attr_filter.each_pair do |attr, attr_md|
+        # skip owners
+        next if attr_md.owner?
         # the target value
         ref = migratable__target_value(attr_md, row, migrated, mth_hash) || next
         if attr_md.collection? then
           # the current value
           value = send(attr_md.reader) || next
           value << ref
-          logger.debug { "Added migrated #{ref.qp} to #{qp} #{attribute}." }
+          logger.debug { "Added the migrated #{ref.qp} to #{qp} #{attr}." }
         else
           set_attribute(attr, ref)
-          logger.debug { "Set #{qp} #{attr} to migrated #{ref.qp}." }
+          logger.debug { "Set the #{qp} #{attr} to migrated #{ref.qp}." }
         end
       end
     end
@@ -154,10 +178,11 @@ module CaRuby
       # the migrated references which are instances of the attribute type
       refs = migrated.select { |other| other != self and attr_md.type === other }
       # skip ambiguous references
+      if refs.size > 1 then logger.debug { "Migrator did not set references to ambiguous targets #{refs.pp_s}." } end
       return unless refs.size == 1
       # the single reference
       ref = refs.first
-       # the shim method, if any
+      # the shim method, if any
       mth = mth_hash[attr_md.to_sym] if mth_hash
       # if there is a shim method, then call it
       mth && respond_to?(mth) ? send(mth, ref, row) : ref

data/lib/caruby/migration/migrator.rb

@@ -16,7 +16,6 @@ require 'caruby/util/pretty_print'
 require 'caruby/util/properties'
 require 'caruby/util/collection'
 require 'caruby/migration/migratable'
-require 'caruby/migration/uniquify'
 
 module CaRuby
   class MigrationError < RuntimeError; end
@@ -35,11 +34,12 @@ module CaRuby
     # @option opts [String] :input required source file to migrate
     # @option opts [String] :shims optional array of shim files to load
     # @option opts [String] :unique ensures that migrated objects which include the {Resource::Unique}
-    #   mix-in do not conflict with existing or future objects (used for testing) 
+    # @option opts [String] :create optional flag indicating that existing target objects are ignored
     # @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
     def initialize(opts)
+      @rec_cnt = 0
       parse_options(opts)
       build
     end
@@ -49,6 +49,9 @@ module CaRuby
     # If a block is given to this method, then the block is called on each stored
     # migration target object.
     #
+    # If the +:create+ option is set, then an input record for a target object which already
+    # exists in the database is noted in a debug log message and ignored rather than updated.
+    #
     # @yield [target] operation performed on the migration target
     # @yieldparam [Resource] target the migrated target domain object
     def migrate_to_database(&block)
@@ -75,6 +78,9 @@ module CaRuby
 
     # Class {#migrate} with a {#save} block.
     def execute_save
+      if @database.nil? then
+        raise MigrationError.new("Migrator cannot save records since the database option was not specified.")
+      end
       @database.open do |db|
         migrate do |target|
           save(target, db)
@@ -108,29 +114,35 @@ module CaRuby
       @input = Options.get(:input, opts)
       raise MigrationError.new("Migrator missing required source file parameter") if @input.nil?
       @database = opts[:database]
-      raise MigrationError.new("Migrator missing required database parameter") if @database.nil?
       @target_class = opts[:target]
       raise MigrationError.new("Migrator missing required target class parameter") if @target_class.nil?
       @bad_rec_file = opts[:bad]
-      logger.info("Migration options: #{opts.reject { |option, value| value.nil_or_empty? }.pp_s}.")
+      @create = opts[:create]
+      logger.info("Migration options: #{printable_options(opts).pp_s}.")
       # flag indicating whether to print a progress monitor
       @print_progress = !opts[:quiet]
     end
+    
+    def printable_options(opts)
+      popts = opts.reject { |option, value| value.nil_or_empty? }
+      # The target class should be a simple class name rather than the class metadata.
+      popts[:target] = popts[:target].qp if popts.has_key?(:target)
+      popts
+    end
 
     def build
       # the current source class => instance map
       raise MigrationError.new("No file to migrate") if @input.nil?
 
       # make a CSV loader which only converts input fields corresponding to non-String attributes
-      logger.info { "Migration input file: #{@input}." }
-      @loader = CsvIO.new(@input) do |value, info|
-        value unless @nonstring_headers.include?(info.header)
-      end
+      logger.info("Migration input file: #{@input}.")
+      @loader = CsvIO.new(@input, &method(:convert))
+      logger.debug { "Migration data input file #{@input} headers: #{@loader.headers.qp}" } 
 
-      # create the class => path => header hash
-      fld_map = load_field_map(@fld_map_file)
       # create the class => path => default value hash
       @def_hash = @def_file ? load_defaults(@def_file) : LazyHash.new { Hash.new }
+      # create the class => path => header hash
+      fld_map = load_field_map(@fld_map_file)
       # create the class => paths hash
       @cls_paths_hash = create_class_paths_hash(fld_map, @def_hash)
       # create the path => class => header hash
@@ -139,6 +151,12 @@ module CaRuby
       @cls_paths_hash.keys.each { |klass| add_owners(klass) }
       # order the creatable classes by dependency, owners first, to smooth the migration process
       @creatable_classes = @cls_paths_hash.keys.sort! { |klass, other| other.depends_on?(klass) ? -1 : (klass.depends_on?(other) ? 1 : 0) }
+      @creatable_classes.each do |klass|
+        if klass.abstract? then
+          raise MigrationError.new("Migrator cannot create the abstract class #{klass}; specify a subclass instead in the mapping file.")
+        end
+      end
+      
       # print the maps
       print_hash = LazyHash.new { Hash.new }
       @cls_paths_hash.each do |klass, paths|
@@ -166,7 +184,27 @@ module CaRuby
         @nonstring_headers.merge!(cls_hdr_hash.values) if attr_md.type != Java::JavaLang::String
       end
     end
-
+    
+    # Converts the given input field value as follows:
+    # * if the info header is a String field, then return the value unchanged
+    # * otherwise, if the value is a case-insensitive match for +true+ or +false+, then convert
+    #   the value to the respective Boolean
+    # * otherwise, return nil which will delegate to the generic CsvIO converter
+    # @param (see CsvIO#convert)
+    # @yield (see CsvIO#convert)
+    def convert(value, info)
+      @nonstring_headers.include?(info.header) ? convert_boolean(value) : value
+    end
+    
+    # @param [String] value the input value
+    # @return [Boolean, nil] the corresponding boolean, or nil if none
+    def convert_boolean(value)
+      case value
+        when /true/i then true
+        when /false/i then false
+      end
+    end
+    
     # Adds missing klass owner classes to the migration class path hash (with empty paths).
     def add_owners(klass)
       klass.owners.each do |owner|
@@ -288,13 +326,13 @@ module CaRuby
         @loader.trash = @bad_rec_file
         logger.info("Unmigrated records will be written to #{File.expand_path(@bad_rec_file)}.")
       end
-      rec_cnt = mgt_cnt = 0
+      @rec_cnt = mgt_cnt = 0
       logger.info { "Migrating #{@input}..." }
       @loader.each do |row|
         # the one-based current record number
-        rec_no = rec_cnt + 1
+        rec_no = @rec_cnt + 1
         # skip if the row precedes the offset option
-        rec_cnt += 1 && next if rec_cnt < @offset
+        @rec_cnt += 1 && next if @rec_cnt < @offset
         begin
           # migrate the row
           logger.debug { "Migrating record #{rec_no}..." }
@@ -328,9 +366,9 @@ module CaRuby
             raise MigrationError.new("Migration not performed on record #{rec_no}")
           end
         end
-        rec_cnt += 1
+        @rec_cnt += 1
       end
-      logger.info("Migrated #{mgt_cnt} of #{rec_cnt} records.")
+      logger.info("Migrated #{mgt_cnt} of #{@rec_cnt} records.")
     end
     
     # Prints a +\++ progress indicator to stdout.
@@ -359,15 +397,29 @@ module CaRuby
       # migrate each object from the input row
       created.each { |obj| obj.migrate(row, migrated) }
       # remove invalid migrations
-      migrated.delete_if { |obj| not migration_valid?(obj) }
+      valid, invalid = migrated.partition { |obj| migration_valid?(obj) }
       # set the references
-      migrated.each { |obj| obj.migrate_references(row, migrated, @mgt_mth_hash[obj.class]) }
+      valid.each { |obj| obj.migrate_references(row, migrated, @mgt_mth_hash[obj.class]) }
       # the target object
-      target = migrated.detect { |obj| @target_class === obj }
-      if target then
-        logger.debug { "Migrated target #{target}." }
-        target
-      end
+      target = valid.detect { |obj| @target_class === obj } || return
+      # the target is invalid if it has an invalid owner
+      return unless owner_valid?(target, valid, invalid)
+      logger.debug { "Migrated target #{target}." }
+      target
+    end
+    
+    # Returns whether the given domain object satisfies at least one of the following conditions:
+    # * it has an owner among the valid objects
+    # * it does not have an owner among the invalid objects
+    #
+    # @param [Resource] obj the domain object to check
+    # @param [<Resource>] valid the valid migrated objects
+    # @param [<Resource>] invalid the invalid migrated objects
+    # @return [Boolean] whether the domain object is valid 
+    def owner_valid?(obj, valid, invalid)
+      otypes = obj.class.owners
+      invalid.all? { |other| not otypes.include?(other.class) } or
+        valid.any? { |other| otypes.include?(other.class) }
     end
 
     # @param [Migratable] obj the migrated object
@@ -391,10 +443,11 @@ module CaRuby
     # @return [Resource] the new instance
     def create(klass, row, created)
       # the new object
+      logger.debug { "Migrator building #{klass.qp}..." }
       created << obj = klass.new
       migrate_attributes(obj, row, created)
       add_defaults(obj, row, created)
-      logger.debug { "Migrator created #{obj}." }
+      logger.debug { "Migrator built #{obj}." }
       obj
     end
     
@@ -441,22 +494,22 @@ module CaRuby
       end
     end
 
-    # Sets the given parent reference AttributeMetadata attr_md attribute to a new domain object.
+    # Sets the given migrated object's reference attribute to a new referenced domain object.
     #
-    # @param [Resource] parent the domain object being migrated
+    # @param [Resource] obj the domain object being migrated
     # @param [AttributeMetadata] attr_md the attribute being migrated
     # @param row (see #create)
     # @param created (see #create)
     # @return the new object
-    def create_reference(parent, attr_md, row, created)
+    def create_reference(obj, attr_md, row, created)
       if attr_md.type.abstract? then
-        raise MigrationError.new("Cannot create #{parent.qp} #{attr_md} with abstract type #{attr_md.type}")
+        raise MigrationError.new("Cannot create #{obj.qp} #{attr_md} with abstract type #{attr_md.type}")
       end
       ref = attr_md.type.new
       ref.migrate(row, Array::EMPTY_ARRAY)
-      parent.send(attr_md.writer, ref)
+      obj.send(attr_md.writer, ref)
       created << ref
-      logger.debug { "Migrator created #{parent.qp} #{attr_md} #{ref}." }
+      logger.debug { "Migrator created #{obj.qp} #{attr_md} #{ref}." }
       ref
     end
 
@@ -472,8 +525,8 @@ module CaRuby
       # set the attribute
       begin
         obj.send(attr_md.writer, value)
-      rescue Exception => e
-        raise MigrationError.new("Could not set #{obj.qp} #{attr_md} to #{value.qp} - #{e}")
+      rescue Exception
+        raise MigrationError.new("Could not set #{obj.qp} #{attr_md} to #{value.qp} - #{$!}")
       end
       logger.debug { "Migrated #{obj.qp} #{attr_md} to #{value}." }
     end
@@ -481,9 +534,23 @@ module CaRuby
     # @param [Resource] obj the domain object to save in the database
     # @return [Resource, nil] obj if the save is successful, nil otherwise
     def save(obj, database)
-      logger.debug { "Migrator saving #{obj}..." }
-      database.save(obj)
-      logger.debug { "Migrator saved #{obj}." }
+      if @create then
+        if database.find(obj) then
+          logger.debug { "Migrator ignored record #{current_record}, since it already exists as #{obj.printable_content(obj.class.secondary_key_attributes)} with id #{obj.identifier}." }
+        else
+          logger.debug { "Migrator creating #{obj}..." }
+          database.create(obj)
+          logger.debug { "Migrator creating #{obj}." }
+        end
+      else
+        logger.debug { "Migrator saving #{obj}..." }
+        database.save(obj)
+        logger.debug { "Migrator saved #{obj}." }
+      end
+    end
+    
+    def current_record
+      @rec_cnt + 1
     end
 
     # @param [String] file the migration fields configuration file
@@ -504,6 +571,7 @@ module CaRuby
         # the header accessor method for the field
         header = @loader.accessor(field)
         raise MigrationError.new("Field defined in migration configuration #{file} not found in input file #{@input} headers: #{field}") if header.nil?
+        # associate each attribute path in the property value with the header
         attr_list.split(/,\s*/).each do |path_s|
           klass, path = create_attribute_path(path_s)
           map[klass][path] = header
@@ -512,6 +580,8 @@ module CaRuby
 
       # include the target class
       map[@target_class] ||= Hash.new
+      # include the default classes
+      @def_hash.each_key { |klass| map[klass] ||= Hash.new }
 
       # add superclass paths into subclass paths
       map.each do |klass, path_hdr_hash|
@@ -524,7 +594,7 @@ module CaRuby
       end
 
       # include only concrete classes
-      classes = map.enum_keys
+      classes = map.keys
       map.delete_if do |klass, paths|
         klass.abstract? or classes.any? { |other| other < klass }
       end
@@ -565,8 +635,15 @@ module CaRuby
       # build the AttributeMetadata path
       path = []
       names.inject(klass) do |parent, name|
-        attr_md = parent.attribute_metadata(name.to_sym) rescue nil
-        raise MigrationError.new("Migration field mapping attribute not found: #{parent.qp}.#{name}") if attr_md.nil?
+        attr = name.to_sym
+        attr_md = begin
+          parent.attribute_metadata(attr)
+        rescue NameError
+          raise MigrationError.new("Migration field mapping attribute #{parent.qp}.#{attr} not found: #{$!}")
+        end
+        if attr_md.collection? then
+          raise MigrationError.new("Migration field mapping attribute #{parent.qp}.#{attr} is a collection, which is not supported")
+        end
         path << attr_md
         attr_md.type
       end
@@ -577,12 +654,21 @@ module CaRuby
       [klass, path]
     end
     
+    # @param [String] name the class name, without the {#context_module}
+    # @return [Class] the corresponding class
     def class_for_name(name)
       # navigate through the scope to the final class
-      name.split('::').inject(@target_class.domain_module) do |scope, cnm|
-        scope.const_get(cnm)
+      name.split('::').inject(context_module) do |ctxt, cnm|
+        ctxt.const_get(cnm)
       end
     end
+    
+    # The context module is given by the target class {ResourceClass#domain_module}.
+    #
+    # @return [Module] the class name resolution context
+    def context_module
+      @target_class.domain_module
+    end
 
     # @return a new class => [paths] hash from the migration fields configuration map
     def create_class_paths_hash(fld_map, def_map)