pry
v0.15.0
© John Mair (Banisterfiend) 2018
(Creador)
© Kyrylo Silin (Kyrylosilin) 2018
(Mantenedor)
Alumni:
Campo de golf:
PRY es una consola de desarrollador de tiempo de ejecución y una alternativa IRB con potentes capacidades de introspección. Pry tiene como objetivo ser más que un reemplazo de IRB. Es un intento de llevar la programación impulsada por REPL al lenguaje Ruby.
edit Class#method )cd , ls y amigos) gem 'pry' , '~> 0.15.0'gem install pry PRY es bastante flexible y permite una personalización significativa del usuario. Es trivial leer de cualquier objeto que tenga un método readline y escribir en cualquier objeto que tenga un método puts . Muchos otros aspectos de PRY también son configurables, lo que lo convierte en una buena opción para implementar conchas personalizadas.
Pry viene con un ejecutable para que se pueda invocar en la línea de comando. Simplemente ingrese pry para comenzar. Se cargará un archivo pryrc en $XDG_CONFIG_HOME/pry/ o el directorio de inicio del usuario si existe. Escriba pry --help en la línea de comando para obtener más información.
Casi todas las funciones de una sesión de Pry se implementan como un comando. Los comandos no son métodos y deben comenzar al comienzo de una línea, sin espacios en blanco en el medio. Los comandos admiten una sintaxis flexible y permiten 'opciones' de la misma manera que los comandos de shell, por ejemplo, el siguiente comando PRY mostrará una lista de todos los métodos de instancia privada (en alcance) que comienzan con 'PA'
pry ( YARD :: Parser :: SourceParser ) : 5 > ls - Mp -- grep ^ pa
YARD :: Parser :: SourceParser #methods: parse parser_class parser_type parser_type= parser_type_for_filename Pry nos permite entrar y salir de diferentes ámbitos (objetos) usando el comando cd . Esto nos permite explorar la vista en tiempo de ejecución de un programa o biblioteca. Para ver qué variables y métodos están disponibles dentro de un alcance particular, utilizamos el comando LS versátil.
Aquí comenzaremos a PRY en el nivel superior, luego en una clase y luego en una variable de instancia dentro de esa clase:
pry ( main ) > class Hello
pry ( main ) * @x = 20
pry ( main ) * end
=> 20
pry ( main ) > cd Hello
pry ( Hello ) : 1 > ls - i
instance variables : @x
pry ( Hello ) : 1 > cd @x
pry ( 20 ) : 2 > self + 10
=> 30
pry ( 20 ) : 2 > cd ..
pry ( Hello ) : 1 > cd ..
pry ( main ) > cd .. El número después de : en el indicador de Pry indica el nivel de anidación. Para mostrar más información sobre la anidación, use el comando nesting . P.ej
pry ( "friend" ) : 3 > nesting
Nesting status :
0 . main ( Pry top level )
1 . Hello
2 . 100
3 . "friend"
=> nil Luego podemos volver a cualquiera de los niveles de anidación anteriores usando el comando jump-to :
pry ( "friend" ) : 3 > jump - to 1
= > 100
pry ( Hello ) : 1 > Pry se puede invocar en medio de un programa en ejecución. Abre una sesión de Pry en el punto que se llama y hace que todo el estado del programa esté disponible en ese punto. Se puede invocar en cualquier objeto utilizando la sintaxis my_object.pry o en la unión de corriente (o cualquier enlace) usando binding.pry . La sesión PRY comenzará dentro del alcance del objeto (o enlace). Cuando finaliza la sesión, el programa continúa con cualquier modificación que haya hecho.
Esta funcionalidad se puede utilizar para cosas como: depuración, implementación de consolas de desarrolladores y aplicación de parches calientes.
código:
# test.rb
require 'pry'
class A
def hello ( ) puts "hello world!" end
end
a = A . new
# start a REPL session
binding . pry
# program resumes here (after pry session)
puts "program resumes here."Sesión de Pry:
pry ( main ) > a . hello
hello world!
=> nil
pry ( main ) > def a . goodbye
pry ( main ) * puts "goodbye cruel world!"
pry ( main ) * end
=> :goodbye
pry ( main ) > a . goodbye
goodbye cruel world!
=> nil
pry ( main ) > exit
program resumes here .Una línea de entrada que comienza con un '.' se reenviará al shell de comando. Esto nos permite navegar por el sistema de archivos, engendrar editores y ejecutar Git y rastrillar directamente desde PRY.
Además, podemos usar el comando shell-mode para incorporar el directorio de trabajo actual en el mensaje Pry y traer (limitado en esta etapa, lo siento), finalización del nombre del archivo. También podemos interpolar el código Ruby directamente en la carcasa usando la sintaxis de interpolación de cadena #{} normal.
En el siguiente código vamos a cambiar al shell-mode y editar el archivo pryrc . Luego atenderemos su contenido y recargaremos el archivo.
pry ( main ) > shell - mode
pry main : /home/john / ruby / projects / pry $ . cd ~
pry main : /home/john $ . emacsclient . pryrc
pry main : /home/john $ . cat . pryrc
def hello_world
puts "hello world!"
end
pry main : /home/john $ load ".pryrc"
=> true
pry main : /home/john $ hello_world
hello world! También podemos interpolar el código Ruby en la carcasa. En el ejemplo a continuación, usamos el comando shell cat en un archivo aleatorio del directorio actual y contamos el número de líneas en ese archivo con wc :
pry main : /home/john $ . cat #{Dir['*.*'].sample} | wc -l
44 Puede explorar el código fuente del método con el comando show-source . Casi todos los métodos de Ruby (y algunos métodos C, con la gema Pry-Doc) pueden ver su fuente. El código que es más largo que una página se envía a través de un buscapersonas (como menos), y todo el código está resaltado correctamente (incluso código C).
El comando show-source acepta dos sintaxis, la sintaxis Class#method RI típica y también simplemente el nombre de un método que está en alcance. Opcionalmente, puede pasar la opción -l para show-source para incluir números de línea en la salida.
En el siguiente ejemplo, ingresaremos la clase Pry , enumere los métodos de instancia que comienzan con 'SE' y mostraremos el código fuente para el método set_last_result :
pry ( main ) > cd Pry
pry ( Pry ) : 1 > ls - M -- grep se
Pry #methods: raise_up raise_up! raise_up_common reset_eval_string select_prompt set_last_result
pry ( Pry ) : 1 > show - source set_last_result - l
From : /home/john / ruby / projects / pry / lib / pry / pry_instance . rb : 405 :
Owner : Pry
Visibility : public
Signature : set_last_result ( result , code = ?)
Number of lines : 6
405 : def set_last_result ( result , code = "" )
406 : @last_result_is_exception = false
407 : @output_ring << result
408 :
409 : self . last_result = result unless code =~ / A s * z /
410 : end Tenga en cuenta que también podemos ver los métodos C (desde Ruby Core) utilizando el complemento pry-doc ; También mostramos la sintaxis alternativa para show-source :
pry ( main ) > show - source Array #select
From : array . c in Ruby Core ( C Method ) :
Number of lines : 15
static VALUE
rb_ary_select ( VALUE ary )
{
VALUE result ;
long i ;
RETURN_ENUMERATOR ( ary , 0 , 0 ) ;
result = rb_ary_new2 ( RARRAY_LEN ( ary ) ) ;
for ( i = 0 ; i < RARRAY_LEN ( ary ) ; i ++ ) {
if ( RTEST ( rb_yield ( RARRAY_PTR ( ary ) [ i ] ) ) ) {
rb_ary_push ( result , rb_ary_elt ( ary , i ) ) ;
}
}
return result ;
} Un caso de uso para PRY es explorar un programa en tiempo de ejecución de cd -ing dentro y fuera de objetos y ver e invocar métodos. En el curso de la exploración, puede ser útil leer la documentación para un método específico que se encuentre. El comando show-source admite dos sintaxis: la sintaxis ri normal y aceptando el nombre de cualquier método que esté actualmente en alcance.
El sistema de documentación PRY no confía en rdoc o ri pregenerado, sino que toma los comentarios directamente por encima del método a pedido. Esto da como resultado una recuperación de documentación más rápida y permite que el sistema PRY recupere la documentación para los métodos que rdoc no recogería. PRY también tiene una comprensión básica de los formatos RDOC y de Yard e intentará sintaxis resaltando la documentación adecuadamente.
No obstante, la funcionalidad ri es muy buena y tiene una ventaja sobre el sistema de Pry en el sentido de que permite la búsqueda de documentación para clases y métodos. Por lo tanto, PRY tiene una buena integración con ri a través del comando ri . La sintaxis para el comando es exactamente como estaría en la línea de comandos, por lo que no es necesario citar cadenas.
En nuestro ejemplo, ingresaremos la clase Gem y veremos la documentación del método try_activate :
pry ( main ) > cd Gem
pry ( Gem ) : 1 > show - source try_activate - d
From : /Users/john / rbenv / versions / 2.7 . 1 / lib / ruby / 2.7 . 0 / rubygems . rb : 194 :
Owner : #<Class:Gem>
Visibility : public
Signature : try_activate ( path )
Number of lines : 28
Try to activate a gem containing path . Returns true if
activation succeeded or wasn 't needed because it was already
activated. Returns false if it can' t find the path in a gem .
def self . try_activate ( path )
# finds the _latest_ version... regardless of loaded specs and their deps
# if another gem had a requirement that would mean we shouldn't
# activate the latest version, then either it would already be activated
# or if it was ambiguous (and thus unresolved) the code in our custom
# require will try to activate the more specific version.
spec = Gem :: Specification . find_by_path path
pry ( Gem ) : 1 > También podemos usar ri de la manera normal:
pry ( main ) ri Array #each
----------------------------------------------------------- Array #each
array . each { | item | block } -> array
------------------------------------------------------------------------
Calls _block_ once for each element in _self_ , passing that element
as a parameter .
a = [ "a" , "b" , "c" ]
a . each { | x | print x , " -- " }
produces :
a -- b -- c -- Puede usar edit Class#method o edit my_method (si el método está en alcance) para abrir un método para editar directamente en su editor favorito. Pry tiene conocimiento de algunos editores diferentes e intentará abrir el archivo en la línea que se define el método.
Puede establecer el editor para usar asignando al accesor Pry.editor . Pry.editor se debe poner en $EDITOR o falla que usará nano como copia de seguridad predeterminada. El archivo que se edita se volverá a cargar automáticamente después de salir del editor: la recarga se puede suprimir al pasar la opción --no-reload para edit
En el siguiente ejemplo, estableceremos nuestro editor predeterminado en "EmacSclient" y abriremos el método Pry#repl para editar:
pry ( main ) > Pry . editor = "emacsclient"
pry ( main ) > edit Pry #repl Muchos otros comandos están disponibles en Pry; Para ver la help de tipo de lista completa en el aviso. Se proporciona una breve descripción de cada comando con instrucciones básicas para su uso; Algunos comandos tienen una ayuda más extensa a la que se puede acceder a través de la escritura command_name --help . Un comando generalmente dirá en su descripción si la opción --help está disponible.
Puede ejecutar una consola PRY en el entorno de su aplicación utilizando la bandera de PRY -r :
pry -r ./config/environment O inicie la consola Rails ( bin/rails console ) y luego escriba pry .
También es posible usar PRY como consola Rails agregando la gema de Ry-Rails a su archivo gem. Esto reemplaza la consola predeterminada con PRY, además de cargar los ayudantes de la consola Rails y agregar algunos comandos útiles específicos de Rails.
Tenga en cuenta que pry-rails no se mantiene actualmente.
También consulte el wiki para obtener más información sobre la integración de PRY con rieles.
La resaltura de sintaxis está activada de forma predeterminada en PRY. Si desea cambiar los colores, consulte la gema Pry-Theme.
Puede activar la sintaxis resaltando y desactivado en una sesión utilizando el comando toggle-color . Alternativamente, puede apagarlo permanentemente colocando la línea Pry.color = false en su archivo pryrc .
En caso de que tenga un problema, pregunta o un informe de errores, no dude en:
El proyecto utiliza la licencia MIT. Vea la licencia.md para más detalles.
Pry es principalmente el trabajo de John Mair (Banisterfiend), para que la lista completa de contribuyentes consulte el gráfico de contribuyentes.
