irb 1.7.1 → 1.13.2

data/lib/irb/context.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 #
 #   irb/context.rb - irb context
 #   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
@@ -22,10 +22,11 @@ module IRB
     # +other+::   uses this as InputMethod
     def initialize(irb, workspace = nil, input_method = nil)
       @irb = irb
+      @workspace_stack = []
       if workspace
-        @workspace = workspace
+        @workspace_stack << workspace
       else
-        @workspace = WorkSpace.new
+        @workspace_stack << WorkSpace.new
       end
       @thread = Thread.current
 
@@ -61,7 +62,7 @@ module IRB
       @io = nil
 
       self.inspect_mode = IRB.conf[:INSPECT_MODE]
-      self.use_tracer = IRB.conf[:USE_TRACER] if IRB.conf[:USE_TRACER]
+      self.use_tracer = IRB.conf[:USE_TRACER]
       self.use_loader = IRB.conf[:USE_LOADER] if IRB.conf[:USE_LOADER]
       self.eval_history = IRB.conf[:EVAL_HISTORY] if IRB.conf[:EVAL_HISTORY]
 
@@ -72,33 +73,34 @@ module IRB
 
       self.prompt_mode = IRB.conf[:PROMPT_MODE]
 
-      if IRB.conf[:SINGLE_IRB] or !defined?(IRB::JobManager)
-        @irb_name = IRB.conf[:IRB_NAME]
-      else
-        @irb_name = IRB.conf[:IRB_NAME]+"#"+IRB.JobManager.n_jobs.to_s
+      @irb_name = IRB.conf[:IRB_NAME]
+
+      unless IRB.conf[:SINGLE_IRB] or !defined?(IRB::JobManager)
+        @irb_name = @irb_name + "#" + IRB.JobManager.n_jobs.to_s
       end
-      @irb_path = "(" + @irb_name + ")"
+
+      self.irb_path = "(" + @irb_name + ")"
 
       case input_method
       when nil
         @io = nil
         case use_multiline?
         when nil
-          if STDIN.tty? && IRB.conf[:PROMPT_MODE] != :INF_RUBY && !use_singleline?
+          if term_interactive? && 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?
           when nil
