¿Hay una manera de lograr grep como la funcionalidad de salida dentro de los carriles de la consola

Question

Con cáscara, que puedo hacer

$ cat name_of_file_with_a_lot_of_text | grep "What I am looking for" 

dentro de la consola de Rails, puedo lograr algo similar, por ejemplo cuando corro un comando y la la salida es enorme, especialmente una consulta DB.

Soy consciente de sacarlo como YAML, pero eso no es lo que estoy buscando.

Gracias.

Answer 1

Sí, puedes. El método se llama gr ... aguarde ... ep. Ruby's grep funciona en String, Array y muchos otros objetos incorporados. Por ejemplo, para obtener todas las to_xxx métodos de una serie, acaba de hacer:

1.methods.grep(/to_/) 

Answer 2

que tenía la misma pregunta y no estaba muy satisfecho con la respuesta un tanto sarcástica de ream88, así que decidí tomar una grieta en ella.

# Allows you to filter output to the console using grep 
# Ex: 
# def foo 
#  puts "Some debugging output here" 
#  puts "The value of x is y" 
#  puts "The value of foo is bar" 
# end 
# 
# grep_stdout(/value/) { foo } 
# # => The value of x is y 
# # => The value of foo is bar 
# # => nil 
def grep_stdout(expression) 
    # First we need to create a ruby "pipe" which is two sets of IO subclasses 
    # the first is read only (which represents a fake $stdin) and the second is 
    # write only (which represents a fake $stdout). 
    placeholder_in, placeholder_out = IO.pipe 

    # This child process handles the grep'ing. Its done in a child process so that 
    # it can operate in parallel with the main process. 
    pid = fork { 
    # sync $stdout so we can report any matches asap 
    $stdout.sync 

    # replace $stdout with placeholder_out 
    $stdin.reopen(placeholder_in) 

    # we have to close both placeholder_out and placeholder_in because all instances 
    # of an IO stream must be closed in order for it to ever reach EOF. There's two 
    # in this method; one in the child process and one in the main process. 
    placeholder_in.close 
    placeholder_out.close 

    # loop continuously until we reach EOF (which happens when all 
    # instances of placeholder_out have closed) 
    read_buffer = '' 
    loop do 
     begin 
     read_buffer << $stdin.readpartial(4096) 
     if line_match = read_buffer.match(/(.*\n)(.*)/) 
      print line_match[1].grep(expression) # grep complete lines 
      read_buffer = line_match[2]   # save remaining partial line for the next iteration 
     end 
     rescue EOFError 
     print read_buffer.grep(expression) # grep any remaining partial line at EOF 
     break 
     end 
    end 
    } 

    # Save the original stdout out to a variable so we can use it again after this 
    # method is done 
    original_stdout = $stdout 

    # Redirect stdout to our pipe 
    $stdout = placeholder_out 

    # sync $stdout so that we can start operating on it as soon as possible 
    $stdout.sync 

    # allow the block to execute and save its return value 
    return_value = yield 

    # Set stdout back to the original so output will flow again 
    $stdout = original_stdout 

    # close the main instances of placeholder_in and placeholder_out 
    placeholder_in.close 
    placeholder_out.close 

    # Wait for the child processes to finish 
    Process.wait pid 

    # Because the connection to the database has a tendency to go away when calling this, reconnect here 
    # if we're using ActiveRecord 
    if defined?(ActiveRecord) 
    suppress_stdout { ActiveRecord::Base.verify_active_connections! } 
    end 

    # return the value of the block 
    return_value 
end 

El inconveniente obvio de mi solución es que la salida se pierde. No estoy seguro de cómo evitarlo sin llamar al yield dos veces.

EDIT He cambiado mi respuesta para que solo llame al fork una vez, lo que me permite conservar la salida del bloque y devolverlo al final. Ganar.

EDIT 2, usted puede obtener toda esta funcionalidad (y más!) En esta joya ahora https://github.com/FutureAdvisor/console_util