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.
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
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.