Class: Lafcadio::DomainObject

Inherits:
Object
  • Object
show all
Includes:
DomainComparable
Defined in:
lib/lafcadio/domain.rb,
lib/lafcadio/test.rb

Overview

)

pk_id and committing

Lafcadio requires that each table has a numeric primary key. It assumes that this key is named pk_id in the database, though that can be overridden.

When you create a domain object by calling DomainObject.new, you should not assign a pk_id to the new instance. The pk_id will automatically be set when you commit the object by calling DomainObject#commit.

However, you may want to manually set pk_id when setting up a test case, so you can ensure that a domain object has a given primary key.

Naming assumptions, and how to override them

By default, Lafcadio assumes that every domain object is indexed by the field pk_id in the database schema. If you’re dealing with a table that uses a different field name, call DomainObject.sql_primary_key_name. However, you will always use pk_id in your Ruby code.

Lafcadio assumes that a domain class corresponds to a table whose name is the pluralized, lower-case, underscored version of the class name. A User class is assumed to be stored in a “users” table, while a ProductCategory class is assumed to be stored in a “product_categories” table. Call DomainObject.table_name to override this behavior.

class LegacyThing < Lafcadio::DomainObject
  string 'some_field'
  sql_primary_key_name 'some_legacy_id'
  table_name 'some_legacy_table'
end
thing = LegacyThing[9909]
thing.pk_id # => 9909

Inheritance

Domain classes can inherit from other domain classes; they have all the fields of any concrete superclasses plus any new fields defined for themselves. You can use normal inheritance to define this:

class User < Lafcadio::DomainObject
  ...
end

class Administrator < User
  ...
end

Lafcadio assumes that each concrete class has a corresponding table, and that each table has a pk_id field that is used to match rows between different levels.

Direct Known Subclasses

MapObject

Defined Under Namespace

Classes: ReadOnlyHash, SubclassRecord

Constant Summary collapse

@@subclass_records = 
Hash.new do |h, k| h[k] = SubclassRecord.new( k ); end
@@default_mock_available = 
Hash.new true
@@default_arg_directives = 
Hash.new { |hash, a_class|
  default_args = {}
  a_class.all_fields.each do |field|
    default_args[field.name] = field.default_mock_value
  end
  hash[a_class] = default_args
}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from DomainComparable

#<=>, #eql?, #hash

Constructor Details

#initialize(field_hash) ⇒ DomainObject

field_hash should contain key-value associations for the different fields of this domain class. For example, instantiating a User class might look like:

User.new(
  'firstNames' => 'John', 'lastName' => 'Doe',
  'email' => '[email protected]', 'password' => 'l33t'
)

In normal usage any code you write that creates a domain object will not define the pk_id field. The system assumes that a domain object with an undefined pk_id has yet to be inserted into the database, and when you commit the domain object a pk_id will automatically be assigned.

If you’re creating mock objects for unit tests, you can explicitly set the pk_id to represent objects that already exist in the database.



680
681
682
683
684
685
686
687
 
# File 'lib/lafcadio/domain.rb', line 680

def initialize( field_hash )
  field_hash = preprocess_field_hash field_hash
  @field_values = {}
  @fields_set = []
  reset_original_values_hash @fieldHash
  check_fields = LafcadioConfig.new()['checkFields']
  verify if %w( onInstantiate onAllStates ).include?( check_fields )
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(methId, *args) ⇒ Object

:nodoc:



736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
 
# File 'lib/lafcadio/domain.rb', line 736

def method_missing( methId, *args ) #:nodoc:
  if ( field = setter_field( methId ) )
    set_field_value( field, args.first )
  elsif ( field = getter_field( methId ) )
    field_value( field )
  else
    object_store = ObjectStore.get_object_store
    if object_store.respond_to? methId
      args = [ self ].concat args
      object_store.send( methId, *args )
    else
      super( methId, *args )
    end
  end
end

Instance Attribute Details

#delete ⇒ Object

Returns the value of attribute delete.



661
662
663
 
# File 'lib/lafcadio/domain.rb', line 661

