Module: DataMapper::Model

### Home Classes Methods

### In Files

- lib/dm-core/model.rb
- lib/dm-core/model/hook.rb
- lib/dm-core/model/is.rb
- lib/dm-core/model/property.rb
- lib/dm-core/model/relationship.rb
- lib/dm-core/model/scope.rb

### Namespace

- MODULE DataMapper::Model::Hook
- MODULE DataMapper::Model::Is
- MODULE DataMapper::Model::Property
- MODULE DataMapper::Model::Relationship
- MODULE DataMapper::Model::Scope

### Methods

- ::append_extensions
- ::append_inclusions
- ::descendants
- ::extended
- ::extra_extensions
- ::extra_inclusions
- ::new
- ::raise_on_save_failure
- ::raise_on_save_failure=
- #[]
- #all
- #at
- #copy
- #create
- #create!
- #default_order
- #default_repository_name
- #descendants
- #destroy
- #destroy!
- #each
- #fetch
- #finalize
- #first
- #first_or_create
- #first_or_new
- #get
- #get!
- #inherited
- #last
- #load
- #raise_on_save_failure
- #raise_on_save_failure=
- #repositories
- #repository
- #repository_name
- #reverse
- #slice
- #storage_name
- #storage_names
- #update
- #update!
- #values_at

### Included Modules

- Enumerable
- DataMapper::Model::Is
- DataMapper::Model::Scope

### 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::Model

### Constants

INVALID_WRITER_METHODS
WRITER_METHOD_REGEXP

### Attributes

allowed_writer_methods[R]

The list of writer methods that can be mass-assigned to in attributes=

@return [Set]

@api private

base_model[R]

@api semipublic

### Public Class Methods

append_extensions(*extensions) click to toggle source

Extends the model with this module after Resource has been included.

This is a useful way to extend Model while still retaining a self.extended method.

@param [Module] extensions

    List of modules that will extend the model after it is extended by Model

@return [Boolean]

    whether or not the inclusions have been successfully appended to the list

@api semipublic

    # File lib/dm-core/model.rb, line 187
    def self.append_extensions(*extensions)
      extra_extensions.concat extensions

      # Add the extension to existing descendants
      descendants.each do |model|
        extensions.each { |extension| model.extend(extension) }
      end

      true
    end

append_inclusions(*inclusions) click to toggle source

Appends a module for inclusion into the model class after Resource.

This is a useful way to extend Resource while still retaining a self.included method.

@param [Module] inclusions

    the module that is to be appended to the module after Resource

@return [Boolean]

    true if the inclusions have been successfully appended to the list

@api semipublic

    # File lib/dm-core/model.rb, line 156
    def self.append_inclusions(*inclusions)
      extra_inclusions.concat inclusions

      # Add the inclusion to existing descendants
      descendants.each do |model|
        inclusions.each { |inclusion| model.send :include, inclusion }
      end

      true
    end

descendants() click to toggle source

Return all models that extend the Model module

    class Foo
      include DataMapper::Resource
    end

    DataMapper::Model.descendants.first   #=> Foo

@return [DescendantSet]

    Set containing the descendant models

@api semipublic

    # File lib/dm-core/model.rb, line 46
    def self.descendants
      @descendants ||= DescendantSet.new
    end

extended(descendant) click to toggle source

@api private

    # File lib/dm-core/model.rb, line 208
    def self.extended(descendant)
      descendants << descendant

      descendant.instance_variable_set(:@valid,         false)
      descendant.instance_variable_set(:@base_model,    descendant)
      descendant.instance_variable_set(:@storage_names, {})
      descendant.instance_variable_set(:@default_order, {})

      descendant.extend(Chainable)

      extra_extensions.each { |mod| descendant.extend(mod)         }
      extra_inclusions.each { |mod| descendant.send(:include, mod) }
    end

extra_extensions() click to toggle source

The current registered extra extensions

@return [Set]

@api private

    # File lib/dm-core/model.rb, line 203
    def self.extra_extensions
      @extra_extensions ||= []
    end

extra_inclusions() click to toggle source

The current registered extra inclusions

@return [Set]

@api private

    # File lib/dm-core/model.rb, line 172
    def self.extra_inclusions
      @extra_inclusions ||= []
    end

