Module DataMapper::Resource
In: lib/dm-core/resource.rb
lib/dm-core/backwards.rb
lib/dm-core/resource/persistence_state.rb
lib/dm-core/resource/persistence_state/dirty.rb
lib/dm-core/resource/persistence_state/clean.rb
lib/dm-core/resource/persistence_state/transient.rb
lib/dm-core/resource/persistence_state/persisted.rb
lib/dm-core/resource/persistence_state/immutable.rb
lib/dm-core/resource/persistence_state/deleted.rb

Methods

Included Modules

DataMapper::Assertions

Classes and Modules

Class DataMapper::Resource::PersistenceState

External Aliases

class -> model
  @api public

Public Class methods

@deprecated

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

Public Instance methods

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

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

[](name)

Alias for attribute_get

[]=(name, value)

Alias for attribute_set

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

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

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

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

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

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

Checks if the resource has no changes to save

@return [Boolean]

  true if the resource may not be persisted

@api public

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

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

Return a collection including the current resource only

@return [Collection]

  a collection containing self

@api private

Destroy the instance, remove it from the repository

@return [Boolean]

  true if resource was destroyed

@api public

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

@return [Boolean]

  true if resource was destroyed

@api public

Checks if this Resource instance is destroyed

@return [Boolean]

  true if the resource has been destroyed

@api public

Checks if the resource has unsaved changes

@return [Boolean]

 true if resource may be persisted

@api public

Hash of attributes that have unsaved changes

@return [Hash]

  attributes that have unsaved changes

@api semipublic

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

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

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

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

Checks if this Resource instance is new

@return [Boolean]

  true if the resource is new and not saved

@api public

Hash of original values of attributes that have unsaved changes

@return [Hash]

  original values of attributes that have unsaved changes

@api semipublic

Get the persisted state for the resource

@return [Resource::PersistenceState]

  the current persisted state for the resource

@api private

Set the persisted state for the resource

@param [Resource::PersistenceState]

  the new persisted state for the resource

@return [undefined]

@api private

Test if the persisted state is set

@return [Boolean]

  true if the persisted state is set

@api private

Returns a Query that will match the resource

@return [Query]

  Query that will match the resource

@api semipublic

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

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

Checks if this Resource instance is readonly

@return [Boolean]

  true if the resource cannot be persisted

@api public

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

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

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

@return [Boolean]

  true if Resource instance and all associations were saved

@api public

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

Checks if this Resource instance is saved

@return [Boolean]

  true if the resource has been saved

@api public

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

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

Deprecated API for updating attributes and saving Resource

@see update

@deprecated

Protected Instance methods

Method for hooking callbacks after resource creation

@return [undefined]

@api private

Method for hooking callbacks after resource destruction

@return [undefined]

@api private

Method for hooking callbacks after resource saving

@return [undefined]

@api private

Method for hooking callbacks after resource updating

@return [undefined]

@api private

Method for hooking callbacks before resource creation

@return [undefined]

@api private

Method for hooking callbacks before resource destruction

@return [undefined]

@api private

Method for hooking callbacks before resource saving

@return [undefined]

@api private

Method for hooking callbacks before resource updating

@return [undefined]

@api private

[Validate]