def delete
  @delete
end

#field_values=(value) ⇒ Object

Sets the attribute field_values

Parameters:

  • value —

    the value to set the attribute field_values to.



660
661
662
 
# File 'lib/lafcadio/domain.rb', line 660

def field_values=(value)
  @field_values = value
end

#fields_set=(value) ⇒ Object

Sets the attribute fields_set

Parameters:

  • value —

    the value to set the attribute fields_set to.



660
661
662
 
# File 'lib/lafcadio/domain.rb', line 660

def fields_set=(value)
  @fields_set = value
end

#last_commit_type ⇒ Object

Returns the value of attribute last_commit_type.



660
661
662
 
# File 'lib/lafcadio/domain.rb', line 660

def last_commit_type
  @last_commit_type
end

Class Method Details

.[](pk_id) ⇒ Object

Shortcut method for retrieving one domain object.

User[7356] # => user with the pk_id 7536



288
 
# File 'lib/lafcadio/domain.rb', line 288

def self.[]( pk_id ); get( pk_id ); end

.abstract_subclass?(a_class) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


290
291
292
 
# File 'lib/lafcadio/domain.rb', line 290

def self.abstract_subclass?( a_class ) #:nodoc:
  abstract_subclasses.include? a_class
end

.abstract_subclasses ⇒ Object

:nodoc:



294
295
296
 
# File 'lib/lafcadio/domain.rb', line 294

def self.abstract_subclasses #:nodoc:
  [ MapObject ]
end

.all(opts = {}) ⇒ Object

Returns every committed instance of the domain class.

User.all # => all users



301
302
303
 
# File 'lib/lafcadio/domain.rb', line 301

def self.all( opts = {} )
  ObjectStore.get_object_store.all( self, opts )
end

.all_fields ⇒ Object

:nodoc:



305
306
307
308
309
 
# File 'lib/lafcadio/domain.rb', line 305

def self.all_fields # :nodoc:
  self_and_concrete_superclasses.map { |a_class|
    a_class.class_fields
  }.flatten
end

.class_field(fieldName) ⇒ Object

:nodoc:



311
312
313
 
# File 'lib/lafcadio/domain.rb', line 311

def self.class_field(fieldName) #:nodoc:
  self.class_fields.find { |field| field.name == fieldName.to_s }
end

.class_fields ⇒ Object

:nodoc:



315
316
317
318
319
320
321
322
323
324
325
326
327
 
# File 'lib/lafcadio/domain.rb', line 315

def self.class_fields #:nodoc:
  unless subclass_record.fields
    subclass_record.fields = self.get_class_fields
    subclass_record.fields.each do |class_field|
      begin
        undef_method class_field.name.to_sym
      rescue NameError
        # not defined globally or in an included Module, skip it
      end
    end
  end
  subclass_record.fields
end

.commit_mock(args, caller = nil) ⇒ Object

:nodoc:



133
134
135
136
137
138
139
140
141
142
 
# File 'lib/lafcadio/test.rb', line 133

def self.commit_mock( args, caller = nil ) #:nodoc:
  dobj = self.new( args )
  link_fields = all_fields.select { |field| field.is_a? DomainObjectField }
  link_fields.each do |field|
    val = dobj.send( field.name )
    maybe_call_default_mock( field, caller ) if ( val and val.pk_id == 1 )
  end
  dobj.commit
  dobj
end

.create_field(field_class, *args) ⇒ Object

:nodoc:



329
330
331
332
333
334
335
336
337
338
339
340
 
# File 'lib/lafcadio/domain.rb', line 329

def self.create_field( field_class, *args ) #:nodoc:
  subclass_record.maybe_init_fields
  att_hash = create_field_att_hash( field_class, *args )
  field = field_class.create_with_args( self, att_hash )
  unless class_field( field.name )
    att_hash.each { |field_name, value|
      setter = field_name + '='
      field.send( setter, value ) if field.respond_to?( setter )
    }
    class_fields << field
  end
end

.create_field_att_hash(field_class, *args) ⇒ Object

:nodoc:



