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

package/lib/ruby/3.4.11/irb/ext/eval_history.rb

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-#
-#   history.rb -
-#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-
-module IRB # :nodoc:
-
-  class Context
-
-    NOPRINTING_IVARS.push "@eval_history_values"
-
-    # See #set_last_value
-    alias _set_last_value set_last_value
-
-    def set_last_value(value)
-      _set_last_value(value)
-
-      if defined?(@eval_history) && @eval_history
-        @eval_history_values.push @line_no, @last_value
-        workspace.evaluate "__ = IRB.CurrentContext.instance_eval{@eval_history_values}"
-      end
-
-      @last_value
-    end
-
-    remove_method :eval_history= if method_defined?(:eval_history=)
-    # The command result history limit. This method is not available until
-    # #eval_history= was called with non-nil value (directly or via
-    # setting <code>IRB.conf[:EVAL_HISTORY]</code> in <code>.irbrc</code>).
-    attr_reader :eval_history
-    # Sets command result history limit. Default value is set from
-    # <code>IRB.conf[:EVAL_HISTORY]</code>.
-    #
-    # +no+ is an Integer or +nil+.
-    #
-    # Returns +no+ of history items if greater than 0.
-    #
-    # If +no+ is 0, the number of history items is unlimited.
-    #
-    # If +no+ is +nil+, execution result history isn't used (default).
-    #
-    # EvalHistory values are available via <code>__</code> variable, see
-    # IRB::EvalHistory.
-    def eval_history=(no)
-      if no
-        if defined?(@eval_history) && @eval_history
-          @eval_history_values.size(no)
-        else
-          @eval_history_values = EvalHistory.new(no)
-          IRB.conf[:__TMP__EHV__] = @eval_history_values
-          workspace.evaluate("__ = IRB.conf[:__TMP__EHV__]")
-          IRB.conf.delete(:__TMP_EHV__)
-        end
-      else
-        @eval_history_values = nil
-      end
-      @eval_history = no
-    end
-  end
-
-  # Represents history of results of previously evaluated commands.
-  #
-  # Available via <code>__</code> variable, only if <code>IRB.conf[:EVAL_HISTORY]</code>
-  # or <code>IRB::CurrentContext().eval_history</code> is non-nil integer value
-  # (by default it is +nil+).
-  #
-  # Example (in `irb`):
-  #
-  #    # Initialize history
-  #    IRB::CurrentContext().eval_history = 10
-  #    # => 10
-  #
-  #    # Perform some commands...
-  #    1 + 2
-  #    # => 3
-  #    puts 'x'
-  #    # x
-  #    # => nil
-  #    raise RuntimeError
-  #    # ...error raised
-  #
-  #    # Inspect history (format is "<item number> <evaluated value>":
-  #    __
-  #    # => 1 10
-  #    # 2 3
-  #    # 3 nil
-  #
-  #    __[1]
-  #    # => 10
-  #
-  class EvalHistory
-
-    def initialize(size = 16)  # :nodoc:
-      @size = size
-      @contents = []
-    end
-
-    def size(size) # :nodoc:
-      if size != 0 && size < @size
-        @contents = @contents[@size - size .. @size]
-      end
-      @size = size
-    end
-
-    # Get one item of the content (both positive and negative indexes work).
-    def [](idx)
-      begin
-        if idx >= 0
-          @contents.find{|no, val| no == idx}[1]
-        else
-          @contents[idx][1]
-        end
-      rescue NameError
-        nil
-      end
-    end
-
-    def push(no, val)  # :nodoc:
-      @contents.push [no, val]
-      @contents.shift if @size != 0 && @contents.size > @size
-    end
-
-    alias real_inspect inspect
-
-    def inspect  # :nodoc:
-      if @contents.empty?
-        return real_inspect
-      end
-
-      unless (last = @contents.pop)[1].equal?(self)
-        @contents.push last
-        last = nil
-      end
-      str = @contents.collect{|no, val|
-        if val.equal?(self)
-          "#{no} ...self-history..."
-        else
-          "#{no} #{val.inspect}"
-        end
-      }.join("\n")
-      if str == ""
-        str = "Empty."
-      end
-      @contents.push last if last
-      str
-    end
-  end
-end

