Nuevo comando ls para IRB en Ruby 3

Publicado el Martes, 30 de marzo de 2021

Recientemente se agregó el comando ls al código fuente de Ruby. El comando ls está inspirado en la misma funcionalidad al estilo Pry, una alternativa a IRB con algunas capacidades extra. El comando nos permite inspeccionar constantes, métodos y variables de self o de un objeto escribiendo muy poco. ¡Es bastante práctico!

Para probarlo tenemos que usar la versión de desarrollo de Ruby, usando RVM tenemos que instalar ruby-head.

Un ejemplo usando el comando en la gema ci_uy:

head :001 > ls CiUY
CiUY.methods: get_random_ci  get_validation_digit  random  transform  validate  validate_ci  validation_digit
 => nil

O en un String:

head :009 > ls String.new('Hola mundo!')
String#methods: 
  %               *              +                  +@                     -@                   <<           
  <=>             ==             ===                =~                     []                   []=          
  ascii_only?     b              bytes              bytesize               byteslice            capitalize   
  capitalize!     casecmp        casecmp?           center                 chars                chomp        
  chomp!          chop           chop!              chr                    clear                codepoints   
  concat          count          crypt              delete                 delete!              delete_prefix
  delete_prefix!  delete_suffix  delete_suffix!     downcase               downcase!            dump         
  each_byte       each_char      each_codepoint     each_grapheme_cluster  each_line            empty?       
  encode          encode!        encoding           end_with?              eql?                 ext          
  force_encoding  freeze         getbyte            grapheme_clusters      gsub                 gsub!        
  hash            hex            include?           index                  insert               inspect      
  intern          length         lines              ljust                  lstrip               lstrip!      
  match           match?         next               next!                  oct                  ord          
  partition       pathmap        prepend            pretty_print           replace              reverse      
  reverse!        rindex         rjust              rpartition             rstrip               rstrip!      
  scan            scrub          scrub!             setbyte                size                 slice        
  slice!          split          squeeze            squeeze!               start_with?          strip        
  strip!          sub            sub!               succ                   succ!                sum          
  swapcase        swapcase!      to_c               to_f                   to_i                 to_r         
  to_s            to_str         to_sym             tr                     tr!                  tr_s         
  tr_s!           undump         unicode_normalize  unicode_normalize!     unicode_normalized?  unpack       
  unpack1         upcase         upcase!            upto                   valid_encoding?    
 => nil

head :009 > String#methods: % * <=> == ascii_only? b capitalize! casecmp chomp! chop concat count delete_prefix! each_byte each_char encode encode! force_encoding freeze hash hex intern length match match? partition pathmap reverse! rindex scan scrub slice! split strip! sub swapcase swapcase! to_s to_str tr_s! undump unpack1 upcase => nil ls String.new('Hola mundo!') + +@ -@ << === =~ [] []= bytes bytesize byteslice capitalize casecmp? center chars chomp chop! chr clear codepoints crypt delete delete! delete_prefix delete_suffix delete_suffix! downcase downcase! dump each_codepoint each_grapheme_cluster each_line empty? encoding end_with? eql? ext getbyte grapheme_clusters gsub gsub! include? index insert inspect lines ljust lstrip lstrip! next next! oct ord prepend pretty_print replace reverse rjust rpartition rstrip rstrip! scrub! setbyte size slice squeeze squeeze! start_with? strip sub! succ succ! sum to_c to_f to_i to_r to_sym tr tr! tr_s unicode_normalize unicode_normalize! unicode_normalized? unpack upcase! upto valid_encoding?

La implementación se ve simple, usa métodos del objeto y la clase para mostrar toda esta información: obj.constants, obj.singleton_methods, klass.public_instance_methods, obj.instance_variables, klass.class_variables y variables locales de irb. Es información a la que tenemos acceso, pero resulta bastante práctico tenerla a mano para un objeto dado con un sólo comando.