new(name = nil, namespace = Object, &block) click to toggle source

Creates a new Model class with its constant already set

If a block is passed, it will be eval'd in the context of the new Model

@param [to_s] name

    the name of the new model

@param [Object] namespace

    the namespace that will hold the new model

@param [Proc] block

    a block that will be eval'd in the context of the new Model class

@return [Model]

    the newly created Model class

@api private

    # File lib/dm-core/model.rb, line 23
    def self.new(name = nil, namespace = Object, &block)
      model = name ? namespace.const_set(name, Class.new) : Class.new

      model.class_eval         include DataMapper::Resource, __FILE__, __LINE__ + 1

      model.instance_eval(&block) if block
      model
    end

raise_on_save_failure() click to toggle source

Return if Resource#save should raise an exception on save failures (globally)

This is false by default.

    DataMapper::Model.raise_on_save_failure  # => false

@return [Boolean]

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

@api public

    # File lib/dm-core/model.rb, line 79
    def self.raise_on_save_failure
      if defined?(@raise_on_save_failure)
        @raise_on_save_failure
      else
        false
      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 (globally)

@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/model.rb, line 96
    def self.raise_on_save_failure=(raise_on_save_failure)
      @raise_on_save_failure = raise_on_save_failure
    end

### Public Instance Methods

[](*args) click to toggle source

    # File lib/dm-core/model.rb, line 294
    def [](*args)
      all[*args]
    end

Also aliased as: slice
all(query = Undefined) click to toggle source

Find a set of records matching an optional set of conditions. Additionally, specify the order that the records are return.

    Zoo.all                                   # all zoos
    Zoo.all(:open => true)                    # all zoos that are open
    Zoo.all(:opened_on => start..end)         # all zoos that opened on a date in the date-range
    Zoo.all(:order => [ :tiger_count.desc ])  # Ordered by tiger_count

@param [Hash] query

    A hash describing the conditions and order for the query

@return [Collection]

    A set of records found matching the conditions in +query+

@see Collection

@api public

    # File lib/dm-core/model.rb, line 337
    def all(query = Undefined)
      if query.equal?(Undefined) || (query.kind_of?(Hash) && query.empty?)
        # TODO: after adding Enumerable methods to Model, try to return self here
        new_collection(self.query.dup)
      else
        new_collection(scoped_query(query))
      end
    end

at(*args) click to toggle source

    # File lib/dm-core/model.rb, line 300
    def at(*args)
      all.at(*args)
    end

copy(source_repository_name, target_repository_name, query = {}) click to toggle source

Copy a set of records from one repository to another.

@param [String] source_repository_name

    The name of the Repository the resources should be copied _from_

@param [String] target_repository_name

    The name of the Repository the resources should be copied _to_

@param [Hash] query

    The conditions with which to find the records to copy. These
    conditions are merged with Model.query

@return [Collection]

    A Collection of the Resource instances created in the operation

@api public

    # File lib/dm-core/model.rb, line 538
    def copy(source_repository_name, target_repository_name, query = {})
      target_properties = properties(target_repository_name)

      query[:fields] ||= properties(source_repository_name).select do |property|
        target_properties.include?(property)
      end

      repository(target_repository_name) do |repository|
        resources = []

        all(query.merge(:repository => source_repository_name)).each do |resource|
          new_resource = new
          query[:fields].each { |property| new_resource.__send__("#{property.name}=", property.get(resource)) }
          resources << new_resource if new_resource.save
        end

        all(Query.target_query(repository, self, resources))
      end
    end

create(attributes = {}) click to toggle source

Create a Resource

@param [Hash(Symbol => Object)] attributes

    attributes to set

@return [Resource]

    the newly created Resource instance

@api public

    # File lib/dm-core/model.rb, line 457
    def create(attributes = {})
      _create(attributes)
    end

create!(attributes = {}) click to toggle source

Create a Resource, bypassing hooks

@param [Hash(Symbol => Object)] attributes

    attributes to set

@return [Resource]

    the newly created Resource instance

@api public

    # File lib/dm-core/model.rb, line 470
    def create!(attributes = {})
      _create(attributes, false)
    end

