docspring 3.0.0 → 3.1.0

data/vendor/bundle/ruby/3.3.0/gems/irb-1.15.1/lib/irb/input-method.rb

@@ -0,0 +1,515 @@
+# frozen_string_literal: true
+#
+#   irb/input-method.rb - input methods used irb
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+
+require_relative 'completion'
+require_relative "history"
+require 'io/console'
+require 'reline'
+
+module IRB
+  class InputMethod
+    BASIC_WORD_BREAK_CHARACTERS = " \t\n`><=;|&{("
+
+    # The irb prompt associated with this input method
+    attr_accessor :prompt
+
+    # Reads the next line from this input method.
+    #
+    # See IO#gets for more information.
+    def gets
+      fail NotImplementedError
+    end
+    public :gets
+
+    def winsize
+      if instance_variable_defined?(:@stdout) && @stdout.tty?
+        @stdout.winsize
+      else
+        [24, 80]
+      end
+    end
+
+    # Whether this input method is still readable when there is no more data to
+    # read.
+    #
+    # See IO#eof for more information.
+    def readable_after_eof?
+      false
+    end
+
+    def support_history_saving?
+      false
+    end
+
+    def prompting?
+      false
+    end
+
+    # For debug message
+    def inspect
+      'Abstract InputMethod'
+    end
+  end
+
+  class StdioInputMethod < InputMethod
+    # Creates a new input method object
+    def initialize
+      @line_no = 0
+      @line = []
+      @stdin = IO.open(STDIN.to_i, :external_encoding => IRB.conf[:LC_MESSAGES].encoding, :internal_encoding => "-")
+      @stdout = IO.open(STDOUT.to_i, 'w', :external_encoding => IRB.conf[:LC_MESSAGES].encoding, :internal_encoding => "-")
+    end
+
+    # Reads the next line from this input method.
+    #
+    # See IO#gets for more information.
+    def gets
+      # Workaround for debug compatibility test https://github.com/ruby/debug/pull/1100
+      puts if ENV['RUBY_DEBUG_TEST_UI']
+
+      print @prompt
+      line = @stdin.gets
+      @line[@line_no += 1] = line
+    end
+
+    # Whether the end of this input method has been reached, returns +true+ if
+    # there is no more data to read.
+    #
+    # See IO#eof? for more information.
+    def eof?
+      if @stdin.wait_readable(0.00001)
+        c = @stdin.getc
+        result = c.nil? ? true : false
+        @stdin.ungetc(c) unless c.nil?
+        result
+      else # buffer is empty
+        false
+      end
+    end
+
+    # Whether this input method is still readable when there is no more data to
+    # read.
+    #
+    # See IO#eof for more information.
+    def readable_after_eof?
+      true
+    end
+
+    def prompting?
+      STDIN.tty?
+    end
+
+    # Returns the current line number for #io.
+    #
+    # #line counts the number of times #gets is called.
+    #
+    # See IO#lineno for more information.
+    def line(line_no)
+      @line[line_no]
+    end
+
+    # The external encoding for standard input.
+    def encoding
+      @stdin.external_encoding
+    end
+
+    # For debug message
+    def inspect
+      'StdioInputMethod'
+    end
+  end
+
+  # Use a File for IO with irb, see InputMethod
+  class FileInputMethod < InputMethod
+    class << self
+      def open(file, &block)
+        begin
+          io = new(file)
+          block.call(io)
+        ensure
+          io&.close
+        end
+      end
+    end
+
+    # Creates a new input method object
+    def initialize(file)
+      @io = file.is_a?(IO) ? file : File.open(file)
+      @external_encoding = @io.external_encoding
+    end
+
+    # Whether the end of this input method has been reached, returns +true+ if
+    # there is no more data to read.
+    #
+    # See IO#eof? for more information.
+    def eof?
+      @io.closed? || @io.eof?
+    end
+
+    # Reads the next line from this input method.
+    #
+    # See IO#gets for more information.
+    def gets
+      print @prompt
+      @io.gets
+    end
+
+    # The external encoding for standard input.
+    def encoding
+      @external_encoding
+    end
+
+    # For debug message
+    def inspect
+      'FileInputMethod'
+    end
+
+    def close
+      @io.close
+    end
+  end
+
+  class ReadlineInputMethod < StdioInputMethod
+    class << self
+      def initialize_readline
+        require "readline"
+      rescue LoadError
+      else
+        include ::Readline
+      end
+    end
+
+    include HistorySavingAbility
+
+    # Creates a new input method object using Readline
+    def initialize
+      self.class.initialize_readline
+      if Readline.respond_to?(:encoding_system_needs)
+        IRB.__send__(:set_encoding, Readline.encoding_system_needs.name, override: false)
+      end
+
+      super
+
+      @eof = false
+      @completor = RegexpCompletor.new
+
+      if Readline.respond_to?("basic_word_break_characters=")
+        Readline.basic_word_break_characters = BASIC_WORD_BREAK_CHARACTERS
+      end
+      Readline.completion_append_character = nil
+      Readline.completion_proc = ->(target) {
+        bind = IRB.conf[:MAIN_CONTEXT].workspace.binding
+        @completor.completion_candidates('', target, '', bind: bind)
+      }
+    end
+
+    def completion_info
+      'RegexpCompletor'
+    end
+
+    # Reads the next line from this input method.
+    #
+    # See IO#gets for more information.
+    def gets
+      Readline.input = @stdin
+      Readline.output = @stdout
+      if l = readline(@prompt, false)
+        HISTORY.push(l) if !l.empty?
+        @line[@line_no += 1] = l + "\n"
+      else
+        @eof = true
+        l
+      end
+    end
+
+    # Whether the end of this input method has been reached, returns +true+
+    # if there is no more data to read.
+    #
+    # See IO#eof? for more information.
+    def eof?
+      @eof
+    end
+
+    def prompting?
+      true
+    end
+
+    # For debug message
+    def inspect
+      readline_impl = (defined?(Reline) && Readline == Reline) ? 'Reline' : 'ext/readline'
+      str = "ReadlineInputMethod with #{readline_impl} #{Readline::VERSION}"
+      inputrc_path = File.expand_path(ENV['INPUTRC'] || '~/.inputrc')
+      str += " and #{inputrc_path}" if File.exist?(inputrc_path)
+      str
+    end
+  end
+
+  class RelineInputMethod < StdioInputMethod
+    HISTORY = Reline::HISTORY
+    include HistorySavingAbility
+    # Creates a new input method object using Reline
+    def initialize(completor)
+      IRB.__send__(:set_encoding, Reline.encoding_system_needs.name, override: false)
+
+      super()
+
+      @eof = false
+      @completor = completor
+
+      Reline.basic_word_break_characters = BASIC_WORD_BREAK_CHARACTERS
+      Reline.completion_append_character = nil
+      Reline.completer_quote_characters = ''
+      Reline.completion_proc = ->(target, preposing, postposing) {
+        bind = IRB.conf[:MAIN_CONTEXT].workspace.binding
+        @completion_params = [preposing, target, postposing, bind]
+        @completor.completion_candidates(preposing, target, postposing, bind: bind)
+      }
+      Reline.output_modifier_proc = proc do |input, complete:|
+        IRB.CurrentContext.colorize_input(input, complete: complete)
+      end
+      Reline.dig_perfect_match_proc = ->(matched) { display_document(matched) }
+      Reline.autocompletion = IRB.conf[:USE_AUTOCOMPLETE]
+
+      if IRB.conf[:USE_AUTOCOMPLETE]
+        begin
+          require 'rdoc'
+          Reline.add_dialog_proc(:show_doc, show_doc_dialog_proc, Reline::DEFAULT_DIALOG_CONTEXT)
+        rescue LoadError
+        end
+      end
+    end
+
+    def completion_info
+      autocomplete_message = Reline.autocompletion ? 'Autocomplete' : 'Tab Complete'
+      "#{autocomplete_message}, #{@completor.inspect}"
+    end
+
+    def check_termination(&block)
+      @check_termination_proc = block
+    end
+
+    def dynamic_prompt(&block)
+      @prompt_proc = block
+    end
+
+    def auto_indent(&block)
+      @auto_indent_proc = block
+    end
+
+    def retrieve_doc_namespace(matched)
+      preposing, _target, postposing, bind = @completion_params
+      @completor.doc_namespace(preposing, matched, postposing, bind: bind)
+    end
+
+    def rdoc_ri_driver
+      return @rdoc_ri_driver if defined?(@rdoc_ri_driver)
+
+      begin
+        require 'rdoc'
+      rescue LoadError
+        @rdoc_ri_driver = nil
+      else
+        options = {}
+        options[:extra_doc_dirs] = IRB.conf[:EXTRA_DOC_DIRS] unless IRB.conf[:EXTRA_DOC_DIRS].empty?
+        @rdoc_ri_driver = RDoc::RI::Driver.new(options)
+      end
+    end
+
+    def show_doc_dialog_proc
+      input_method = self # self is changed in the lambda below.
+      ->() {
+        dialog.trap_key = nil
+        alt_d = [
+          [27, 100], # Normal Alt+d when convert-meta isn't used.
+          # When option/alt is not configured as a meta key in terminal emulator,
+          # option/alt + d will send a unicode character depend on OS keyboard setting.
+          [195, 164], # "ä" in somewhere (FIXME: environment information is unknown).
+          [226, 136, 130] # "∂" Alt+d on Mac keyboard.
+        ]
+
+        if just_cursor_moving and completion_journey_data.nil?
+          return nil
+        end
+        cursor_pos_to_render, result, pointer, autocomplete_dialog = context.pop(4)
+        return nil if result.nil? or pointer.nil? or pointer < 0
+
+        name = input_method.retrieve_doc_namespace(result[pointer])
+        # Use first one because document dialog does not support multiple namespaces.
+        name = name.first if name.is_a?(Array)
+
+        show_easter_egg = name&.match?(/\ARubyVM/) && !ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
+
+        driver = input_method.rdoc_ri_driver
+
+        if key.match?(dialog.name)
+          if show_easter_egg
+            IRB.__send__(:easter_egg)
+          else
+            # RDoc::RI::Driver#display_names uses pager command internally.
+            # Some pager command like `more` doesn't use alternate screen
+            # so we need to turn on and off alternate screen manually.
+            begin
+              print "\e[?1049h"
+              driver.display_names([name])
+            rescue RDoc::RI::Driver::NotFoundError
+            ensure
+              print "\e[?1049l"
+            end
+          end
+        end
+
+        begin
+          name = driver.expand_name(name)
+        rescue RDoc::RI::Driver::NotFoundError
+          return nil
+        rescue
+          return nil # unknown error
+        end
+        doc = nil
+        used_for_class = false
+        if not name =~ /#|\./
+          found, klasses, includes, extends = driver.classes_and_includes_and_extends_for(name)
+          if not found.empty?
+            doc = driver.class_document(name, found, klasses, includes, extends)
+            used_for_class = true
+          end
+        end
+        unless used_for_class
+          doc = RDoc::Markup::Document.new
+          begin
+            driver.add_method(doc, name)
+          rescue RDoc::RI::Driver::NotFoundError
+            doc = nil
+          rescue
+            return nil # unknown error
+          end
+        end
+        return nil if doc.nil?
+        width = 40
+
+        right_x = cursor_pos_to_render.x + autocomplete_dialog.width
+        if right_x + width > screen_width
+          right_width = screen_width - (right_x + 1)
+          left_x = autocomplete_dialog.column - width
+          left_x = 0 if left_x < 0
+          left_width = width > autocomplete_dialog.column ? autocomplete_dialog.column : width
+          if right_width.positive? and left_width.positive?
+            if right_width >= left_width
+              width = right_width
+              x = right_x
+            else
+              width = left_width
+              x = left_x
+            end
+          elsif right_width.positive? and left_width <= 0
+            width = right_width
+            x = right_x
+          elsif right_width <= 0 and left_width.positive?
+            width = left_width
+            x = left_x
+          else # Both are negative width.
+            return nil
+          end
+        else
+          x = right_x
+        end
+        formatter = RDoc::Markup::ToAnsi.new
+        formatter.width = width
+        dialog.trap_key = alt_d
+        mod_key = RUBY_PLATFORM.match?(/darwin/) ? "Option" : "Alt"
+        if show_easter_egg
+          type = STDOUT.external_encoding == Encoding::UTF_8 ? :unicode : :ascii
+          contents = IRB.send(:easter_egg_logo, type).split("\n")
+          message = "Press #{mod_key}+d to see more"
+          contents[0][0, message.size] = message
+        else
+          message = "Press #{mod_key}+d to read the full document"
+          contents = [message] + doc.accept(formatter).split("\n")
+        end
+        contents = contents.take(preferred_dialog_height)
+
+        y = cursor_pos_to_render.y
+        Reline::DialogRenderInfo.new(pos: Reline::CursorPos.new(x, y), contents: contents, width: width, bg_color: '49')
+      }
+    end
+
+    def display_document(matched)
+      driver = rdoc_ri_driver
+      return unless driver
+
+      if matched =~ /\A(?:::)?RubyVM/ and not ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
+        IRB.__send__(:easter_egg)
+        return
+      end
+
+      namespace = retrieve_doc_namespace(matched)
+      return unless namespace
+
+      if namespace.is_a?(Array)
+        out = RDoc::Markup::Document.new
+        namespace.each do |m|
+          begin
+            driver.add_method(out, m)
+          rescue RDoc::RI::Driver::NotFoundError
+          end
+        end
+        driver.display(out)
+      else
+        begin
+          driver.display_names([namespace])
+        rescue RDoc::RI::Driver::NotFoundError
+        end
+      end
+    end
+
+    # Reads the next line from this input method.
+    #
+    # See IO#gets for more information.
+    def gets
+      Reline.input = @stdin
+      Reline.output = @stdout
+      Reline.prompt_proc = @prompt_proc
+      Reline.auto_indent_proc = @auto_indent_proc if @auto_indent_proc
+      if l = Reline.readmultiline(@prompt, false, &@check_termination_proc)
+        Reline::HISTORY.push(l) if !l.empty?
+        @line[@line_no += 1] = l + "\n"
+      else
+        @eof = true
+        l
+      end
+    end
+
+    # Whether the end of this input method has been reached, returns +true+
+    # if there is no more data to read.
+    #
+    # See IO#eof? for more information.
+    def eof?
+      @eof
+    end
+
+    def prompting?
+      true
+    end
+
+    # For debug message
+    def inspect
+      config = Reline::Config.new
+      str = "RelineInputMethod with Reline #{Reline::VERSION}"
+      inputrc_path = File.expand_path(config.inputrc_path)
+      str += " and #{inputrc_path}" if File.exist?(inputrc_path)
+      str
+    end
+  end
+
+  class ReidlineInputMethod < RelineInputMethod
+    def initialize
+      warn <<~MSG.strip
+        IRB::ReidlineInputMethod is deprecated, please use IRB::RelineInputMethod instead.
+      MSG
+      super
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/irb-1.15.1/lib/irb/inspector.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+#
+#   irb/inspector.rb - inspect methods
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+
+module IRB # :nodoc:
+
+  # Convenience method to create a new Inspector, using the given +inspect+
+  # proc, and optional +init+ proc and passes them to Inspector.new
+  #
+  #     irb(main):001:0> ins = IRB::Inspector(proc{ |v| "omg! #{v}" })
+  #     irb(main):001:0> IRB.CurrentContext.inspect_mode = ins # => omg! #<IRB::Inspector:0x007f46f7ba7d28>
+  #     irb(main):001:0> "what?" #=> omg! what?
+  #
+  def IRB::Inspector(inspect, init = nil)
+    Inspector.new(inspect, init)
+  end
+
+  # An irb inspector
+  #
+  # In order to create your own custom inspector there are two things you
+  # should be aware of:
+  #
+  # Inspector uses #inspect_value, or +inspect_proc+, for output of return values.
+  #
+  # This also allows for an optional #init+, or +init_proc+, which is called
+  # when the inspector is activated.
+  #
+  # Knowing this, you can create a rudimentary inspector as follows:
+  #
+  #     irb(main):001:0> ins = IRB::Inspector.new(proc{ |v| "omg! #{v}" })
+  #     irb(main):001:0> IRB.CurrentContext.inspect_mode = ins # => omg! #<IRB::Inspector:0x007f46f7ba7d28>
+  #     irb(main):001:0> "what?" #=> omg! what?
+  #
+  class Inspector
+    KERNEL_INSPECT = Object.instance_method(:inspect)
+    # Default inspectors available to irb, this includes:
+    #
+    # +:pp+::       Using Kernel#pretty_inspect
+    # +:yaml+::     Using YAML.dump
+    # +:marshal+::  Using Marshal.dump
+    INSPECTORS = {}
+
+    class << self
+      # Determines the inspector to use where +inspector+ is one of the keys passed
+      # during inspector definition.
+      def keys_with_inspector(inspector)
+        INSPECTORS.select{|k, v| v == inspector}.collect{|k, v| k}
+      end
+
+      # Example
+      #
+      #     Inspector.def_inspector(key, init_p=nil){|v| v.inspect}
+      #     Inspector.def_inspector([key1,..], init_p=nil){|v| v.inspect}
+      #     Inspector.def_inspector(key, inspector)
+      #     Inspector.def_inspector([key1,...], inspector)
+      def def_inspector(key, arg=nil, &block)
+        if block_given?
+          inspector = IRB::Inspector(block, arg)
+        else
+          inspector = arg
+        end
+
+        case key
+        when Array
+          for k in key
+            def_inspector(k, inspector)
+          end
+        when Symbol
+          INSPECTORS[key] = inspector
+          INSPECTORS[key.to_s] = inspector
+        when String
+          INSPECTORS[key] = inspector
+          INSPECTORS[key.intern] = inspector
+        else
+          INSPECTORS[key] = inspector
+        end
+      end
+    end
+
+    # Creates a new inspector object, using the given +inspect_proc+ when
+    # output return values in irb.
+    def initialize(inspect_proc, init_proc = nil)
+      @init = init_proc
+      @inspect = inspect_proc
+    end
+
+    # Proc to call when the inspector is activated, good for requiring
+    # dependent libraries.
+    def init
+      @init.call if @init
+    end
+
+    def support_stream_output?
+      second_parameter_type = @inspect.parameters[1]&.first
+      second_parameter_type == :req || second_parameter_type == :opt
+    end
+
+    # Proc to call when the input is evaluated and output in irb.
+    def inspect_value(v, output, colorize: true)
+      support_stream_output? ? @inspect.call(v, output, colorize: colorize) : output << @inspect.call(v, colorize: colorize)
+    rescue => e
+      puts "An error occurred when inspecting the object: #{e.inspect}"
+
+      begin
+        puts "Result of Kernel#inspect: #{KERNEL_INSPECT.bind_call(v)}"
+        ''
+      rescue => e
+        puts "An error occurred when running Kernel#inspect: #{e.inspect}"
+        puts e.backtrace.join("\n")
+        ''
+      end
+    end
+  end
+
+  Inspector.def_inspector([false, :to_s, :raw]){|v| v.to_s}
+  Inspector.def_inspector([:p, :inspect]){|v, colorize: true|
+    Color.colorize_code(v.inspect, colorable: colorize && Color.colorable? && Color.inspect_colorable?(v))
+  }
+  Inspector.def_inspector([true, :pp, :pretty_inspect], proc{require_relative "color_printer"}){|v, output, colorize: true|
+    IRB::ColorPrinter.pp(v, output, colorize: colorize)
+  }
+  Inspector.def_inspector([:yaml, :YAML], proc{require "yaml"}){|v|
+    begin
+      YAML.dump(v)
+    rescue
+      puts "(can't dump yaml. use inspect)"
+      v.inspect
+    end
+  }
+
+  Inspector.def_inspector([:marshal, :Marshal, :MARSHAL, Marshal]){|v|
+    Marshal.dump(v)
+  }
+end

