Model

# File lib/treequel/model.rb, line 273
def []=( attrname, value )
        attrtype = self.find_attribute_type( attrname.to_sym ) or
                raise ArgumentError, "unknown attribute %p" % [ attrname ]
        value = Array( value ) unless attrtype.single?

        self.mark_dirty
        if value.nil?
                @values.delete( attrtype.name.to_sym )
        else
                @values[ attrtype.name.to_sym ] = value
        end

        # If the objectClasses change, we (may) need to re-apply mixins
        if attrname.to_s.downcase == 'objectclass'
                self.log.debug "  objectClass change -- reapplying mixins"
                self.apply_applicable_mixins( self.dn )
        else
                self.log.debug "  no objectClass changes -- no need to reapply mixins"
        end

        return value
end

# File lib/treequel/model.rb, line 310
def delete( *attributes )
        return super if attributes.empty?

        self.log.debug "Deleting attributes: %p" % [ attributes ]
        self.mark_dirty

        attributes.flatten.each do |attribute|

                # With a hash, delete each value for each key
                if attribute.is_a?( Hash )
                        self.delete_specific_values( attribute )

                # With an array of attributes to delete, replace
                # MULTIPLE attribute types with an empty array, and SINGLE
                # attribute types with nil
                elsif attribute.respond_to?( :to_sym )
                        attrtype = self.find_attribute_type( attribute.to_sym )
                        if attrtype.single?
                                @values[ attribute.to_sym ] = nil
                        else
                                @values[ attribute.to_sym ] = []
                        end
                else
                        raise ArgumentError,
                                "can't convert a %p to a Symbol or a Hash" % [ attribute.class ]
                end
        end

        return true
end

# File lib/treequel/model.rb, line 495
def destroy( opts={} )
        opts = DEFAULT_DESTROY_OPTIONS.merge( opts )

        self.before_destroy or raise Treequel::BeforeHookFailed, :destroy
        self.delete
        self.after_destroy

        return true
rescue Treequel::BeforeHookFailed => err
        self.log.info( err.message )
        raise if opts[:raise_on_failure]
end

# File lib/treequel/model.rb, line 435
def diff_with_entry( attribute, values )
        mods         = []
        attribute    = attribute.to_s
        entry        = self.entry || {}
        entry_values = entry.key?( attribute ) ? entry[attribute] : []

        # Workaround for the fact that Time has a #to_ary, causing it to become an
        # Array of integers when cast via Array().
        values = [ values ] if values.is_a?( Time )

        values = Array( values ).compact.
                collect {|val| self.get_converted_attribute(attribute, val) }
        self.log.debug "  comparing %s values to entry: %p vs. %p" %
                [ attribute, values, entry_values ]

        # If the attributes on the server are the same as the local ones,
        # it's a NOOP.
        if values.sort == entry_values.sort
                self.log.debug "    no change."
                return nil

        # If the directory doesn't have this attribute, but the local
        # object does, it's an ADD
        elsif entry_values.empty?
                self.log.debug "    ADD %s: %p" % [ attribute, values ]
                return LDAP::Mod.new( LDAP::LDAP_MOD_ADD, attribute, values )

        # ...or if the local value doesn't have anything for this attribute
        # but the directory does, it's a DEL
        elsif values.empty?
                self.log.debug "    DELETE %s" % [ attribute ]
                return LDAP::Mod.new( LDAP::LDAP_MOD_DELETE, attribute )

        # ...otherwise it's a REPLACE
        else
                self.log.debug "    REPLACE %s: %p with %p" %
                        [ attribute, entry_values, values ]
                return LDAP::Mod.new( LDAP::LDAP_MOD_REPLACE, attribute, values )
        end

end

# File lib/treequel/model.rb, line 343
def errors
        return @errors ||= Treequel::Model::Errors.new
end

# File lib/treequel/model.rb, line 530
def extensions
        eigenclass = ( class << self; self; end )
        return eigenclass.included_modules.find_all do |mod|
                (class << mod; self; end).include?(Treequel::Model::ObjectClass)
        end
