#!/usr/bin/ruby -w

puts "#{ARGV.size } Parameters"

i = 1
ARGV.each do |a|
    puts "Parameter #{i} : #{a}"
    i = i + 1
end

if ARGV.size != 1
    puts "Only one parameter Please"
end

Ruby, nos muestra la influencia de Perl en el lenguaje, utilizando el mismo enfoque. Los parámetros se pasan en un array de nombre ARGV. De la misma forma que Perl, Ruby no almacena el nombre del programa en la primera entrada del array, sino que lo proporciona en una variables especial… la cual, curiosamente, recibe el mismo nombre que en Perl $0.

A diferencia de Perl, Ruby es un lenguaje orientado a objetos en el que todo es un objeto, así que la forma de obtener el tamaño del array (el número de parámetros que pasamos al script) es invocando el método size o length (size es un alias de length así que se pueden usar cualquiera de ellos).

Puesto que ARGV es un array en Ruby, podemos iterar a lo largo de sus elementos usando el método each de la forma indicada en el código de arriba o como vimos en el capítulo sobre bucles.

Como sucede con muchos de los otros lenguajes que ya hemos visto, Tuby ofrece varios módulos para poder procesar argumentos de la línea de comandos muy fácilmente. Uno de los más clásicos es GetoptLong (como ya os podíais imaginar), si bien optparser es una de las opciones más utilizadas. Para que resulte más sencillo comparar el ejemplo con otros lenguajes utilizaremos GetoptLong, sin embargo, para el caso de Ruby no es la mejor opción.

El programa tendrá una pinta como esta:

#!/usr/bin/ruby

require 'getoptlong'

opts = GetoptLong.new(
  [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
  [ '--input', '-i', GetoptLong::REQUIRED_ARGUMENT ],
  [ '--output', '-o', GetoptLong::REQUIRED_ARGUMENT ]
)

ofile = "output.txt"
ifile = "input.txt"
opts.quiet = true  # Elimina errores por defecto

begin
  opts.each do |opt, arg|
    case opt
    when '--help' then puts "Ayuda para el programa"
    when '--input'  then ifile = arg
    when '--output' then ofile=arg
    end
  end
rescue Exception => err
    puts ">>#{err.class()}: #{err.message}"
    puts "Uso: #{$0}  [--help] [--input file] [--output file]"
    exit
end

print ("Copiando #{ifile} a #{ofile}\n")

Como podéis ver GetoptLong nos permite escribir rápidamente código para procesar la línea de comandos, incluyendo opciones cortas, largas además de poder especificar si las opciones necesitan parámetros o no.

GetoptLong incluye algunas opciones más para poder controlar si queremos permitir la repetición de opciones o si queremos forzar un determinado orden de las opciones.

Resumen

• Ruby recibe los parámetros en un array llamado ARGV como cadenas de caracteres
• $0 es una variable especial que contiene el nombre del programa. Esta variable se puede modificar
• El módulo GetoptLong permite procesar parámetros de la línea de comandos de fácil y sencilla. Requiere el uso de excepciones para manejar los errores.