pry
v0.15.0
© John Mair (Banisterfiend) 2018
(ผู้สร้าง)
© Kyrylo Silin (Kyrylosilin) 2018
(ผู้ดูแล)
ศิษย์เก่า:
ลิงค์:
PRY เป็นคอนโซลนักพัฒนารันไทม์และทางเลือก IRB ที่มีความสามารถในการวิปัสสนาที่ทรงพลัง PRY มีจุดมุ่งหมายที่จะเป็นมากกว่าการทดแทน IRB มันเป็นความพยายามที่จะนำการเขียนโปรแกรมที่ขับเคลื่อนด้วยภาษาทับทิม
edit Class#method )cd , ls และเพื่อน) gem 'pry' , '~> 0.15.0'gem install pry แงะมีความยืดหยุ่นพอสมควรและอนุญาตให้ปรับแต่งผู้ใช้อย่างมีนัยสำคัญ มันเป็นเรื่องเล็กน้อยที่จะอ่านจากวัตถุใด ๆ ที่มีวิธี readline และเขียนไปยังวัตถุใด ๆ ที่มีวิธี puts อีกหลายแง่มุมของแงะสามารถกำหนดค่าได้ทำให้เป็นตัวเลือกที่ดีสำหรับการใช้งานเชลล์ที่กำหนดเอง
PRY มาพร้อมกับปฏิบัติการเพื่อให้สามารถเรียกใช้ที่บรรทัดคำสั่ง เพียงเข้า pry เพื่อเริ่มต้น ไฟล์ pryrc ใน $XDG_CONFIG_HOME/pry/ หรือไดเรกทอรีโฮมสอร์ของผู้ใช้จะถูกโหลดหากมีอยู่ พิมพ์ pry --help ที่บรรทัดคำสั่งสำหรับข้อมูลเพิ่มเติม
เกือบทุกส่วนของฟังก์ชั่นในเซสชันแงะถูกนำมาใช้เป็นคำสั่ง คำสั่งไม่ใช่วิธีการและต้องเริ่มต้นที่จุดเริ่มต้นของบรรทัดโดยไม่มีช่องว่างระหว่างกัน คำสั่งรองรับไวยากรณ์ที่ยืดหยุ่นและอนุญาต 'ตัวเลือก' ในลักษณะเดียวกับคำสั่งเชลล์ตัวอย่างเช่นคำสั่งแงะต่อไปนี้จะแสดงรายการวิธีการอินสแตนซ์ส่วนตัวทั้งหมด (ในขอบเขต) ที่เริ่มต้นด้วย '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 ช่วยให้เราสามารถปรากฏตัวเข้าและออกจากขอบเขตที่แตกต่างกัน (วัตถุ) โดยใช้คำสั่ง cd สิ่งนี้ช่วยให้เราสามารถสำรวจมุมมองเวลาทำงานของโปรแกรมหรือห้องสมุด ในการดูตัวแปรและวิธีการใดที่มีอยู่ภายในขอบเขตเฉพาะเราใช้คำสั่ง LS อเนกประสงค์
ที่นี่เราจะเริ่มแงะในระดับบนสุดจากนั้นแงะในชั้นเรียนและจากนั้นในตัวแปรอินสแตนซ์ภายในคลาสนั้น:
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 .. หมายเลขหลังจาก : ในพรอมต์แจ้งแสดงถึงระดับการทำรัง ในการแสดงข้อมูลเพิ่มเติมเกี่ยวกับการทำรังให้ใช้คำสั่ง nesting เช่น
pry ( "friend" ) : 3 > nesting
Nesting status :
0 . main ( Pry top level )
1 . Hello
2 . 100
3 . "friend"
=> nil จากนั้นเราสามารถข้ามกลับไปที่ระดับการทำรังก่อนหน้านี้โดยใช้คำสั่ง jump-to :
pry ( "friend" ) : 3 > jump - to 1
= > 100
pry ( Hello ) : 1 > PRY สามารถเรียกใช้ในช่วงกลางของโปรแกรมการทำงาน มันเปิดเซสชันแงะ ณ จุดที่เรียกและทำให้สถานะโปรแกรมทั้งหมด ณ จุดนั้นพร้อมใช้งาน มันสามารถเรียกใช้กับวัตถุใด ๆ โดยใช้ my_object.pry ไวยากรณ์หรือในการเชื่อมโยงปัจจุบัน (หรือการเชื่อมโยงใด ๆ ) โดยใช้ binding.pry เซสชันแงะจะเริ่มต้นภายในขอบเขตของวัตถุ (หรือผูกพัน) เมื่อเซสชันสิ้นสุดโปรแกรมจะดำเนินการต่อไปด้วยการแก้ไขใด ๆ ที่คุณทำ
ฟังก์ชั่นนี้สามารถใช้สำหรับสิ่งต่าง ๆ เช่น: การดีบักการใช้คอนโซลนักพัฒนาและใช้แพทช์ร้อน
รหัส:
# 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 ( 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 .บรรทัดของอินพุตที่เริ่มต้นด้วย '.' จะถูกส่งต่อไปยังเชลล์คำสั่ง สิ่งนี้ช่วยให้เราสามารถนำทางระบบไฟล์ตัวแก้ไขวางไข่และเรียกใช้ Git และ Rake โดยตรงจากภายในแงะ
นอกจากนี้เราสามารถใช้คำสั่ง shell-mode เพื่อรวมไดเรกทอรีการทำงานปัจจุบันลงใน PRY PRY และนำ (จำกัด ในขั้นตอนนี้ขออภัย) ชื่อไฟล์ที่สมบูรณ์ นอกจากนี้เรายังสามารถแก้ไขรหัสทับทิมลงในเชลล์ได้โดยตรงโดยใช้ไวยากรณ์การแก้ไขสตริง #{} ปกติ
ในรหัสด้านล่างเราจะเปลี่ยนเป็น shell-mode และแก้ไขไฟล์ pryrc จากนั้นเราจะแมวเนื้อหาและโหลดไฟล์ใหม่
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! นอกจากนี้เรายังสามารถแทรกรหัสทับทิมลงในเชลล์ ในตัวอย่างด้านล่างเราใช้ cat คำสั่งเชลล์บนไฟล์สุ่มจากไดเรกทอรีปัจจุบันและนับจำนวนบรรทัดในไฟล์นั้นด้วย wc :
pry main : /home/john $ . cat #{Dir['*.*'].sample} | wc -l
44 คุณสามารถเรียกดูซอร์สโค้ดเมธอดด้วยคำสั่ง show-source เกือบทุกวิธีทับทิม (และวิธี C บางวิธีด้วยอัญมณีแงะ-ดอค) สามารถดูแหล่งที่มาได้ รหัสที่ยาวกว่าหน้าจะถูกส่งผ่านเพจเจอร์ (เช่นน้อยกว่า) และรหัสทั้งหมดจะถูกเน้นไวยากรณ์อย่างเหมาะสม (แม้แต่รหัส C)
คำสั่ง show-source ยอมรับสองไวยากรณ์คือไวยากรณ์ Class#method ทั่วไปและเพียงแค่ชื่อของวิธีที่อยู่ในขอบเขต คุณสามารถเลือกผ่านตัวเลือก -l เพื่อ show-source เพื่อรวมหมายเลขบรรทัดในเอาต์พุต
ในตัวอย่างต่อไปนี้เราจะเข้าสู่คลาส Pry ให้แสดงรายการเมธอดอินสแตนซ์ที่ขึ้นต้นด้วย 'SE' และแสดงซอร์สโค้ดสำหรับวิธี 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 โปรดทราบว่าเราสามารถดูวิธี C (จาก Ruby Core) โดยใช้ปลั๊กอิน pry-doc นอกจากนี้เรายังแสดงไวยากรณ์สำรองสำหรับ 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 ;
} หนึ่งกรณีการใช้งานสำหรับแงะคือการสำรวจโปรแกรมในเวลาทำงานโดย cd -ing เข้าและออกจากวัตถุและวิธีการดูและการเรียกใช้ ในการสำรวจอาจเป็นประโยชน์ในการอ่านเอกสารสำหรับวิธีการเฉพาะที่คุณเจอ คำสั่ง show-source รองรับไวยากรณ์สองตัวคือไวยากรณ์ ri ปกติรวมถึงการยอมรับชื่อของวิธีการใด ๆ ที่อยู่ในขอบเขต
ระบบเอกสาร PRY ไม่ได้พึ่งพา rdoc หรือ ri ที่สร้างไว้ล่วงหน้า แต่จะคว้าความคิดเห็นไว้ข้างบนความต้องการโดยตรง สิ่งนี้ส่งผลให้เกิดการดึงเอกสารที่เร็วขึ้นและช่วยให้ระบบแงะสามารถดึงเอกสารสำหรับวิธีการที่ rdoc จะไม่ได้รับ PRY ยังมีความเข้าใจพื้นฐานของทั้งรูปแบบ RDOC และ YARD และจะพยายามที่จะเน้นไวยากรณ์การจัดทำเอกสารอย่างเหมาะสม
อย่างไรก็ตามฟังก์ชั่น ri นั้นดีมากและมีข้อได้เปรียบเหนือระบบของ PRY ซึ่งช่วยให้การค้นหาเอกสารสำหรับชั้นเรียนและวิธีการ ดังนั้นแงะจึงมีการบูรณาการที่ดีกับ ri ผ่านคำสั่ง ri ไวยากรณ์สำหรับคำสั่งนั้นตรงตามที่จะอยู่ในบรรทัดคำสั่ง - ดังนั้นจึงไม่จำเป็นต้องอ้างถึงสตริง
ในตัวอย่างของเราเราจะเข้าสู่คลาส Gem และดูเอกสารประกอบสำหรับวิธี 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 > นอกจากนี้เรายังสามารถใช้ ri ได้ตามปกติ:
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 -- คุณสามารถใช้ edit Class#method หรือ edit my_method (หากวิธีการอยู่ในขอบเขต) เพื่อเปิดวิธีการแก้ไขโดยตรงในโปรแกรมแก้ไขที่คุณชื่นชอบ PRY มีความรู้เกี่ยวกับบรรณาธิการที่แตกต่างกันสองสามตัวและจะพยายามเปิดไฟล์ที่บรรทัดที่กำหนดวิธีการ
คุณสามารถตั้งค่าตัวแก้ไขให้ใช้โดยการกำหนดให้กับผู้เข้าร่วม Pry.editor Pry.editor จะเริ่มต้นเป็น $EDITOR หรือล้มเหลวที่จะใช้ nano เป็นค่าเริ่มต้นการสำรองข้อมูล ไฟล์ที่แก้ไขจะถูกโหลดใหม่โดยอัตโนมัติหลังจากออกจากตัวแก้ไข -การโหลดซ้ำสามารถระงับได้โดยผ่านตัวเลือก --no-reload เพื่อ edit
ในตัวอย่างด้านล่างเราจะตั้งค่าตัวแก้ไขเริ่มต้นของเราเป็น "EmacsClient" และเปิดวิธี Pry#repl สำหรับการแก้ไข:
pry ( main ) > Pry . editor = "emacsclient"
pry ( main ) > edit Pry #repl มีคำสั่งอื่น ๆ อีกมากมายที่มีอยู่ในแงะ หากต้องการดู help ประเภทรายการทั้งหมดที่พรอมต์ คำอธิบายสั้น ๆ ของแต่ละคำสั่งมีคำแนะนำพื้นฐานสำหรับการใช้งาน คำสั่งบางคำมีความช่วยเหลือที่ครอบคลุมมากขึ้นซึ่งสามารถเข้าถึงได้ผ่านการพิมพ์ command_name --help โดยทั่วไปคำสั่งจะพูดในคำอธิบายว่าตัวเลือก --help พร้อมใช้งาน
คุณสามารถเรียกใช้คอนโซลแงะในสภาพแวดล้อมของแอปของคุณโดยใช้ธง PRY's -r :
pry -r ./config/environment หรือเริ่มคอนโซลราง ( bin/rails console ) จากนั้นพิมพ์ pry
นอกจากนี้ยังเป็นไปได้ที่จะใช้แงะเป็นคอนโซลรางของคุณโดยการเพิ่มอัญมณีแงะรางลงใน Gemfile ของคุณ สิ่งนี้แทนที่คอนโซลเริ่มต้นด้วยการแงะนอกเหนือจากการโหลดผู้ช่วยคอนโซลรางและเพิ่มคำสั่งเฉพาะรางที่มีประโยชน์
โปรดทราบว่าไม่ได้รับการบำรุงรักษา pry-rails
ตรวจสอบ Wiki สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการรวมแงะกับ Rails
การไฮไลต์ไวยากรณ์เปิดขึ้นโดยค่าเริ่มต้นเป็น PRY หากคุณต้องการเปลี่ยนสีลองดูอัญมณีแงะ
คุณสามารถสลับไวยากรณ์ที่เน้นและปิดในเซสชันโดยใช้คำสั่ง toggle-color อีกทางเลือกหนึ่งคุณสามารถปิดได้อย่างถาวรโดยวางสาย Pry.color = false ในไฟล์ pryrc ของคุณ
ในกรณีที่คุณมีปัญหาคำถามหรือรายงานข้อผิดพลาดอย่าลังเลที่จะ:
โครงการใช้ใบอนุญาต MIT ดูใบอนุญาตสำหรับรายละเอียด
PRY ส่วนใหญ่เป็นผลงานของ John Mair (Banisterfiend) สำหรับรายชื่อผู้มีส่วนร่วมทั้งหมดดูกราฟผู้มีส่วนร่วม
