caruby-core 1.4.4 → 1.4.5

data/History.txt

@@ -18,6 +18,8 @@
 
 * Merge nondomain collection value properly.
 
+=== 1.4.5 / 2011-02-26
 
+* Fix default option
 
 

data/README.md

@@ -6,8 +6,6 @@ caRuby: Simplifying caBIG(TM)
 **Author**:       OHSU Knight Cancer Institute    
 **Copyright**:    2010, 2011    
 **License**:      MIT License    
-**Latest Version**: 1.4.1   
-**Release Date**: February 25th 2011    
 
 Synopsis
 --------

data/lib/caruby/migration/migrator.rb

@@ -129,7 +129,7 @@ module CaRuby
       # 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) : {}
+      @def_hash = @def_file ? load_defaults(@def_file) : LazyHash.new { Hash.new }
       # create the class => paths hash
       @cls_paths_hash = create_class_paths_hash(fld_map, @def_hash)
       # create the path => class => header hash

data/lib/caruby/version.rb

@@ -1,3 +1,3 @@
 module CaRuby
-  VERSION = "1.4.4"
+  VERSION = "1.4.5"
 end

data/test/lib/caruby/csv/csv_mapper_test.rb

@@ -0,0 +1,40 @@
+$:.unshift 'lib'
+$:.unshift 'examples/clinical_trials/lib'
+
+require 'set'
+require "test/unit"
+require 'caruby/csv/csv_mapper'
+
+require 'caruby/util/log' and
+CaRuby::Log.instance.open('test/results/log/csv.log', :shift_age => 10, :shift_size => 1048576, :debug => true)
+
+require 'clinical_trials'
+
+class CsvMapperTest < Test::Unit::TestCase
+  FIXTURES = File.join('test', 'fixtures', 'caruby', 'csv')
+
+  CONFIG_DIR = File.join(FIXTURES, 'config')
+
+  DATA_DIR = File.join(FIXTURES, 'data')
+
+  def test_read_mapper
+    config = File.join(CONFIG_DIR, 'study_fields.yaml')
+    csv = File.join(DATA_DIR, 'study.csv')
+    mapper = CaRuby::CsvMapper.new(config, ClinicalTrials::StudyEvent, csv)
+    assert_equal([ClinicalTrials::StudyEvent], mapper.classes, "Classes incorrect")
+    map = {[:calendar_event_point]=>:event_point, [:identifier]=>:id, [:study, :activity_status]=>:status, [:study, :name]=>:study}
+    paths = map.keys.to_set
+    path_md_sym_hash = mapper.paths(ClinicalTrials::StudyEvent).to_compact_hash { |path| path.map { |attr_md| attr_md.to_sym } }
+    assert_equal(paths, path_md_sym_hash.values.to_set, "Paths incorrect")
+    path_md_hdr_hash = mapper.paths.to_compact_hash { |path| mapper.header(path) }
+    actual = path_md_sym_hash.invert.join(path_md_hdr_hash).to_hash
+    assert_equal(map, actual, "Header map incorrect")
+  end
+
+  def test_write_mapper
+    config = File.join(CONFIG_DIR, 'study_fields.yaml')
+    csv = File.join(DATA_DIR, 'dummy.csv')
+    headers = ['Id', 'Study', 'Status', 'Event Point']
+    mapper = CaRuby::CsvMapper.new(config, ClinicalTrials::StudyEvent, csv, :mode => 'w', :headers => headers)
+  end
+end

data/test/lib/caruby/csv/csvio_test.rb

