Module: DataMapper::Resource

### Home Classes Methods

### In Files

- lib/dm-core/backwards.rb
- lib/dm-core/resource.rb
- lib/dm-core/resource/persistence_state.rb
- lib/dm-core/resource/persistence_state/clean.rb
- lib/dm-core/resource/persistence_state/deleted.rb
- lib/dm-core/resource/persistence_state/dirty.rb
- lib/dm-core/resource/persistence_state/immutable.rb
- lib/dm-core/resource/persistence_state/persisted.rb
- lib/dm-core/resource/persistence_state/transient.rb

### Namespace

- CLASS DataMapper::Resource::PersistenceState

### Methods

- ::append_inclusions
- ::descendants
- ::extra_inclusions
- ::included
- #<=>
- #==
- #[]
- #[]=
- #after_create_hook
- #after_destroy_hook
- #after_save_hook
- #after_update_hook
- #attribute_dirty?
- #attribute_get
- #attribute_loaded?
- #attribute_set
- #attributes
- #attributes=
- #before_create_hook
- #before_destroy_hook
- #before_save_hook
- #before_update_hook
- #clean?
- #collection
- #collection=
- #collection_for_self
- #destroy
- #destroy!
- #destroyed?
- #dirty?
- #dirty_attributes
- #eql?
- #hash
- #inspect
- #key
- #new?
- #original_attributes
- #persistence_state
- #persistence_state=
- #persistence_state?
- #query
- #raise_on_save_failure
- #raise_on_save_failure=
- #readonly?
- #reload
- #repository
- #save
- #save!
- #saved?
- #update
- #update!
- #update_attributes

### Included Modules

- DataMapper::Assertions

### Files

- LICENSE
- README.rdoc

### Class/Module Index

Quicksearch

