pry
v0.15.0
© John Mair (Banisterfiend) 2018
(Criador)
© Kyrylo Silin (Kyrylosilin) 2018
(Mantenedor)
Ex -alunos:
Links:
Pry é um console de desenvolvedor de tempo de execução e alternativa do IRB com poderosas capacidades de introspecção. Pry pretende ser mais do que uma substituição do IRB. É uma tentativa de trazer programação orientada por Repl para a linguagem Ruby.
edit Class#method )cd , ls e amigos) gem 'pry' , '~> 0.15.0'gem install pry O Pry é bastante flexível e permite personalização significativa do usuário. É trivial ler em qualquer objeto que tenha um método readline e gravar em qualquer objeto que tenha um método puts . Muitos outros aspectos do Pry também são configuráveis, tornando -o uma boa opção para implementar conchas personalizadas.
Pry vem com um executável para que possa ser chamado na linha de comando. Basta entrar em pry para começar. Um arquivo pryrc em $XDG_CONFIG_HOME/pry/ OU O diretório inicial do usuário será carregado se houver. Tipo pry --help na linha de comando para obter mais informações.
Quase todas as funcionalidades de uma sessão de alfinete são implementadas como um comando. Os comandos não são métodos e devem começar no início de uma linha, sem espaço em branco no meio. Os comandos suportam uma sintaxe flexível e permitem 'opções' da mesma maneira que os comandos do shell, por exemplo, o seguinte comando de pry mostrará uma lista de todos os métodos de instância privada (no escopo) que começam com '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 e sair de diferentes escopos (objetos) usando o comando cd . Isso nos permite explorar a visualização em tempo de execução de um programa ou biblioteca. Para visualizar quais variáveis e métodos estão disponíveis em um escopo específico, usamos o comando LS versátil.
Aqui começaremos a melhorar no nível superior, depois articular em uma aula e depois em uma variável de instância dentro dessa 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 .. O número após o : no prompt de alfinete indica o nível de nidificação. Para exibir mais informações sobre o ninho, use o comando nesting . Por exemplo
pry ( "friend" ) : 3 > nesting
Nesting status :
0 . main ( Pry top level )
1 . Hello
2 . 100
3 . "friend"
=> nil Podemos voltar para qualquer um dos níveis anteriores de nidificação usando o comando jump-to :
pry ( "friend" ) : 3 > jump - to 1
= > 100
pry ( Hello ) : 1 > Pry pode ser invocado no meio de um programa de corrida. Ele abre uma sessão de alfinete no momento em que é chamado e disponibiliza todo o estado do programa nesse ponto. Ele pode ser chamado em qualquer objeto usando a sintaxe my_object.pry ou na ligação atual (ou qualquer ligação) usando binding.pry . A sessão de trava começará dentro do escopo do objeto (ou ligação). Quando a sessão termina, o programa continua com quaisquer modificações que você fez.
Essa funcionalidade pode ser usada para coisas como: depuração, implementação de consoles de desenvolvedores e aplicação de patches quentes.
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."Sessão 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 .Uma linha de entrada que começa com um ''. será encaminhado para o shell de comando. Isso nos permite navegar pelo sistema de arquivos, gerar editores e executar o Git e o Rake diretamente de dentro do Pry.
Além disso, podemos usar o comando shell-mode para incorporar o presente diretório de trabalho no prompt de pry e trazer (Limited nesta fase, desculpe) conclusão do nome do arquivo. Também podemos interpolar o código Ruby diretamente no shell usando a sintaxe de interpolação #{} string normal.
No código abaixo, vamos mudar para shell-mode e editar o arquivo pryrc . Em seguida, vamos colocar seu conteúdo e recarregaremos o arquivo.
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! Também podemos interpolar o código Ruby no shell. No exemplo abaixo, usamos o cat do comando Shell em um arquivo aleatório do diretório atual e contamos o número de linhas nesse arquivo com wc :
pry main : /home/john $ . cat #{Dir['*.*'].sample} | wc -l
44 Você pode navegar pelo código-fonte do método com o comando show-source . Quase todos os métodos Ruby (e alguns métodos C, com a gema Pry-Doc) podem ter sua fonte vista. O código mais longo que uma página é enviado através de um pager (como menos) e todo o código é destacado corretamente (mesmo código C).
O comando show-source aceita duas sintaxes, a sintaxe típica Class#method RI e também simplesmente o nome de um método que está no escopo. Opcionalmente, você pode passar a opção -l para show-source para incluir números de linha na saída.
No exemplo a seguir, entraremos na classe Pry , listaremos os métodos de instância começando com 'SE' e exibiremos o código -fonte do 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 Observe que também podemos visualizar os métodos C (do Ruby Core) usando o plug pry-doc ; Também mostramos a sintaxe 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 ;
} Um caso de uso para Pry é explorar um programa em tempo de execução, cd e fora dos objetos e visualizando e invocando métodos. No decorrer de explorar, pode ser útil ler a documentação para um método específico que você encontra. O comando show-source suporta duas sintaxes - a sintaxe normal ri , além de aceitar o nome de qualquer método que esteja atualmente em escopo.
O sistema de documentação da PRY não depende do rdoc ou ri pré-gerado, em vez disso, agarra os comentários diretamente acima do método sob demanda. Isso resulta em recuperação de documentação mais rápida e permite que o sistema PRY recupere a documentação para métodos que não seriam escolhidos pelo rdoc . A Pry também tem um entendimento básico dos formatos RDOC e Yard e tentará sintaxe destacar a documentação adequadamente.
No entanto, a funcionalidade ri é muito boa e tem uma vantagem sobre o sistema da PRY, pois permite procurar documentação para classes e métodos. PRY, portanto, tem boa integração com ri através do comando ri . A sintaxe para o comando é exatamente como seria na linha de comando - portanto, não é necessário citar strings.
Em nosso exemplo, entraremos na classe Gem e visualizaremos a documentação do 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 > Também podemos usar ri da maneira 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 -- Você pode usar edit Class#method ou edit my_method (se o método estiver no escopo) para abrir um método para editar diretamente em seu editor favorito. Pry tem conhecimento de alguns editores diferentes e tentará abrir o arquivo na linha, o método é definido.
Você pode definir o editor para atribuir ao Pry.editor Acessor. Pry.editor será inadimplente para $EDITOR ou falha que usará nano como o padrão de backup. O arquivo editado será automaticamente recarregado após a saída do editor -a recarga pode ser suprimida passando a opção --no-reload para edit
No exemplo abaixo, definiremos nosso editor padrão como "Emacsclient" e abriremos o método Pry#repl for Editing:
pry ( main ) > Pry . editor = "emacsclient"
pry ( main ) > edit Pry #repl Muitos outros comandos estão disponíveis em Pry; Para ver o tipo de lista completa help no prompt. Uma breve descrição de cada comando é fornecida com instruções básicas para uso; Alguns comandos têm uma ajuda mais extensa que pode ser acessada via Typing command_name --help . Um comando normalmente diz em sua descrição se a opção --help estiver disponível.
Você pode executar um console de alfinete no ambiente do seu aplicativo usando a bandeira -r de Pry:
pry -r ./config/environment Ou inicie o console do Rails ( bin/rails console ) e depois digite pry .
Também é possível usar o Pry como seu console do Rails, adicionando a jóia dos Rails Prys ao seu Gemfile. Isso substitui o console padrão pelo Pry, além de carregar os ajudantes do Console do Rails e adicionar alguns comandos úteis específicos dos trilhos.
Observe que pry-rails não são mantidos no momento.
Confira também o Wiki para obter mais informações sobre como integrar a Pry com os trilhos.
O destaque da sintaxe é o padrão por padrão. Se você quiser alterar as cores, confira a jóia do time de arco.
Você pode alternar a sintaxe destacando e desativando em uma sessão usando o comando toggle-color . Como alternativa, você pode desligá -lo permanentemente colocando a linha Pry.color = false no seu arquivo pryrc .
Caso você tenha um problema, pergunta ou relatório de bug, fique à vontade para:
O projeto usa a licença do MIT. Consulte License.md para obter detalhes.
Pry é principalmente o trabalho de John Mair (Banisterfiend), para uma lista completa de colaboradores, consulte o gráfico dos colaboradores.
