irb 1.8.1 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b6bfef2fbb8e5e7d7587a567055e2b7f019678d2355f6ae52f7a7d8161df0c0
-  data.tar.gz: 653be685d9f249341c3e165cb4303baa05563c5556cc2bf2584243c39ec0cb92
+  metadata.gz: 810aa12a1fbfdbd0ff9f9c4d5c4ac71e62e8241f87cb1a306be1ff81aaef08cb
+  data.tar.gz: 781d169232ac355b9723e8dc03d6c0de4c16327b4a4a3339cd1e90bad7e1c0b1
 SHA512:
-  metadata.gz: 215ce7d8130e1a43382706858c487d7835971e326e93eb1c2ccb559b7dec5f1ecd216b451ad535beaba5e908419ec3e1c13bcc8dea8a0e6d2d7c45fed4639fdb
-  data.tar.gz: c950ff10929df5ac8365ec0b86fcafe1ac85685ef955b6d12ec7febaf2a9bc85be8b325a58b60583c2a7567889cc6fbe9c6c6eb9b16a10f35409b7da21c7cd32
+  metadata.gz: 51d97e80d977c6ce100f66cc0ad4becae17600d36653be88cc7c2f1e6cd0b7127cec01344bc69b04de1b043f8d45a1d07f6b4b8ad3fad4584585aca269cfa65f
+  data.tar.gz: a197cf8c07a1ea728a3c9d0d70fdd28a2a5b9a4e9ebf72a8fd8d6495627cf4c369e6831879a766c5dd8819438bb1f126b0d4d669becc4c63a7ad6c4ea51a3a79

data/Gemfile

@@ -17,3 +17,10 @@ gem "rake"
 gem "test-unit"
 gem "test-unit-ruby-core"
 gem "debug", github: "ruby/debug"
+
+gem "racc"
+
+if RUBY_VERSION >= "3.0.0"
+  gem "rbs"
+  gem "prism", ">= 0.17.1"
+end

data/README.md

@@ -52,6 +52,10 @@ $ gem install irb
 
 ## Usage
 