package/lib/ruby/3.4.11/irb/ext/loader.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-#
-#   loader.rb -
-#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-
-module IRB # :nodoc:
-  # Raised in the event of an exception in a file loaded from an Irb session
-  class LoadAbort < Exception;end
-
-  # Provides a few commands for loading files within an irb session.
-  #
-  # See ExtendCommandBundle for more information.
-  module IrbLoader
-
-    alias ruby_load load
-    alias ruby_require require
-
-    # Loads the given file similarly to Kernel#load
-    def irb_load(fn, priv = nil)
-      path = search_file_from_ruby_path(fn)
-      raise LoadError, "No such file to load -- #{fn}" unless path
-
-      load_file(path, priv)
-    end
-
-    def search_file_from_ruby_path(fn) # :nodoc:
-      if File.absolute_path?(fn)
-        return fn if File.exist?(fn)
-        return nil
-      end
-
-      for path in $:
-        if File.exist?(f = File.join(path, fn))
-          return f
-        end
-      end
-      return nil
-    end
-
-    # Loads a given file in the current session and displays the source lines
-    #
-    # See Irb#suspend_input_method for more information.
-    def source_file(path)
-      irb = irb_context.irb
-      irb.suspend_name(path, File.basename(path)) do
-        FileInputMethod.open(path) do |io|
-          irb.suspend_input_method(io) do
-            |back_io|
-            irb.signal_status(:IN_LOAD) do
-              if back_io.kind_of?(FileInputMethod)
-                irb.eval_input
-              else
-                begin
-                  irb.eval_input
-                rescue LoadAbort
-                  print "load abort!!\n"
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-
-    # Loads the given file in the current session's context and evaluates it.
-    #
-    # See Irb#suspend_input_method for more information.
-    def load_file(path, priv = nil)
-      irb = irb_context.irb
-      irb.suspend_name(path, File.basename(path)) do
-
-        if priv
-          ws = WorkSpace.new(Module.new)
-        else
-          ws = WorkSpace.new
-        end
-        irb.suspend_workspace(ws) do
-          FileInputMethod.open(path) do |io|
-            irb.suspend_input_method(io) do
-              |back_io|
-              irb.signal_status(:IN_LOAD) do
-                if back_io.kind_of?(FileInputMethod)
-                  irb.eval_input
-                else
-                  begin
-                    irb.eval_input
-                  rescue LoadAbort
-                    print "load abort!!\n"
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-
-    def old # :nodoc:
-      back_io = @io
-      back_path = irb_path
-      back_name = @irb_name
-      back_scanner = @irb.scanner
-      begin
-        @io = FileInputMethod.new(path)
-        @irb_name = File.basename(path)
-        self.irb_path = path
-        @irb.signal_status(:IN_LOAD) do
-          if back_io.kind_of?(FileInputMethod)
-            @irb.eval_input
-          else
-            begin
-              @irb.eval_input
-            rescue LoadAbort
-              print "load abort!!\n"
-            end
-          end
-        end
-      ensure
-        @io = back_io
-        @irb_name = back_name
-        self.irb_path = back_path
-        @irb.scanner = back_scanner
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/irb/ext/multi-irb.rb