- DataMapper
- DataMapper::Adapters
- DataMapper::Adapters::AbstractAdapter
- DataMapper::Adapters::InMemoryAdapter
- DataMapper::Assertions
- DataMapper::Associations
- DataMapper::Associations::ManyToMany
- DataMapper::Associations::ManyToMany::Collection
- DataMapper::Associations::ManyToMany::Relationship
- DataMapper::Associations::ManyToOne
- DataMapper::Associations::ManyToOne::Relationship
- DataMapper::Associations::OneToMany
- DataMapper::Associations::OneToMany::Collection
- DataMapper::Associations::OneToMany::Relationship
- DataMapper::Associations::OneToOne
- DataMapper::Associations::OneToOne::Relationship
- DataMapper::Associations::Relationship
- DataMapper::Chainable
- DataMapper::Collection
- DataMapper::Deprecate
- DataMapper::DescendantSet
- DataMapper::Equalizer
- DataMapper::Ext
- DataMapper::Ext::Array
- DataMapper::Ext::Hash
- DataMapper::Ext::Module
- DataMapper::Ext::Object
- DataMapper::Ext::String
- DataMapper::Hook
- DataMapper::Hook::ClassMethods
- DataMapper::IdentityMap
- DataMapper::ImmutableDeletedError
- DataMapper::ImmutableError
- DataMapper::IncompleteModelError
- DataMapper::Inflector
- DataMapper::Inflector::Inflections
- DataMapper::LocalObjectSpace
- DataMapper::Logger
- DataMapper::Mash
- DataMapper::Model
- DataMapper::Model::Hook
- DataMapper::Model::Hook::MethodCommand
- DataMapper::Model::Hook::Methods
- DataMapper::Model::Hook::ProcCommand
- DataMapper::Model::Is
- DataMapper::Model::Property
- DataMapper::Model::Relationship
- DataMapper::Model::Scope
- DataMapper::NamingConventions
- DataMapper::NamingConventions::Field
- DataMapper::NamingConventions::Field::Underscored
- DataMapper::NamingConventions::Field::UnderscoredAndPluralized
- DataMapper::NamingConventions::Field::UnderscoredAndPluralizedWithoutModule
- DataMapper::NamingConventions::Field::Yaml
- DataMapper::NamingConventions::Resource
- DataMapper::NamingConventions::Resource::Underscored
- DataMapper::NamingConventions::Resource::UnderscoredAndPluralized
- DataMapper::NamingConventions::Resource::UnderscoredAndPluralizedWithoutLeadingModule
- DataMapper::NamingConventions::Resource::UnderscoredAndPluralizedWithoutModule
- DataMapper::NamingConventions::Resource::Yaml
- DataMapper::ObjectNotFoundError
- DataMapper::OrderedSet
- DataMapper::OrderedSet::Cache
- DataMapper::OrderedSet::Cache::API
- DataMapper::PersistenceError
- DataMapper::PluginNotFoundError
- DataMapper::Property
- DataMapper::Property::Binary
- DataMapper::Property::Boolean
- DataMapper::Property::Class
- DataMapper::Property::Date
- DataMapper::Property::DateTime
- DataMapper::Property::Decimal
- DataMapper::Property::Discriminator
- DataMapper::Property::Discriminator::Model
- DataMapper::Property::Float
- DataMapper::Property::Integer
- DataMapper::Property::Lookup
- DataMapper::Property::Numeric
- DataMapper::Property::Object
- DataMapper::Property::PassThroughLoadDump
- DataMapper::Property::Serial
- DataMapper::Property::String
- DataMapper::Property::Text
- DataMapper::Property::Time
- DataMapper::Property::Typecast
- DataMapper::Property::Typecast::Numeric
- DataMapper::Property::Typecast::Time
- DataMapper::PropertySet
- DataMapper::Query
- DataMapper::Query::Conditions
- DataMapper::Query::Conditions::AbstractComparison
- DataMapper::Query::Conditions::AbstractOperation
- DataMapper::Query::Conditions::AndOperation
- DataMapper::Query::Conditions::Comparison
- DataMapper::Query::Conditions::EqualToComparison
- DataMapper::Query::Conditions::FlattenOperation
- DataMapper::Query::Conditions::GreaterThanComparison
- DataMapper::Query::Conditions::GreaterThanOrEqualToComparison
- DataMapper::Query::Conditions::InclusionComparison
- DataMapper::Query::Conditions::LessThanComparison
- DataMapper::Query::Conditions::LessThanOrEqualToComparison
- DataMapper::Query::Conditions::LikeComparison
- DataMapper::Query::Conditions::NotOperation
- DataMapper::Query::Conditions::NullOperation
- DataMapper::Query::Conditions::Operation
- DataMapper::Query::Conditions::OrOperation
- DataMapper::Query::Conditions::RegexpComparison
- DataMapper::Query::Conditions::RelationshipHandler
- DataMapper::Query::Direction
- DataMapper::Query::Operator
- DataMapper::Query::Path
- DataMapper::Query::Sort
- DataMapper::RelationshipSet
- DataMapper::Repository
- DataMapper::RepositoryNotSetupError
- DataMapper::Resource
- DataMapper::Resource::PersistenceState
- DataMapper::Resource::PersistenceState::Clean
- DataMapper::Resource::PersistenceState::Deleted
- DataMapper::Resource::PersistenceState::Dirty
- DataMapper::Resource::PersistenceState::Immutable
- DataMapper::Resource::PersistenceState::Persisted
- DataMapper::Resource::PersistenceState::Transient
- DataMapper::SaveFailureError
- DataMapper::Spec
- DataMapper::Spec::Adapters
- DataMapper::Spec::Adapters::Adapter
- DataMapper::Spec::Adapters::Helpers
- DataMapper::Spec::Adapters::InMemoryAdapter
- DataMapper::Spec::CollectionHelpers
- DataMapper::Spec::CollectionHelpers::GroupMethods
- DataMapper::Spec::Helpers
- DataMapper::Spec::PendingHelpers
- DataMapper::Subject
- DataMapper::SubjectSet
- DataMapper::SubjectSet::NameCache
- DataMapper::Undefined
- DataMapper::UnknownRelationshipError
- DataMapper::UnsavedParentError
- DataMapper::UpdateConflictError
- Blog
- Blog::Article
- ChildSubType
- CounterAdapter
- Heffalump
- Kernel
- LazyArray
- Object
- OtherComparison
- Pathname
- SubType
- Symbol

