How to Call Shell Commands from Ruby: A Comprehensive Guide

In Ruby, interacting with the system shell is straightforward, allowing you to execute commands, capture output, and handle errors efficiently. Whether you’re automating tasks, running scripts, or managing system operations, Ruby offers multiple ways to interact with the shell. In this guide, we’ll explore various methods to call shell commands from within a Ruby program and how to handle their outputs and errors.

1. Using Backticks (`command`)

The simplest way to execute a shell command in Ruby is by using backticks. This method runs the command in a subshell and returns its standard output as a string.

output = `echo 'Hello, World!'`
puts output

Output:

Hello, World!

Backticks are convenient for quick tasks where you need the command’s output.

2. Using the %x Syntax

The %x syntax is an alternative to backticks and works similarly. It allows more flexibility in choosing delimiters, making it easier to work with complex commands.

output = %x(echo 'Hello, World!')
puts output

Output:

Hello, World!

3. Using system

The system method executes the given command in a subshell but returns true if the command was successful and false otherwise. It does not capture the output; instead, the output is displayed directly in the terminal.

success = system("echo 'Hello, World!'")
puts "Command executed successfully: #{success}"

Output:

Hello, World!
Command executed successfully: true

4. Using exec

The exec method replaces the current Ruby process with the command’s process. It never returns, as the current process is replaced entirely by the executed command.

exec("echo 'This will replace the Ruby process'")

Output:

This will replace the Ruby process

5. Using Open3 for Advanced Needs

For more advanced use cases, such as capturing both stdout and stderr, or interacting with the process’s input/output streams, you can use the Open3 module.

require 'open3'

stdout, stderr, status = Open3.capture3("ls -l")
puts "STDOUT: #{stdout}"
puts "STDERR: #{stderr}"
puts "STATUS: #{status.exitstatus}"

Output:

STDOUT: total 0
-rw-r--r--  1 user  group  0 Sep  3 12:34 file.txt

STDERR: 
STATUS: 0

6. Using IO.popen

IO.popen allows you to start a process and then read or write to its standard input/output streams.

IO.popen("ls -l") do |output|
  output.each do |line|
    puts line
  end
end

Output:

total 0
-rw-r--r--  1 user  group  0 Sep  3 12:34 file.txt

7. Handling Command Exit Status

To check the exit status of a command executed using backticks, %x, or system, you can use the $? global variable.

`ls`
puts "Exit status: #{$?.exitstatus}"

Output:

Exit status: 0

8. Choosing the Right Method

• Backticks / %x: Best for when you need the command’s output in your Ruby code.
• system: Ideal for when you want to execute a command without capturing its output.
• exec: Use when you want to replace the current process entirely.
• Open3: Suitable for more complex scenarios where you need to capture stderr or handle input/output streams.

Ruby provides a versatile set of tools for executing shell commands, each with its own strengths. Whether you need a simple command execution or complex process management, there’s a method that fits your needs. Understanding these methods will allow you to integrate system operations seamlessly into your Ruby applications.