Understanding and Using Ruby Rake

Something that you will see a lot in Ruby projects is Rake. Rake is a build tool for automating tasks.

This means you can define a set of tasks that should be carried out as part of a build process, or perhaps a set of tasks that should be executed every time you run a specific command.

Rake allows you to create tasks that depend on one another or have prerequisites. This makes creating automated processes very easy.

In today’s tutorial we will be looking at Rake, how it works and what you will find yourself using it for.

Installing Rake

Like all good things Ruby, Rake is available as a Gem that you can install on your computer:

gem install rake  
[/bash]

If you’ve already got your Ruby environment set up, then there’s really nothing else much to say about installation!


## Creating a Rake file

The first thing we need to do is to create a `Rakefile` (without an extension). This file is where you list the tasks that you want to perform. Rakefiles are defined using Ruby, so if you’re familiar with the Ruby syntax, there should be nothing too crazy about this:  
```ruby  
task default: %w[hello]

task :hello do  
puts "Hello world!"  
end  

In this Rakefile we have two distinct things.

Firstly we have a task called default. All Rakefiles will have a default task. In this case, we’re saying that when the default task is run, we should execute the hello task.

Secondly we have the hello task. When this task is run it will simply print Hello world! to the screen.

If you save the Rakefile and run the following command from terminal, you should see the correct output:

$ rake  
Hello world!  
[/bash]


## Tasks can have prerequisites

So as you can see, it is very easy to define an automated task using Rake because it is just Ruby code.

However, the real power of Rake is when you start using tasks with prerequisites. This makes it possible to run a list of tasks in a given order.

For example, imagine if we wanted to automate deploying our website to our web server. We might have the following tasks:  
```ruby  
task :ssh_into_server do  
puts "ssh into server"  
end

task :move_to_directory do  
puts "cd to the correct directory"  
end

task :pull_code do  
puts "pulling code from Github"  
end

task :get_dependencies do  
puts "getting the dependencies"  
end

task :migrate_the_database do  
puts "migrating the database"  
end

task :set_file_permissions do  
puts "setting the file permissions"  
end

task :symlink_the_new_version do  
puts "symlinking the new version"  
end  

We can state that these tasks should be performed in the correct order by creating a new task that has prerequisites.

task :deploy => [:ssh_into_server, :move_to_directory, :pull_code, :get_dependencies, :migrate_the_database, :set_file_permissions, :symlink_the_new_version] do  
puts “deploying the website!”  
end  

Now with one single command we can completely automate the deployment of the website to the production server:

$ rake deploy  
[/bash]


## Namespacing

A couple of weeks ago we looked at namespacing our code using [Modules](http://culttt.com/2015/07/01/creating-and-using-modules-in-ruby).

Namespacing is also an important topic in Rake as bigger projects could potentially have rake tasks that have conflicting names.

To solve this problem we can use namespaces. For example we might namespace our deployment process from above like this:  
```ruby  
namespace :ship_it do  
task :ssh_into_server do  
puts "ssh into server"  
end

# The rest of the tasks  
end  

Now to run the deploy task you would include the namespace as part of the command:

$ rake ship_it:deploy  
[/bash]


## Describing tasks

When you are first getting to grips with an existing project, it can be useful to check out the existing rake tasks to see what has been defined.

To list out the Rake tasks you can run the following command from terminal:  
```bash  
$ rake –tasks  
[/bash]

However, if you do that now you won’t see any output. To provide additional help to the user we can write a short description about the task:  
```ruby  
desc "SSH into the server."  
task :ssh_into_server do  
puts "ssh into server"  
end  

Now when you run the command again, you should see the following output:

$ rake —tasks  
rake ship_it:ssh_into_server # SSH into the server  
[/bash]


## Rake in the wild

You will find Rake in just about every Ruby project out in the wild. Rails makes good use of Rake and whenever you create a new Ruby gem, Rake will be included (more on that next week!).

In today’s tutorial we’ve looked at a hypothetical way of deploying a website to a server using Rake to automate a series of steps.

However, there is already a Rake-like tool out there called Capistrano that does this exact job, but much better.

[Capistrano](http://capistranorb.com) basically follows the same methodology of Rake by allowing you to define the tasks that should be invoked when deploying your website. However, Capistrano has an ecosystem of add ons and plugins that you can make use of, rather than rolling your own set of tasks.

For a long time, Capistrano has been a very popular way of deploying Ruby projects. However it can also be effectively used for any other type of project.


Understanding and Using Ruby Rake
Share this