ruby: cómo analizar correctamente varios números de argumentos de línea de comandos

Question

n00b alerta de pregunta! aquí está el problema: Estoy creando un script de shell que toma un mínimo de 3 argumentos: una cadena, un número de línea y al menos un archivo.

He escrito una secuencia de comandos que aceptará EXACTAMENTE 3 argumentos, pero no sé cómo manejar múltiples argumentos de nombre de archivo.

aquí es las partes pertinentes de mi código (saltarse la escritura de nuevo en el archivo etc):

#!/usr/bin/env ruby 

the_string = ARGV[0] 
line_number = ARGV[1] 
the_file = ARGV[2] 

def insert_script(str, line_n, file) 
    f = file 
    s = str 
    ln = line_n.to_i 

    if (File.file? f) 
    read_in(f,ln,s) 
    else 
    puts "false" 
    end 
end 

def read_in(f,ln,s) 
    lines = File.readlines(f) 
    lines[ln] = s + "\n" 
    return lines 
end 

# run it 
puts insert_script(the_string, line_number, the_file) 

ahora sé que es fácil escribir un bloque que va a recorrer todos los argumentos:

ARGV.each do |a| 
    puts a 
end 

pero necesito SOLO recorrer las args de ARGV [2] (el primer nombre de archivo) hasta el último nombre de archivo.

Sé que tiene que haber, como mínimo, al menos una forma fácil de hacerlo, ¡pero no puedo ver qué es en este momento!

en cualquier caso - Estaría más que feliz si alguien me puede indicar un tutorial o un ejemplo, estoy seguro de que hay mucho por ahí, pero parece que no puedo encontrarlos.

gracias

Answer 1

Si modifica la matriz ARGV para eliminar los elementos que ya no le interesan tratar como nombres de archivo, puede treat all remaining elements as filenames and iterate over their contents with ARGF.

que es un bocado, un pequeño ejemplo demostrará que sea más fácil:

argf.rb:

#!/usr/bin/ruby 

str = ARGV.shift 
line = ARGV.shift 

ARGF.each do |f| 
    puts f 
end 

$ ./argf.rb one two argf.rb argf.rb 
#!/usr/bin/ruby 

str = ARGV.shift 
line = ARGV.shift 

ARGF.each do |f| 
    puts f 
end 
#!/usr/bin/ruby 

str = ARGV.shift 
line = ARGV.shift 

ARGF.each do |f| 
    puts f 
end 
$ 

Hay dos copias del archivo argf.rb impresos a la consola porque Di el nombre de archivo argf.rb dos veces en la línea de comando. Fue abierto e iterado más de una vez por cada mención.

Si desea operar los archivos como archivos, en lugar de leer sus contenidos, simplemente puede modificar la matriz ARGV y luego usar los elementos restantes directamente.

Answer 2

Echa un vistazo a OptionParser - http://ruby-doc.org/stdlib-1.9.3/libdoc/optparse/rdoc/OptionParser.html. Le permite especificar la cantidad de argumentos, ya sean obligatorios u opcionales, que manejen errores como MissingArgument o InvalidOption.

Answer 3

¿Consideraría utilizar una joya útil? Trollop es grande para el analizador de la línea de comandos, ya que da automáticamente los mensajes de ayuda, modificadores de línea de comandos largos y cortos, etc.

require 'trollop' 

opts = Trollop::options do 
    opt :string, "The string", :type => :string 
    opt :line, "line number", :type => :int 
    opt :file, "file(s)", :type => :strings 
end 

p opts 

Cuando lo llamo "commandline.rb" y ejecutarlo:

$ ruby commandline.rb --string "foo bar" --line 3 --file foo.txt bar.txt 

{:string=>"foo bar", :line=>3, :file=>["foo.txt", "bar.txt"], :help=>false, :string_given=>true, :line_given=>true, :file_given=>true} 

Answer 4

Un truco alternativo (y algo más feo) si no quieres usar otra biblioteca o cambiar la matriz ARGV es usar.hasta

2.upto(ARGV.length-1) do |i| 
    puts ARGV[i] 
end 

Answer 5

La forma canónica es utilizar shift, así:

the_string = ARGV.shift 
line_number = ARGV.shift 
ARGV.each do |file| 
    puts insert_script(the_string, line_number, the_file) 
end