No matching classes.

# DataMapper::Resource

### Public Class Methods

append_inclusions(*inclusions) click to toggle source

@deprecated

    # File lib/dm-core/resource.rb, line 6
    def self.append_inclusions(*inclusions)
      raise "DataMapper::Resource.append_inclusions is deprecated, use DataMapper::Model.append_inclusions instead (#{caller.first})"
    end

descendants() click to toggle source

@deprecated

    # File lib/dm-core/resource.rb, line 16
    def self.descendants
      raise "DataMapper::Resource.descendants is deprecated, use DataMapper::Model.descendants instead (#{caller.first})"
    end

extra_inclusions() click to toggle source

@deprecated

    # File lib/dm-core/resource.rb, line 11
    def self.extra_inclusions
      raise "DataMapper::Resource.extra_inclusions is deprecated, use DataMapper::Model.extra_inclusions instead (#{caller.first})"
    end

included(model) click to toggle source

Makes sure a class gets all the methods when it includes Resource

Note that including this module into an anonymous class will leave the model descendant tracking mechanism with no possibility to reliably track the anonymous model across code reloads. This means that {DataMapper::DescendantSet} will currently leak memory in scenarios where anonymous models are reloaded multiple times (as is the case in dm-rails development mode for example).

@api private

    # File lib/dm-core/resource.rb, line 70
    def self.included(model)
      model.extend Model
    end

### Public Instance Methods

<=>(other) click to toggle source

Compares two Resources to allow them to be sorted

@param [Resource] other

    The other Resource to compare with

@return [Integer]

    Return 0 if Resources should be sorted as the same, -1 if the
    other Resource should be after self, and 1 if the other Resource
    should be before self

@api public

    # File lib/dm-core/resource.rb, line 505
    def <=>(other)
      model = self.model
      unless other.kind_of?(model.base_model)
        raise ArgumentError, "Cannot compare a #{other.class} instance with a #{model} instance"
      end
      model.default_order(repository_name).each do |direction|
        cmp = direction.get(self) <=> direction.get(other)
        return cmp if cmp.nonzero?
      end
      0
    end

==(other) click to toggle source

Compares another Resource for equivalency

Resource is equivalent to `other` if they are the same object (identical object_id) or all of their attribute are equivalent

@param [Resource] other

    the other Resource to compare with

@return [Boolean]

    true if they are equivalent, false if not

@api public

    # File lib/dm-core/resource.rb, line 488
    def ==(other)
      return true if equal?(other)
      return false unless other.kind_of?(Resource) && model.base_model.equal?(other.model.base_model)
      cmp?(other, :==)
    end

[](name) click to toggle source
Alias for: attribute_get
[]=(name, value) click to toggle source
Alias for: attribute_set
attribute_dirty?(name) click to toggle source

Checks if an attribute has unsaved changes

@param [Symbol] name

    name of attribute to check for unsaved changes

@return [Boolean]

    true if attribute has unsaved changes

@api semipublic

    # File lib/dm-core/resource.rb, line 600
    def attribute_dirty?(name)
      dirty_attributes.key?(properties[name])
    end

attribute_get(name) click to toggle source

Returns the value of the attribute.

Do not read from instance variables directly, but use this method. This method handles lazy loading the attribute and returning of defaults if nessesary.

@example

    class Foo
      include DataMapper::Resource

      property :first_name, String
      property :last_name,  String

      def full_name
        "#{attribute_get(:first_name)} #{attribute_get(:last_name)}"
      end

      # using the shorter syntax
      def name_for_address_book
        "#{last_name}, #{first_name}"
      end
    end

@param [Symbol] name

    name of attribute to retrieve

@return [Object]

    the value stored at that given attribute
    (nil if none, and default if necessary)