@@ -1,258 +0,0 @@
-# frozen_string_literal: true
-#
-#   irb/multi-irb.rb - multiple irb module
-#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-
-module IRB
-  class JobManager # :nodoc:
-
-    # Creates a new JobManager object
-    def initialize
-      @jobs = []
-      @current_job = nil
-    end
-
-    # The active irb session
-    attr_accessor :current_job
-
-    # The total number of irb sessions, used to set +irb_name+ of the current
-    # Context.
-    def n_jobs
-      @jobs.size
-    end
-
-    # Returns the thread for the given +key+ object, see #search for more
-    # information.
-    def thread(key)
-      th, = search(key)
-      th
-    end
-
-    # Returns the irb session for the given +key+ object, see #search for more
-    # information.
-    def irb(key)
-      _, irb = search(key)
-      irb
-    end
-
-    # Returns the top level thread.
-    def main_thread
-      @jobs[0][0]
-    end
-
-    # Returns the top level irb session.
-    def main_irb
-      @jobs[0][1]
-    end
-
-    # Add the given +irb+ session to the jobs Array.
-    def insert(irb)
-      @jobs.push [Thread.current, irb]
-    end
-
-    # Changes the current active irb session to the given +key+ in the jobs
-    # Array.
-    #
-    # Raises an IrbAlreadyDead exception if the given +key+ is no longer alive.
-    #
-    # If the given irb session is already active, an IrbSwitchedToCurrentThread
-    # exception is raised.
-    def switch(key)
-      th, irb = search(key)
-      fail IrbAlreadyDead unless th.alive?
-      fail IrbSwitchedToCurrentThread if th == Thread.current
-      @current_job = irb
-      th.run
-      Thread.stop
-      @current_job = irb(Thread.current)
-    end
-
-    # Terminates the irb sessions specified by the given +keys+.
-    #
-    # Raises an IrbAlreadyDead exception if one of the given +keys+ is already
-    # terminated.
-    #
-    # See Thread#exit for more information.
-    def kill(*keys)
-      for key in keys
-        th, _ = search(key)
-        fail IrbAlreadyDead unless th.alive?
-        th.exit
-      end
-    end
-
-    # Returns the associated job for the given +key+.
-    #
-    # If given an Integer, it will return the +key+ index for the jobs Array.
-    #
-    # When an instance of Irb is given, it will return the irb session
-    # associated with +key+.
-    #
-    # If given an instance of Thread, it will return the associated thread
-    # +key+ using Object#=== on the jobs Array.
-    #
-    # Otherwise returns the irb session with the same top-level binding as the
-    # given +key+.
-    #
-    # Raises a NoSuchJob exception if no job can be found with the given +key+.
-    def search(key)
-      job = case key
-            when Integer
-              @jobs[key]
-            when Irb
-              @jobs.find{|k, v| v.equal?(key)}
-            when Thread
-              @jobs.assoc(key)
-            else
-              @jobs.find{|k, v| v.context.main.equal?(key)}
-            end
-      fail NoSuchJob, key if job.nil?
-      job
-    end
-
-    # Deletes the job at the given +key+.
-    def delete(key)
-      case key
-      when Integer
-        fail NoSuchJob, key unless @jobs[key]
-        @jobs[key] = nil
-      else
-        catch(:EXISTS) do
-          @jobs.each_index do
-            |i|
-            if @jobs[i] and (@jobs[i][0] == key ||
-                @jobs[i][1] == key ||
-                @jobs[i][1].context.main.equal?(key))
-              @jobs[i] = nil
-              throw :EXISTS
-            end
-          end
-          fail NoSuchJob, key
-        end
-      end
-      until assoc = @jobs.pop; end unless @jobs.empty?
-      @jobs.push assoc
-    end
-
-    # Outputs a list of jobs, see the irb command +irb_jobs+, or +jobs+.
-    def inspect
-      ary = []
-      @jobs.each_index do
-        |i|
-        th, irb = @jobs[i]
-        next if th.nil?
-
-        if th.alive?
-          if th.stop?
-            t_status = "stop"
-          else
-            t_status = "running"
-          end
-        else
-          t_status = "exited"
-        end
-        ary.push format("#%d->%s on %s (%s: %s)",
-          i,
-          irb.context.irb_name,
-          irb.context.main,
-          th,
-          t_status)
-      end
-      ary.join("\n")
-    end
-  end
-
-  @JobManager = JobManager.new
-
-  # The current JobManager in the session
-  def IRB.JobManager # :nodoc:
-    @JobManager
-  end
-
-  # The current Context in this session
-  def IRB.CurrentContext # :nodoc:
-    IRB.JobManager.irb(Thread.current).context
-  end
-
-  # Creates a new IRB session, see Irb.new.
-  #
-  # The optional +file+ argument is given to Context.new, along with the
-  # workspace created with the remaining arguments, see WorkSpace.new
-  def IRB.irb(file = nil, *main) # :nodoc:
-    workspace = WorkSpace.new(*main)
-    parent_thread = Thread.current
-    Thread.start do
-      begin
-        irb = Irb.new(workspace, file)
-      rescue
-        print "Subirb can't start with context(self): ", workspace.main.inspect, "\n"
-        print "return to main irb\n"
-        Thread.pass
-        Thread.main.wakeup
-        Thread.exit
-      end
-      @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
-      @JobManager.insert(irb)
-      @JobManager.current_job = irb
-      begin
-        system_exit = false
-        catch(:IRB_EXIT) do
-          irb.eval_input
-        end
-      rescue SystemExit
-        system_exit = true
-        raise
-        #fail
-      ensure
-        unless system_exit
-          @JobManager.delete(irb)
-          if @JobManager.current_job == irb
-            if parent_thread.alive?
-              @JobManager.current_job = @JobManager.irb(parent_thread)
-              parent_thread.run
-            else
-              @JobManager.current_job = @JobManager.main_irb
-              @JobManager.main_thread.run
-            end
-          end
-        end
-      end
-    end
-    Thread.stop
-    @JobManager.current_job = @JobManager.irb(Thread.current)
-  end
-
-  @CONF[:SINGLE_IRB_MODE] = false
-  @JobManager.insert(@CONF[:MAIN_CONTEXT].irb)
-  @JobManager.current_job = @CONF[:MAIN_CONTEXT].irb
-
-  class Irb
-    def signal_handle
-      unless @context.ignore_sigint?
-        print "\nabort!!\n" if @context.verbose?
-        exit
-      end
-
-      case @signal_status
-      when :IN_INPUT
-        print "^C\n"
-        IRB.JobManager.thread(self).raise RubyLex::TerminateLineInput
-      when :IN_EVAL
-        IRB.irb_abort(self)
-      when :IN_LOAD
-        IRB.irb_abort(self, LoadAbort)
-      when :IN_IRB
-        # ignore
-      else
-        # ignore other cases as well
-      end
-    end
-  end
-
-  trap("SIGINT") do
-    @JobManager.current_job.signal_handle
-    Thread.stop
-  end
-
-end

