Execute bash commands from a Rakefile

Question

I would like to execute a number of bash commands from a Rakefile.

I have tried the following in my Rakefile

Answer 1

There are two ways:

sh " expr "

or

%x( expr )

Mind that ( expr ) can be { expr } , | expr | or ` expr `

The difference is, sh "expr" is a ruby method to execute something, and %x( expr ) is the ruby built-in method. The result and action are different. Here is an example

task :default do
value = sh "echo hello"
puts value
value = %x(echo world)
puts value
end

get:

hello  # from sh "echo hello"
true   # from puts value
world  # from puts value

You can see that %x( expr ) will only do the shell expr but the stdout will not show in the screen. So, you'd better use%x( expr ) when you need the command result.

But if you just want to do a shell command, I recommend you use sh "expr". Because sh "irb" will make you go into the irb shell, while %x(irb) will dead.

Answer 2

I think the way rake wants this to happen is with: http://rubydoc.info/gems/rake/FileUtils#sh-instance_method Example:

task :test do
  sh "ls"
end

The built-in rake function sh takes care of the return value of the command (the task fails if the command has a return value other than 0) and in addition it also outputs the commands output.

Answer 3

%{echo "World!"} defines a String. I expect you wanted %x{echo "World!"}.

%x{echo "World!"} executes the command and returns the output (stdout). You will not see the result. But you may do:

puts %x{echo "World!"}

There are more ways to call a system command:

• Backticks: `
• system( cmd )
• popen
• Open3#popen3

Answer 4

There are several ways to execute shell commands in ruby. A simple one (and probably the most common) is to use backticks:

task :hello do
  `echo "World!"`
end

Backticks have a nice effect where the standard output of the shell command becomes the return value. So, for example, you can get the output of ls by doing

shell_dir_listing = `ls`

But there are many other ways to call shell commands and they all have benefits/drawbacks and work differently. This article explains the choices in detail, but here's a quick summary possibilities:

• stdout = %x{cmd} - Alternate syntax for backticks, behind the scenes it's doing the same thing

• exec(cmd) - Completely replace the running process with a new cmd process

• success = system(cmd) - Run a subprocess and return true/false on success/failure (based on cmd exit status)

• IO#popen(cmd) { |io| } - Run a subprocess and connect stdout and stderr to io

• stdin, stdout, stderr = Open3.popen3(cmd) - Run a subprocess and connect to all pipes (in, out, err)

Answer 5

Given that the consensus seems to prefer rake's #sh method, but OP explicitly requests bash, this answer may have some use.

This is relevant since Rake#sh uses the Kernel#system call to run shell commands. Ruby hardcodes that to /bin/sh, ignoring the user's configured shell or $SHELL in the environment.

Here's a workaround which invokes bash from /bin/sh, allowing you to still use the sh method:

task :hello_world do
  sh <<-EOS.strip_heredoc, {verbose: false}
    /bin/bash -xeu <<'BASH'
    echo "Hello, world!"
    BASH
  EOS
end

class String
  def strip_heredoc
    gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, ''.freeze)
  end
end

#strip_heredoc is borrowed from rails:

https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/string/strip.rb

You could probably get it by requiring active_support, or maybe it's autoloaded when you're in a rails project, but I was using this outside rails and so had to def it myself.

There are two heredocs, an outer one with the markers EOS and an inner one with the markers BASH.

The way this works is by feeding the inside heredoc between the BASH markers to bash's stdin. Note that it is running within the context of /bin/sh, so it's a posix heredoc, not a ruby one. Normally that requires the end marker to be in column 1, which isn't the case here because of the indenting.

However, because it's wrapped within a ruby heredoc, the strip_heredoc method applied there de-indents it, placing the entirety of the left side of the inner heredoc in column 1 prior to /bin/sh seeing it.

/bin/sh also would normally expand variables within the heredoc, which could interfere with the script. The single quotes around the start marker, 'BASH', tell /bin/sh not to expand anything inside the heredoc before it is passed to bash.

However /bin/sh does still apply escapes to the string before passing it to bash. That means backslash escapes have to be doubled to make it through /bin/sh to bash, i.e. \ becomes \\.

The bash options -xeu are optional.

The -eu arguments tell bash to run in strict mode, which stops execution upon any failure or reference to an undefined variable. This will return an error to rake, which will stop the rake task. Usually, this is what you want. The arguments can be dropped if you want normal bash behavior.

The -x option to bash and {verbose: false} argument to #sh work in concert so that rake only prints the bash commands which are actually executed. This is useful if your bash script isn't meant to run in its entirety, for example, if it has a test which allows it to exit gracefully early in the script.

Be careful to not set an exit code other than 0 if you don't want the rake task to fail. Usually, that means you don't want to use any || exit constructs without setting the exit code explicitly, i.e. || exit 0.