When joining or eager loading an association with a parameterized scope,
the scope block will not be called with a `nil` argument. Rather,
`ActiveRecord::Reflection::AssociationReflection#check_eager_loadable!`
will raise an `ArgumentError`.
Closes#43539.
Co-authored-by: jcoleman <james.coleman@getbraintree.com>
This matches the indentation used in generated code, such as code from
`railties/lib/rails/generators/rails/scaffold_controller/templates/controller.rb.tt`.
This patch tries to solve Heroku's new [PostgreSQL extension policy](https://devcenter.heroku.com/changelog-items/2446)
while keeping the migration and schema code idiomatic.
PostgreSQL adapter method `enable_extension` now allows to add an schema in its name.
The extension must be installed on another schema.
Usage:
`enable_extension('other_schema.hstore')`
The `enable_extension` can work with `schema` only if the given schema
already exists in the database.
If we access the pool we can ensure that the ActiveRecord::Base pool is
set back at the end. This will set us up to avoid calling
`establish_connection` from any task / database task. Without this we'll
need to set the connection back when we move to a class specifically for
migration connections.
These helpers are called from both test class definition and test execution,
so we're defining them as both class and instance methods on AR::TestCase.
Defining methods on toplevel changes the behavior of all Ruby Objects which of
course includes the test target, and thus that will spoil the meaning of the
whole testing. This is something that testing libraries or helpers should never
do.
These methods are just called from testing methods, so we can just move them
under AR::TestCase as its instance methods.
This fixes the indentation of the example code of the first bullet
point. The "Learn more" link was moved to the bottom of the bullet point,
similar to the other bullet points.
`ActiveRecord::Base::normalizes` declares a normalization for one or
more attributes. The normalization is applied when the attribute is
assigned or updated, and the normalized value will be persisted to the
database. The normalization is also applied to the corresponding
keyword argument of finder methods. This allows a record to be created
and later queried using unnormalized values. For example:
```ruby
class User < ActiveRecord::Base
normalizes :email, with: -> email { email.strip.downcase }
end
user = User.create(email: " CRUISE-CONTROL@EXAMPLE.COM\n")
user.email # => "cruise-control@example.com"
user = User.find_by(email: "\tCRUISE-CONTROL@EXAMPLE.COM ")
user.email # => "cruise-control@example.com"
user.email_before_type_cast # => "cruise-control@example.com"
User.exists?(email: "\tCRUISE-CONTROL@EXAMPLE.COM ") # => true
User.exists?(["email = ?", "\tCRUISE-CONTROL@EXAMPLE.COM "]) # => false
```
As of https://github.com/rails/rails/pull/46525, the behaviour around
before_committed! callbacks has changed: callbacks are run on every
enrolled record in a transaction, even multiple copies of the same record.
This is a significant change that apps should be able to opt into in order
to avoid unexpected issues.
