pry
v0.15.0
© John Mair (BanisterFiend) 2018
(Créateur)
© Kyrylo Silin (Kyrylosilin) 2018
(Mainteneur)
Anciennes:
Links:
Pry est une console de développeur d'exécution et une alternative IRB avec de puissantes capacités d'introspection. Pry vise à être plus qu'un remplacement de la CISR. Il s'agit d'une tentative d'apporter la programmation motivée par les REP à la langue Ruby.
edit Class#method )cd , ls et amis) gem 'pry' , '~> 0.15.0'gem install pry PRY est assez flexible et permet une personnalisation importante des utilisateurs. Il est trivial de lire tout objet qui a une méthode readline et d'écrire à tout objet qui a une méthode puts . De nombreux autres aspects de PRY sont également configurables, ce qui en fait un bon choix pour implémenter des shells personnalisés.
PRY est livré avec un exécutable afin qu'il puisse être invoqué sur la ligne de commande. Entrez simplement pry pour commencer. Un fichier pryrc dans $XDG_CONFIG_HOME/pry/ ou le répertoire personnel de l'utilisateur sera chargé s'il existe. Tapez pry --help sur la ligne de commande pour plus d'informations.
Presque toutes les fonctionnalités d'une session PRY sont implémentées en tant que commande. Les commandes ne sont pas des méthodes et doivent commencer au début d'une ligne, sans espace blanc entre les deux. Les commandes prennent en charge une syntaxe flexible et autorisent les «options» de la même manière que les commandes shell, par exemple la commande PRY suivante affichera une liste de toutes les méthodes d'instructions privées (dans la portée) qui commencent par «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 nous permet de pénétrer dans et sortir de différentes lunettes (objets) en utilisant la commande cd . Cela nous permet d'explorer la vue d'exécution d'un programme ou d'une bibliothèque. Pour afficher les variables et les méthodes disponibles dans une portée particulière, nous utilisons la commande LS polyvalente.
Ici, nous commencerons Pry au niveau supérieur, puis pry sur une classe puis sur une variable d'instance à l'intérieur de cette classe:
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 .. Le nombre après : dans l'invite Pry indique le niveau de nidification. Pour afficher plus d'informations sur la nidification, utilisez la commande nesting . Par exemple
pry ( "friend" ) : 3 > nesting
Nesting status :
0 . main ( Pry top level )
1 . Hello
2 . 100
3 . "friend"
=> nil Nous pouvons ensuite revenir à l'un des niveaux de nidification précédents en utilisant la commande jump-to :
pry ( "friend" ) : 3 > jump - to 1
= > 100
pry ( Hello ) : 1 > Pry peut être invoqué au milieu d'un programme de course. Il ouvre une session PRY au point qu'elle s'appelle et rend tout l'état du programme à ce stade. Il peut être invoqué sur n'importe quel objet en utilisant la syntaxe my_object.pry ou sur la liaison actuelle (ou toute liaison) à l'aide binding.pry . La session PRY commencera alors dans le cadre de l'objet (ou de la liaison). Lorsque la session se termine, le programme se poursuit avec toutes les modifications que vous y avez apportées.
Cette fonctionnalité peut être utilisée pour des éléments tels que: débogage, implémentation de consoles de développeurs et application des correctifs chauds.
code:
# 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."Session 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 .Une ligne d'entrée qui commence par un '.' sera transmis au shell de commande. Cela nous permet de naviguer dans le système de fichiers, de spawn éditeurs et d'exécuter Git et de ramener directement à partir de PRY.
De plus, nous pouvons utiliser la commande shell-mode pour incorporer le répertoire de travail actuel dans l'invite Pry et apporter (Limited à ce stade, désolé) le nom de fichier. Nous pouvons également interpoler le code Ruby directement dans le shell en utilisant la syntaxe d'interpolation de chaîne #{} normale.
Dans le code ci-dessous, nous allons passer en shell-mode et modifier le fichier pryrc . Nous allons ensuite contenir son contenu et recharger le fichier.
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! Nous pouvons également interpoler le code Ruby dans la coquille. Dans l'exemple ci-dessous, nous utilisons le Shell Command cat sur un fichier aléatoire à partir du répertoire actuel et comptons le nombre de lignes dans ce fichier avec wc :
pry main : /home/john $ . cat #{Dir['*.*'].sample} | wc -l
44 Vous pouvez parcourir le code source de la méthode avec la commande show-source . Presque toutes les méthodes de rubis (et certaines méthodes C, avec le GEM de Pry-Doc) peuvent avoir leur source visualisée. Le code plus long qu'une page est envoyé via un téléavertisseur (comme moins), et tout le code est correctement en surbrillance de syntaxe (même le code C).
La commande show-source accepte deux syntaxes, la syntaxe Class#method typique et également simplement le nom d'une méthode qui est dans la portée. Vous pouvez éventuellement passer l'option -l pour show-source pour inclure les numéros de ligne dans la sortie.
Dans l'exemple suivant, nous entrons dans la classe Pry , énumérez les méthodes d'instance commençant par «SE» et afficherons le code source de la méthode 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 Notez que nous pouvons également afficher les méthodes C (à partir de Ruby Core) à l'aide du plugin pry-doc ; Nous montrons également la syntaxe alternative pour 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 cas d'utilisation pour PRY consiste à explorer un programme au moment de l'exécution par cd dans et hors des objets et des méthodes de visualisation et d'appel. Au cours de l'exploration, il peut être utile de lire la documentation pour une méthode spécifique que vous rencontrez. La commande show-source prend en charge deux syntaxes - la syntaxe ri normale ainsi que l'acceptation du nom de toute méthode qui est actuellement dans la portée.
Le système de documentation PRY ne s'appuie pas sur rdoc ou ri pré-généré, mais il saisit les commentaires directement au-dessus de la méthode à la demande. Il en résulte une récupération de documentation plus rapide et permet au système PRY de récupérer la documentation des méthodes qui ne seraient pas récupérées par rdoc . PRY a également une compréhension de base des formats RDOC et de Yard et tentera de mettre en évidence la documentation de manière appropriée.
Néanmoins, la fonctionnalité ri est très bonne et a un avantage sur le système de Pry en ce qu'elle permet la recherche de documentation pour les classes ainsi que les méthodes. Pry a donc une bonne intégration avec ri via la commande ri . La syntaxe de la commande est exactement comme elle serait en ligne de commande - il n'est donc pas nécessaire de citer les chaînes.
Dans notre exemple, nous entrons dans la classe Gem et afficherons la documentation de la méthode 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 > Nous pouvons également utiliser ri de la manière normale:
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 -- Vous pouvez utiliser edit Class#method ou edit my_method (si la méthode est dans la portée) pour ouvrir une méthode pour l'édition directement dans votre éditeur préféré. Pry a connaissance de quelques éditeurs différents et tentera d'ouvrir le fichier à la ligne, la méthode est définie.
Vous pouvez définir l'éditeur à utiliser en attribuant à l'accessoire Pry.editor . Pry.editor sera par défaut à $EDITOR ou à l'échec qui utilisera nano comme défaut de sauvegarde. Le fichier modifié sera automatiquement rechargé après avoir quitté l'éditeur - Le rechargement peut être supprimé en passant l'option --no-reload pour edit
Dans l'exemple ci-dessous, nous définirons notre éditeur par défaut sur "EmacsClient" et ouvrirons la méthode Pry#repl pour l'édition:
pry ( main ) > Pry . editor = "emacsclient"
pry ( main ) > edit Pry #repl De nombreuses autres commandes sont disponibles en PRY; Pour voir l' help complète de la liste à l'invite. Une brève description de chaque commande est fournie avec des instructions de base à utiliser; Certaines commandes ont une aide plus étendue qui peut être accessible via Type command_name --help . Une commande dira généralement dans sa description si l'option --help est disponible.
Vous pouvez exécuter une console Pry dans l'environnement de votre application en utilisant le drapeau de Pry -r :
pry -r ./config/environment Ou démarrez la console des rails ( bin/rails console ), puis tapez pry .
Il est également possible d'utiliser Pry comme console Rails en ajoutant le gemme de Pry-Rails à votre Gemfile. Cela remplace la console par défaut par Pry, en plus de charger les aides à la console Rails et d'ajouter des commandes spécifiques aux rails utiles.
Notez que pry-rails n'est pas actuellement maintenu.
Consultez également le wiki pour plus d'informations sur l'intégration de Pry aux rails.
La mise en évidence de la syntaxe est allumée par défaut dans PRY. Si vous voulez changer les couleurs, consultez le joyau de Pry-Theme.
Vous pouvez basculer la syntaxe qui met en évidence sur et désactiver dans une session en utilisant la commande toggle-color . Alternativement, vous pouvez l'éteindre en permanence en mettant la ligne Pry.color = false dans votre fichier pryrc .
Dans le cas où vous avez un problème, une question ou un rapport de bogue, n'hésitez pas à:
Le projet utilise la licence MIT. Voir Licence.MD pour plus de détails.
Pry est principalement le travail de John Mair (BanisterFiend), pour la liste complète des contributeurs, voir le graphique des contributeurs.
