Module: DataMapper::Model

Module | DataMapper::Model
In: | lib/dm-core/model.rb lib/dm-core/model/descendant_set.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

### Methods

[] all append_extensions append_inclusions at copy create create! default_order default_repository_name descendants entries extended extra_extensions extra_inclusions first first_or_create first_or_new get get! inherited last load model_method_defined? new new repositories repository repository_name resource_method_defined? reverse slice storage_name storage_names to_a

### Included Modules

Is Scope

### Classes and Modules

Module DataMapper::Model::Hook
Module DataMapper::Model::Is
Module DataMapper::Model::Property
Module DataMapper::Model::Relationship
Module DataMapper::Model::Scope
Class DataMapper::Model::DescendantSet

### Attributes

base_model | [R] | TODO: document @api semipublic
descendants | [R] | 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 private

### Public Class methods

append_extensions(*extensions)

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

append_inclusions(*inclusions)

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

descendants()

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 private

extended(model)

TODO: document @api private

extra_extensions()

The current registered extra extensions

@return [Set]

@api private

extra_inclusions()

The current registered extra inclusions

@return [Set]

@api private

new(storage_name = nil, &block)

Creates a new Model class with default_storage_name `storage_name`

If a block is passed, it will be eval‘d in the context of 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 semipublic

### Public Instance methods

[](*args)
all(query = nil)

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

at(*args)
copy(source, destination, query = {})

Copy a set of records from one repository to another.

@param [String] source

      The name of the Repository the resources should be copied _from_

@param [String] destination

      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

create(attributes = {})

Create a Resource

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

      attributes to set

@return [Resource]

      the newly created Resource instance

@api public

create!(attributes = {})

Create a Resource, bypassing hooks

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

      attributes to set

@return [Resource]

      the newly created Resource instance

@api public

default_order(repository_name = default_repository_name)

TODO: document @api semipublic

default_repository_name()

TODO: document @api semipublic

entries()

TODO: spec this

first(*args)

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

first_or_create(conditions = {}, attributes = {})

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

first_or_new(conditions = {}, attributes = {})

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

get(*key)

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,NilClass]

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

@api public

get!(*key)

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

inherited(model)
last(*args)

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

load(records, query)

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

model_method_defined?(method)

TODO: document @api private

new(*args, &block)
repositories()

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

repository(name = nil) {|*block_args| ...}

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

repository_name()

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

resource_method_defined?(method)

TODO: document @api private

reverse()
slice(*args)

Alias for #[]

storage_name(repository_name = default_repository_name)

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

storage_names()

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

@return [Hash(Symbol => String)]

      All available names of storage recepticles

@api public

to_a()

Alias for entries

[Validate]