+> **Note**
+>
+> We're working hard to match Pry's variety of powerful features in IRB, and you can track our progress or find contribution ideas in [this document](https://github.com/ruby/irb/blob/master/COMPARED_WITH_PRY.md).
+
 ### The `irb` Executable
 
 You can start a fresh IRB session by typing `irb` in your terminal.
@@ -150,7 +154,7 @@ Context
 
 Starting from version 1.8.0, IRB boasts a powerful integration with `debug.gem`, providing a debugging experience akin to `pry-byebug`.
 
-After hitting a `binding.irb` breakpoint, you can activate the debugger with the `debug` command.
+After hitting a `binding.irb` breakpoint, you can activate the debugger with the `debug` command. Alternatively, if the `debug` method happens to already be defined in the current scope, you can call `irb_debug`.
 
 ```shell
 From: test.rb @ line 3 :
@@ -231,6 +235,79 @@ However, there are also some limitations to be aware of:
 2. As IRB [doesn't currently support remote-connection](https://github.com/ruby/irb/issues/672), it can't be used with `debug.gem`'s remote debugging feature.
 3. Access to the previous return value via the underscore `_` is not supported.
 
+## Type Based Completion
+
+IRB's default completion `IRB::RegexpCompletor` uses Regexp. IRB has another experimental completion `IRB::TypeCompletion` that uses type analysis.
+
+### How to Enable IRB::TypeCompletion
+
+To enable IRB::TypeCompletion, run IRB with `--type-completor` option
+```
+$ irb --type-completor
+```
+Or write the code below to IRB's rc-file.
+```ruby
+IRB.conf[:COMPLETOR] = :type # default is :regexp
+```
+You also need `gem prism` and `gem rbs` to use this feature.
+
+To check if it's enabled, type `irb_info` into IRB and see the `Completion` section.
+```
+irb(main):001> irb_info
+...
+# Enabled
+Completion: Autocomplete, TypeCompletion::Completor(Prism: 0.17.1, RBS: 3.3.0)
+# Not enabled
+Completion: Autocomplete, RegexpCompletor
+...
+```
+If you have `sig/` directory or `rbs_collection.lock.yaml` in current directory, IRB will load it.
+
+### Advantage over Default IRB::RegexpCompletor
+
+IRB::TypeCompletion can autocomplete chained methods, block parameters and more if type information is available.
+These are some examples IRB::RegexpCompletor cannot complete.
+
+```ruby
+irb(main):001> 'Ruby'.upcase.chars.s # Array methods (sample, select, shift, size)
+```
+
+```ruby
+irb(main):001> 10.times.map(&:to_s).each do |s|
+irb(main):002>   s.up # String methods (upcase, upcase!, upto)
+```
+
+```ruby
+irb(main):001> class User < ApplicationRecord
+irb(main):002>   def foo
+irb(main):003>     sa # save, save!
+```
+
+As a trade-off, completion calculation takes more time than IRB::RegexpCompletor.
+
+### Difference between Steep's Completion
+
+Compared with Steep, IRB::TypeCompletion has some difference and limitations.
+```ruby
+[0, 'a'].sample.
+# Steep completes intersection of Integer methods and String methods
+# IRB::TypeCompletion completes both Integer and String methods
+```
+
+Some features like type narrowing is not implemented.
+```ruby
+def f(arg = [0, 'a'].sample)
+  if arg.is_a?(String)
+    arg. # Completes both Integer and String methods
+```
+
+Unlike other static type checker, IRB::TypeCompletion uses runtime information to provide better completion.
+```ruby
+irb(main):001> a = [1]
+=> [1]
+irb(main):002> a.first. # Completes Integer methods
+```
+
 ## Configuration
 
 ### Environment Variables
@@ -269,6 +346,30 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/irb.
 
+### Set up the environment
+
+1. Fork the project to your GithHub account
+2. Clone the fork with `git clone git@github.com:[your_username]/irb.git`
+3. Run `bundle install`
+4. Run `bundle exec rake` to make sure tests pass locally
+
+### Run integration tests
+
+If your changes affect component rendering, such as the autocompletion's dialog/dropdown, you may need to run IRB's integration tests, known as `yamatanarroroti`.
+
+Before running these tests, ensure that you have `libvterm` installed. If you're using Homebrew, you can install it by running:
+
+```bash
+brew install libvterm
+```
+
+After installing `libvterm`, you can run the integration tests using the following commands:
+
+```bash
+WITH_VTERM=1 bundle install
+WITH_VTERM=1 bundle exec rake test test_yamatanooroti
+```
+
 ## Releasing
 
 ```

data/Rakefile

@@ -5,7 +5,7 @@ Rake::TestTask.new(:test) do |t|
   t.libs << "test" << "test/lib"
   t.libs << "lib"
   t.ruby_opts << "-rhelper"
-  t.test_files = FileList["test/irb/test_*.rb"]
+  t.test_files = FileList["test/irb/test_*.rb", "test/irb/type_completion/test_*.rb"]
 end
 
 # To make sure they have been correctly setup for Ruby CI.
@@ -13,7 +13,7 @@ desc "Run each irb test file in isolation."
 task :test_in_isolation do
   failed = false
 
-  FileList["test/irb/test_*.rb"].each do |test_file|
+  FileList["test/irb/test_*.rb", "test/irb/type_completion/test_*.rb"].each do |test_file|
     ENV["TEST"] = test_file
     begin
       Rake::Task["test"].execute

data/lib/irb/cmd/irb_info.rb

@@ -14,6 +14,7 @@ module IRB
         str  = "Ruby version: #{RUBY_VERSION}\n"
         str += "IRB version: #{IRB.version}\n"
         str += "InputMethod: #{IRB.CurrentContext.io.inspect}\n"
+        str += "Completion: #{IRB.CurrentContext.io.respond_to?(:completion_info) ? IRB.CurrentContext.io.completion_info : 'off'}\n"
         str += ".irbrc path: #{IRB.rc_file}\n" if File.exist?(IRB.rc_file)
         str += "RUBY_PLATFORM: #{RUBY_PLATFORM}\n"
         str += "LANG env: #{ENV["LANG"]}\n" if ENV["LANG"] && !ENV["LANG"].empty?

data/lib/irb/cmd/show_source.rb

@@ -2,6 +2,7 @@
 
 require_relative "nop"
 require_relative "../source_finder"
+require_relative "../pager"
 require_relative "../color"
 
 module IRB
@@ -40,12 +41,16 @@ module IRB
       private
 
       def show_source(source)
-        puts
-        puts "#{bold("From")}: #{source.file}:#{source.first_line}"
-        puts
-        code = IRB::Color.colorize_code(File.read(source.file))
-        puts code.lines[(source.first_line - 1)...source.last_line].join
-        puts
+        file_content = IRB::Color.colorize_code(File.read(source.file))
+        code = file_content.lines[(source.first_line - 1)...source.last_line].join
+        content = <<~CONTENT
+
+          #{bold("From")}: #{source.file}:#{source.first_line}
+
+          #{code}
+        CONTENT
+
+        Pager.page_content(content)
       end
 
       def bold(str)

data/lib/irb/completion.rb

@@ -8,30 +8,7 @@
 require_relative 'ruby-lex'
 
 module IRB
-  module InputCompletor # :nodoc:
-    using Module.new {
-      refine ::Binding do
-        def eval_methods
-          ::Kernel.instance_method(:methods).bind(eval("self")).call
-        end
-
-        def eval_private_methods
-          ::Kernel.instance_method(:private_methods).bind(eval("self")).call
-        end
-
-        def eval_instance_variables
-          ::Kernel.instance_method(:instance_variables).bind(eval("self")).call
-        end
-
-        def eval_global_variables
-          ::Kernel.instance_method(:global_variables).bind(eval("self")).call
-        end
-
-        def eval_class_constants
-          ::Module.instance_method(:constants).bind(eval("self.class")).call
-        end
-      end
-    }
+  class BaseCompletor # :nodoc:
 
     # Set of reserved words used by Ruby, you should not use these for
     # constants or variables
@@ -56,7 +33,13 @@ module IRB
       yield
     ]
 