@api public

    # File lib/dm-core/resource.rb, line 239
    def attribute_get(name)
      property = properties[name]
      persistence_state.get(property) if property
    end

Also aliased as: []
attribute_loaded?(name) click to toggle source

Checks if an attribute has been loaded from the repository

@example

    class Foo
      include DataMapper::Resource

      property :name,        String
      property :description, Text,   :lazy => false
    end

    Foo.new.attribute_loaded?(:description)   #=> false

@return [Boolean]

    true if ivar +name+ has been loaded

@return [Boolean]

    true if ivar +name+ has been loaded

@api private

    # File lib/dm-core/resource.rb, line 587
    def attribute_loaded?(name)
      properties[name].loaded?(self)
    end

attribute_set(name, value) click to toggle source

Sets the value of the attribute and marks the attribute as dirty if it has been changed so that it may be saved. Do not set from instance variables directly, but use this method. This method handles the lazy loading the property and returning of defaults if nessesary.

@example

    class Foo
      include DataMapper::Resource

      property :first_name, String
      property :last_name,  String

      def full_name(name)
        name = name.split(' ')
        attribute_set(:first_name, name[0])
        attribute_set(:last_name, name[1])
      end

      # using the shorter syntax
      def name_from_address_book(name)
        name = name.split(', ')
        first_name = name[1]
        last_name = name[0]
      end
    end

@param [Symbol] name

    name of attribute to set

@param [Object] value

    value to store

@return [undefined]

@api public

    # File lib/dm-core/resource.rb, line 281
    def attribute_set(name, value)
      property = properties[name]
      if property
        value = property.typecast(value)
        self.persistence_state = persistence_state.set(property, value)
      end
    end

Also aliased as: []=
attributes(key_on = :name) click to toggle source

Gets all the attributes of the Resource instance

@param [Symbol] key_on

    Use this attribute of the Property as keys.
    defaults to :name. :field is useful for adapters
    :property or nil use the actual Property object.

@return [Hash]

    All the attributes

@api public

    # File lib/dm-core/resource.rb, line 302
    def attributes(key_on = :name)
      attributes = {}

      lazy_load(properties)
      fields.each do |property|
        if model.public_method_defined?(name = property.name)
          key = case key_on
            when :name  then name
            when :field then property.field
            else             property
          end

          attributes[key] = __send__(name)
        end
      end

      attributes
    end

attributes=(attributes) click to toggle source

Assign values to multiple attributes in one call (mass assignment)

@param [Hash] attributes

    names and values of attributes to assign

@return [Hash]

    names and values of attributes assigned

@api public

    # File lib/dm-core/resource.rb, line 330
    def attributes=(attributes)
      model = self.model
      attributes.each do |name, value|
        case name
          when String, Symbol
            if model.allowed_writer_methods.include?(setter = "#{name}=")
              __send__(setter, value)
            else
              raise ArgumentError, "The attribute '#{name}' is not accessible in #{model}"
            end
          when Associations::Relationship, Property
            # only call a public #typecast (e.g. on Property instances)
            if name.respond_to?(:typecast)
              value = name.typecast(value)
            end
            self.persistence_state = persistence_state.set(name, value)
        end
      end
    end

clean?() click to toggle source

Checks if the resource has no changes to save

@return [Boolean]

    true if the resource may not be persisted

@api public

    # File lib/dm-core/resource.rb, line 181
    def clean?
      persistence_state.kind_of?(PersistenceState::Clean) ||
        persistence_state.kind_of?(PersistenceState::Immutable)
    end

collection() click to toggle source

Returns the Collection the Resource is associated with

@return [nil]

    nil if this is a new record

@return [Collection]

    a Collection that self belongs to

@api private

    # File lib/dm-core/resource.rb, line 629
    def collection
      return @_collection if @_collection || new? || readonly?
      collection_for_self
    end

collection=(collection) click to toggle source

Associates a Resource to a Collection

@param [Collection, nil] collection

    the collection to associate the resource with