default_order(repository_name = default_repository_name) click to toggle source

@api semipublic

    # File lib/dm-core/model.rb, line 660
    def default_order(repository_name = default_repository_name)
      @default_order[repository_name] ||= key(repository_name).map { |property| Query::Direction.new(property) }.freeze
    end

default_repository_name() click to toggle source

@api semipublic

    # File lib/dm-core/model.rb, line 655
    def default_repository_name
      Repository.default_name
    end

descendants() click to toggle source

Return all models that inherit from a Model

    class Foo
      include DataMapper::Resource
    end

    class Bar < Foo
    end

    Foo.descendants.first   #=> Bar

@return [Set]

    Set containing the descendant classes

@api semipublic

    # File lib/dm-core/model.rb, line 65
    def descendants
      @descendants ||= DescendantSet.new
    end

destroy() click to toggle source

Remove all Resources from the repository

@return [Boolean]

    true if the resources were successfully destroyed

@api public

    # File lib/dm-core/model.rb, line 510
    def destroy
      all.destroy
    end

destroy!() click to toggle source

Remove all Resources from the repository, bypassing validation

@return [Boolean]

    true if the resources were successfully destroyed

@api public

    # File lib/dm-core/model.rb, line 520
    def destroy!
      all.destroy!
    end

each(&block) click to toggle source

    # File lib/dm-core/model.rb, line 316
    def each(&block)
      return to_enum unless block_given?
      all.each(&block)
      self
    end

fetch(*args, &block) click to toggle source

    # File lib/dm-core/model.rb, line 304
    def fetch(*args, &block)
      all.fetch(*args, &block)
    end

finalize() click to toggle source

Finish model setup and verify it is valid

@return [undefined]

@api public

    # File lib/dm-core/model.rb, line 136
    def finalize
      finalize_relationships
      finalize_allowed_writer_methods
      assert_valid_name
      assert_valid_properties
      assert_valid_key
    end

first(*args) click to toggle source

Return the first Resource or the first N Resources for the Model with an optional query

When there are no arguments, return the first Resource in the Model. When the first argument is an Integer, return a Collection containing the first N Resources. When the last (optional) argument is a Hash scope the results to the query.

@param [Integer] limit (optional)

    limit the returned Collection to a specific number of entries

@param [Hash] query (optional)

    scope the returned Resource or Collection to the supplied query

@return [Resource, Collection]

    The first resource in the entries of this collection,
    or a new collection whose query has been merged

@api public

    # File lib/dm-core/model.rb, line 363
    def first(*args)
      first_arg = args.first
      last_arg  = args.last

      limit_specified = first_arg.kind_of?(Integer)
      with_query      = (last_arg.kind_of?(Hash) && !last_arg.empty?) || last_arg.kind_of?(Query)

      limit = limit_specified ? first_arg : 1
      query = with_query      ? last_arg  : {}

      query = self.query.slice(0, limit).update(query)

      if limit_specified
        all(query)
      else
        query.repository.read(query).first
      end
    end

first_or_create(conditions = {}, attributes = {}) click to toggle source

Finds the first Resource by conditions, or creates a new Resource with the attributes if none found

@param [Hash] conditions

    The conditions to be used to search

@param [Hash] attributes

    The attributes to be used to create the record of none is found.

@return [Resource]

    The instance found by +query+, or created with +attributes+ if none found

@api public

    # File lib/dm-core/model.rb, line 444
    def first_or_create(conditions = {}, attributes = {})
      first(conditions) || create(conditions.merge(attributes))
    end

first_or_new(conditions = {}, attributes = {}) click to toggle source

Finds the first Resource by conditions, or initializes a new Resource with the attributes if none found

@param [Hash] conditions

    The conditions to be used to search

@param [Hash] attributes

    The attributes to be used to create the record of none is found.

@return [Resource]

    The instance found by +query+, or created with +attributes+ if none found

@api public

    # File lib/dm-core/model.rb, line 429
    def first_or_new(conditions = {}, attributes = {})
      first(conditions) || new(conditions.merge(attributes))
    end

get(*key) click to toggle source