@@ -0,0 +1,69 @@
+$:.unshift 'lib'
+
+require "test/unit"
+require 'ftools'
+require 'date'
+require 'caruby/csv/csvio'
+require 'caruby/util/log'
+require 'caruby/util/file_separator'
+
+class CsvIOTest < Test::Unit::TestCase
+  FIXTURES_DIR = File.join('test', 'fixtures', 'caruby', 'csv', 'data')
+  OUTPUT_DIR = File.join('test', 'results', 'caruby', 'csv')
+  LOG_FILE = File.join('test', 'results', 'log', 'csv.log')
+
+  def setup
+    CaRuby::Log.instance.open(LOG_FILE, :debug => true)
+    File.makedirs(OUTPUT_DIR)
+  end
+
+  def test_read
+    loader = CsvIO.new(File.join(FIXTURES_DIR, 'variety.csv'))
+    loader.each do |row|
+      assert_not_nil(row[:id], "Missing id")
+      assert_not_nil(row[:string_field], "Missing string_field")
+      assert_not_nil(row[:integer], "Missing integer method")
+      assert(Integer === row[:integer], "Incorrect integer field value type")
+      assert_not_nil(row[:float], "Missing float method")
+      assert(Float === row[:float], "Incorrect float field value type")
+      assert_not_nil(row[:date], "Missing date method")
+      assert_equal(Date, row[:date].class, "Incorrect date field value type")
+    end
+  end
+
+  def test_empty
+    loader = CsvIO.new(File.join(FIXTURES_DIR, 'empty.csv'))
+    row = loader.shift
+    assert_nil(row[:one], "Missing value not nil")
+    assert_nil(row[:two], "Missing value not nil")
+  end
+
+  def test_accessor
+    loader = CsvIO.new(File.join(FIXTURES_DIR, 'variety.csv'))
+    assert_equal(:id, loader.accessor('Id'), "Accessor incorrect")
+    assert_equal(:string_field, loader.accessor('String Field'), "Accessor incorrect")
+  end
+
+  def test_write
+    input = File.join(FIXTURES_DIR, 'variety.csv')
+    output = File.join(OUTPUT_DIR, 'variety.csv')
+    headers = records = nil
+    # Read the input file content.
+    File.open(input) do |file|
+      headers = file.readline.chomp.split(/,\s*/)
+      records = file.map { |line| line.chomp.split(/,\s*/) }
+    end
+    # Write the output file.
+    CsvIO.open(output, :mode => 'w', :headers => headers) do |csvio|
+      records.each { |rec| csvio << rec }
+    end
+    # Compare the output to the input.
+    File.open(output) do |file|
+      assert_equal(headers, file.readline.chomp.split(/,\s*/), "Headers don't match")
+      file.each_with_index do |line, i|
+        rec = line.chomp.split(/,\s*/)
+        assert_equal(records[i], rec, "Line #{i.succ} doesn't match")
+      end
+    end
+  end
+end

data/test/lib/caruby/database/persistable_test.rb

@@ -0,0 +1,92 @@
+$:.unshift 'lib'
+$:.unshift 'examples/clinical_trials/lib'
+
+require 'test/unit'
+
+require 'caruby/util/log' and
+CaRuby::Log.instance.open('test/results/log/clinical_trials.log', :shift_age => 10, :shift_size => 1048576, :debug => true)
+
+require 'clinical_trials'
+
+class PersistableTest < Test::Unit::TestCase
+
+  def setup
+    @coord = ClinicalTrials::User.new(:login => 'study.coordinator@test.org')
+    address = ClinicalTrials::Address.new(:street => '555 Elm St', :city => 'Burlington', :state => 'VT', :zip_code => '55555')
+    @pnt = ClinicalTrials::Participant.new(:name => 'Test Participant')
+    @study = ClinicalTrials::Study.new(:name => 'Test Study')
+    @evt = ClinicalTrials::StudyEvent.new(:calendar_event_point => 1.0)
+    @consent = ClinicalTrials::Consent.new(:statement => 'Test statement')
+    @loader = lambda { |obj, attr| load(obj, attr) }
+    @@counter = 0
+    @study.identifier = @@counter += 1
+    @study.add_lazy_loader(@loader)
+    @references = {
+      @study => {:coordinator => @coord, :enrollment => [@pnt], :study_events => [@evt], :consents => [@consent]},
+      @pnt => {:address => address}
+    }
+  end
+
+  def test_independent_reference
+    assert_not_nil(@study.coordinator, "Independent reference not loaded")
+    assert_not_nil(@study.coordinator.identifier, "Independent reference loaded but identifier not set")
+  end
+
+  def test_dependent_reference
+    assert_not_nil(@study.events.first, "Dependent events reference not loaded")
+    assert_not_nil(@study.events.first.identifier, "Dependent events reference loaded but identifier not set")
+  end
+
+  def test_unidirectional_dependent
+    assert_nil(@study.consents.first, "Unidirectional dependent consents reference incorrectly loaded")
+    # explicitly set the consents loader
+    @study.remove_lazy_loader
+    @study.add_lazy_loader(@loader)
+    # verify the load merge
+    assert_not_nil(@study.consents.first, "Dependent consents reference not loaded")
+    assert_not_nil(@study.consents.first.identifier, "Dependent consents reference loaded but identifier not set")
+  end
+
+  def test_unidirectional_dependent_merge
+    # explicitly set the consents loader
+    @study.remove_lazy_loader
+    @study.add_lazy_loader(@loader)
+    # verify the load merge
+    assert_equal(1, @study.consents.size, "Unambiguous dependent consent not merged")
+    assert_not_nil(@study.consents.first.identifier, "Dependent consents reference loaded but identifier not set")
+  end
+
+  def test_unidirectional_dependent_ambiguous_merge
+    # add the consent
+    @study.consents << @consent
+    # make an ambiguous "persistent" consent
+    @references[@study][:consents] << @consent.copy
+    # explicitly set the consents loader
+    @study.remove_lazy_loader
+    @study.add_lazy_loader(@loader)
+    # verify the load merge
+    assert_equal(3, @study.consents.size, "Ambiguous dependent consent not added")
+    assert_nil(@consent.identifier, "Consent identifier incorrectly merged from ambiguous dependent consent")
+  end
+
+  # Verifies that the loader is disabled when an attribute is set.
+  def test_setter_disable
+    @study.coordinator = @coord
+    assert_nil(@study.coordinator.identifier, "Independent reference loaded after set")
+  end
+  
+  private
+
+  def load(obj, attribute)
+    value = @references[obj][attribute]
+    raise ArgumentError.new("Value not found for #{attribute}: #{obj}") if value.nil?
+    duplicate_with_id(value)
+  end
+
+  def duplicate_with_id(obj)
+    return obj.map { |item| duplicate_with_id(item) } if Enumerable === obj
+    copy = obj.copy(obj.class.nondomain_attributes)
+    copy.identifier ||= @@counter += 1
+    copy
+  end
+end