@return [nil]

    nil if this is a new record

@return [Collection]

    a Collection that self belongs to

@api private

    # File lib/dm-core/resource.rb, line 645
    def collection=(collection)
      @_collection = collection
    end

collection_for_self() click to toggle source

Return a collection including the current resource only

@return [Collection]

    a collection containing self

@api private

    # File lib/dm-core/resource.rb, line 655
    def collection_for_self
      Collection.new(query, [ self ])
    end

destroy() click to toggle source

Destroy the instance, remove it from the repository

@return [Boolean]

    true if resource was destroyed

@api public

    # File lib/dm-core/resource.rb, line 436
    def destroy
      return true if destroyed?
      catch :halt do
        before_destroy_hook
        _destroy
        after_destroy_hook
      end
      destroyed?
    end

destroy!() click to toggle source

Destroy the instance, remove it from the repository, bypassing hooks

@return [Boolean]

    true if resource was destroyed

@api public

    # File lib/dm-core/resource.rb, line 452
    def destroy!
      return true if destroyed?
      _destroy(false)
      destroyed?
    end

destroyed?() click to toggle source

Checks if this Resource instance is destroyed

@return [Boolean]

    true if the resource has been destroyed

@api public

    # File lib/dm-core/resource.rb, line 171
    def destroyed?
      readonly? && !key.nil?
    end

dirty?() click to toggle source

Checks if the resource has unsaved changes

@return [Boolean]

    true if resource may be persisted

@api public

    # File lib/dm-core/resource.rb, line 192
    def dirty?
      run_once(true) do
        dirty_self? || dirty_parents? || dirty_children?
      end
    end

dirty_attributes() click to toggle source

Hash of attributes that have unsaved changes

@return [Hash]

    attributes that have unsaved changes

@api semipublic

    # File lib/dm-core/resource.rb, line 610
    def dirty_attributes
      dirty_attributes = {}

      original_attributes.each_key do |property|
        next unless property.respond_to?(:dump)
        dirty_attributes[property] = property.dump(property.get!(self))
      end

      dirty_attributes
    end

eql?(other) click to toggle source

Compares another Resource for equality

Resource is equal to `other` if they are the same object (identical object_id) or if they are both of the *same model* and all of their attributes are equivalent

@param [Resource] other

    the other Resource to compare with

@return [Boolean]

    true if they are equal, false if not

@api public

    # File lib/dm-core/resource.rb, line 471
    def eql?(other)
      return true if equal?(other)
      instance_of?(other.class) && cmp?(other, :eql?)
    end

hash() click to toggle source

Returns hash value of the object. Two objects with the same hash value assumed equal (using eql? method)

DataMapper resources are equal when their models have the same hash and they have the same set of properties

When used as key in a Hash or Hash subclass, objects are compared by eql? and thus hash value has direct effect on lookup

@api private

    # File lib/dm-core/resource.rb, line 527
    def hash
      model.hash ^ key.hash
    end

inspect() click to toggle source

Get a Human-readable representation of this Resource instance

    Foo.new   #=> #<Foo name=nil updated_at=nil created_at=nil id=nil>

@return [String]

    Human-readable representation of this Resource instance

@api public

    # File lib/dm-core/resource.rb, line 539
    def inspect
      # TODO: display relationship values
      attrs = properties.map do |property|
        value = if new? || property.loaded?(self)
          property.get!(self).inspect
        else
          '<not loaded>'
        end

        "#{property.instance_variable_name}=#{value}"
      end

      "#<#{model.name} #{attrs.join(' ')}>"
    end

key() click to toggle source

Retrieve the key(s) for this resource.

This always returns the persisted key value, even if the key is changed and not yet persisted. This is done so all relations still work.

@return [Array(Key)]

    the key(s) identifying this resource

@api public

    # File lib/dm-core/resource.rb, line 132
    def key
      return @_key if defined?(@_key)

      model_key = model.key(repository_name)

      key = model_key.map do |property|
        original_attributes[property] || (property.loaded?(self) ? property.get!(self) : nil)
      end

      # only memoize a valid key
      @_key = key if model_key.valid?(key)
    end