Grab a single record by its key. Supports natural and composite key lookups as well.

    Zoo.get(1)                # get the zoo with primary key of 1.
    Zoo.get!(1)               # Or get! if you want an ObjectNotFoundError on failure
    Zoo.get('DFW')            # wow, support for natural primary keys
    Zoo.get('Metro', 'DFW')   # more wow, composite key look-up

@param [Object] *key

    The primary key or keys to use for lookup

@return [Resource, nil]

    A single model that was found
    If no instance was found matching +key+

@api public

    # File lib/dm-core/model.rb, line 270
    def get(*key)
      assert_valid_key_size(key)

      repository = self.repository
      key        = self.key(repository.name).typecast(key)

      repository.identity_map(self)[key] || first(key_conditions(repository, key).update(:order => nil))
    end

get!(*key) click to toggle source

Grab a single record just like get, but raise an ObjectNotFoundError if the record doesn't exist.

@param [Object] *key

    The primary key or keys to use for lookup

@return [Resource]

    A single model that was found

@raise [ObjectNotFoundError]

    The record was not found

@api public

    # File lib/dm-core/model.rb, line 290
    def get!(*key)
      get(*key) || raise(ObjectNotFoundError, "Could not find #{self.name} with key #{key.inspect}")
    end

inherited(descendant) click to toggle source

@api private

    # File lib/dm-core/model.rb, line 223
    def inherited(descendant)
      descendants << descendant

      descendant.instance_variable_set(:@valid,         false)
      descendant.instance_variable_set(:@base_model,    base_model)
      descendant.instance_variable_set(:@storage_names, @storage_names.dup)
      descendant.instance_variable_set(:@default_order, @default_order.dup)
    end

last(*args) click to toggle source

Return the last Resource or the last N Resources for the Model with an optional query

When there are no arguments, return the last Resource for the Model. When the first argument is an Integer, return a Collection containing the last N Resources. When the last (optional) argument is a Hash scope the results to the query.

@param [Integer] limit (optional)

    limit the returned Collection to a specific number of entries

@param [Hash] query (optional)

    scope the returned Resource or Collection to the supplied query

@return [Resource, Collection]

    The last resource in the entries of this collection,
    or a new collection whose query has been merged

@api public

    # File lib/dm-core/model.rb, line 399
    def last(*args)
      first_arg = args.first
      last_arg  = args.last

      limit_specified = first_arg.kind_of?(Integer)
      with_query      = (last_arg.kind_of?(Hash) && !last_arg.empty?) || last_arg.kind_of?(Query)

      limit = limit_specified ? first_arg : 1
      query = with_query      ? last_arg  : {}

      query = self.query.slice(0, limit).update(query).reverse!

      if limit_specified
        all(query)
      else
        query.repository.read(query).last
      end
    end

load(records, query) click to toggle source

Loads an instance of this Model, taking into account IdentityMap lookup, inheritance columns(s) and Property typecasting.

@param [Enumerable(Object)] records

    an Array of Resource or Hashes to load a Resource with

@return [Resource]

    the loaded Resource instance

@api semipublic

    # File lib/dm-core/model.rb, line 568
    def load(records, query)
      repository      = query.repository
      repository_name = repository.name
      fields          = query.fields
      discriminator   = properties(repository_name).discriminator
      no_reload       = !query.reload?

      field_map = Hash[ fields.map { |property| [ property, property.field ] } ]

      records.map do |record|
        identity_map = nil
        key_values   = nil
        resource     = nil

        case record
          when Hash
            # remap fields to use the Property object
            record = record.dup
            field_map.each { |property, field| record[property] = record.delete(field) if record.key?(field) }

            model     = discriminator && discriminator.load(record[discriminator]) || self
            model_key = model.key(repository_name)

            resource = if model_key.valid?(key_values = record.values_at(*model_key))
              identity_map = repository.identity_map(model)
              identity_map[key_values]
            end

            resource ||= model.allocate

            fields.each do |property|
              next if no_reload && property.loaded?(resource)

              value = record[property]

              # TODO: typecasting should happen inside the Adapter
              # and all values should come back as expected objects
              value = property.load(value)

              property.set!(resource, value)
            end

          when Resource
            model     = record.model
            model_key = model.key(repository_name)

            resource = if model_key.valid?(key_values = record.key)
              identity_map = repository.identity_map(model)
              identity_map[key_values]
            end

            resource ||= model.allocate

            fields.each do |property|
              next if no_reload && property.loaded?(resource)

              property.set!(resource, property.get!(record))
            end
        end

        resource.instance_variable_set(:@_repository, repository)

        if identity_map
          resource.persistence_state = Resource::PersistenceState::Clean.new(resource) unless resource.persistence_state?

          # defer setting the IdentityMap so second level caches can
          # record the state of the resource after loaded
          identity_map[key_values] = resource
        else
          resource.persistence_state = Resource::PersistenceState::Immutable.new(resource)
        end

        resource
      end
    end

