@ai-ecoverse/wasix-ruby 3.4.11-3 → 3.4.11-4

package/lib/ruby/3.4.11/irb/input-method.rb

@@ -1,515 +0,0 @@
-# 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

package/lib/ruby/3.4.11/irb/inspector.rb

@@ -1,131 +0,0 @@
-# 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
-
-    # Proc to call when the input is evaluated and output in irb.
-    def inspect_value(v)
-      @inspect.call(v)
-    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|
-    Color.colorize_code(v.inspect, colorable: Color.colorable? && Color.inspect_colorable?(v))
-  }
-  Inspector.def_inspector([true, :pp, :pretty_inspect], proc{require_relative "color_printer"}){|v|
-    IRB::ColorPrinter.pp(v, +'').chomp
-  }
-  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

package/lib/ruby/3.4.11/irb/irb.gemspec

@@ -1,46 +0,0 @@
-begin
-  require_relative "lib/irb/version"
-rescue LoadError
-  # for Ruby core repository
-  require_relative "version"
-end
-
-Gem::Specification.new do |spec|
-  spec.name          = "irb"
-  spec.version       = IRB::VERSION
-  spec.authors       = ["aycabta", "Keiju ISHITSUKA"]
-  spec.email         = ["aycabta@gmail.com", "keiju@ruby-lang.org"]
-
-  spec.summary       = %q{Interactive Ruby command-line tool for REPL (Read Eval Print Loop).}
-  spec.description   = %q{Interactive Ruby command-line tool for REPL (Read Eval Print Loop).}
-  spec.homepage      = "https://github.com/ruby/irb"
-  spec.licenses      = ["Ruby", "BSD-2-Clause"]
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["documentation_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = "#{spec.homepage}/releases"
-
-  spec.files         = [
-    ".document",
-    "Gemfile",
-    "LICENSE.txt",
-    "README.md",
-    "Rakefile",
-    "bin/console",
-    "bin/setup",
-    "doc/irb/irb-tools.rd.ja",
-    "doc/irb/irb.rd.ja",
-    "exe/irb",
-    "irb.gemspec",
-    "man/irb.1",
-  ] + Dir.glob("lib/**/*")
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.7")
-
-  spec.add_dependency "reline", ">= 0.4.2"
-  spec.add_dependency "rdoc", ">= 4.0.0"
-end