new?() click to toggle source

Checks if this Resource instance is new

@return [Boolean]

    true if the resource is new and not saved

@api public

    # File lib/dm-core/resource.rb, line 151
    def new?
      persistence_state.kind_of?(PersistenceState::Transient)
    end

original_attributes() click to toggle source

Hash of original values of attributes that have unsaved changes

@return [Hash]

    original values of attributes that have unsaved changes

@api semipublic

    # File lib/dm-core/resource.rb, line 560
    def original_attributes
      if persistence_state.respond_to?(:original_attributes)
        persistence_state.original_attributes.dup.freeze
      else
        {}.freeze
      end
    end

persistence_state() click to toggle source

Get the persisted state for the resource

@return [Resource::PersistenceState]

    the current persisted state for the resource

@api private

    # File lib/dm-core/resource.rb, line 83
    def persistence_state
      @_persistence_state ||= Resource::PersistenceState::Transient.new(self)
    end

persistence_state=(state) click to toggle source

Set the persisted state for the resource

@param [Resource::PersistenceState]

    the new persisted state for the resource

@return [undefined]

@api private

    # File lib/dm-core/resource.rb, line 95
    def persistence_state=(state)
      @_persistence_state = state
    end

persistence_state?() click to toggle source

Test if the persisted state is set

@return [Boolean]

    true if the persisted state is set

@api private

    # File lib/dm-core/resource.rb, line 105
    def persistence_state?
      defined?(@_persistence_state) ? true : false
    end

query() click to toggle source

Returns a Query that will match the resource

@return [Query]

    Query that will match the resource

@api semipublic

    # File lib/dm-core/resource.rb, line 665
    def query
      repository.new_query(model, :fields => fields, :conditions => conditions)
    end

raise_on_save_failure() click to toggle source

Return if Resource#save should raise an exception on save failures (per-resource)

This delegates to model.raise_on_save_failure by default.

    user.raise_on_save_failure  # => false

@return [Boolean]

    true if a failure in Resource#save should raise an exception

@api public

    # File lib/dm-core/resource.rb, line 30
    def raise_on_save_failure
      if defined?(@raise_on_save_failure)
        @raise_on_save_failure
      else
        model.raise_on_save_failure
      end
    end

raise_on_save_failure=(raise_on_save_failure) click to toggle source

Specify if Resource#save should raise an exception on save failures (per-resource)

@param [Boolean]

    a boolean that if true will cause Resource#save to raise an exception

@return [Boolean]

    true if a failure in Resource#save should raise an exception

@api public

    # File lib/dm-core/resource.rb, line 47
    def raise_on_save_failure=(raise_on_save_failure)
      @raise_on_save_failure = raise_on_save_failure
    end

readonly?() click to toggle source

Checks if this Resource instance is readonly

@return [Boolean]

    true if the resource cannot be persisted

@api public

    # File lib/dm-core/resource.rb, line 204
    def readonly?
      persistence_state.kind_of?(PersistenceState::Immutable)
    end

reload() click to toggle source

Reloads association and all child association

This is accomplished by resetting the Resource key to it's original value, and then removing all the ivars for properties and relationships. On the next access of those ivars, the resource will eager load what it needs. While this is more of a lazy reload, it should result in more consistent behavior since no cached results will remain from the initial load.

@return [Resource]

    the receiver, the current Resource instance

@api public

    # File lib/dm-core/resource.rb, line 363
    def reload
      if key
        reset_key
        clear_subjects
      end

      self.persistence_state = persistence_state.rollback

      self
    end

repository() click to toggle source

Repository this resource belongs to in the context of this collection or of the resource's class.

@return [Repository]

    the respository this resource belongs to, in the context of
    a collection OR in the instance's Model's context

@api semipublic

    # File lib/dm-core/resource.rb, line 117
    def repository
      # only set @_repository explicitly when persisted
      defined?(@_repository) ? @_repository : model.repository
    end