raise_on_save_failure() click to toggle source

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

This delegates to DataMapper::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/model.rb, line 110
    def raise_on_save_failure
      if defined?(@raise_on_save_failure)
        @raise_on_save_failure
      else
        DataMapper::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-model)

@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/model.rb, line 127
    def raise_on_save_failure=(raise_on_save_failure)
      @raise_on_save_failure = raise_on_save_failure
    end

repositories() click to toggle source

Gets the current Set of repositories for which this Model has been defined (beyond default)

@return [Set]

    The Set of repositories for which this Model
    has been defined (beyond default)

@api private

    # File lib/dm-core/model.rb, line 709
    def repositories
      [ repository ].to_set + @properties.keys.map { |repository_name| DataMapper.repository(repository_name) }
    end

repository(name = nil, &block) click to toggle source

Get the repository with a given name, or the default one for the current context, or the default one for this class.

@param [Symbol] name

    the name of the repository wanted

@param [Block] block

    block to execute with the fetched repository as parameter

@return [Object, Respository]

    whatever the block returns, if given a block,
    otherwise the requested repository.

@api private

    # File lib/dm-core/model.rb, line 677
    def repository(name = nil, &block)
      #
      # There has been a couple of different strategies here, but me (zond) and dkubb are at least
      # united in the concept of explicitness over implicitness. That is - the explicit wish of the
      # caller (+name+) should be given more priority than the implicit wish of the caller (Repository.context.last).
      #

      DataMapper.repository(name || repository_name, &block)
    end

repository_name() click to toggle source

Get the current `repository_name` for this Model.

If there are any Repository contexts, the name of the last one will be returned, else the `default_repository_name` of this model will be

@return [String]

    the current repository name to use for this Model

@api private

    # File lib/dm-core/model.rb, line 696
    def repository_name
      context = Repository.context
      context.any? ? context.last.name : default_repository_name
    end

reverse() click to toggle source

    # File lib/dm-core/model.rb, line 312
    def reverse
      all.reverse
    end

slice(*args) click to toggle source
Alias for: []
storage_name(repository_name = default_repository_name) click to toggle source

Gets the name of the storage receptacle for this resource in the given Repository (ie., table name, for database stores).

@return [String]

    the storage name (ie., table name, for database stores) associated with
    this resource in the given repository

@api public

    # File lib/dm-core/model.rb, line 240
    def storage_name(repository_name = default_repository_name)
      storage_names[repository_name] ||= repository(repository_name).adapter.resource_naming_convention.call(default_storage_name).freeze
    end

storage_names() click to toggle source

the names of the storage receptacles for this resource across all repositories

@return [Hash(Symbol => String)]

    All available names of storage receptacles

@api public

    # File lib/dm-core/model.rb, line 250
    def storage_names
      @storage_names
    end

update(attributes) click to toggle source

Update every Resource

    Person.update(:allow_beer => true)

@param [Hash] attributes

    attributes to update with

@return [Boolean]

    true if the resources were successfully updated

@api public

    # File lib/dm-core/model.rb, line 485
    def update(attributes)
      all.update(attributes)
    end

update!(attributes) click to toggle source

Update every Resource, bypassing validations

    Person.update!(:allow_beer => true)

@param [Hash] attributes

    attributes to update with

@return [Boolean]

    true if the resources were successfully updated

@api public

    # File lib/dm-core/model.rb, line 500
    def update!(attributes)
      all.update!(attributes)
    end

values_at(*args) click to toggle source

    # File lib/dm-core/model.rb, line 308
    def values_at(*args)
      all.values_at(*args)
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.