342
343
344
345
346
347
348
349
350
351
352
353
354
 
# File 'lib/lafcadio/domain.rb', line 342

def self.create_field_att_hash( field_class, *args ) #:nodoc:
  att_hash = args.last
  unless att_hash.is_a? Hash
    att_hash = subclass_record.default_field_setup_hash[field_class].clone
  end
  if field_class == DomainObjectField
    att_hash['linked_type'] = args.first
    att_hash['name'] = args[1] if args[1] and !args[1].is_a? Hash
  else
    att_hash['name'] = args.first.to_s
  end
  att_hash
end

.create_fields(field_class, *args) ⇒ Object

:nodoc:



356
357
358
359
360
361
362
363
364
365
366
367
368
369
 
# File 'lib/lafcadio/domain.rb', line 356

def self.create_fields( field_class, *args ) #:nodoc:
  arg = args.shift
  until args.empty?
    next_arg = args.shift
    if next_arg.is_a? String or next_arg.is_a? Symbol
      create_field( field_class, arg )
      arg = next_arg
    else
      create_field( field_class, arg, next_arg )
      arg = args.shift
    end
  end
  create_field( field_class, arg ) unless arg.nil?
end

.custom_mock(custom_args = nil) ⇒ Object

Commits and returns a custom mock object of the given domain class. All the field values are set to defaults, except for the fields passed in through custom_args. This mock object will have a pk_id greater than 1, and each successive call to DomainObject.custom_mock will return an object with a unique pk_id.

This class method is only visible if you include lafcadio/test.rb.

class User < Lafcadio::DomainObject
  strings :fname, :lname, :email
end
u1 = User.custom_mock
u1.fname # => 'test text'
u1.lname # => 'test text'
u1.email # => 'test text'
u1.pk_id # => probably 2, guaranteed to be greater than 1
u2 = User.custom_mock( 'fname' => 'Francis', 'lname' => 'Hwang' )
u2.fname # => 'Francis'
u2.lname # => 'Hwang'
u2.email # => 'test text'
u2.pk_id # => probably 3, guaranteed to not be u1.pk_id and to be
         #    greater than 1



167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/lafcadio/test.rb', line 167

def self.custom_mock( custom_args = nil )
  dobj_args = default_args
  object_store = ObjectStore.get_object_store
  dbb = object_store.db_bridge
  dbb.set_next_pk_id( self, 2 ) if dbb.next_pk_id( self ) == 1
  dobj_args['pk_id'] = nil
  if custom_args.is_a? Hash
    custom_args.each do |k, v| dobj_args[k.to_s] = v; end
  end
  commit_mock( dobj_args )
end

.default_args ⇒ Object

Returns a hash of default arguments for mock instances of this domain class. DomainObject.default_mock uses exactly these arguments to create the default mock for a given domain class, and DomainObject.custom_mock overrides some of the field arguments based on its custom arguments.

By default this will retrieve simple values based on the field type:

  • BooleanField: true

  • DateField: Date.today

  • DateTimeField: Time.now

  • DomainObjectField: The instance of the domain class with pk_id 1

  • EmailField: “[email protected]”

  • FloatField: 0.0

  • IntegerField: 1

  • StringField: “test text”

  • TextListField: [ ‘a’, ‘b’, ‘c’ ]

You can override this method, if you like. However, it will probably be simpler just to call DomainObject.mock_value.

This class method is only visible if you include lafcadio/test.rb.



200
201
202
203
204
205
206
207
208
209
210
 
# File 'lib/lafcadio/test.rb', line 200

def self.default_args
  default_args = {}
  @@default_arg_directives[self].each do |name, value_or_proc|
    if value_or_proc.is_a? Proc
      default_args[name] = value_or_proc.call
    else
      default_args[name] = value_or_proc
    end
  end
  default_args
end

.default_field_setup_hash(field_class, hash) ⇒ Object

Sets a default setup hash for a field of a certain class. Useful for mapping domain classes with lots of fields and unusual field configurations.