save() click to toggle source

Save the instance and loaded, dirty associations to the data-store

@return [Boolean]

    true if Resource instance and all associations were saved

@api public

    # File lib/dm-core/resource.rb, line 410
    def save
      assert_not_destroyed(:save)
      retval = _save
      assert_save_successful(:save, retval)
      retval
    end

save!() click to toggle source

Save the instance and loaded, dirty associations to the data-store, bypassing hooks

@return [Boolean]

    true if Resource instance and all associations were saved

@api public

    # File lib/dm-core/resource.rb, line 423
    def save!
      assert_not_destroyed(:save!)
      retval = _save(false)
      assert_save_successful(:save!, retval)
      retval
    end

saved?() click to toggle source

Checks if this Resource instance is saved

@return [Boolean]

    true if the resource has been saved

@api public

    # File lib/dm-core/resource.rb, line 161
    def saved?
      persistence_state.kind_of?(PersistenceState::Persisted)
    end

update(attributes) click to toggle source

Updates attributes and saves this Resource instance

@param [Hash] attributes

    attributes to be updated

@return [Boolean]

    true if resource and storage state match

@api public

    # File lib/dm-core/resource.rb, line 383
    def update(attributes)
      assert_update_clean_only(:update)
      self.attributes = attributes
      save
    end

update!(attributes) click to toggle source

Updates attributes and saves this Resource instance, bypassing hooks

@param [Hash] attributes

    attributes to be updated

@return [Boolean]

    true if resource and storage state match

@api public

    # File lib/dm-core/resource.rb, line 398
    def update!(attributes)
      assert_update_clean_only(:update!)
      self.attributes = attributes
      save!
    end

update_attributes(attributes = {}, *allowed) click to toggle source

Deprecated API for updating attributes and saving Resource

@see update

@deprecated

    # File lib/dm-core/resource.rb, line 56
    def update_attributes(attributes = {}, *allowed)
      raise "#{model}#update_attributes is deprecated, use #{model}#update instead (#{caller.first})"
    end

### Protected Instance Methods

after_create_hook() click to toggle source

Method for hooking callbacks after resource creation

@return [undefined]

@api private

    # File lib/dm-core/resource.rb, line 703
    def after_create_hook
      execute_hooks_for(:after, :create)
    end

after_destroy_hook() click to toggle source

Method for hooking callbacks after resource destruction

@return [undefined]

@api private

    # File lib/dm-core/resource.rb, line 739
    def after_destroy_hook
      execute_hooks_for(:after, :destroy)
    end

after_save_hook() click to toggle source

Method for hooking callbacks after resource saving

@return [undefined]

@api private

    # File lib/dm-core/resource.rb, line 685
    def after_save_hook
      execute_hooks_for(:after, :save)
    end

after_update_hook() click to toggle source

Method for hooking callbacks after resource updating

@return [undefined]

@api private

    # File lib/dm-core/resource.rb, line 721
    def after_update_hook
      execute_hooks_for(:after, :update)
    end

before_create_hook() click to toggle source

Method for hooking callbacks before resource creation

@return [undefined]

@api private

    # File lib/dm-core/resource.rb, line 694
    def before_create_hook
      execute_hooks_for(:before, :create)
    end

before_destroy_hook() click to toggle source

Method for hooking callbacks before resource destruction

@return [undefined]

@api private

    # File lib/dm-core/resource.rb, line 730
    def before_destroy_hook
      execute_hooks_for(:before, :destroy)
    end

before_save_hook() click to toggle source

Method for hooking callbacks before resource saving

@return [undefined]

@api private

    # File lib/dm-core/resource.rb, line 676
    def before_save_hook
      execute_hooks_for(:before, :save)
    end

before_update_hook() click to toggle source

Method for hooking callbacks before resource updating

@return [undefined]

@api private

    # File lib/dm-core/resource.rb, line 712
    def before_update_hook
      execute_hooks_for(:before, :update)
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.