Getting Ready for Rails 6.0: How to Dual Boot

# Gemfile
def next?
  File.basename(__FILE__) == "Gemfile.next"
end

source 'https://rubygems.org'
# ...

If you have any problems installing next_rails, you can manually add the next? method to your Gemfile and create a symlink like this:

$ cd path/to/project
$ ln -s Gemfile Gemfile.next

Bump Rails (Gemfile.next)

In this simple example, I only need to upgrade rails (from Rails 5.2 to Rails 6.0). It’s very likely that you will have to upgrade more dependencies. The first step is to get my Gemfile to look like this:

def next?
  File.basename(__FILE__) == "Gemfile.next"
end

source 'https://rubygems.org'
if next?
  gem 'rails', '~> 6.0.0'
else
  gem 'rails', '~> 5.2.3'
end

# ...

Now I can install my current dependencies with bundle install and my future dependencies with next bundle update. If next bundle update doesn’t work for you, you can just run BUNDLE_GEMFILE=Gemfile.next bundle install. As a general rule, if next <command> doesn’t work in your environment you can replace it with BUNDLE_GEMFILE=Gemfile.next <command>.

next bundle <command> might not work because you are using an old version of Bundler opens a new window . So, you should try using Bundler 2.0 or higher.

Run Tests

After running next bundle update, I have a brand new Gemfile.next.lock file. That means that my dependencies are ready to run my test suite. So I can run them like this:

$ next bundle exec rake

There are many advantages to using dual booting in your Rails application. In no particular order:

• You can run your test suite with two different versions of Rails. Running bundle exec rake still works thanks to the conditionals in your Gemfile.
• You can run your application in development with two different versions of Rails. Simply prepend next to bundle exec rails server.
• You can even run your application in staging using the next version of Rails. Simply make sure that you set this environment variable: BUNDLE_GEMFILE
• You can quickly debug issues between your current version of Rails and the next one. Dual booting plus debugger is a powerful combo for finding bugs between versions.

Setup Continuous Integration

Depending on the type of project, we like to use Travis CI opens a new window for open source projects and Circle CI opens a new window for client projects. Below you will find a couple of sample configuration files that you could use.

Both samples will require you to commit and push Gemfile.next to your repository; will run a build matrix; and might need some tweaking.

Circle CI

For all of our client projects we prefer this continuous integration service. Here is the configuration that you could use for dual booting in Circle CI:

A few notes about this configuration:

• It’s using Ruby 2.6 and a Postgres database
• It’s using Circle CI’s API version 2.0 opens a new window
• It has a lot of duplication (there is probably a way to DRY opens a new window it)
• The key is to configure a workflow with two jobs (one for Rails 5.2 and another one for Rails 6.0) like this:

workflows:
  version: 2
  build:
    jobs:
      - "build-rails-5-2"
      - "build-rails-6-0"

Travis CI

For all of our open source projects we prefer this continuous integration service. Here is the configuration that you could use for dual booting in Travis CI:

A few notes about this configuration:

• It’s for an open source application that is using Postgres
• You might not need some of the things in this sample
• It’s certainly simpler than the Circle CI configuration. I love how simple it is to configure a build matrix in Travis CI:

rvm:
- 2.2.6
gemfile:
- Gemfile
- Gemfile.next

Start Fixing The Rails 6.0 Test Suite

Now that you have your test suite running in both Rails 5.2 and Rails 6.0, you can start tweaking your code and dependencies to work with both gemfiles. There will be two big hurdles:

1. Getting Bundler to bundle your dependencies
2. Getting your test suite to pass

Summary

This has been quite a useful technique for us at FastRuby.io opens a new window . We have used it with client projects, internal projects, and open source applications.

I hope that you will find it useful in getting ready for the next version of Rails!