package/lib/ruby/3.4.11/irb/ext/tracer.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-#
-#   irb/lib/tracer.rb -
-#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-# Loading the gem "tracer" will cause it to extend IRB commands with:
-# https://github.com/ruby/tracer/blob/v0.2.2/lib/tracer/irb.rb
-begin
-  require "tracer"
-rescue LoadError
-  $stderr.puts "Tracer extension of IRB is enabled but tracer gem wasn't found."
-  return # This is about to disable loading below
-end
-
-module IRB
-  class CallTracer < ::CallTracer
-    IRB_DIR = File.expand_path('../..', __dir__)
-
-    def skip?(tp)
-      super || tp.path.match?(IRB_DIR) || tp.path.match?('<internal:prelude>')
-    end
-  end
-  class WorkSpace
-    alias __evaluate__ evaluate
-    # Evaluate the context of this workspace and use the Tracer library to
-    # output the exact lines of code are being executed in chronological order.
-    #
-    # See https://github.com/ruby/tracer for more information.
-    def evaluate(statements, file = __FILE__, line = __LINE__)
-      if IRB.conf[:USE_TRACER] == true
-        CallTracer.new(colorize: Color.colorable?).start do
-          __evaluate__(statements, file, line)
-        end
-      else
-        __evaluate__(statements, file, line)
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/irb/ext/use-loader.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-#
-#   use-loader.rb -
-#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-
-require_relative "../command/load"
-require_relative "loader"
-
-class Object
-  alias __original__load__IRB_use_loader__ load
-  alias __original__require__IRB_use_loader__ require
-end
-
-module IRB
-  module ExtendCommandBundle
-    remove_method :irb_load if method_defined?(:irb_load)
-    # Loads the given file similarly to Kernel#load, see IrbLoader#irb_load
-    def irb_load(*opts, &b)
-      Command::Load.execute(irb_context, *opts, &b)
-    end
-    remove_method :irb_require if method_defined?(:irb_require)
-    # Loads the given file similarly to Kernel#require
-    def irb_require(*opts, &b)
-      Command::Require.execute(irb_context, *opts, &b)
-    end
-  end
-
-  class Context
-
-    IRB.conf[:USE_LOADER] = false
-
-    # Returns whether +irb+'s own file reader method is used by
-    # +load+/+require+ or not.
-    #
-    # This mode is globally affected (irb-wide).
-    def use_loader
-      IRB.conf[:USE_LOADER]
-    end
-
-    alias use_loader? use_loader
-
-    remove_method :use_loader= if method_defined?(:use_loader=)
-    # Sets <code>IRB.conf[:USE_LOADER]</code>
-    #
-    # See #use_loader for more information.
-    def use_loader=(opt)
-
-      if IRB.conf[:USE_LOADER] != opt
-        IRB.conf[:USE_LOADER] = opt
-        if opt
-          (class<<workspace.main;self;end).instance_eval {
-            alias_method :load, :irb_load
-            alias_method :require, :irb_require
-          }
-        else
-          (class<<workspace.main;self;end).instance_eval {
-            alias_method :load, :__original__load__IRB_use_loader__
-            alias_method :require, :__original__require__IRB_use_loader__
-          }
-        end
-      end
-      print "Switch to load/require#{unless use_loader; ' non';end} trace mode.\n" if verbose?
-      opt
-    end
-  end
-end

package/lib/ruby/3.4.11/irb/ext/workspaces.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-#
-#   push-ws.rb -
-#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-
-module IRB # :nodoc:
-  class Context
-    # Creates a new workspace with the given object or binding, and appends it
-    # onto the current #workspaces stack.
-    #
-    # See IRB::Context#change_workspace and IRB::WorkSpace.new for more
-    # information.
-    def push_workspace(*_main)
-      if _main.empty?
-        if @workspace_stack.size > 1
-          # swap the top two workspaces
-          previous_workspace, current_workspace = @workspace_stack.pop(2)
-          @workspace_stack.push current_workspace, previous_workspace
-        end
-      else
-        new_workspace = WorkSpace.new(workspace.binding, _main[0])
-        @workspace_stack.push new_workspace
-        new_workspace.load_helper_methods_to_main
-      end
-    end
-
-    # Removes the last element from the current #workspaces stack and returns
-    # it, or +nil+ if the current workspace stack is empty.
-    #
-    # Also, see #push_workspace.
-    def pop_workspace
-      @workspace_stack.pop if @workspace_stack.size > 1
-    end
-  end
-end