What is new in Rails 6.0 / bogdanvlviv / Bogdan

Hello!

This post about news and some changes that have been done in Rails 6.0.

Rails 6.0 requires Ruby 2.5.0 or newer
Parallel testing
ActiveRecord::Relation#pick as shorthand for single-value plucks
ActiveRecord::Relation#create_or_find_by/! to lean on unique constraints
Action Mailbox
Action Text
Action Cable testing
Other links

Rails 6.0 requires Ruby 2.5.0 or newer

Pull Requests:

Parallel testing

Pull Requests:

You know that class ActiveSupport::TestCase uses minitest under the hood (Minitest::Test is the superclass of the class). To ActiveSupport::TestCase was added parallelize method. It allows you to parallelize your test suite with forked processes. Running tests in parallel reduces the time it takes your entire test suite to run.

Running test in threads is supported as well, but note that it doesn’t make your test run faster (read “Minitest Parallelization and You” since it uses Minitest::Parallel::Executor).

The default parallelization method is to fork processes using Ruby’s DRb system.

To enable parallelization with forked processes add the following to your test/test_helper.rb:

class ActiveSupport::TestCase
  parallelize(workers: 3, with: :processes)
end

The :workers option controls how many times the the process is forked or how many threads are used. The default number of workers is the actual physical core count on the machine you are on:

class ActiveSupport::TestCase
  parallelize(workers: :number_of_processors)
end

If you would like to parallelize your test suite with threads, you should set :with option to :threads:

class ActiveSupport::TestCase
  parallelize(workers: 3, with: :threads)
end

You can also use environment variable PARALLEL_WORKERS to easily change the number of workers a test run should use. This is useful for CI environments or other environments where you may need more or less workers than you do for local testing:

PARALLEL_WORKERS=6 bin/rails test

When parallelizing test with processes, Active Record automatically handles creating a database and loading the schema into the database for each process. The databases will be suffixed with the number corresponding to the worker. For example, if you have 2 workers the tests will create test_database-0 and test_database-1 databases respectively. If the number of workers passed is 1 or fewer the processes will not be forked and the tests will not be parallelized and the tests will use the original test_database database. Also, two hooks are provided, one runs when the process is forked but before the tests run, and one runs before the forked process is closed. These can be useful if your app uses multiple databases or perform other tasks that depend on the number of workers. The parallelize_setup method is called right after the process is forked. The parallelize_teardown method is called right before the process is closed:

class ActiveSupport::TestCase
  parallelize_setup do |worker|
    # code
  end

  parallelize_teardown do |worker|
    # code
  end

  parallelize(workers: 2)
end

Note that these methods are not available with the threaded parallelization.

ActiveRecord::Relation#pick as shorthand for single-value plucks

Pull Requests:

Add Relation#pick as short-hand for single-value plucks

I am sure you know about the method #pluck that has been in Rails since version 3.2.0. Let’s refresh our knowledge. #pluck is a shortcut to select one or more attributes without loading a bunch of records just to grab the attributes you want:

User.pluck(:name)
# SELECT "users"."name" FROM "users"
# => ["Bogdan", "David"]

User.where(id: 1).pluck(:name, :email)
# SELECT "users"."name", "users"."email" FROM "users" WHERE "users"."id" = ?  [["id", 1]]
# => [["Bogdan", "bogdanvlviv@gmail.com"]]

User.where("1=0").pluck(:name)
# SELECT "users"."name" FROM "users" WHERE (1=0)
# => []

But sometimes you just need single value(s) from the result. To get this you can do something like:

User.limit(1).pluck(:name).first
# SELECT "users"."name" FROM "users" LIMIT ?  [["LIMIT", 1]]
# => "Bogdan"

User.where(id: 1).limit(1).pluck(:name, :email).first
# SELECT "users"."name", "users"."email" FROM "users" WHERE "users"."id" = ? LIMIT ?  [["id", 1], ["LIMIT", 1]]
# => ["Bogdan", "bogdanvlviv@gmail.com"]

Since Rails 6.0 you can use the method #pick, it is shorthand for limit(1).pluck(*column_names).first:

User.pick(:name)
# SELECT "users"."name" FROM "users" LIMIT ?  [["LIMIT", 1]]
# => "Bogdan"

User.where(id: 1).pick(:name, :email)
# SELECT "users"."name", "users"."email" FROM "users" WHERE "users"."id" = ? LIMIT ?  [["id", 1], ["LIMIT", 1]]
# => ["Bogdan", "bogdanvlviv@gmail.com"]

User.pick(Arel.sql("UPPER(name)"))
# SELECT UPPER(name) FROM "users" LIMIT ?  [["LIMIT", 1]]
# => "BOGDAN"

User.where("1=0").pick(:name)
# SELECT "users"."name" FROM "users" WHERE (1=0) LIMIT ?  [["LIMIT", 1]]
# => nil