class LotsOfBooleans < Lafcadio::DomainObject
  default_field_setup_hash(
    Lafcadio::BooleanField, { 'enum_type' => :capital_yes_no }
  )
  booleans 'this', 'that', 'the_other', 'and_another_one',
           'this_one_too'
end



382
383
384
 
# File 'lib/lafcadio/domain.rb', line 382

def self.default_field_setup_hash( field_class, hash )
  subclass_record.default_field_setup_hash[field_class] = hash
end

.default_mock(calling_class = nil) ⇒ Object

Commits and returns a mock object of the given domain class. All the field values are set to defaults. This mock object will have a pk_id of 1. Successive calls to DomainObject.default_mock will always return the same mock object.

This class method is only visible if you include lafcadio/test.rb.

class User < Lafcadio::DomainObject
  strings :fname, :lname, :email
end
u1 = User.default_mock
u1.fname # => 'test text'
u1.lname # => 'test text'
u1.email # => 'test text'
u1.pk_id # => 1



228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
# File 'lib/lafcadio/test.rb', line 228

def self.default_mock( calling_class = nil )
  if @@default_mock_available[self]
    begin
      dobj = ObjectStore.get_object_store.get( self, 1 )
      dobj
    rescue DomainObjectNotFoundError
      dbb = ObjectStore.get_object_store.db_bridge
      dbb.set_next_pk_id( self, 1 ) if dbb.next_pk_id( self ) > 1
      commit_mock( default_args, calling_class )
    end
  else
    raise( TypeError, self.name + ".default_mock not allowed", caller )
  end
end

.default_mock_available(is_avail) ⇒ Object

:nodoc:



243
244
245
 
# File 'lib/lafcadio/test.rb', line 243

def self.default_mock_available( is_avail ) #:nodoc:
  @@default_mock_available[self] = is_avail
end

.dependent_classes ⇒ Object

:nodoc:



386
387
388
389
390
391
392
393
394
395
396
397
 
# File 'lib/lafcadio/domain.rb', line 386

def self.dependent_classes #:nodoc:
  dependent_classes = {}
  DomainObject.subclasses.each { |aClass|
    if (
      !abstract_subclass?( aClass ) and
      ( field = aClass.link_field( self ) )
    )
      dependent_classes[aClass] = field
    end
  }
  dependent_classes
end

.domain_class ⇒ Object

:nodoc:



399
400
401
 
# File 'lib/lafcadio/domain.rb', line 399

def self.domain_class #:nodoc:
  self
end

.domain_dirs ⇒ Object

:nodoc:



403
404
405
406
407
408
409
 
# File 'lib/lafcadio/domain.rb', line 403

def self.domain_dirs #:nodoc:
  if ( domainDirStr = LafcadioConfig.new['domainDirs'] )
    domainDirStr.split(',')
  else
    []
  end
end

.exist?(search_term, field_name = :pk_id) ⇒ Boolean

Tests whether a given domain object exists.

User.exist?( 8280 ) # => returns true iff there's a User 8280
User.exist?( 'Hwang', :lastName ) # => returns true iff there's a User
                                  #    with the last name 'Hwang'

Returns:

  • (Boolean) 


416
417
418
419
420
421
 
# File 'lib/lafcadio/domain.rb', line 416

def self.exist?( search_term, field_name = :pk_id )
  query = Query.infer( self ) { |dobj|
    dobj.send( field_name ).equals( search_term )
  }
  !ObjectStore.get_object_store.query( query ).empty?
end

.field(fieldName) ⇒ Object

:nodoc:



423
424
425
426
427
428
429
430
431
 
# File 'lib/lafcadio/domain.rb', line 423

def self.field( fieldName ) #:nodoc:
  aDomainClass = self
  field = nil
  while aDomainClass < DomainObject && !field
    field = aDomainClass.class_field( fieldName )
    aDomainClass = aDomainClass.superclass
  end
  field
end

.first ⇒ Object

Returns the first domain object it can find.

very_first_user = User.first



436
 
# File 'lib/lafcadio/domain.rb', line 436

def self.first; all.first; end

.get(*args) ⇒ Object