-            if (defined?(ReadlineInputMethod) && STDIN.tty? &&
+            if (defined?(ReadlineInputMethod) && term_interactive? &&
                 IRB.conf[:PROMPT_MODE] != :INF_RUBY)
               @io = ReadlineInputMethod.new
             else
@@ -121,16 +123,14 @@ module IRB
       when '-'
         @io = FileInputMethod.new($stdin)
         @irb_name = '-'
-        @irb_path = '-'
+        self.irb_path = '-'
       when String
         @io = FileInputMethod.new(input_method)
         @irb_name = File.basename(input_method)
-        @irb_path = input_method
+        self.irb_path = input_method
       else
         @io = input_method
       end
-      self.save_history = IRB.conf[:SAVE_HISTORY] if IRB.conf[:SAVE_HISTORY]
-
       @extra_doc_dirs = IRB.conf[:EXTRA_DOC_DIRS]
 
       @echo = IRB.conf[:ECHO]
@@ -148,18 +148,112 @@ module IRB
         @newline_before_multiline_output = true
       end
 
-      @command_aliases = IRB.conf[:COMMAND_ALIASES]
+      @user_aliases = IRB.conf[:COMMAND_ALIASES].dup
+      @command_aliases = @user_aliases.merge(KEYWORD_ALIASES)
+    end
+
+    private def term_interactive?
+      return true if ENV['TEST_IRB_FORCE_INTERACTIVE']
+      STDIN.tty? && ENV['TERM'] != 'dumb'
+    end
+
+    # because all input will eventually be evaluated as Ruby code,
+    # command names that conflict with Ruby keywords need special workaround
+    # we can remove them once we implemented a better command system for IRB
+    KEYWORD_ALIASES = {
+      :break => :irb_break,
+      :catch => :irb_catch,
+      :next => :irb_next,
+    }.freeze
+
+    private_constant :KEYWORD_ALIASES
+
+    def use_tracer=(val)
+      require_relative "ext/tracer" if val
+      IRB.conf[:USE_TRACER] = val
+    end
+
+    def eval_history=(val)
+      self.class.remove_method(__method__)
+      require_relative "ext/eval_history"
+      __send__(__method__, val)
+    end
+
+    def use_loader=(val)
+      self.class.remove_method(__method__)
+      require_relative "ext/use-loader"
+      __send__(__method__, val)
+    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
+
+    private def build_type_completor
+      if RUBY_ENGINE == 'truffleruby'
+        # Avoid SyntaxError. truffleruby does not support endless method definition yet.
+        warn 'TypeCompletor is not supported on TruffleRuby yet'
+        return
+      end
+
+      begin
+        require 'repl_type_completor'
+      rescue LoadError => e
+        warn "TypeCompletor requires `gem repl_type_completor`: #{e.message}"
+        return
+      end
+
+      ReplTypeCompletor.preload_rbs
+      TypeCompletor.new(self)
+    end
+
+    def save_history=(val)
+      IRB.conf[:SAVE_HISTORY] = val
+    end
+
+    def save_history
+      IRB.conf[:SAVE_HISTORY]
+    end
+
+    # A copy of the default <code>IRB.conf[:HISTORY_FILE]</code>
+    def history_file
+      IRB.conf[:HISTORY_FILE]
+    end
+
+    # Set <code>IRB.conf[:HISTORY_FILE]</code> to the given +hist+.
+    def history_file=(hist)
+      IRB.conf[:HISTORY_FILE] = hist
+    end
+
+    # Workspace in the current context.
+    def workspace
+      @workspace_stack.last
+    end
+
+    # Replace the current workspace with the given +workspace+.
+    def replace_workspace(workspace)
+      @workspace_stack.pop
+      @workspace_stack.push(workspace)
     end
 
     # The top-level workspace, see WorkSpace#main
     def main
-      @workspace.main
+      workspace.main
     end
 
     # The toplevel workspace, see #home_workspace
     attr_reader :workspace_home
-    # WorkSpace in the current context.
-    attr_accessor :workspace
     # The current thread in this context.
     attr_reader :thread
     # The current input method.
@@ -180,9 +274,27 @@ module IRB
     # Can be either name from <code>IRB.conf[:IRB_NAME]</code>, or the number of
     # the current job set by JobManager, such as <code>irb#2</code>
     attr_accessor :irb_name
-    # Can be either the #irb_name surrounded by parenthesis, or the
-    # +input_method+ passed to Context.new
-    attr_accessor :irb_path
+
+    # Can be one of the following:
+    # - the #irb_name surrounded by parenthesis
+    # - the +input_method+ passed to Context.new
+    # - the file path of the current IRB context in a binding.irb session
+    attr_reader :irb_path
+
+    # Sets @irb_path to the given +path+ as well as @eval_path
+    # @eval_path is used for evaluating code in the context of IRB session
+    # It's the same as irb_path, but with the IRB name postfix
+    # This makes sure users can distinguish the methods defined in the IRB session
+    # from the methods defined in the current file's context, especially with binding.irb
+    def irb_path=(path)
+      @irb_path = path
+
+      if File.exist?(path)
+        @eval_path = "#{path}(#{IRB.conf[:IRB_NAME]})"
+      else
+        @eval_path = path
+      end
+    end
 
     # Whether multiline editor mode is enabled or not.
     #
@@ -203,18 +315,29 @@ module IRB
     attr_reader :prompt_mode
     # Standard IRB prompt.
     #
-    # See IRB@Customizing+the+IRB+Prompt for more information.
+    # See {Custom Prompts}[rdoc-ref:IRB@Custom+Prompts] for more information.
     attr_accessor :prompt_i
     # IRB prompt for continuated strings.
     #
-    # See IRB@Customizing+the+IRB+Prompt for more information.
+    # See {Custom Prompts}[rdoc-ref:IRB@Custom+Prompts] for more information.
     attr_accessor :prompt_s
     # IRB prompt for continuated statement. (e.g. immediately after an +if+)
     #
-    # See IRB@Customizing+the+IRB+Prompt for more information.
+    # See {Custom Prompts}[rdoc-ref:IRB@Custom+Prompts] for more information.
     attr_accessor :prompt_c
-    # See IRB@Customizing+the+IRB+Prompt for more information.
-    attr_accessor :prompt_n
+
+    # TODO: Remove this when developing v2.0
+    def prompt_n
+      warn "IRB::Context#prompt_n is deprecated and will be removed in the next major release."
+      ""
+    end
+
+    # TODO: Remove this when developing v2.0
+    def prompt_n=(_)
+      warn "IRB::Context#prompt_n= is deprecated and will be removed in the next major release."
+      ""
+    end
+
     # Can be either the default <code>IRB.conf[:AUTO_INDENT]</code>, or the
     # mode set by #prompt_mode=
     #
@@ -322,13 +445,13 @@ module IRB
     # The default value is 16.
     #
     # Can also be set using the +--back-trace-limit+ command line option.
-    #
-    # See IRB@Command+line+options for more command line options.
     attr_accessor :back_trace_limit
 
     # User-defined IRB command aliases
     attr_accessor :command_aliases
 
+    attr_accessor :with_debugger
+
     # Alias for #use_multiline
     alias use_multiline? use_multiline
     # Alias for #use_singleline
@@ -372,9 +495,7 @@ module IRB
     # StdioInputMethod or RelineInputMethod or ReadlineInputMethod, see #io
     # for more information.
     def prompting?
-      verbose? || (STDIN.tty? && @io.kind_of?(StdioInputMethod) ||
-                   @io.kind_of?(RelineInputMethod) ||
-                   (defined?(ReadlineInputMethod) && @io.kind_of?(ReadlineInputMethod)))
+      verbose? || @io.prompting?
     end
 
     # The return value of the last statement evaluated.
@@ -384,19 +505,18 @@ module IRB
     # to #last_value.
     def set_last_value(value)
       @last_value = value
-      @workspace.local_variable_set :_, value
+      workspace.local_variable_set :_, value
     end
 
     # Sets the +mode+ of the prompt in this context.
     #
-    # See IRB@Customizing+the+IRB+Prompt for more information.
+    # See {Custom Prompts}[rdoc-ref:IRB@Custom+Prompts] for more information.
     def prompt_mode=(mode)
       @prompt_mode = mode
       pconf = IRB.conf[:PROMPT][mode]
       @prompt_i = pconf[:PROMPT_I]
       @prompt_s = pconf[:PROMPT_S]
       @prompt_c = pconf[:PROMPT_C]
-      @prompt_n = pconf[:PROMPT_N]
       @return_format = pconf[:RETURN]
       @return_format = "%s\n" if @return_format == nil
       if ai = pconf.include?(:AUTO_INDENT)
@@ -428,8 +548,6 @@ module IRB
     #
     # Can also be set using the +--inspect+ and +--noinspect+ command line
     # options.
-    #
-    # See IRB@Command+line+options for more command line options.
     def inspect_mode=(opt)
 
       if i = Inspector::INSPECTORS[opt]
@@ -473,45 +591,55 @@ module IRB
       @inspect_mode
     end
 
-    def evaluate(line, line_no) # :nodoc:
+    def evaluate(statement, line_no) # :nodoc:
       @line_no = line_no
-      result = nil
 
+      case statement
+      when Statement::EmptyInput
+        return
+      when Statement::Expression
+        result = evaluate_expression(statement.code, line_no)
+        set_last_value(result)
+      when Statement::Command
+        statement.command_class.execute(self, statement.arg)
+        set_last_value(nil)
+      end
+
+      nil
+    end
+
+    def from_binding?
+      @irb.from_binding
+    end
+
+    def evaluate_expression(code, line_no) # :nodoc:
+      result = nil
       if IRB.conf[:MEASURE] && IRB.conf[:MEASURE_CALLBACKS].empty?
         IRB.set_measure_callback
       end
 
       if IRB.conf[:MEASURE] && !IRB.conf[:MEASURE_CALLBACKS].empty?
         last_proc = proc do
-          result = @workspace.evaluate(line, irb_path, line_no)
+          result = workspace.evaluate(code, @eval_path, line_no)
         end
         IRB.conf[:MEASURE_CALLBACKS].inject(last_proc) do |chain, item|
           _name, callback, arg = item
           proc do
-            callback.(self, line, line_no, arg) do
+            callback.(self, code, line_no, arg) do
               chain.call
             end
           end
         end.call
       else
-        result = @workspace.evaluate(line, irb_path, line_no)
+        result = workspace.evaluate(code, @eval_path, line_no)
       end
-
-      set_last_value(result)
+      result
     end
 
     def inspect_last_value # :nodoc:
       @inspect_method.inspect_value(@last_value)
     end
 
-    alias __exit__ exit
-    # Exits the current session, see IRB.irb_exit
-    def exit(ret = 0)
-      IRB.irb_exit(@irb, ret)
-    rescue UncaughtThrowError
-      super
-    end
-
     NOPRINTING_IVARS = ["@last_value"] # :nodoc:
     NO_INSPECTING_IVARS = ["@irb", "@io"] # :nodoc:
     IDNAME_IVARS = ["@prompt_mode"] # :nodoc:
@@ -542,17 +670,5 @@ module IRB
     def local_variables # :nodoc:
       workspace.binding.local_variables
     end
-
-    # Return true if it's aliased from the argument and it's not an identifier.
-    def symbol_alias?(command)
-      return nil if command.match?(/\A\w+\z/)
-      command_aliases.key?(command.to_sym)
-    end
-
-    # Return true if the command supports transforming args
-    def transform_args?(command)
-      command = command_aliases.fetch(command.to_sym, command)
-      ExtendCommandBundle.load_command(command)&.respond_to?(:transform_args)
-    end
   end
 end

data/lib/irb/debug/ui.rb

@@ -0,0 +1,103 @@
+require 'io/console/size'
+require 'debug/console'
+
+module IRB
+  module Debug
+    class UI < DEBUGGER__::UI_Base
+      def initialize(irb)
+        @irb = irb
+      end
+
+      def remote?
+        false
+      end
+
+      def activate session, on_fork: false
+      end
+
+      def deactivate
+      end
+
+      def width
+        if (w = IO.console_size[1]) == 0 # for tests PTY
+          80
+        else
+          w
+        end
+      end
+
+      def quit n
+        yield
+        exit n
+      end
+
+      def ask prompt
+        setup_interrupt do
+          print prompt
+          ($stdin.gets || '').strip
+        end
+      end
+
+      def puts str = nil
+        case str
+        when Array
+          str.each{|line|
+            $stdout.puts line.chomp
+          }
+        when String
+          str.each_line{|line|
+            $stdout.puts line.chomp
+          }
+        when nil
+          $stdout.puts
+        end
+      end
+
+      def readline _
+        setup_interrupt do
+          tc = DEBUGGER__::SESSION.instance_variable_get(:@tc)
+          cmd = @irb.debug_readline(tc.current_frame.binding || TOPLEVEL_BINDING)
+
+          case cmd
+          when nil # when user types C-d
+            "continue"
+          else
+            cmd
+          end
+        end
+      end
+
+      def setup_interrupt
+        DEBUGGER__::SESSION.intercept_trap_sigint false do
+          current_thread = Thread.current # should be session_server thread
+
+          prev_handler = trap(:INT){
+            current_thread.raise Interrupt
+          }
+
+          yield
+        ensure
+          trap(:INT, prev_handler)
+        end
+      end
+
+      def after_fork_parent
+        parent_pid = Process.pid
+
+        at_exit{
+          DEBUGGER__::SESSION.intercept_trap_sigint_end
+          trap(:SIGINT, :IGNORE)
+
+          if Process.pid == parent_pid
+            # only check child process from its parent
+            begin
+              # wait for all child processes to keep terminal
+              Process.waitpid
+            rescue Errno::ESRCH, Errno::ECHILD
+            end
+          end
+        }
+      end
+    end
+  end
+end

data/lib/irb/{cmd/debug.rb → debug.rb}

@@ -1,34 +1,13 @@
-require_relative "nop"
+# frozen_string_literal: true
 
 module IRB
-  # :stopdoc:
-
-  module ExtendCommand
-    class Debug < Nop
-      category "Debugging"
-      description "Start the debugger of debug.gem."
-
-      BINDING_IRB_FRAME_REGEXPS = [
-        '<internal:prelude>',
-        binding.method(:irb).source_location.first,
-      ].map { |file| /\A#{Regexp.escape(file)}:\d+:in `irb'\z/ }
-      IRB_DIR = File.expand_path('..', __dir__)
-
-      def execute(pre_cmds: nil, do_cmds: nil)
-        unless binding_irb?
-          puts "`debug` command is only available when IRB is started with binding.irb"
-          return
-        end
-
-        unless setup_debugger
-          puts <<~MSG
-            You need to install the debug gem before using this command.
-            If you use `bundle exec`, please add `gem "debug"` into your Gemfile.
-          MSG
-          return
-        end
+  module Debug
+    IRB_DIR = File.expand_path('..', __dir__)
 
+    class << self
+      def insert_debug_break(pre_cmds: nil, do_cmds: nil)
         options = { oneshot: true, hook_call: false }
+
         if pre_cmds || do_cmds
           options[:command] = ['irb', pre_cmds, do_cmds]
         end
@@ -41,37 +20,29 @@ module IRB
         # a TracePoint on #debug_break.
         file, lineno = IRB::Irb.instance_method(:debug_break).source_location
         DEBUGGER__::SESSION.add_line_breakpoint(file, lineno + 1, **options)
-        # exit current Irb#run call
-        throw :IRB_EXIT
-      end
-
-      private
-
-      def binding_irb?
-        caller.any? do |frame|
-          BINDING_IRB_FRAME_REGEXPS.any? do |regexp|
-            frame.match?(regexp)
-          end
-        end
-      end
-
-      module SkipPathHelperForIRB
-        def skip_internal_path?(path)
-          # The latter can be removed once https://github.com/ruby/debug/issues/866 is resolved
-          super || path.match?(IRB_DIR) || path.match?('<internal:prelude>')
-        end
       end
 
-      def setup_debugger
+      def setup(irb)
+        # When debug session is not started at all
         unless defined?(DEBUGGER__::SESSION)
           begin
             require "debug/session"
           rescue LoadError # debug.gem is not written in Gemfile
             return false unless load_bundled_debug_gem
           end
-          DEBUGGER__.start(nonstop: true)
+          DEBUGGER__::CONFIG.set_config
+          configure_irb_for_debugger(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)
+          DEBUGGER__::SESSION.reset_ui(IRB::Debug::UI.new(irb))
         end
 
+        # Apply patches to debug gem so it skips IRB frames
         unless DEBUGGER__.respond_to?(:capture_frames_without_irb)
           DEBUGGER__.singleton_class.send(:alias_method, :capture_frames_without_irb, :capture_frames)
 
@@ -86,9 +57,43 @@ module IRB
           DEBUGGER__::ThreadClient.prepend(SkipPathHelperForIRB)
         end
 
+        if !@output_modifier_defined && !DEBUGGER__::CONFIG[:no_hint]
+          irb_output_modifier_proc = Reline.output_modifier_proc
+
+          Reline.output_modifier_proc = proc do |output, complete:|
+            unless output.strip.empty?
+              cmd = output.split(/\s/, 2).first
+
+              if !complete && DEBUGGER__.commands.key?(cmd)
+                output = output.sub(/\n$/, " # debug command\n")
+              end
+            end
+
+            irb_output_modifier_proc.call(output, complete: complete)
+          end
+
+          @output_modifier_defined = true
+        end
+
         true
       end
 
+      private
+
+      def configure_irb_for_debugger(irb)
+        require 'irb/debug/ui'
+        IRB.instance_variable_set(:@debugger_irb, irb)
+        irb.context.with_debugger = true
+        irb.context.irb_name += ":rdbg"
+      end
+
+      module SkipPathHelperForIRB
+        def skip_internal_path?(path)
+          # The latter can be removed once https://github.com/ruby/debug/issues/866 is resolved
+          super || path.match?(IRB_DIR) || path.match?('<internal:prelude>')
+        end
+      end
+
       # This is used when debug.gem is not written in Gemfile. Even if it's not
       # installed by `bundle install`, debug.gem is installed by default because
       # it's a bundled gem. This method tries to activate and load that.
@@ -121,16 +126,5 @@ module IRB
         end
       end
     end
-
-    class DebugCommand < Debug
-      def self.category
-        "Debugging"
-      end
-
-      def self.description
-        command_name = self.name.split("::").last.downcase
-        "Start the debugger of debug.gem and run its `#{command_name}` command."
-      end
-    end
   end
 end