data/test/lib/caruby/domain/domain_test.rb

@@ -0,0 +1,126 @@
+$:.unshift 'lib'
+$:.unshift 'examples/clinical_trials/lib'
+
+require 'test/unit'
+
+# open the logger
+require 'caruby/util/log'
+CaRuby::Log.instance.open('test/results/log/clinical_trials.log', :shift_age => 10, :shift_size => 1048576, :debug => true)
+
+require 'clinical_trials'
+
+# CaRuby::Resource test cases.
+class DomainTest < Test::Unit::TestCase
+  def setup
+    super
+    @crd = ClinicalTrials::User.new(:login => 'study.coordinator@test.org')
+    address = ClinicalTrials::Address.new(:street => '555 Elm St', :city => 'Burlington', :state => 'VT', :zip_code => '55555')
+    @pnt = ClinicalTrials::Participant.new(:name => 'Test Participant', :address => address)
+    @study = ClinicalTrials::Study.new(:name => 'Test Study', :coordinator => @crd, :enrollment => [@pnt])
+    @evt = ClinicalTrials::StudyEvent.new(:study => @study, :calendar_event_point => 1.0)
+  end
+
+  def test_alias
+    assert(ClinicalTrials::Study.method_defined?(:events), "Study alias not recognized: events")
+    assert_equal(@pnt.address.zip_code, @pnt.address.postal_code, 'zip_code not aliased to postal_code')
+    assert_equal(:zip_code, @pnt.address.class.standard_attribute(:postal_code), 'postal_code does not map to a standard attribute symbol')
+  end
+
+  def test_redefine
+    @pnt.address.zip_code = 55555
+    assert_equal('55555', @pnt.address.zip_code, "Address zip_code not redefined to support a numeric value")
+  end
+
+  def test_merge_attributes
+    assert_same(@study.enrollment.first, @pnt, "Merge incorrect")
+  end
+
+  def test_merge_unambiguous_dependent_collection_attribute
+    @study.enrollment.clear
+    assert_same(@study.enrollment, @study.merge_attribute(:enrollment, [@pnt]), "Merge collection attribute result incorrect")
+    assert_not_nil(@study.enrollment.first, "Merge collection attribute didn't add source item")
+    assert_same(@study.enrollment.first, @pnt, "Merge collection attribute incorrect")
+  end
+
+  def test_merge_ambiguous_dependent_collection_attribute
+    @study.enrollment.clear
+    assert_same(@study.enrollment, @study.merge_attribute(:enrollment, [@pnt]), "Merge collection attribute result incorrect")
+    assert_not_nil(@study.enrollment.first, "Merge collection attribute didn't add source item")
+    assert_same(@study.enrollment.first, @pnt, "Merge collection attribute incorrect")
+  end
+
+  def test_owner_inverse_setter
+    assert_equal([@evt], @study.events.to_a, 'Event not added to owner events')
+    # add another event
+    # note: calendar_event_point must be unique within the study or it won't be added to the study events set
+    @evt.calendar_event_point = 1.0
+    ClinicalTrials::StudyEvent.new(:study => @study, :calendar_event_point => 2.0)
+    assert_equal(2, @study.events.to_a.size, 'Second event not added to owner events')
+  end
+
+  def test_study_defaults
+    assert_nil(@study.activity_status, 'Activity status is already set')
+    @study.add_defaults
+    assert_equal('Active', @study.activity_status, 'Activity status is not set to default')
+  end
+
+  def test_event_defaults
+    @evt.calendar_event_point = nil
+    @evt.add_defaults
+    assert_equal(1.0, @evt.calendar_event_point, 'Event calendar_event_point is not set to default')
+  end
+
+  # Tests whether add_defaults method propagates to dependents.
+  def test_participant_defaults
+    assert_nil(@pnt.address.country, 'Participant address country is already set')
+    @pnt.add_defaults
+    assert_equal('US', @pnt.address.country, 'Participant address country is not set to default')
+  end
+
+  def test_dependents
+    assert_equal([@evt], @study.dependents.to_a, "Study dependents incorrect")
+    assert(@evt.dependent?, "Event not dependent")
+  end
+
+  def test_searchable_attributes
+    assert_equal([:name], @study.searchable_attributes.to_a, "Study finder attributes without identifier incorrect")
+  end
+
+  def test_event_key
+    @evt.calendar_event_point = 1.0
+    assert_equal([@study, 1.0], @evt.key, "Event key incorrect")
+  end
+
+#  def test_address_key
+#    assert_nil(@pnt.address.key, "Address key incorrect")
+#  end
+
+  def test_set_collection_attribute
+    consent = ClinicalTrials::Consent.new(:statement => 'Test Statement 1')
+    consents = @study.consents << consent
+    other_consent = ClinicalTrials::Consent.new(:statement => 'Test Statement 2')
+    @study.set_attribute(:consents, [other_consent])
+    assert_equal([other_consent], @study.consents.to_a, "Consents not set")
+    assert_same(consents, @study.consents)
+  end
+
+  def test_value_hash
+    assert_equal({:study => @study}, @evt.value_hash([:identifier, :study]), "Event value hash incorrect")
+  end
+
+  def test_reference_closure
+    assert_equal([@study, @evt], @study.reference_hierarchy { |ref| ref.class.dependent_attributes }.to_a, "Reference closure with block incorrect")
+  end
+
+  def test_visit_path
+    visited = []
+    @study.visit_path([:enrollment, :address]) { |ref| visited << ref }
+    assert_equal([@study, @pnt, @pnt.address], visited, "Path visitor incorrect")
+  end
+
+  def test_visit_dependents
+    visited = []
+    @study.visit_dependents { |ref| visited << ref }
+    assert_equal([@study, @evt], visited, "Dependents visitor incorrect")
+  end
+end

