pry
v0.15.0
© John Mair (BanisterFiend) 2018
(Schöpfer)
© Kyrylo Silin (Kyrylosilin) 2018
(Betreuer)
Alumni:
Links:
Pry ist eine Alternative zur Laufzeitentwicklerkonsole und eine IRB -Alternative mit leistungsfähigen Selbstbeobachtungsfähigkeiten. Pry zielt darauf ab, mehr als ein IRB -Ersatz zu sein. Es ist ein Versuch, die replgetriebene Programmierung in die Ruby -Sprache zu bringen.
edit Class#method )cd , ls und Freunde) gem 'pry' , '~> 0.15.0'gem install pry Pry ist ziemlich flexibel und ermöglicht eine erhebliche Benutzeranpassung. Es ist trivial, aus jedem Objekt zu lesen, das eine readline -Methode hat und an jedes Objekt schreibt, das eine puts -Methode hat. Viele andere Aspekte von Pry sind ebenfalls konfigurierbar, was es zu einer guten Wahl für die Implementierung kundenspezifischer Shells macht.
Pry wird mit einer ausführbaren Datei geliefert, damit sie in der Befehlszeile aufgerufen werden kann. Geben Sie einfach pry ein, um zu beginnen. Eine pryrc -Datei in $XDG_CONFIG_HOME/pry/ oder im Heimverzeichnis des Benutzers wird geladen, wenn sie vorhanden ist. Geben Sie pry --help in die Befehlszeile ein, um weitere Informationen zu erhalten.
Fast jede Funktionalität in einer Pry -Sitzung wird als Befehl implementiert. Befehle sind keine Methoden und müssen am Beginn einer Zeile beginnen, ohne weiße Space dazwischen. Befehle unterstützen eine flexible Syntax und ermöglichen "Optionen" auf die gleiche Weise wie Shell -Befehle. Zum Beispiel zeigt der folgende PRY -Befehl eine Liste aller privaten Instanzmethoden (im Bereich), die mit 'PA' beginnen.
pry ( YARD :: Parser :: SourceParser ) : 5 > ls - Mp -- grep ^ pa
YARD :: Parser :: SourceParser #methods: parse parser_class parser_type parser_type= parser_type_for_filename Mit Pry können wir mit dem cd -Befehl verschiedene Bereiche (Objekte) ein- und aussteigen. Auf diese Weise können wir die Laufzeitansicht eines Programms oder einer Bibliothek erkunden. Um anzuzeigen, welche Variablen und Methoden in einem bestimmten Bereich verfügbar sind, verwenden wir den vielseitigen LS -Befehl.
Hier beginnen wir auf oberster Ebene, dann auf einer Klasse und dann in einer Instanzvariablen in dieser Klasse:
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 .. Die Zahl nach der : In der Pry -Eingabeaufforderung gibt das Nistniveau an. Verwenden Sie den Befehl nesting , um weitere Informationen über die Verschachtelung anzuzeigen. Z.B
pry ( "friend" ) : 3 > nesting
Nesting status :
0 . main ( Pry top level )
1 . Hello
2 . 100
3 . "friend"
=> nil Wir können dann zu einem der vorherigen Nistpegel zurückkehren, indem wir den Befehl jump-to -Befehl verwenden:
pry ( "friend" ) : 3 > jump - to 1
= > 100
pry ( Hello ) : 1 > Pry kann in der Mitte eines laufenden Programms aufgerufen werden. Es eröffnet zu dem Zeitpunkt, an dem es aufgerufen wird, und macht alle Programmstatus zu diesem Zeitpunkt zur Verfügung. Es kann auf jedem Objekt unter Verwendung der my_object.pry -Syntax oder der Strombindung (oder einer beliebigen Bindung) unter Verwendung von binding.pry aufgerufen werden. Die PRY -Sitzung beginnt dann im Rahmen des Objekts (oder Bindung). Wenn die Sitzung endet, fährt das Programm mit allen Änderungen fort, die Sie daran vorgenommen haben.
Diese Funktionalität kann für Dinge verwendet werden: Debugging, Implementierung von Entwicklerkonsolen und Anwendung heißer Patches.
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."PRY Session:
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 .Eine Eingangslinie, die mit einem '.' wird an die Kommandoschale weitergeleitet. Auf diese Weise können wir durch das Dateisystem navigieren, die Redakteure spawnen und Git direkt von innerhalb von Pry ausführen.
Darüber hinaus können wir den Befehl shell-mode verwenden, um das vorliegende Arbeitsverzeichnis in die Pry-Eingabeaufforderung zu integrieren und (in diesem Stadium begrenzt, sorry) den Fertigstellung von Dateinamen einzubeziehen. Wir können den Ruby -Code auch direkt in die Shell einbauen, indem wir die normale Interpolationssyntax #{} String -Interpolation verwenden.
Im folgenden Code wechseln wir zu shell-mode und bearbeiten die pryrc Datei. Wir werden dann seinen Inhalt katzen und die Datei neu laden.
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! Wir können auch Rubincode in die Schale einbauen. Im folgenden Beispiel verwenden wir die Shell cat in einer zufälligen Datei aus dem aktuellen Verzeichnis und zählen die Anzahl der Zeilen in dieser Datei mit wc :
pry main : /home/john $ . cat #{Dir['*.*'].sample} | wc -l
44 Sie können den Methodenquellencode mit dem Befehl show-source durchsuchen. Fast alle Ruby-Methoden (und einige C-Methoden mit dem Pry-Doc-Edelstein) können ihre Quelle sehen. Code, der länger als eine Seite ist, wird über einen Pager (wie z.
Der Befehl Class#method show-source akzeptiert zwei syntaxe Sie können optional die Option -l übergeben, um show-source um Zeilennummern in die Ausgabe aufzunehmen.
Im folgenden Beispiel geben wir die Pry -Klasse ein, listen Sie die Instanzmethoden auf, die mit 'SE' beginnen, und zeigen den Quellcode für die Methode set_last_result an:
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 Beachten Sie, dass wir auch C-Methoden (aus Ruby Core) mit dem pry-doc -Plugin anzeigen können. Wir zeigen auch die alternative Syntax für 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 ;
} Ein Anwendungsfall für PRY besteht darin, ein Programm zur Laufzeit zu untersuchen, indem sie Objekte in und aus Objekten und Aussenkung cd und Methoden anzusehen und aufzurufen. Bei der Erforschung kann es nützlich sein, die Dokumentation für eine bestimmte Methode zu lesen, auf die Sie stoßen. Der Befehl show-source unterstützt zwei Syntaxe - die normale ri -Syntax und akzeptiert den Namen jeder Methode, die sich derzeit in Geltungsbereich befindet.
Das Pry-Dokumentationssystem beruht nicht auf vorgenerierte rdoc oder ri , sondern greift die Kommentare direkt über der Methode auf Bedarf ab. Dies führt zu einem schnelleren Abrufen von Dokumentationen und ermöglicht es dem Pry -System, Dokumentation für Methoden abzurufen, die nicht von rdoc aufgegriffen werden würden. Pry hat auch ein grundlegendes Verständnis für die RDOC- und die Hofformate und wird versuchen, die Dokumentation angemessen zu syntaxen.
Trotzdem ist die ri -Funktionalität sehr gut und hat einen Vorteil gegenüber dem System von Prys, da sie Dokumentationsangebote sowohl für Klassen als auch nach Methoden ermöglicht. Pry hat daher eine gute Integration in ri durch den ri -Befehl. Die Syntax für den Befehl ist genau so wie in der Befehlszeile - daher ist es nicht erforderlich, Zeichenfolgen zu zitieren.
In unserem Beispiel werden wir die Gem -Klasse eingeben und die Dokumentation für die Methode try_activate anzeigen:
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 > Wir können ri auch auf normale Weise verwenden:
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 -- Sie können edit Class#method oder edit my_method (falls die Methode im Bereich umfassen) eine Methode zum direkten Bearbeiten in Ihrem bevorzugten Editor geöffnet. Pry hat Kenntnisse über verschiedene Redakteure und wird versuchen, die Datei in der Zeile zu öffnen, die die Methode definiert ist.
Sie können den Editor so einstellen, dass es dem Pry.editor Accessor zugewiesen wird. Pry.editor wird standardmäßig $EDITOR oder fehlgehen, die nano als Backup -Standard verwenden. Die bearbeitete Datei wird nach dem Verlassen des Editors automatisch neu geladen. Das Nachladen kann unterdrückt werden, indem die Option --no-reload zum edit bestanden wird
Im folgenden Beispiel setzen wir unseren Standard -Editor auf "emacsclient" und öffnen die Pry#repl -Methode für die Bearbeitung:
pry ( main ) > Pry . editor = "emacsclient"
pry ( main ) > edit Pry #repl Viele andere Befehle sind in Pry erhältlich; Um die vollständige Listentyp help bei der Eingabeaufforderung zu sehen. Eine kurze Beschreibung jedes Befehls wird mit grundlegenden Anweisungen zur Verwendung enthalten. Einige Befehle haben eine umfangreichere Hilfe, auf die über TIPPIGING command_name --help zugegriffen werden kann. Ein Befehl wird normalerweise in seiner Beschreibung angegeben, ob die Option --help verfügbar ist.
Sie können eine Pry -Konsole in der Umgebung Ihrer App mit der Prys -r -Flagge ausführen:
pry -r ./config/environment Oder starten Sie die Schienenkonsole ( bin/rails console ) und geben Sie dann pry ein.
Es ist auch möglich, Pry als Rails-Konsole zu verwenden, indem Sie Ihr Gem-Datum des Pry-Rails-Edelsteins hinzufügen. Dies ersetzt die Standardkonsole durch Pry, zusätzlich zum Laden der Rails-Konsolenhelfer und dem Hinzufügen einiger nützlicher Schienenspezifische Befehle.
Beachten Sie, dass derzeit nicht pry-rails wird.
Schauen Sie sich auch das Wiki an, um weitere Informationen über die Integration von Prejit in Rails zu erhalten.
Die Syntax -Hervorhebung ist standardmäßig in Pry. Wenn Sie die Farben ändern möchten, schauen Sie sich das Edelstein für das Pry-Themen an.
Sie können die Syntax-Hervorhebung in einer Sitzung mithilfe des toggle-color umkippten. Alternativ können Sie es dauerhaft ausschalten, indem Sie die Linie Pry.color = false in Ihre pryrc -Datei einlegen.
Falls Sie ein Problem, eine Frage oder einen Fehlerbericht haben, können Sie sich gerne:
Das Projekt verwendet die MIT -Lizenz. Weitere Informationen finden Sie unter Lizenz.MD.
Pry ist in erster Linie die Arbeit von John Mair (BanisterFiend), um eine vollständige Liste der Mitwirkenden zu sehen, siehe die Mitwirkenden.
