@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
@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
@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
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
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
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
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
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
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
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
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
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
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
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
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
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 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 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 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 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 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
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
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
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
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
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
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
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
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
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
Generated with the Darkfish Rdoc Generator 2.