-    BASIC_WORD_BREAK_CHARACTERS = " \t\n`><=;|&{("
+    def completion_candidates(preposing, target, postposing, bind:)
+      raise NotImplementedError
+    end
+
+    def doc_namespace(preposing, matched, postposing, bind:)
+      raise NotImplementedError
+    end
 
     GEM_PATHS =
       if defined?(Gem::Specification)
@@ -73,7 +56,7 @@ module IRB
         []
       end.freeze
 
-    def self.retrieve_gem_and_system_load_path
+    def retrieve_gem_and_system_load_path
       candidates = (GEM_PATHS | $LOAD_PATH)
       candidates.map do |p|
         if p.respond_to?(:to_path)
@@ -84,8 +67,8 @@ module IRB
       end.compact.sort
     end
 
-    def self.retrieve_files_to_require_from_load_path
-      @@files_from_load_path ||=
+    def retrieve_files_to_require_from_load_path
+      @files_from_load_path ||=
         (
           shortest = []
           rest = retrieve_gem_and_system_load_path.each_with_object([]) { |path, result|
@@ -103,13 +86,43 @@ module IRB
         )
     end
 
-    def self.retrieve_files_to_require_relative_from_current_dir
-      @@files_from_current_dir ||= Dir.glob("**/*.{rb,#{RbConfig::CONFIG['DLEXT']}}", base: '.').map { |path|
+    def retrieve_files_to_require_relative_from_current_dir
+      @files_from_current_dir ||= Dir.glob("**/*.{rb,#{RbConfig::CONFIG['DLEXT']}}", base: '.').map { |path|
         path.sub(/\.(rb|#{RbConfig::CONFIG['DLEXT']})\z/, '')
       }
     end
+  end
+
+  class RegexpCompletor < BaseCompletor # :nodoc:
+    using Module.new {
+      refine ::Binding do
+        def eval_methods
+          ::Kernel.instance_method(:methods).bind(eval("self")).call
+        end
+
+        def eval_private_methods
+          ::Kernel.instance_method(:private_methods).bind(eval("self")).call
+        end
+
+        def eval_instance_variables
+          ::Kernel.instance_method(:instance_variables).bind(eval("self")).call
+        end
+
+        def eval_global_variables
+          ::Kernel.instance_method(:global_variables).bind(eval("self")).call
+        end
+
+        def eval_class_constants
+          ::Module.instance_method(:constants).bind(eval("self.class")).call
+        end
+      end
+    }
+
+    def inspect
+      'RegexpCompletor'
+    end
 
-    CompletionRequireProc = lambda { |target, preposing = nil, postposing = nil|
+    def complete_require_path(target, preposing, postposing)
       if target =~ /\A(['"])([^'"]+)\Z/
         quote = $1
         actual_target = $2
@@ -124,39 +137,37 @@ module IRB
           break
         end
       end
-      result = []
-      if tok && tok.event == :on_ident && tok.state == Ripper::EXPR_CMDARG
-        case tok.tok
-        when 'require'
-          result = retrieve_files_to_require_from_load_path.select { |path|
-            path.start_with?(actual_target)
-          }.map { |path|
-            quote + path
-          }
-        when 'require_relative'
-          result = retrieve_files_to_require_relative_from_current_dir.select { |path|
-            path.start_with?(actual_target)
-          }.map { |path|
-            quote + path
-          }
-        end
+      return unless tok&.event == :on_ident && tok.state == Ripper::EXPR_CMDARG
+
+      case tok.tok
+      when 'require'
+        retrieve_files_to_require_from_load_path.select { |path|
+          path.start_with?(actual_target)
+        }.map { |path|
+          quote + path
+        }
+      when 'require_relative'
+        retrieve_files_to_require_relative_from_current_dir.select { |path|
+          path.start_with?(actual_target)
+        }.map { |path|
+          quote + path
+        }
       end
-      result
-    }
+    end
 
-    CompletionProc = lambda { |target, preposing = nil, postposing = nil|
+    def completion_candidates(preposing, target, postposing, bind:)
       if preposing && postposing
-        result = CompletionRequireProc.(target, preposing, postposing)
-        unless result
-          result = retrieve_completion_data(target).compact.map{ |i| i.encode(Encoding.default_external) }
-        end
-        result
-      else
-        retrieve_completion_data(target).compact.map{ |i| i.encode(Encoding.default_external) }
+        result = complete_require_path(target, preposing, postposing)
+        return result if result
       end
-    }
+      retrieve_completion_data(target, bind: bind, doc_namespace: false).compact.map{ |i| i.encode(Encoding.default_external) }
+    end
 
-    def self.retrieve_completion_data(input, bind: IRB.conf[:MAIN_CONTEXT].workspace.binding, doc_namespace: false)
+    def doc_namespace(_preposing, matched, _postposing, bind:)
+      retrieve_completion_data(matched, bind: bind, doc_namespace: true)
+    end
+
+    def retrieve_completion_data(input, bind:, doc_namespace:)
       case input
       # this regexp only matches the closing character because of irb's Reline.completer_quote_characters setting
       # details are described in: https://github.com/ruby/irb/pull/523
@@ -394,44 +405,10 @@ module IRB
       end
     end
 
-    PerfectMatchedProc = ->(matched, bind: IRB.conf[:MAIN_CONTEXT].workspace.binding) {
-      begin
-        require 'rdoc'
-      rescue LoadError
-        return
-      end
-
-      RDocRIDriver ||= RDoc::RI::Driver.new
-
-      if matched =~ /\A(?:::)?RubyVM/ and not ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
-        IRB.__send__(:easter_egg)
-        return
-      end
-
-      namespace = retrieve_completion_data(matched, bind: bind, doc_namespace: true)
-      return unless namespace
-
-      if namespace.is_a?(Array)
-        out = RDoc::Markup::Document.new
-        namespace.each do |m|
-          begin
-            RDocRIDriver.add_method(out, m)
-          rescue RDoc::RI::Driver::NotFoundError
-          end
-        end
-        RDocRIDriver.display(out)
-      else
-        begin
-          RDocRIDriver.display_names([namespace])
-        rescue RDoc::RI::Driver::NotFoundError
-        end
-      end
-    }
-
     # Set of available operators in Ruby
     Operators = %w[% & * ** + - / < << <= <=> == === =~ > >= >> [] []= ^ ! != !~]
 
-    def self.select_message(receiver, message, candidates, sep = ".")
+    def select_message(receiver, message, candidates, sep = ".")
       candidates.grep(/^#{Regexp.quote(message)}/).collect do |e|
         case e
         when /^[a-zA-Z_]/
@@ -443,4 +420,20 @@ module IRB
       end
     end
   end
+
+  module InputCompletor
+    class << self
+      private def regexp_completor
+        @regexp_completor ||= RegexpCompletor.new
+      end
+
+      def retrieve_completion_data(input, bind: IRB.conf[:MAIN_CONTEXT].workspace.binding, doc_namespace: false)
+        regexp_completor.retrieve_completion_data(input, bind: bind, doc_namespace: doc_namespace)
+      end
+    end
+    CompletionProc = ->(target, preposing = nil, postposing = nil) {
+      regexp_completor.completion_candidates(preposing, target, postposing, bind: IRB.conf[:MAIN_CONTEXT].workspace.binding)
+    }
+  end
+  deprecate_constant :InputCompletor
 end

data/lib/irb/context.rb

@@ -86,14 +86,14 @@ module IRB
         when nil
           if STDIN.tty? && IRB.conf[:PROMPT_MODE] != :INF_RUBY && !use_singleline?
             # Both of multiline mode and singleline mode aren't specified.
-            @io = RelineInputMethod.new
+            @io = RelineInputMethod.new(build_completor)
           else
             @io = nil
           end
         when false
           @io = nil
         when true
-          @io = RelineInputMethod.new
+          @io = RelineInputMethod.new(build_completor)
         end
         unless @io
           case use_singleline?
@@ -149,6 +149,43 @@ module IRB
       @command_aliases = IRB.conf[:COMMAND_ALIASES]
     end
 
+    private def build_completor
+      completor_type = IRB.conf[:COMPLETOR]
+      case completor_type
+      when :regexp
+        return RegexpCompletor.new
+      when :type
+        completor = build_type_completor
+        return completor if completor
+      else
+        warn "Invalid value for IRB.conf[:COMPLETOR]: #{completor_type}"
+      end
+      # Fallback to RegexpCompletor
+      RegexpCompletor.new
+    end
+
+    TYPE_COMPLETION_REQUIRED_PRISM_VERSION = '0.17.1'
+
+    private def build_type_completor
+      unless Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0') && RUBY_ENGINE != 'truffleruby'
+        warn 'TypeCompletion requires RUBY_VERSION >= 3.0.0'
+        return
+      end
+      begin
+        require 'prism'
+      rescue LoadError => e
+        warn "TypeCompletion requires Prism: #{e.message}"
+        return
+      end
+      unless Gem::Version.new(Prism::VERSION) >= Gem::Version.new(TYPE_COMPLETION_REQUIRED_PRISM_VERSION)
+        warn "TypeCompletion requires Prism::VERSION >= #{TYPE_COMPLETION_REQUIRED_PRISM_VERSION}"
+        return
+      end
+      require 'irb/type_completion/completor'
+      TypeCompletion::Types.preload_in_thread
+      TypeCompletion::Completor.new
+    end
+
     def save_history=(val)
       IRB.conf[:SAVE_HISTORY] = val
     end

data/lib/irb/debug/ui.rb

@@ -4,8 +4,7 @@ require 'debug/console'
 module IRB
   module Debug
     class UI < DEBUGGER__::UI_Base
-      def initialize(thread, irb)
-        @thread = thread
+      def initialize(irb)
         @irb = irb
       end
 
@@ -56,7 +55,7 @@ module IRB
 
       def readline _
         setup_interrupt do
-          tc = DEBUGGER__::SESSION.get_thread_client(@thread)
+          tc = DEBUGGER__::SESSION.instance_variable_get(:@tc)
           cmd = @irb.debug_readline(tc.current_frame.binding || TOPLEVEL_BINDING)
 
           case cmd

data/lib/irb/debug.rb

@@ -32,17 +32,14 @@ module IRB
           end
           DEBUGGER__::CONFIG.set_config
           configure_irb_for_debugger(irb)
-          thread = Thread.current
 
-          DEBUGGER__.initialize_session{ IRB::Debug::UI.new(thread, irb) }
+          DEBUGGER__.initialize_session{ IRB::Debug::UI.new(irb) }
         end
 
         # When debug session was previously started but not by IRB
         if defined?(DEBUGGER__::SESSION) && !irb.context.with_debugger
           configure_irb_for_debugger(irb)
-          thread = Thread.current
-
-          DEBUGGER__::SESSION.reset_ui(IRB::Debug::UI.new(thread, irb))
+          DEBUGGER__::SESSION.reset_ui(IRB::Debug::UI.new(irb))
         end
 
         # Apply patches to debug gem so it skips IRB frames

data/lib/irb/easter-egg.rb

@@ -98,18 +98,26 @@ module IRB
       end
     end
 
+    private def easter_egg_logo(type)
+      @easter_egg_logos ||= File.read(File.join(__dir__, 'ruby_logo.aa'), encoding: 'UTF-8:UTF-8')
+        .split(/TYPE: ([A-Z]+)\n/)[1..]
+        .each_slice(2)
+        .to_h
+      @easter_egg_logos[type.to_s.upcase]
+    end
+
     private def easter_egg(type = nil)
       type ||= [:logo, :dancing].sample
       case type
       when :logo
-        File.open(File.join(__dir__, 'ruby_logo.aa')) do |f|
-          require "rdoc"
-          RDoc::RI::Driver.new.page do |io|
-            IO.copy_stream(f, io)
-          end
+        require "rdoc"
+        RDoc::RI::Driver.new.page do |io|
+          io.write easter_egg_logo(:large)
         end
       when :dancing
-        begin
+        STDOUT.cooked do
+          interrupted = false
+          prev_trap = trap("SIGINT") { interrupted = true }
           canvas = Canvas.new(Reline.get_screen_size)
           Reline::IOGate.set_winch_handler do
             canvas = Canvas.new(Reline.get_screen_size)
@@ -125,10 +133,12 @@ module IRB
             buff[0, 20] = "\e[0mPress Ctrl+C to stop\e[31m\e[1m"
             print "\e[H" + buff
             sleep 0.05
+            break if interrupted
           end
         rescue Interrupt
         ensure
           print "\e[0m\e[?1049l"
+          trap("SIGINT", prev_trap)
         end
       end
     end

data/lib/irb/history.rb

@@ -10,6 +10,7 @@ module IRB
 
     def load_history
       history = self.class::HISTORY
+
       if history_file = IRB.conf[:HISTORY_FILE]
         history_file = File.expand_path(history_file)
       end
@@ -32,7 +33,8 @@ module IRB
     end
 
     def save_history
-      history = self.class::HISTORY
+      history = self.class::HISTORY.to_a
+
       if num = IRB.conf[:SAVE_HISTORY] and (num = num.to_i) != 0
         if history_file = IRB.conf[:HISTORY_FILE]
           history_file = File.expand_path(history_file)