rails 4.2.11.3 → 5.0.0.beta1

data/guides/source/active_record_basics.md

@@ -1,374 +0,0 @@
-Active Record Basics
-====================
-
-This guide is an introduction to Active Record.
-
-After reading this guide, you will know:
-
-* What Object Relational Mapping and Active Record are and how they are used in
-  Rails.
-* How Active Record fits into the Model-View-Controller paradigm.
-* How to use Active Record models to manipulate data stored in a relational
-  database.
-* Active Record schema naming conventions.
-* The concepts of database migrations, validations and callbacks.
-
---------------------------------------------------------------------------------
-
-What is Active Record?
-----------------------
-
-Active Record is the M in [MVC](getting_started.html#the-mvc-architecture) - the
-model - which is the layer of the system responsible for representing business
-data and logic. Active Record facilitates the creation and use of business
-objects whose data requires persistent storage to a database. It is an
-implementation of the Active Record pattern which itself is a description of an
-Object Relational Mapping system.
-
-### The Active Record Pattern
-
-[Active Record was described by Martin Fowler](http://www.martinfowler.com/eaaCatalog/activeRecord.html)
-in his book _Patterns of Enterprise Application Architecture_. In
-Active Record, objects carry both persistent data and behavior which
-operates on that data. Active Record takes the opinion that ensuring
-data access logic as part of the object will educate users of that
-object on how to write to and read from the database.
-
-### Object Relational Mapping
-
-Object-Relational Mapping, commonly referred to as its abbreviation ORM, is
-a technique that connects the rich objects of an application to tables in
-a relational database management system. Using ORM, the properties and
-relationships of the objects in an application can be easily stored and
-retrieved from a database without writing SQL statements directly and with less
-overall database access code.
-
-### Active Record as an ORM Framework
-
-Active Record gives us several mechanisms, the most important being the ability
-to:
-
-* Represent models and their data.
-* Represent associations between these models.
-* Represent inheritance hierarchies through related models.
-* Validate models before they get persisted to the database.
-* Perform database operations in an object-oriented fashion.
-
-Convention over Configuration in Active Record
-----------------------------------------------
-
-When writing applications using other programming languages or frameworks, it
-may be necessary to write a lot of configuration code. This is particularly true
-for ORM frameworks in general. However, if you follow the conventions adopted by
-Rails, you'll need to write very little configuration (in some case no
-configuration at all) when creating Active Record models. The idea is that if
-you configure your applications in the very same way most of the time then this
-should be the default way. Thus, explicit configuration would be needed
-only in those cases where you can't follow the standard convention.
-
-### Naming Conventions
-
-By default, Active Record uses some naming conventions to find out how the
-mapping between models and database tables should be created. Rails will
-pluralize your class names to find the respective database table. So, for
-a class `Book`, you should have a database table called **books**. The Rails
-pluralization mechanisms are very powerful, being capable to pluralize (and
-singularize) both regular and irregular words. When using class names composed
-of two or more words, the model class name should follow the Ruby conventions,
-using the CamelCase form, while the table name must contain the words separated
-by underscores. Examples:
-
-* Database Table - Plural with underscores separating words (e.g., `book_clubs`).
-* Model Class - Singular with the first letter of each word capitalized (e.g.,
-`BookClub`).
-
-| Model / Class    | Table / Schema |
-| ---------------- | -------------- |
-| `Article`        | `articles`     |
-| `LineItem`       | `line_items`   |
-| `Deer`           | `deers`        |
-| `Mouse`          | `mice`         |
-| `Person`         | `people`       |
-
-
-### Schema Conventions
-
-Active Record uses naming conventions for the columns in database tables,
-depending on the purpose of these columns.
-
-* **Foreign keys** - These fields should be named following the pattern
-  `singularized_table_name_id` (e.g., `item_id`, `order_id`). These are the
-  fields that Active Record will look for when you create associations between
-  your models.
-* **Primary keys** - By default, Active Record will use an integer column named
-  `id` as the table's primary key. When using [Active Record
-  Migrations](migrations.html) to create your tables, this column will be
-  automatically created.
-
-There are also some optional column names that will add additional features
-to Active Record instances:
-
-* `created_at` - Automatically gets set to the current date and time when the
-  record is first created.
-* `updated_at` - Automatically gets set to the current date and time whenever
-  the record is updated.
-* `lock_version` - Adds [optimistic
-  locking](http://api.rubyonrails.org/classes/ActiveRecord/Locking.html) to
-  a model.
-* `type` - Specifies that the model uses [Single Table
-  Inheritance](http://api.rubyonrails.org/classes/ActiveRecord/Base.html#class-ActiveRecord::Base-label-Single+table+inheritance).
-* `(association_name)_type` - Stores the type for
-  [polymorphic associations](association_basics.html#polymorphic-associations).
-* `(table_name)_count` - Used to cache the number of belonging objects on
-  associations. For example, a `comments_count` column in a `Articles` class that
-  has many instances of `Comment` will cache the number of existent comments
-  for each article.
-
-NOTE: While these column names are optional, they are in fact reserved by Active Record. Steer clear of reserved keywords unless you want the extra functionality. For example, `type` is a reserved keyword used to designate a table using Single Table Inheritance (STI). If you are not using STI, try an analogous keyword like "context", that may still accurately describe the data you are modeling.
-
-Creating Active Record Models
------------------------------
-
-It is very easy to create Active Record models. All you have to do is to
-subclass the `ActiveRecord::Base` class and you're good to go:
-
-```ruby
-class Product < ActiveRecord::Base
-end
-```
-
-This will create a `Product` model, mapped to a `products` table at the
-database. By doing this you'll also have the ability to map the columns of each
-row in that table with the attributes of the instances of your model. Suppose
-that the `products` table was created using an SQL sentence like:
-
-```sql
-CREATE TABLE products (
-   id int(11) NOT NULL auto_increment,
-   name varchar(255),
-   PRIMARY KEY  (id)
-);
-```
-
-Following the table schema above, you would be able to write code like the
-following:
-
-```ruby
-p = Product.new
-p.name = "Some Book"
-puts p.name # "Some Book"
-```
-
-Overriding the Naming Conventions
----------------------------------
-
-What if you need to follow a different naming convention or need to use your
-Rails application with a legacy database? No problem, you can easily override
-the default conventions.
-
-You can use the `ActiveRecord::Base.table_name=` method to specify the table
-name that should be used:
-
-```ruby
-class Product < ActiveRecord::Base
-  self.table_name = "my_products"
-end
-```
-
-If you do so, you will have to define manually the class name that is hosting
-the fixtures (my_products.yml) using the `set_fixture_class` method in your test
-definition:
-
-```ruby
-class ProductTest < ActiveSupport::TestCase
-  set_fixture_class my_products: Product
-  fixtures :my_products
-  ...
-end
-```
-
-It's also possible to override the column that should be used as the table's
-primary key using the `ActiveRecord::Base.primary_key=` method:
-
-```ruby
-class Product < ActiveRecord::Base
-  self.primary_key = "product_id"
-end
-```
-
-CRUD: Reading and Writing Data
-------------------------------
-
-CRUD is an acronym for the four verbs we use to operate on data: **C**reate,
-**R**ead, **U**pdate and **D**elete. Active Record automatically creates methods
-to allow an application to read and manipulate data stored within its tables.
-
-### Create
-
-Active Record objects can be created from a hash, a block or have their
-attributes manually set after creation. The `new` method will return a new
-object while `create` will return the object and save it to the database.
-
-For example, given a model `User` with attributes of `name` and `occupation`,
-the `create` method call will create and save a new record into the database:
-
-```ruby
-user = User.create(name: "David", occupation: "Code Artist")
-```
-
-Using the `new` method, an object can be instantiated without being saved:
-
-```ruby
-user = User.new
-user.name = "David"
-user.occupation = "Code Artist"
-```
-
-A call to `user.save` will commit the record to the database.
-
-Finally, if a block is provided, both `create` and `new` will yield the new
-object to that block for initialization:
-
-```ruby
-user = User.new do |u|
-  u.name = "David"
-  u.occupation = "Code Artist"
-end
-```
-
-### Read
-
-Active Record provides a rich API for accessing data within a database. Below
-are a few examples of different data access methods provided by Active Record.
-
-```ruby
-# return a collection with all users
-users = User.all
-```
-
-```ruby
-# return the first user
-user = User.first
-```
-
-```ruby
-# return the first user named David
-david = User.find_by(name: 'David')
-```
-
-```ruby
-# find all users named David who are Code Artists and sort by created_at in reverse chronological order
-users = User.where(name: 'David', occupation: 'Code Artist').order(created_at: :desc)
-```
-
-You can learn more about querying an Active Record model in the [Active Record
-Query Interface](active_record_querying.html) guide.
-
-### Update
-
-Once an Active Record object has been retrieved, its attributes can be modified
-and it can be saved to the database.
-
-```ruby
-user = User.find_by(name: 'David')
-user.name = 'Dave'
-user.save
-```
-
-A shorthand for this is to use a hash mapping attribute names to the desired
-value, like so:
-
-```ruby
-user = User.find_by(name: 'David')
-user.update(name: 'Dave')
-```
-
-This is most useful when updating several attributes at once. If, on the other
-hand, you'd like to update several records in bulk, you may find the
-`update_all` class method useful:
-
-```ruby
-User.update_all "max_login_attempts = 3, must_change_password = 'true'"
-```
-
-### Delete
-
-Likewise, once retrieved an Active Record object can be destroyed which removes
-it from the database.
-
-```ruby
-user = User.find_by(name: 'David')
-user.destroy
-```
-
-Validations
------------
-
-Active Record allows you to validate the state of a model before it gets written
-into the database. There are several methods that you can use to check your
-models and validate that an attribute value is not empty, is unique and not
-already in the database, follows a specific format and many more.
-
-Validation is a very important issue to consider when persisting to the database, so
-the methods `save` and `update` take it into account when
-running: they return `false` when validation fails and they didn't actually
-perform any operation on the database. All of these have a bang counterpart (that
-is, `save!` and `update!`), which are stricter in that
-they raise the exception `ActiveRecord::RecordInvalid` if validation fails.
-A quick example to illustrate:
-
-```ruby
-class User < ActiveRecord::Base
-  validates :name, presence: true
-end
-
-user = User.new
-user.save  # => false
-user.save! # => ActiveRecord::RecordInvalid: Validation failed: Name can't be blank
-```
-
-You can learn more about validations in the [Active Record Validations
-guide](active_record_validations.html).
-
-Callbacks
----------
-
-Active Record callbacks allow you to attach code to certain events in the
-life-cycle of your models. This enables you to add behavior to your models by
-transparently executing code when those events occur, like when you create a new
-record, update it, destroy it and so on. You can learn more about callbacks in
-the [Active Record Callbacks guide](active_record_callbacks.html).
-
-Migrations
-----------
-
-Rails provides a domain-specific language for managing a database schema called
-migrations. Migrations are stored in files which are executed against any
-database that Active Record supports using `rake`. Here's a migration that
-creates a table:
-
-```ruby
-class CreatePublications < ActiveRecord::Migration
-  def change
-    create_table :publications do |t|
-      t.string :title
-      t.text :description
-      t.references :publication_type
-      t.integer :publisher_id
-      t.string :publisher_type
-      t.boolean :single_issue
-
-      t.timestamps null: false
-    end
-    add_index :publications, :publication_type_id
-  end
-end
-```
-
-Rails keeps track of which files have been committed to the database and
-provides rollback features. To actually create the table, you'd run `rake db:migrate`
-and to roll it back, `rake db:rollback`.
-
-Note that the above code is database-agnostic: it will run in MySQL,
-PostgreSQL, Oracle and others. You can learn more about migrations in the
-[Active Record Migrations guide](migrations.html).

data/guides/source/active_record_callbacks.md

@@ -1,413 +0,0 @@
-Active Record Callbacks
-=======================
-
-This guide teaches you how to hook into the life cycle of your Active Record
-objects.
-
-After reading this guide, you will know:
-
-* The life cycle of Active Record objects.
-* How to create callback methods that respond to events in the object life cycle.
-* How to create special classes that encapsulate common behavior for your callbacks.
-
---------------------------------------------------------------------------------
-
-The Object Life Cycle
----------------------
-
-During the normal operation of a Rails application, objects may be created, updated, and destroyed. Active Record provides hooks into this *object life cycle* so that you can control your application and its data.
-
-Callbacks allow you to trigger logic before or after an alteration of an object's state.
-
-Callbacks Overview
-------------------
-
-Callbacks are methods that get called at certain moments of an object's life cycle. With callbacks it is possible to write code that will run whenever an Active Record object is created, saved, updated, deleted, validated, or loaded from the database.
-
-### Callback Registration
-
-In order to use the available callbacks, you need to register them. You can implement the callbacks as ordinary methods and use a macro-style class method to register them as callbacks:
-
-```ruby
-class User < ActiveRecord::Base
-  validates :login, :email, presence: true
-
-  before_validation :ensure_login_has_a_value
-
-  protected
-    def ensure_login_has_a_value
-      if login.nil?
-        self.login = email unless email.blank?
-      end
-    end
-end
-```
-
-The macro-style class methods can also receive a block. Consider using this style if the code inside your block is so short that it fits in a single line:
-
-```ruby
-class User < ActiveRecord::Base
-  validates :login, :email, presence: true
-
-  before_create do
-    self.name = login.capitalize if name.blank?
-  end
-end
-```
-
-Callbacks can also be registered to only fire on certain life cycle events:
-
-```ruby
-class User < ActiveRecord::Base
-  before_validation :normalize_name, on: :create
-
-  # :on takes an array as well
-  after_validation :set_location, on: [ :create, :update ]
-
-  protected
-    def normalize_name
-      self.name = self.name.downcase.titleize
-    end
-
-    def set_location
-      self.location = LocationService.query(self)
-    end
-end
-```
-
-It is considered good practice to declare callback methods as protected or private. If left public, they can be called from outside of the model and violate the principle of object encapsulation.
-
-Available Callbacks
--------------------
-
-Here is a list with all the available Active Record callbacks, listed in the same order in which they will get called during the respective operations:
-
-### Creating an Object
-
-* `before_validation`
-* `after_validation`
-* `before_save`
-* `around_save`
-* `before_create`
-* `around_create`
-* `after_create`
-* `after_save`
-* `after_commit/after_rollback`
-
-### Updating an Object
-
-* `before_validation`
-* `after_validation`
-* `before_save`
-* `around_save`
-* `before_update`
-* `around_update`
-* `after_update`
-* `after_save`
-* `after_commit/after_rollback`
-
-### Destroying an Object
-
-* `before_destroy`
-* `around_destroy`
-* `after_destroy`
-* `after_commit/after_rollback`
-
-WARNING. `after_save` runs both on create and update, but always _after_ the more specific callbacks `after_create` and `after_update`, no matter the order in which the macro calls were executed.
-
-### `after_initialize` and `after_find`
-
-The `after_initialize` callback will be called whenever an Active Record object is instantiated, either by directly using `new` or when a record is loaded from the database. It can be useful to avoid the need to directly override your Active Record `initialize` method.
-
-The `after_find` callback will be called whenever Active Record loads a record from the database. `after_find` is called before `after_initialize` if both are defined.
-
-The `after_initialize` and `after_find` callbacks have no `before_*` counterparts, but they can be registered just like the other Active Record callbacks.
-
-```ruby
-class User < ActiveRecord::Base
-  after_initialize do |user|
-    puts "You have initialized an object!"
-  end
-
-  after_find do |user|
-    puts "You have found an object!"
-  end
-end
-
->> User.new
-You have initialized an object!
-=> #<User id: nil>
-
->> User.first
-You have found an object!
-You have initialized an object!
-=> #<User id: 1>
-```
-
-### `after_touch`
-
-The `after_touch` callback will be called whenever an Active Record object is touched.
-
-```ruby
-class User < ActiveRecord::Base
-  after_touch do |user|
-    puts "You have touched an object"
-  end
-end
-
->> u = User.create(name: 'Kuldeep')
-=> #<User id: 1, name: "Kuldeep", created_at: "2013-11-25 12:17:49", updated_at: "2013-11-25 12:17:49">
-
->> u.touch
-You have touched an object
-=> true
-```
-
-It can be used along with `belongs_to`:
-
-```ruby
-class Employee < ActiveRecord::Base
-  belongs_to :company, touch: true
-  after_touch do
-    puts 'An Employee was touched'
-  end
-end
-
-class Company < ActiveRecord::Base
-  has_many :employees
-  after_touch :log_when_employees_or_company_touched
-
-  private
-  def log_when_employees_or_company_touched
-    puts 'Employee/Company was touched'
-  end
-end
-
->> @employee = Employee.last
-=> #<Employee id: 1, company_id: 1, created_at: "2013-11-25 17:04:22", updated_at: "2013-11-25 17:05:05">
-
-# triggers @employee.company.touch
->> @employee.touch
-Employee/Company was touched
-An Employee was touched
-=> true
-```
-
-Running Callbacks
------------------
-
-The following methods trigger callbacks:
-
-* `create`
-* `create!`
-* `decrement!`
-* `destroy`
-* `destroy!`
-* `destroy_all`
-* `increment!`
-* `save`
-* `save!`
-* `save(validate: false)`
-* `toggle!`
-* `update_attribute`
-* `update`
-* `update!`
-* `valid?`
-
-Additionally, the `after_find` callback is triggered by the following finder methods:
-
-* `all`
-* `first`
-* `find`
-* `find_by`
-* `find_by_*`
-* `find_by_*!`
-* `find_by_sql`
-* `last`
-
-The `after_initialize` callback is triggered every time a new object of the class is initialized.
-
-NOTE: The `find_by_*` and `find_by_*!` methods are dynamic finders generated automatically for every attribute. Learn more about them at the [Dynamic finders section](active_record_querying.html#dynamic-finders)
-
-Skipping Callbacks
-------------------
-
-Just as with validations, it is also possible to skip callbacks by using the following methods:
-
-* `decrement`
-* `decrement_counter`
-* `delete`
-* `delete_all`
-* `increment`
-* `increment_counter`
-* `toggle`
-* `touch`
-* `update_column`
-* `update_columns`
-* `update_all`
-* `update_counters`
-
-These methods should be used with caution, however, because important business rules and application logic may be kept in callbacks. Bypassing them without understanding the potential implications may lead to invalid data.
-
-Halting Execution
------------------
-
-As you start registering new callbacks for your models, they will be queued for execution. This queue will include all your model's validations, the registered callbacks, and the database operation to be executed.
-
-The whole callback chain is wrapped in a transaction. If any _before_ callback method returns exactly `false` or raises an exception, the execution chain gets halted and a ROLLBACK is issued; _after_ callbacks can only accomplish that by raising an exception.
-
-WARNING. Any exception that is not `ActiveRecord::Rollback` will be re-raised by Rails after the callback chain is halted. Raising an exception other than `ActiveRecord::Rollback` may break code that does not expect methods like `save` and `update_attributes` (which normally try to return `true` or `false`) to raise an exception.
-
-Relational Callbacks
---------------------
-
-Callbacks work through model relationships, and can even be defined by them. Suppose an example where a user has many articles. A user's articles should be destroyed if the user is destroyed. Let's add an `after_destroy` callback to the `User` model by way of its relationship to the `Article` model:
-
-```ruby
-class User < ActiveRecord::Base
-  has_many :articles, dependent: :destroy
-end
-
-class Article < ActiveRecord::Base
-  after_destroy :log_destroy_action
-
-  def log_destroy_action
-    puts 'Article destroyed'
-  end
-end
-
->> user = User.first
-=> #<User id: 1>
->> user.articles.create!
-=> #<Article id: 1, user_id: 1>
->> user.destroy
-Article destroyed
-=> #<User id: 1>
-```
-
-Conditional Callbacks
----------------------
-
-As with validations, we can also make the calling of a callback method conditional on the satisfaction of a given predicate. We can do this using the `:if` and `:unless` options, which can take a symbol, a string, a `Proc` or an `Array`. You may use the `:if` option when you want to specify under which conditions the callback **should** be called. If you want to specify the conditions under which the callback **should not** be called, then you may use the `:unless` option.
-
-### Using `:if` and `:unless` with a `Symbol`
-
-You can associate the `:if` and `:unless` options with a symbol corresponding to the name of a predicate method that will get called right before the callback. When using the `:if` option, the callback won't be executed if the predicate method returns false; when using the `:unless` option, the callback won't be executed if the predicate method returns true. This is the most common option. Using this form of registration it is also possible to register several different predicates that should be called to check if the callback should be executed.
-
-```ruby
-class Order < ActiveRecord::Base
-  before_save :normalize_card_number, if: :paid_with_card?
-end
-```
-
-### Using `:if` and `:unless` with a String
-
-You can also use a string that will be evaluated using `eval` and hence needs to contain valid Ruby code. You should use this option only when the string represents a really short condition:
-
-```ruby
-class Order < ActiveRecord::Base
-  before_save :normalize_card_number, if: "paid_with_card?"
-end
-```
-
-### Using `:if` and `:unless` with a `Proc`
-
-Finally, it is possible to associate `:if` and `:unless` with a `Proc` object. This option is best suited when writing short validation methods, usually one-liners:
-
-```ruby
-class Order < ActiveRecord::Base
-  before_save :normalize_card_number,
-    if: Proc.new { |order| order.paid_with_card? }
-end
-```
-
-### Multiple Conditions for Callbacks
-
-When writing conditional callbacks, it is possible to mix both `:if` and `:unless` in the same callback declaration:
-
-```ruby
-class Comment < ActiveRecord::Base
-  after_create :send_email_to_author, if: :author_wants_emails?,
-    unless: Proc.new { |comment| comment.article.ignore_comments? }
-end
-```
-
-Callback Classes
-----------------
-
-Sometimes the callback methods that you'll write will be useful enough to be reused by other models. Active Record makes it possible to create classes that encapsulate the callback methods, so it becomes very easy to reuse them.
-
-Here's an example where we create a class with an `after_destroy` callback for a `PictureFile` model:
-
-```ruby
-class PictureFileCallbacks
-  def after_destroy(picture_file)
-    if File.exist?(picture_file.filepath)
-      File.delete(picture_file.filepath)
-    end
-  end
-end
-```
-
-When declared inside a class, as above, the callback methods will receive the model object as a parameter. We can now use the callback class in the model:
-
-```ruby
-class PictureFile < ActiveRecord::Base
-  after_destroy PictureFileCallbacks.new
-end
-```
-
-Note that we needed to instantiate a new `PictureFileCallbacks` object, since we declared our callback as an instance method. This is particularly useful if the callbacks make use of the state of the instantiated object. Often, however, it will make more sense to declare the callbacks as class methods:
-
-```ruby
-class PictureFileCallbacks
-  def self.after_destroy(picture_file)
-    if File.exist?(picture_file.filepath)
-      File.delete(picture_file.filepath)
-    end
-  end
-end
-```
-
-If the callback method is declared this way, it won't be necessary to instantiate a `PictureFileCallbacks` object.
-
-```ruby
-class PictureFile < ActiveRecord::Base
-  after_destroy PictureFileCallbacks
-end
-```
-
-You can declare as many callbacks as you want inside your callback classes.
-
-Transaction Callbacks
----------------------
-
-There are two additional callbacks that are triggered by the completion of a database transaction: `after_commit` and `after_rollback`. These callbacks are very similar to the `after_save` callback except that they don't execute until after database changes have either been committed or rolled back. They are most useful when your active record models need to interact with external systems which are not part of the database transaction.
-
-Consider, for example, the previous example where the `PictureFile` model needs to delete a file after the corresponding record is destroyed. If anything raises an exception after the `after_destroy` callback is called and the transaction rolls back, the file will have been deleted and the model will be left in an inconsistent state. For example, suppose that `picture_file_2` in the code below is not valid and the `save!` method raises an error.
-
-```ruby
-PictureFile.transaction do
-  picture_file_1.destroy
-  picture_file_2.save!
-end
-```
-
-By using the `after_commit` callback we can account for this case.
-
-```ruby
-class PictureFile < ActiveRecord::Base
-  after_commit :delete_picture_file_from_disk, on: [:destroy]
-
-  def delete_picture_file_from_disk
-    if File.exist?(filepath)
-      File.delete(filepath)
-    end
-  end
-end
-```
-
-NOTE: the `:on` option specifies when a callback will be fired. If you
-don't supply the `:on` option the callback will fire for every action.
-
-WARNING. The `after_commit` and `after_rollback` callbacks are guaranteed to be called for all models created, updated, or destroyed within a transaction block. If any exceptions are raised within one of these callbacks, they will be ignored so that they don't interfere with the other callbacks. As such, if your callback code could raise an exception, you'll need to rescue it and handle it appropriately within the callback.