You probably noticed that the method #pluck does not guarantee the order of the returned value(s) by any column. So note that #pick does not guarantee to return the value(s) of the first row ordered by any column either. For instance, if you want to get value(s) of the first row ordered by id column, you should apply order(:id) before pick:

User.order(:id).pick(:name)
# SELECT "users"."name" FROM "users" ORDER BY "users"."id" ASC LIMIT ?  [["LIMIT", 1]]
# => "Bogdan"

ActiveRecord::Relation#create_or_find_by/! to lean on unique constraints

Pull Requests:

#create_or_find_by attempts to create a record with the given attributes in a table that has a unique constraint on one or several of its columns. If a row already exists with one or several of these unique constraints, the exception such an insertion would normally raise is caught and the existing record with those attributes is found using #find_by!.

This is similar to #find_or_create_by, but avoids the problem of stale reads between the SELECT and the INSERT, as that method needs to first query the table, then attempt to insert a row if none is found.

There are several drawbacks to #create_or_find_by, though:

The underlying table must have the relevant columns defined with unique constraints.
A unique constraint violation may be triggered by only one, or at least less than all, of the given attributes. This means that the subsequent #find_by! may fail to find a matching record, which will then raise an ActiveRecord::RecordNotFound exception, rather than a record with the given attributes.
While we avoid the race condition between SELECT -> INSERT from #find_or_create_by, we actually have another race condition between INSERT -> SELECT, which can be triggered if a DELETE between those two statements is run by another client. But for most applications, that’s a significantly less likely condition to hit.
It relies on exception handling to handle control flow, which may be marginally slower.

This method will return a record if all given attributes are covered by unique constraints (unless the INSERT -> DELETE -> SELECT race condition is triggered), but if creation was attempted and failed due to validation errors it won’t be persisted, you get what #create returns in such situation.

#create_or_find_by! is like #create_or_find_by, but calls create! so an exception is raised if the created record is invalid.

Implementation of these methods look like:

def create_or_find_by(attributes, &block)
  transaction(requires_new: true) { create(attributes, &block) }
rescue ActiveRecord::RecordNotUnique
  find_by!(attributes)
 end

def create_or_find_by!(attributes, &block)
  transaction(requires_new: true) { create!(attributes, &block) }
rescue ActiveRecord::RecordNotUnique
  find_by!(attributes)
end

Examples using of these methods:

User.create_or_find_by(email: "bogdanvlviv@gmail.com") do |user|
  user.name = "Bogdan"
end

User.create_or_find_by!(email: "bogdanvlviv@gmail.com") do |user|
  user.name = "Богдан"
end

Action Mailbox

Pull Requests:

Action Mailbox allows you to route incoming emails to controller-like mailboxes. You can read more about Action Mailbox in the Action Mailbox Basics guide.

Action Text

Pull Requests:

Action Text brings rich text content and editing to Rails. It includes the Trix editor that handles everything from formatting to links to quotes to lists to embedded images and galleries. The rich text content generated by the Trix editor is saved in its own RichText model that’s associated with any existing Active Record model in the application. Any embedded images (or other attachments) are automatically stored using Active Storage and associated with the included RichText model.

You can read more about Action Text in the Action Text Overview guide.

Action Cable testing

Pull Requests:

Other links

Start Rails 6.0 development!!!

Introduce custom serializers to ActiveJob arguments

Deprecate update_attributes and update_attributes!

String#strip_heredoc preserves frozenness`

String#truncate_bytes

Add support for timezones to Active Job

Add :private option to ActiveSupport’s Module#delegate

Don’t enforce UTF-8 by default

Support i18n key at translation of value in submit tag

Add “rails routes –expanded” mode

Enable select tag helper to mark prompt option as selected and/or disabled for required field

Introduce explicit rails server handler option

Add before? and after? methods to date and time classes

Disable ActionView::Template finalizers in test environment

Add AR::Base.base_class? predicate

Deprecate controller level force_ssl

Add #dig to ActionDispatch::Request::Session

Deprecate support for using HOST environment to specify server IP

Define callbacks on descendants

Introduce ActionDispatch::DebugExceptions interceptors

Add touch_all method to ActiveRecord::Relation

Part 1 Easy Multi db in Rails: Add basic rake tasks for multi db setup Fix two-level database configurations with URLs Fix structure:dump for multiple databases Allow schema/structure load for multiple databases Add multidb application test Don’t create namespaced tasks if single db application Db schema cache dump and clear multi db Part 5: Multi db improvements, Fix query cache for multiple connections Part 7: Multi db improvements, Add ability to block writes to a database Part 8: Multi db improvements, Adds basic automatic database switching to Rails Add ability to change the names of the default handlers Add ActiveRecord::Base.connected_to?

Use ImageProcessing gem for ActiveStorage variants

Merge Arel

Update ‘rails_welcome.png’ to reflect a more diverse population

rails link: Update 'rails_welcome.png' to reflect a more diverse populationhttps://t.co/oyUMkGwuBk pic.twitter.com/LYKTsZ8NK4
— Bogdan (@bogdanvlviv) April 26, 2018