end

# File lib/treequel/model.rb, line 231
def initialize_copy( other )
        super
        self.apply_applicable_mixins( @dn, @entry )
        self.after_initialize
end

# File lib/treequel/model.rb, line 539
def inspect
        return "#<%s:0x%x (%s): %s>" % [
                self.class.name,
                self.object_id * 2,
                self.loaded? ?
                    self.extensions.map( &:name ).join( ', ' ) :
                    'not yet loaded',
                self.dn
        ]
end

# File lib/treequel/model.rb, line 300
def merge( attributes )
        attributes.each do |attrname, value|
                self[ attrname ] = value
        end
end

# File lib/treequel/model.rb, line 479
def modification_ldif
        mods = self.modifications
        return LDAP::LDIF.mods_to_ldif( self.dn, mods )
end

# File lib/treequel/model.rb, line 418
def modifications
        return unless self.modified?
        self.log.debug "Gathering modifications..."

        mods = []
        @values.sort_by {|k, _| k.to_s }.each do |attribute, vals|
                self.log.debug "  finding mods for %s" % [ attribute ]
                mod = self.diff_with_entry( attribute, vals ) or next
                mods << mod
        end

        return mods
end

# File lib/treequel/model.rb, line 259
def modified?
        return @dirty ? true : false
end

# File lib/treequel/model.rb, line 265
def reset_dirty_flag
        @dirty = false
end

# File lib/treequel/model.rb, line 520
def respond_to?( sym, include_priv=false )
        return super if caller(1).first =~ %r{/r?spec/} &&
                caller(1).first !~ /respond_to/ # RSpec workaround
        return true if super
        plainsym, _ = attribute_from_method( sym )
        return self.find_attribute_type( plainsym ) ? true : false
end

# File lib/treequel/model.rb, line 486
def revert
        self.clear_caches
        @dirty = false

        return true
end

# File lib/treequel/model.rb, line 378
def save( opts={} )
        opts = DEFAULT_SAVE_OPTIONS.merge( opts )

        self.log.debug "Saving %s..." % [ self.dn ]
        if opts[ :validate ]
                raise Treequel::ValidationFailed, self.errors unless self.valid?( opts )
                self.log.debug "  validation succeeded."
        end

        unless mods = self.modifications
                self.log.debug "  no modifications... no save necessary."
                return false
        end

        self.log.debug "  got %d modifications." % [ mods.length ]
        self.before_save( mods ) or
                raise Treequel::BeforeHookFailed, :save

        if self.exists?
                self.log.debug "  already exists, so updating."
                self.update( mods )
        else
                self.log.debug "  doesn't exist, so creating."
                self.create( mods )
        end

        self.after_save( mods )

        return true
rescue Treequel::BeforeHookFailed => err
        self.log.info( err.message )
        raise if opts[:raise_on_failure]
rescue Treequel::ValidationFailed => err
        self.log.error( "Save aborted: validation failed." )
        self.log.info( err.errors.full_messages.join(', ') )
        raise if opts[:raise_on_failure]
end

# File lib/treequel/model.rb, line 511
def search( scope=:subtree, filter='(objectClass=*)', parameters={}, &block )
        parameters[:selectattrs] |= ['objectClass'] unless
                !parameters.key?( :selectattrs ) || parameters[ :selectattrs ].empty?

        super
end

# File lib/treequel/model.rb, line 349
def valid?( opts={} )
        self.errors.clear
        self.validate( opts )
        return self.errors.empty? ? true : false
end

# File lib/treequel/model.rb, line 358
def validate( options={} )
        options = DEFAULT_VALIDATION_OPTIONS.merge( options )

        self.before_validation or
                raise Treequel::BeforeHookFailed, :validation
        self.errors.add( :objectClass, 'must have at least one' ) if self.object_classes.empty?

        super( options )
        self.log.debug "Validations failed:\s  %s" % [ self.errors.full_messages.join("\n  ") ] if
                self.errors.count.nonzero?

        self.after_validation
end