How to Pass Command Line Arguments to a Rake Task in Ruby

By the end of this page, you will understand how Rake task arguments work in Ruby, how to pass values from the command line, how to pass values from one task to another, and when to use task arguments versus environment variables.

Rake allows tasks to accept named arguments. This is useful when a task needs input at runtime, such as an ID, a filename, an environment name, or a value that should be inserted into one or more databases.

In Ruby, a Rake task can declare parameters like this:

task :import, [:value] do |t, args|
  puts args[:value]
end

The key idea is:

• :import is the task name
• [:value] declares the task arguments
• args[:value] reads the passed value inside the task

This matters because hardcoding values inside tasks makes automation brittle. Real projects often run tasks in different environments or with different inputs. Task arguments make the task reusable.

There are two common ways to pass data into a Rake task:

1. Task arguments

   • Example: rake import[123]
   • Best when the task has a small number of explicit inputs

2. Environment variables

   • Example: VALUE=123 rake import
   • Best when shells, CI systems, or deployment scripts already use environment-based configuration

When calling one Rake task from another, you can use invoke and pass arguments directly.

Think of a Rake task like a small command-line function.

• The task name is the function name
• The task arguments are the function parameters
• The code block is the function body

For example, this Ruby method:

def greet(name)
  puts "Hello, #{name}"
end

is conceptually similar to this Rake task:

task :greet, [:name] do |t, args|
  puts "Hello, #{args[:name]}"
end

If you imagine a Rake task as a function that can be run from the terminal, the argument syntax becomes much easier to understand.

Basic syntax

A task with one argument:

task :insert_value, [:value] do |t, args|
  puts "Value received: #{args[:value]}"
end

Run it from the command line:

rake insert_value[hello]

In some shells, especially zsh, you may need quotes:

rake 'insert_value[hello]'

Example with multiple arguments

task :copy_data, [:source_db, :target_db, :value] do |t, args|
  puts "Copying #{args[:value]} from #{args[:source_db]} to #{args[:target_db]}"
end

Run it like this:

rake 'copy_data[main,archive,42]'

Consider this task:

task :insert_value, [:value] do |t, args|
  value = args[:value]

  if value.nil? || value.empty?
    puts "Missing value"
    next
  end

  puts "Inserting #{value}"
end

Command:

rake 'insert_value[abc]'

Here is what happens step by step:

1. Rake looks for a task named insert_value.
2. It sees that the task expects one argument: :value.
3. The string abc is passed into that argument.
4. Inside the block, args[:value] returns "abc".
5. The variable value is assigned "abc".
6. The if condition checks whether the value is missing or empty.
   • It is not missing.

Rake task arguments are useful in many practical Ruby projects.

Data maintenance

rake 'backfill_user_status[active]'

Use case:

• backfilling missing records
• updating old data after a schema change
• running one-off migration helpers

Multi-database operations

rake 'sync_value[promo_2025]'

Use case:

• insert a shared configuration value into several databases
• update tenant-specific records
• distribute seed data across environments

File processing

rake 'import_csv[customers.csv]'

Use case:

• importing reports
• parsing exports from another system
• running local admin scripts

Scheduled jobs and CI pipelines

VALUE=release_17 rake publish_config

Use case:

• passing deployment metadata
• running tasks in automated pipelines
• environment-based configuration in scripts

Admin and support tools

In real codebases, developers often wrap business logic in plain Ruby objects or service classes, and keep the Rake task thin.

Common pattern: thin task, real logic elsewhere

class MultiDbInserter
  def self.call(value)
    databases = ["users_db", "orders_db"]

    databases.each do |db|
      puts "Inserting #{value} into #{db}"
    end
  end
end

task :insert_value, [:value] do |t, args|
  value = args[:value]

  if value.nil? || value.strip.empty?
    raise ArgumentError, "value is required"
  end

  MultiDbInserter.call(value)
end

Why this is common:

• the task stays easy to read
• the business logic can be tested separately
• the same logic can be reused from scripts, jobs, or controllers

Guard clauses

Developers often validate arguments early:

task , []  ||
   ,   args[]

  puts 

1. Forgetting to declare task arguments

Broken code:

task :insert_value do |t, args|
  puts args[:value]
end

Why it fails:

• The task does not declare [:value], so the argument is not defined as expected.

Correct version:

task :insert_value, [:value] do |t, args|
  puts args[:value]
end

2. Not quoting the command in shells that expand brackets

Problematic command:

rake insert_value[hello]

In some shells, this may be interpreted by the shell instead of being passed to Rake.

Safer version:

rake 'insert_value[hello]'

3. Assuming a task can be invoked repeatedly without re-enabling

Broken expectation:

Rake:[].invoke()
[].invoke()

Task arguments vs environment variables

Task arguments

• good for required positional inputs
• easy to see from the command itself
• useful when manually running tasks

Environment variables

• good for external configuration
• useful in CI/CD pipelines
• better when passing many settings or secrets

Calling a task directly vs extracting logic to a class

Declare a task with arguments

task :name, [:arg1, :arg2] do |t, args|
  puts args[:arg1]
end

Run from the command line

rake 'name[value1,value2]'

Access arguments

args[:arg1]
args[:arg2]

Validate required input

raise ArgumentError, "arg1 is required" unless args[:arg1]

Call one task from another

Rake::Task[:name].invoke("value1", "value2")

Run a task again in the same process

Rake:[].reenable
[].invoke()

How do I pass an argument to a Rake task from the command line?

Declare the task with arguments and run it like this:

task :example, [:value] do |t, args|
  puts args[:value]
end

rake 'example[hello]'

Why do I need quotes around task[arg]?

Some shells interpret square brackets before passing the command to Rake. Quotes ensure the full string reaches Rake unchanged.

How do I pass arguments from one Rake task to another?

Use invoke:

Rake::Task[:example].invoke("hello")

Why does my task only run once when I call it multiple times?

Rake tasks are executed once per process by default. Use reenable before invoking again.

Should I use task arguments or environment variables?

Use task arguments for small explicit inputs. Use environment variables when values come from CI, deployment scripts, or external shell environments.

Can a Rake task have multiple arguments?

• Rake task dependencies — Useful for understanding how tasks can run before or after other tasks.
• Environment variables in Ruby — Related because ENV is a common alternative to task arguments.
• Ruby methods and parameters — Helps you understand task arguments as function-like inputs.
• Guard clauses — Important for validating arguments early and keeping task code clean.
• Service objects in Ruby — A common way to move real logic out of Rake tasks.
• Command-line interfaces in Ruby — Broader context for building parameterized scripts and tools.
• Ruby exceptions and error handling — Useful when a task should fail clearly on invalid input.