data/test/lib/caruby/domain/inversible_test.rb

@@ -0,0 +1,99 @@
+$:.unshift 'lib'
+
+require 'caruby'
+require "test/unit"
+
+class InversibleTest < Test::Unit::TestCase
+  module Domain
+    extend CaRuby::ResourceModule
+  end
+  
+  module Resource
+    include CaRuby::Resource
+    attr_accessor :identifier
+  end
+  
+  class Person; end
+  
+  class Account
+    include Resource
+    Domain.add_class(self)
+    
+    attr_accessor :person
+    add_attribute(:person, Person)
+  end
+  
+  class Person
+    include Resource
+    Domain.add_class(self)
+    
+    attr_accessor :spouse
+    add_attribute(:spouse, Person)
+    
+    set_attribute_inverse(:spouse, :spouse)
+    
+    attr_accessor :account
+    add_attribute(:account, Account)
+    
+    set_attribute_inverse(:account, :person)
+  end
+  
+  class Child; end
+  
+  class Parent
+    include Resource
+    Domain.add_class(self)
+    
+    attr_accessor :children
+    add_attribute(:children, Child, :collection)
+  end
+  
+  class Child
+    include Resource
+    Domain.add_class(self)
+    
+    attr_accessor :parent
+    add_attribute(:parent, Parent)
+    
+    set_attribute_inverse(:parent, :children)
+  end
+
+  def test_1_1
+    p1 = Person.new
+    a1 = Account.new
+    p1.account = a1
+    assert_same(p1, a1.person, "1:1 inverse not set")
+    a2 = Account.new
+    p1.account = a2
+    assert_same(p1, a2.person, "1:1 inverse not set")
+    assert_nil(a1.person, "1:1 previous inverse not cleared")
+    p1.account = nil
+    assert_nil(a2.person, "1:1 previous inverse not cleared")
+  end
+  
+  def test_1_1_same
+    p1 = Person.new
+    p2 = Person.new
+    p1.spouse = p2
+    assert_same(p1, p2.spouse, "1:1 inverse not set")
+    p3 = Person.new
+    p1.spouse = p3
+    assert_same(p3, p1.spouse, "1:1 inverse not set")
+    assert_nil(p2.spouse, "1:1 previous inverse not cleared")
+    p1.spouse = nil
+    assert_nil(p3.spouse, "1:1 previous inverse not cleared")
+  end
+
+  def test_1_m
+    p1 = Parent.new
+    c = Child.new
+    c.parent = p1
+    assert_same(c, p1.children.first, "1:M inverse not set")
+    p2 = Parent.new
+    c.parent = p2
+    assert_same(c, p2.children.first, "1:M inverse not set")
+    assert(p1.children.empty?, "1:M previous inverse not cleared")
+    c.parent = nil
+    assert(p2.children.empty?, "1:M previous inverse not cleared")
+  end
+end