This class method has a few uses, depending on how you use it.

  1. Pass DomainObject.get a block in order to run a complex query:

    adult_hwangs = User.get { |user|
  user.lastName.equals( 'Hwang' ) &
    user.birthday.lte( Date.today - ( 365 * 18 ) )
}

    See query.rb for more information about how to form these queries.

  2. Pass it a simple search term and a field name to retrieve every domain object matching the term. The field name will default to pk_id.

    hwangs = User.get( 'Hwang', :lastName )
user123 = User.get( 123 ).first

  3. Pass it a { :group => :count } hash to retrieve a count result hash. This interface is fairly new and may be refined (that is, changed) in the future.

    num_users = User.get( :group => :count ).first[:count]



454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
 
# File 'lib/lafcadio/domain.rb', line 454

def self.get( *args )
  if block_given?
    query = Query.infer( self ) { |dobj| yield( dobj ) }
    ObjectStore.get_object_store.query( query )
  elsif args.size == 1
    arg = args.first
    if arg.is_a? Fixnum
      ObjectStore.get_object_store.get( self, *args )
    else
      qry = Query.new( self, :group_functions => [ :count ] )
      ObjectStore.get_object_store.group_query qry
    end
  else
    search_term = args.shift
    field_name = (
      args.shift or link_field( search_term.domain_class ).name
    )
    qry = Query::Equals.new( field_name, search_term, self )
    ObjectStore.get_object_store.query qry
  end
end

.get_class_fields ⇒ Object

Returns an Array of ObjectField instances for this domain class, parsing them from XML if necessary. You can override this to define a domain class’ fields, though it will probably just be simpler to use one-line class methods instead.



480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
 
# File 'lib/lafcadio/domain.rb', line 480

def self.get_class_fields
  if self.methods( false ).include?( 'get_class_fields' )
    [ subclass_record.pk_field ]
  elsif abstract_subclass?( self )
    []
  else
    xmlParser = try_load_xml_parser
    if xmlParser
      xmlParser.get_class_fields     
    else
      error_msg = "Couldn't find either an XML class description file " +
                  "or get_class_fields method for " + self.name
      raise MissingError, error_msg, caller
    end
  end
end

.is_child_domain_class? ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


497
498
499
 
# File 'lib/lafcadio/domain.rb', line 497

def self.is_child_domain_class? #:nodoc:
  superclass != DomainObject and !abstract_subclass?( superclass )
end

.last ⇒ Object

Returns the last domain object.

last_msg = Message.last



504
 
# File 'lib/lafcadio/domain.rb', line 504

def self.last; all.last; end

.link_field(linked_domain_class) ⇒ Object

:nodoc:



506
507
508
509
510
511
 
# File 'lib/lafcadio/domain.rb', line 506

def self.link_field( linked_domain_class ) # :nodoc:
  class_fields.find { |field|
    field.is_a? DomainObjectField and
    field.linked_type == linked_domain_class
  }
end

.maybe_call_default_mock(field, caller) ⇒ Object

:nodoc:



247
248
249
250
251
252
253
254
255
256
 
# File 'lib/lafcadio/test.rb', line 247

def self.maybe_call_default_mock( field, caller ) #:nodoc:
  linked_type = field.linked_type
  begin
    ObjectStore.get_object_store.get( linked_type, 1 )
  rescue DomainObjectNotFoundError
    unless linked_type == caller
      linked_type.send( 'default_mock', self )
    end
  end
end

.method_missing(methodId, *args) ⇒ Object

:nodoc:



513
514
515
516
517
518
519
520
521
522
523
524
525
526
 
# File 'lib/lafcadio/domain.rb', line 513

def self.method_missing( methodId, *args ) #:nodoc:
  dispatched = false
  method_name = methodId.id2name
  begin
    method_missing_try_create_field( method_name, *args )
    dispatched = true
  rescue NameError
    begin
      method_missing_try_create_fields( method_name, *args )
      dispatched = true
    rescue NameError; end
  end
  super unless dispatched
end

.method_missing_try_create_field(method_name, *args) ⇒ Object

:nodoc:



528
529
530
531
532
 
