Marcos Fernandes
setembro 26, 2025

Ruby na Linha de Comando: Um Guia Completo para Desenvolvedores

#ruby

Se você está usando Ruby como linguagem de script ou desenvolvendo aplicações, dominar o uso da linha de comando é essencial. Neste tutorial abrangente, vamos explorar todas as funcionalidades que o interpretador Ruby oferece através da linha de comando, desde opções básicas até ferramentas avançadas como Rake.

Executando Programas Ruby

A forma mais direta de iniciar o interpretador Ruby é chamando o comando ruby seguido do nome do arquivo. A estrutura básica é:

ruby ‹ opções › ‹ -- › ‹ arquivo_programa › ‹ argumentos ›*

O exemplo mais simples seria:

$ ruby meu_codigo.rb

Detectando Erros de Sintaxe

Quando há erros de sintaxe, Ruby tenta localizar e sugerir onde está o problema. Vamos criar um exemplo com erro:

class TemUmErro
  def este_metodo_termina
    p "ele certamente termina"
  end
  
  def este_nao_termina
    return "uma coisa"
  # falta o 'end' aqui!
  
  def este_esta_certo
    p "perfeito"
  end
end

Ruby mostrará um erro similar a:

syntax error, unexpected end-of-input, expecting 'end' (SyntaxError)

Executando Ruby com a Opção -e

A opção -e permite executar uma linha de script diretamente, transformando Ruby em uma poderosa calculadora de linha de comando:

$ ruby -e "p (1..5).map { _1 ** 2 }"
[1, 4, 9, 16, 25]

Processando Arquivos com Opções Avançadas

Ruby oferece várias opções poderosas para processar arquivos linha por linha:

Opção -n: Loop Automático

A opção -n envolve seu código em um loop while gets:

$ ruby -ne 'puts "linha: #{$_}"' < arquivo_teste
linha: Esta é a linha um
linha: Esta é a linha dois  
linha: Esta é a linha três

Opção -p: Loop com Impressão Automática

$ ruby -pe '"linha: #{$_}"' < arquivo_teste

Opção -a: Divisão Automática

Com -a, cada linha é automaticamente dividida e armazenada em $F:

$ ruby -nae 'puts "linha: #{$F}"' < arquivo_teste
linha: ["Esta", "é", "a", "linha", "um"]
linha: ["Esta", "é", "a", "linha", "dois"]

Processando Argumentos da Linha de Comando

Array ARGV

Todos os argumentos após o nome do programa ficam disponíveis no array global ARGV:

# arquivo: teste.rb
ARGV.each { |argumento| p argumento }

Executando:

$ ruby -w teste.rb "Olá Mundo" a1 1.6180
"Olá Mundo"
"a1" 
"1.6180"

Importante: Em Ruby, ARGV[0] é o primeiro argumento para o programa, não o nome do programa. O nome do programa atual está disponível na variável global $0 ou $PROGRAM_NAME.

Objeto ARGF: Múltiplos Arquivos como Stream Único

Ruby fornece o objeto de conveniência ARGF que trata múltiplos arquivos como um único stream:

# Processa múltiplos arquivos linha por linha
while (linha = gets)
  printf "%d: %10s[%d] %s", 
         ARGF.lineno, 
         ARGF.filename, 
         ARGF.file.lineno, 
         linha
end

Edição In-Place com ARGF

Ruby permite editar arquivos in-place, mantendo backups. Use a opção -i com extensão de backup:

# reverter.rb - inverte cada linha
while (linha = gets)
  puts linha.chomp.reverse
end
$ ruby -i.bak reverter.rb arquivo_teste outro_arquivo

Parsing Avançado de Opções com OptionParser

Para scripts complexos, Ruby fornece a classe OptionParser que permite criar interfaces de linha de comando profissionais:

require "optparse"

parser = OptionParser.new
tipo_ordenacao = nil

# Opções curtas e longas
parser.on("-a", "Alfabético") do
  tipo_ordenacao = :alfabetico
end

parser.on("--recente", "Mais Recente") do
  tipo_ordenacao = :recencia
end

parser.on("-s", "--tamanho", "Tamanho") do
  tipo_ordenacao = :tamanho