data/vendor/bundle/ruby/3.3.0/gems/irb-1.15.1/lib/irb/lc/error.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+#
+#   irb/lc/error.rb -
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+
+module IRB
+  # :stopdoc:
+
+  class UnrecognizedSwitch < StandardError
+    def initialize(val)
+      super("Unrecognized switch: #{val}")
+    end
+  end
+  class CantReturnToNormalMode < StandardError
+    def initialize
+      super("Can't return to normal mode.")
+    end
+  end
+  class IllegalParameter < StandardError
+    def initialize(val)
+      super("Invalid parameter(#{val}).")
+    end
+  end
+  class IrbAlreadyDead < StandardError
+    def initialize
+      super("Irb is already dead.")
+    end
+  end
+  class IrbSwitchedToCurrentThread < StandardError
+    def initialize
+      super("Switched to current thread.")
+    end
+  end
+  class NoSuchJob < StandardError
+    def initialize(val)
+      super("No such job(#{val}).")
+    end
+  end
+  class CantChangeBinding < StandardError
+    def initialize(val)
+      super("Can't change binding to (#{val}).")
+    end
+  end
+  class UndefinedPromptMode < StandardError
+    def initialize(val)
+      super("Undefined prompt mode(#{val}).")
+    end
+  end
+
+  # :startdoc:
+end