# File 'lib/lafcadio/domain.rb', line 528

def self.method_missing_try_create_field( method_name, *args ) # :nodoc:
  maybe_field_class_name = method_name.underscore_to_camel_case + 'Field'
  field_class = Lafcadio.const_get( maybe_field_class_name )
  create_field( field_class, *args )
end

.method_missing_try_create_fields(method_name, *args) ⇒ Object

:nodoc:



534
535
536
537
538
539
540
541
542
543
 
# File 'lib/lafcadio/domain.rb', line 534

def self.method_missing_try_create_fields( method_name, *args ) # :nodoc:
  singular = method_name.singular
  if singular
    maybe_field_class_name = singular.underscore_to_camel_case + 'Field'
    field_class = Lafcadio.const_get( maybe_field_class_name )
    create_fields( field_class, *args )
  else
    raise NameError
  end
end

.mock_value(field_sym, value) ⇒ Object

Sets the mock value for the given field. These mock values are used in DomainObject.default_mock and DomainObject.custom_mock

This class method is only visible if you include lafcadio/test.rb.

class User < Lafcadio::DomainObject
  strings :fname, :lname, :email
end
User.mock_value :fname, 'Bill'
User.mock_value :lname, 'Smith'
u1 = User.default_mock
u1.fname # => 'Bill'
u1.lname # => 'Smith'
u1.email # => 'test text'
u1.pk_id # => 1



274
275
276
 
# File 'lib/lafcadio/test.rb', line 274

def self.mock_value( field_sym, value )
  @@default_arg_directives[self][field_sym.id2name] = value
end

.mock_values(hash) ⇒ Object

Sets the mock value for the fields in hash. These mock values are used in DomainObject.default_mock and DomainObject.custom_mock

This class method is only visible if you include lafcadio/test.rb.

class User < Lafcadio::DomainObject
  strings :fname, :lname, :email
end
User.mock_values { :fname => 'Bill', :lname => 'Smith' }
u1 = User.default_mock
u1.fname # => 'Bill'
u1.lname # => 'Smith'
u1.email # => 'test text'
u1.pk_id # => 1



293
294
295
 
# File 'lib/lafcadio/test.rb', line 293

def self.mock_values( hash )
  hash.each do |field_sym, value| mock_value( field_sym, value ); end
end

.only ⇒ Object

Returns the only committed instance of the domain class. Will raise an IndexError if there are 0, or more than 1, domain objects.

the_one_user = User.only



549
 
# File 'lib/lafcadio/domain.rb', line 549

def self.only; all.only; end

.postgres_pk_id_seq ⇒ Object 



551
552
553
 
# File 'lib/lafcadio/domain.rb', line 551

def self.postgres_pk_id_seq
  "#{ table_name }_#{ sql_primary_key_name }_seq"
end

.require_domain_file(typeString) ⇒ Object

:nodoc:



555
556
557
558
559
560
561
562
563
564
565
566
567
 
# File 'lib/lafcadio/domain.rb', line 555

def self.require_domain_file( typeString ) # :nodoc:
  typeString =~ /([^\:]*)$/
  fileName = $1
  domain_dirs.each { |domainDir|
    if Dir.entries(domainDir).index("#{fileName}.rb")
      require "#{ domainDir }#{ fileName }"
    end
  }
  if (domainFiles = LafcadioConfig.new['domainFiles'])
    domainFiles = domainFiles.split( ',' ) if domainFiles.is_a? String
    domainFiles.each { |domainFile| require domainFile }
  end
end

.self_and_concrete_superclasses ⇒ Object

:nodoc:



569
570
571
572
573
574
575
576
577
578
579
 
# File 'lib/lafcadio/domain.rb', line 569

def self.self_and_concrete_superclasses # :nodoc:
  classes = [ ]
  a_domain_class = self
  until(
    a_domain_class == DomainObject || abstract_subclass?( a_domain_class )
  )
    classes << a_domain_class
    a_domain_class = a_domain_class.superclass
  end
  classes
end

.singleton_method_added(symbol) ⇒ Object

