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

task :hello do
  %{echo "World!"}
end

but upon executing rake hello there is no output? How do I execute bash commands from a Rakefile?

NOTE:This is not a duplicate as it's specifically asking how to execute bash commands from a Rakefile.

Answer 1

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 -xeuo pipefail <<'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 deindents 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 -xeuo pipefail are optional.

The -euo pipefail arguments tell bash to run in strict mode, which stops execution upon any failure or reference to an undefined variable, even a command in a pipeline. 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.

If you run into any bash weirdness along the way, turn off the -o pipefail. I've seen a bit of bugginess related to it specifically when pipelining to grep.

Answer 2

%{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 3

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