class Audrey::Object::Custom

Audrey::Object::Custom

Public Class Methods

descendant?(object) click to toggle source
# File lib/audrey.rb, line 1883
def self.descendant?(object)
        if object.is_a?(Class)
                return object < Audrey::Object::Custom
        else
                return object.class < Audrey::Object::Custom
        end
end
fields() click to toggle source
# File lib/audrey.rb, line 1859
def self.fields
        # $tm.hrm
        
        # get superclass fields
        if self.superclass.respond_to?('fields')
                rv = self.superclass.fields()
        else
                rv = {}
        end
        
        # get own fields
        rv = rv.merge(own_fields())
        
        # return
        return rv
end
has_checks?() click to toggle source
# File lib/audrey.rb, line 1919
def self.has_checks?
        # cache return value
        if not instance_variable_defined?(:@has_checks_cache)
                @has_checks_cache = has_checks_search()
        end
        
        # return
        return @has_checks_cache
end
new(opts={}) { |self| ... } click to toggle source
# File lib/audrey.rb, line 1793
def initialize(opts={})
        # If a node is passed as an option, use that node and don't create a
        # new object.
        if @node = opts['node']
                if block_given?
                        @node.db.transaction() do |tr|
                                yield self
                                tr.commit
                        end
                end
        
        # If no node is passed, create a new object. If a block is given, run
        # that block within a transaction.
        else
                db = Audrey.explicit_or_current_db(opts['accessor'])
                
                # if within block
                if block_given?
                        db.transaction() do |tr|
                                within_initialize db, opts
                                yield self
                                tr.commit
                        end
                else
                        within_initialize db, opts
                end
        end
end
new_auto_fields(object) click to toggle source
# File lib/audrey.rb, line 1898
def self.new_auto_fields(object)
        # $tm.hrm
        
        # loop through fields
        fields.each do |name, dfn|
                dfn.auto_add object
        end
        
        # rescurse to super class
        unless self == Audrey::Object::Custom
                self.superclass.new_auto_fields(object)
        end
end
own_fields() click to toggle source
# File lib/audrey.rb, line 1840
def self.own_fields
        # $tm.hrm
        
        # ensure @own_fields exists
        if not instance_variable_defined?(:@own_fields)
                @own_fields = {}
        end
        
        # return
        return @own_fields
end

Private Class Methods

[](key) click to toggle source
# File lib/audrey.rb, line 1982
def self.[](key)
        # $tm.hrm
        
        # if this class has an id field
        if idf = self.id_field
                db = Audrey.explicit_or_current_db(nil)
                q0 = db.q0
                q0.aclass = self
                q0.fields[idf] = key
                return q0.first
        
        # else exception
        else
                raise 'no-id-field-defined'
        end
end
field(name, opts={}) { |dfn| ... } click to toggle source
# File lib/audrey.rb, line 2006
def self.field(name, opts={})
        use_dfn = Audrey::Object::Custom::Field
        
        # get custom field definition class
        if aclass = opts['aclass']
                if Audrey::RUBY_OBJECT_TO_AUDREY[aclass]
                        aclass = Audrey::RUBY_OBJECT_TO_AUDREY[aclass]['aclass']
                end
                
                if aclass.respond_to?('field_definition')
                        use_dfn = aclass.field_definition
                end
        end
        
        # create definition
        dfn = use_dfn.new(name)
        own_fields[dfn.name] = dfn
        
        # field rules
        if block_given?
                yield dfn
        end
        
        # add to class
        dfn.add_to_class self
end
id_field() click to toggle source
# File lib/audrey.rb, line 1972
def self.id_field()
        if instance_variable_defined?(:@id_field)
                return @id_field
        else
                return self.superclass.id_field
        end
end
id_field=(val) click to toggle source
# File lib/audrey.rb, line 1968
def self.id_field=(val)
        @id_field = val
end

Public Instance Methods

audrey() click to toggle source
# File lib/audrey.rb, line 1829
def audrey
        return @node
end

Private Instance Methods

within_initialize(db, opts) click to toggle source
# File lib/audrey.rb, line 1940
def within_initialize(db, opts)
        uuid = db.insert_object(self)
        @node = Audrey::Node::Hash.new(db, 'aclass'=>self.class, 'pk'=>uuid)
        self.class.new_auto_fields self
end