:nodoc:



581
582
583
584
585
586
587
588
589
 
# File 'lib/lafcadio/domain.rb', line 581

def self.singleton_method_added( symbol ) # :nodoc:
  if symbol.id2name == 'sql_primary_key_name' && self < DomainObject
    begin
      field( 'pk_id' ).db_field_name = self.send( symbol )
    rescue NameError
      subclass_record.sql_primary_key = self.send( symbol )
    end
  end
end

.sql_primary_key_name(set_db_field_name = nil) ⇒ Object

If set_db_field_name is nil, this will return the sql name of the primary key. If set_db_field_name isn’t nil, it will set the sql name.

class User < Lafcadio::DomainObject
  string 'firstNames'
end
User.sql_primary_key_name # => 'pk_id'
class User < Lafcadio::DomainObject
  sql_primary_key_name 'some_other_id'
end
User.sql_primary_key_name # => 'some_other_id'



602
603
604
605
 
# File 'lib/lafcadio/domain.rb', line 602

def self.sql_primary_key_name( set_db_field_name = nil )
  field( 'pk_id' ).db_field_name = set_db_field_name if set_db_field_name
  field( 'pk_id' ).db_field_name
end

.subclass_record ⇒ Object

:nodoc:



607
608
609
 
# File 'lib/lafcadio/domain.rb', line 607

def self.subclass_record # :nodoc:
  @@subclass_records.synchronize { @@subclass_records[self] }
end

.subclasses ⇒ Object

:nodoc:



611
612
613
 
# File 'lib/lafcadio/domain.rb', line 611

def self.subclasses #:nodoc:
  @@subclass_records.keys
end

.table_name(set_table_name = nil) ⇒ Object

If set_table_name is nil, DomainObject.table_name will return the table name. Lafcadio assumes that a domain class corresponds to a table whose name is the pluralized, lower-case, underscored version of the class name. A User class is assumed to be stored in a “users” table, while a ProductCategory class is assumed to be stored in a “product_categories” table.

If set_table_name is not nil, this will set the table name.

class User < Lafcadio::DomainObject
  string 'firstNames'
end
User.table_name # => 'users'
class User < Lafcadio::DomainObject
  table_name 'some_table'
end
User.table_name # => 'some_table'



632
633
634
635
636
637
638
639
640
641
642
643
644
645
 
# File 'lib/lafcadio/domain.rb', line 632

def self.table_name( set_table_name = nil )
  if set_table_name
    @table_name = set_table_name
  elsif @table_name
    @table_name
  else
    xmlParser = try_load_xml_parser
    if (!xmlParser.nil? && table_name = xmlParser.table_name)
      table_name
    else
      self.basename.camel_case_to_underscore.plural
    end
  end
end

.try_load_xml_parser ⇒ Object

:nodoc:



647
648
649
650
651
652
653
654
655
656
657
658
 
# File 'lib/lafcadio/domain.rb', line 647

def self.try_load_xml_parser # :nodoc:
  if ( dirName = LafcadioConfig.new['classDefinitionDir'] )
    xmlFileName = self.basename + '.xml'
    xmlPath = File.join( dirName, xmlFileName )
    begin
      xml = File.open( xmlPath ) do |f| f.gets( nil ); end
      ClassDefinitionXmlParser.new( self, xml )
    rescue Errno::ENOENT
      # no xml file, so no @xmlParser
    end
  end
end

Instance Method Details

#clone ⇒ Object

Returns a clone, with all of the fields copied.



690
691
692
693
694
695
 
# File 'lib/lafcadio/domain.rb', line 690

def clone
  copy = super
  copy.field_values = @field_values.clone
  copy.fields_set = @fields_set.clone
  copy
end

#commit ⇒ Object

Commits this domain object to the database.



698
699
700
 
# File 'lib/lafcadio/domain.rb', line 698

def commit
  ObjectStore.get_object_store.commit self
end

#delete! ⇒ Object

Deletes a domain object, committing the delete to the database immediately.



713
714
715
716
 
# File 'lib/lafcadio/domain.rb', line 713