end

parser.parse!
p "estamos ordenando por #{tipo_ordenacao}"

Opções com Argumentos

parser.on("-dBANCO", "Tipo de Banco de Dados") do |valor|
  banco_dados = valor
end

# Argumento opcional (entre colchetes)
parser.on("-a [DIRETORIO]", "Alfabético") do |valor|
  diretorio_trabalho = valor || "."
end

Variáveis de Ambiente

Ruby permite acessar e modificar variáveis de ambiente através do objeto ENV:

# Acessando variáveis de ambiente
puts ENV['SHELL']
puts ENV['HOME']
puts ENV['USER']

# Modificando variáveis (local ao processo)
ENV['MINHA_VAR'] = 'valor_personalizado'

# Removendo variável (definir como nil)
ENV['VAR_TEMPORARIA'] = nil

Dominando o Rake: Automação de Tarefas

Rake é uma poderosa ferramenta de automação que vai muito além de um simples build tool. Vamos criar um exemplo prático:

Criando Seu Primeiro Rakefile

# Rakefile
require "fileutils"

desc "Remove arquivos com nomes terminados em til"
task :deletar_backups_unix do
  arquivos = Dir["*~"]
  rm(arquivos, verbose: true) unless arquivos.empty?
end

desc "Remove arquivos com extensão .bak"  
task :deletar_backups_windows do
  arquivos = Dir["*.bak"]
  rm(arquivos, verbose: true) unless arquivos.empty?
end

Composição de Tarefas e Dependências

# Tarefa composta com dependências
desc "Remove backups Unix e Windows"
task deletar_backups: [:deletar_backups_unix, :deletar_backups_windows] do
  puts "Todos os backups foram deletados"
end

# Tarefa padrão
task default: :deletar_backups

Passando Argumentos para Tarefas Rake

def deletar(diretorio, padrao)
  arquivos = Dir["#{diretorio}/#{padrao}"]
  rm(arquivos, verbose: true) unless arquivos.empty?
end

desc "Remove backups Unix em diretório específico"
task :deletar_unix, [:dir] do |tarefa, args|
  deletar(args[:dir], "*~")
end

Execute com:

$ rake deletar_unix[codigo]

Listando Tarefas Disponíveis

$ rake -T
rake deletar_backups         # Remove backups Unix e Windows
rake deletar_backups_unix    # Remove arquivos com nomes terminados em til  
rake deletar_backups_windows # Remove arquivos com extensão .bak

Criando Executáveis Ruby

Em sistemas Unix, você pode tornar seus scripts Ruby executáveis diretamente:

Configurando o Shebang

#!/usr/bin/env ruby
# Seu código Ruby aqui

puts "Olá, mundo Ruby executável!"
puts "Argumentos recebidos: #{ARGV}"

Torne o arquivo executável:

$ chmod +x meu_script.rb
$ ./meu_script.rb arg1 arg2

Configuração do Caminho de Bibliotecas

Ruby determina onde procurar bibliotecas através da variável $LOAD_PATH (também conhecida como $:). Você pode verificar os caminhos atuais:

$ ruby -e 'puts $LOAD_PATH'

Para adicionar caminhos personalizados, use:

# Via variável de ambiente
ENV['RUBYLIB'] = '/caminho/para/biblioteca'

# Via linha de comando
# ruby -I /caminho/para/biblioteca meu_script.rb

# Dentro do programa
$: << '/caminho/para/biblioteca'

Conclusão

Dominar o uso da linha de comando em Ruby abre um universo de possibilidades para automação, processamento de dados e criação de ferramentas eficientes. As funcionalidades que exploramos - desde opções básicas do interpretador até ferramentas avançadas como Rake e OptionParser - formam a base para criar soluções robustas e profissionais.

Os próximos passos incluem experimentar com estes conceitos em seus próprios projetos, explorando opções mais avançadas do Ruby e Rake, e construindo suas próprias ferramentas de linha de comando. Lembre-se: a prática consistente é a chave para dominar essas poderosas funcionalidades do Ruby.

Comentários (0)

Nenhum comentário:

Postar um comentário