def delete!
  self.delete = true
  commit
end

#domain_class ⇒ Object

Returns the subclass of DomainObject that this instance represents. Because of the way that proxying works, clients should call this method instead of Object.class.



721
722
723
 
# File 'lib/lafcadio/domain.rb', line 721

def domain_class
  self.class.domain_class
end

#field_value(field) ⇒ Object

:nodoc:



725
726
727
728
729
730
 
# File 'lib/lafcadio/domain.rb', line 725

def field_value( field ) #:nodoc:
  unless @fields_set.include?( field )
    set_field_value( field, @fieldHash[field.name] )
  end
  @field_values[field.name]
end

#getter_field(methId) ⇒ Object

:nodoc:



732
733
734
 
# File 'lib/lafcadio/domain.rb', line 732

def getter_field( methId ) #:nodoc:
  self.class.field methId.id2name
end

#post_commit_trigger ⇒ Object

This template method is called after every commit. Subclasses can override it to ensure code is executed after a commit.



774
775
776
 
# File 'lib/lafcadio/domain.rb', line 774

def post_commit_trigger
  nil
end

#pre_commit_trigger ⇒ Object

This template method is called before every commit. Subclasses can override it to ensure code is executed before a commit.



754
755
756
 
# File 'lib/lafcadio/domain.rb', line 754

def pre_commit_trigger
  nil
end

#preprocess_field_hash(fieldHash) ⇒ Object

:nodoc:



758
759
760
761
762
763
764
765
766
767
768
769
770
 
# File 'lib/lafcadio/domain.rb', line 758

def preprocess_field_hash( fieldHash ) # :nodoc:
  if fieldHash.is_a? Hash
    fieldHash.keys.each { |key|
      if self.class.field( key.to_s ).nil?
        raise ArgumentError, "Invalid field name #{ key.to_s }"
      end
    }
    @fieldHash = {}
    fieldHash.each do |k, v| @fieldHash[k.to_s] = v; end
  else
    @fieldHash = fieldHash
  end
end

#reset_original_values_hash(f = @field_values) ⇒ Object

:nodoc:



778
779
780
 
# File 'lib/lafcadio/domain.rb', line 778

def reset_original_values_hash( f = @field_values ) #:nodoc:
  @original_values = ReadOnlyHash.new( f.clone )
end

#set_field_value(field, value) ⇒ Object

:nodoc:



782
783
784
785
786
787
788
789
790
791
792
793
794
795
 
# File 'lib/lafcadio/domain.rb', line 782

def set_field_value( field, value ) #:nodoc:
  if (
    field.is_a?( DomainObjectField ) and
    !value.is_a?( DomainObjectProxy ) and value
  )
    value = DomainObjectProxy.new(value)
  end
  if ( LafcadioConfig.new()['checkFields'] == 'onAllStates' &&
       !field.instance_of?( PrimaryKeyField ) )
    field.verify( value, pk_id )
  end
  @field_values[field.name] = value
  @fields_set << field
end

#setter_field(methId) ⇒ Object

:nodoc:



797
798
799
800
801
802
803
 
# File 'lib/lafcadio/domain.rb', line 797

def setter_field( methId ) #:nodoc:
  if methId.id2name =~ /(.*)=$/
    self.class.field $1
  else
    nil
  end
end

#update!(changes) ⇒ Object

Updates a domain object and commits the changes to the database immediately.

user99 = User[99]
user99.update!( :firstNames => 'Bill', :password => 'n3wp4ssw0rd' )



810
811
812
813
 
# File 'lib/lafcadio/domain.rb', line 810

def update!( changes )
  changes.each do |sym, value| self.send( sym.to_s + '=', value ); end
  commit
end

#verify ⇒ Object

If you’re running against a MockObjectStore, this will verify each field and raise an error if there’s any invalid fields.



817
818
819
820
821
822
823
 
# File 'lib/lafcadio/domain.rb', line 817

def verify
  if ObjectStore.mock?
    self.class.get_class_fields.each { |field|
      field.verify( self.send( field.name ), self.pk_id )
    }
  end
end