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

package/lib/ruby/3.4.11/irb/debug/ui.rb

@@ -1,101 +0,0 @@
-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
-          Pager.page_content(str, retain_content: true)
-        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.eval_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

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

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-module IRB
-  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
-        if DEBUGGER__::LineBreakpoint.instance_method(:initialize).parameters.include?([:key, :skip_src])
-          options[:skip_src] = true
-        end
-
-        # To make debugger commands like `next` or `continue` work without asking
-        # the user to quit IRB after that, we need to exit IRB first and then hit
-        # a TracePoint on #debug_break.
-        file, lineno = IRB::Irb.instance_method(:debug_break).source_location
-        DEBUGGER__::SESSION.add_line_breakpoint(file, lineno + 1, **options)
-      end
-
-      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__::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)
-
-          def DEBUGGER__.capture_frames(*args)
-            frames = capture_frames_without_irb(*args)
-            frames.reject! do |frame|
-              frame.realpath&.start_with?(IRB_DIR) || frame.path == "<internal:prelude>"
-            end
-            frames
-          end
-
-          DEBUGGER__::ThreadClient.prepend(SkipPathHelperForIRB)
-        end
-
-        if !DEBUGGER__::CONFIG[:no_hint] && irb.context.io.is_a?(RelineInputMethod)
-          Reline.output_modifier_proc = proc do |input, complete:|
-            unless input.strip.empty?
-              cmd = input.split(/\s/, 2).first
-
-              if !complete && DEBUGGER__.commands.key?(cmd)
-                input = input.sub(/\n$/, " # debug command\n")
-              end
-            end
-
-            irb.context.colorize_input(input, complete: complete)
-          end
-        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"
-        irb.context.io.load_history if irb.context.io.class < HistorySavingAbility
-      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.
-      def load_bundled_debug_gem
-        # Discover latest debug.gem under GEM_PATH
-        debug_gem = Gem.paths.path.flat_map { |path| Dir.glob("#{path}/gems/debug-*") }.select do |path|
-          File.basename(path).match?(/\Adebug-\d+\.\d+\.\d+(\w+)?\z/)
-        end.sort_by do |path|
-          Gem::Version.new(File.basename(path).delete_prefix('debug-'))
-        end.last
-        return false unless debug_gem
-
-        # Discover debug/debug.so under extensions for Ruby 3.2+
-        ext_name = "/debug/debug.#{RbConfig::CONFIG['DLEXT']}"
-        ext_path = Gem.paths.path.flat_map do |path|
-          Dir.glob("#{path}/extensions/**/#{File.basename(debug_gem)}#{ext_name}")
-        end.first
-
-        # Attempt to forcibly load the bundled gem
-        if ext_path
-          $LOAD_PATH << ext_path.delete_suffix(ext_name)
-        end
-        $LOAD_PATH << "#{debug_gem}/lib"
-        begin
-          require "debug/session"
-          puts "Loaded #{File.basename(debug_gem)}"
-          true
-        rescue LoadError
-          false
-        end
-      end
-    end
-  end
-end

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

@@ -1,276 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "command"
-require_relative "command/internal_helpers"
-require_relative "command/backtrace"
-require_relative "command/break"
-require_relative "command/catch"
-require_relative "command/cd"
-require_relative "command/chws"
-require_relative "command/context"
-require_relative "command/continue"
-require_relative "command/debug"
-require_relative "command/delete"
-require_relative "command/disable_irb"
-require_relative "command/edit"
-require_relative "command/exit"
-require_relative "command/finish"
-require_relative "command/force_exit"
-require_relative "command/help"
-require_relative "command/history"
-require_relative "command/info"
-require_relative "command/irb_info"
-require_relative "command/load"
-require_relative "command/ls"
-require_relative "command/measure"
-require_relative "command/next"
-require_relative "command/pushws"
-require_relative "command/show_doc"
-require_relative "command/show_source"
-require_relative "command/step"
-require_relative "command/subirb"
-require_relative "command/whereami"
-
-module IRB
-  module Command
-    NO_OVERRIDE = 0
-    OVERRIDE_PRIVATE_ONLY = 0x01
-    OVERRIDE_ALL = 0x02
-
-    class << self
-      # This API is for IRB's internal use only and may change at any time.
-      # Please do NOT use it.
-      def _register_with_aliases(name, command_class, *aliases)
-        @commands[name.to_sym] = [command_class, aliases]
-      end
-
-      def all_commands_info
-        user_aliases = IRB.CurrentContext.command_aliases.each_with_object({}) do |(alias_name, target), result|
-          result[target] ||= []
-          result[target] << alias_name
-        end
-
-        commands.map do |command_name, (command_class, aliases)|
-          aliases = aliases.map { |a| a.first }
-
-          if additional_aliases = user_aliases[command_name]
-            aliases += additional_aliases
-          end
-
-          display_name = aliases.shift || command_name
-          {
-            display_name: display_name,
-            description: command_class.description,
-            category: command_class.category
-          }
-        end
-      end
-
-      def command_override_policies
-        @@command_override_policies ||= commands.flat_map do |cmd_name, (cmd_class, aliases)|
-          [[cmd_name, OVERRIDE_ALL]] + aliases
-        end.to_h
-      end
-
-      def execute_as_command?(name, public_method:, private_method:)
-        case command_override_policies[name]
-        when OVERRIDE_ALL
-          true
-        when OVERRIDE_PRIVATE_ONLY
-          !public_method
-        when NO_OVERRIDE
-          !public_method && !private_method
-        end
-      end
-
-      def command_names
-        command_override_policies.keys.map(&:to_s)
-      end
-
-      # Convert a command name to its implementation class if such command exists
-      def load_command(command)
-        command = command.to_sym
-        commands.each do |command_name, (command_class, aliases)|
-          if command_name == command || aliases.any? { |alias_name, _| alias_name == command }
-            return command_class
-          end
-        end
-        nil
-      end
-    end
-
-    _register_with_aliases(:irb_context, Command::Context,
-      [:context, NO_OVERRIDE]
-    )
-
-    _register_with_aliases(:irb_exit, Command::Exit,
-      [:exit, OVERRIDE_PRIVATE_ONLY],
-      [:quit, OVERRIDE_PRIVATE_ONLY],
-      [:irb_quit, OVERRIDE_PRIVATE_ONLY]
-    )
-
-    _register_with_aliases(:irb_exit!, Command::ForceExit,
-      [:exit!, OVERRIDE_PRIVATE_ONLY]
-    )
-
-    _register_with_aliases(:irb_current_working_workspace, Command::CurrentWorkingWorkspace,
-      [:cwws, NO_OVERRIDE],
-      [:pwws, NO_OVERRIDE],
-      [:irb_print_working_workspace, OVERRIDE_ALL],
-      [:irb_cwws, OVERRIDE_ALL],
-      [:irb_pwws, OVERRIDE_ALL],
-      [:irb_current_working_binding, OVERRIDE_ALL],
-      [:irb_print_working_binding, OVERRIDE_ALL],
-      [:irb_cwb, OVERRIDE_ALL],
-      [:irb_pwb, OVERRIDE_ALL],
-    )
-
-    _register_with_aliases(:irb_change_workspace, Command::ChangeWorkspace,
-      [:chws, NO_OVERRIDE],
-      [:cws, NO_OVERRIDE],
-      [:irb_chws, OVERRIDE_ALL],
-      [:irb_cws, OVERRIDE_ALL],
-      [:irb_change_binding, OVERRIDE_ALL],
-      [:irb_cb, OVERRIDE_ALL],
-      [:cb, NO_OVERRIDE],
-    )
-
-    _register_with_aliases(:irb_workspaces, Command::Workspaces,
-      [:workspaces, NO_OVERRIDE],
-      [:irb_bindings, OVERRIDE_ALL],
-      [:bindings, NO_OVERRIDE],
-    )
-
-    _register_with_aliases(:irb_push_workspace, Command::PushWorkspace,
-      [:pushws, NO_OVERRIDE],
-      [:irb_pushws, OVERRIDE_ALL],
-      [:irb_push_binding, OVERRIDE_ALL],
-      [:irb_pushb, OVERRIDE_ALL],
-      [:pushb, NO_OVERRIDE],
-    )
-
-    _register_with_aliases(:irb_pop_workspace, Command::PopWorkspace,
-      [:popws, NO_OVERRIDE],
-      [:irb_popws, OVERRIDE_ALL],
-      [:irb_pop_binding, OVERRIDE_ALL],
-      [:irb_popb, OVERRIDE_ALL],
-      [:popb, NO_OVERRIDE],
-    )
-
-    _register_with_aliases(:irb_load, Command::Load)
-    _register_with_aliases(:irb_require, Command::Require)
-    _register_with_aliases(:irb_source, Command::Source,
-      [:source, NO_OVERRIDE]
-    )
-
-    _register_with_aliases(:irb, Command::IrbCommand)
-    _register_with_aliases(:irb_jobs, Command::Jobs,
-      [:jobs, NO_OVERRIDE]
-    )
-    _register_with_aliases(:irb_fg, Command::Foreground,
-      [:fg, NO_OVERRIDE]
-    )
-    _register_with_aliases(:irb_kill, Command::Kill,
-      [:kill, OVERRIDE_PRIVATE_ONLY]
-    )
-
-    _register_with_aliases(:irb_debug, Command::Debug,
-      [:debug, NO_OVERRIDE]
-    )
-    _register_with_aliases(:irb_edit, Command::Edit,
-      [:edit, NO_OVERRIDE]
-    )
-
-    _register_with_aliases(:irb_break, Command::Break,
-      [:break, OVERRIDE_ALL]
-    )
-    _register_with_aliases(:irb_catch, Command::Catch,
-      [:catch, OVERRIDE_PRIVATE_ONLY]
-    )
-    _register_with_aliases(:irb_next, Command::Next,
-      [:next, OVERRIDE_ALL]
-    )
-    _register_with_aliases(:irb_delete, Command::Delete,
-      [:delete, NO_OVERRIDE]
-    )
-
-    _register_with_aliases(:irb_step, Command::Step,
-      [:step, NO_OVERRIDE]
-    )
-    _register_with_aliases(:irb_continue, Command::Continue,
-      [:continue, NO_OVERRIDE]
-    )
-    _register_with_aliases(:irb_finish, Command::Finish,
-      [:finish, NO_OVERRIDE]
-    )
-    _register_with_aliases(:irb_backtrace, Command::Backtrace,
-      [:backtrace, NO_OVERRIDE],
-      [:bt, NO_OVERRIDE]
-    )
-
-    _register_with_aliases(:irb_debug_info, Command::Info,
-      [:info, NO_OVERRIDE]
-    )
-
-    _register_with_aliases(:irb_help, Command::Help,
-      [:help, NO_OVERRIDE],
-      [:show_cmds, NO_OVERRIDE]
-    )
-
-    _register_with_aliases(:irb_show_doc, Command::ShowDoc,
-      [:show_doc, NO_OVERRIDE]
-    )
-
-    _register_with_aliases(:irb_info, Command::IrbInfo)
-
-    _register_with_aliases(:irb_ls, Command::Ls,
-      [:ls, NO_OVERRIDE]
-    )
-
-    _register_with_aliases(:irb_measure, Command::Measure,
-      [:measure, NO_OVERRIDE]
-    )
-
-    _register_with_aliases(:irb_show_source, Command::ShowSource,
-      [:show_source, NO_OVERRIDE]
-    )
-
-    _register_with_aliases(:irb_whereami, Command::Whereami,
-      [:whereami, NO_OVERRIDE]
-    )
-
-    _register_with_aliases(:irb_history, Command::History,
-      [:history, NO_OVERRIDE],
-      [:hist, NO_OVERRIDE]
-    )
-
-    _register_with_aliases(:irb_disable_irb, Command::DisableIrb,
-      [:disable_irb, NO_OVERRIDE]
-    )
-
-    register(:cd, Command::CD)
-  end
-
-  ExtendCommand = Command
-
-  # For backward compatibility, we need to keep this module:
-  # - As a container of helper methods
-  # - As a place to register commands with the deprecated def_extend_command method
-  module ExtendCommandBundle
-    # For backward compatibility
-    NO_OVERRIDE = Command::NO_OVERRIDE
-    OVERRIDE_PRIVATE_ONLY = Command::OVERRIDE_PRIVATE_ONLY
-    OVERRIDE_ALL = Command::OVERRIDE_ALL
-
-    # Deprecated. Doesn't have any effect.
-    @EXTEND_COMMANDS = []
-
-    class << self
-      # Drepcated. Use Command.regiser instead.
-      def def_extend_command(cmd_name, cmd_class, _, *aliases)
-        Command._register_with_aliases(cmd_name, cmd_class, *aliases)
-        Command.class_variable_set(:@@command_override_policies, nil)
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/irb/easter-egg.rb

@@ -1,152 +0,0 @@
-require "reline"
-
-module IRB
-  class << self
-    class Vec
-      def initialize(x, y, z)
-        @x, @y, @z = x, y, z
-      end
-
-      attr_reader :x, :y, :z
-
-      def sub(other)
-        Vec.new(@x - other.x, @y - other.y, @z - other.z)
-      end
-
-      def dot(other)
-        @x*other.x + @y*other.y + @z*other.z
-      end
-
-      def cross(other)
-        ox, oy, oz = other.x, other.y, other.z
-        Vec.new(@y*oz-@z*oy, @z*ox-@x*oz, @x*oy-@y*ox)
-      end
-
-      def normalize
-        r = Math.sqrt(self.dot(self))
-        Vec.new(@x / r, @y / r, @z / r)
-      end
-    end
-
-    class Canvas
-      def initialize((h, w))
-        @data = (0..h-2).map { [0] * w }
-        @scale = [w / 2.0, h-2].min
-        @center = Complex(w / 2, h-2)
-      end
-
-      def line((x1, y1), (x2, y2))
-        p1 = Complex(x1, y1) / 2 * @scale + @center
-        p2 = Complex(x2, y2) / 2 * @scale + @center
-        line0(p1, p2)
-      end
-
-      private def line0(p1, p2)
-        mid = (p1 + p2) / 2
-        if (p1 - p2).abs < 1
-          x, y = mid.rect
-          @data[y / 2][x] |= (y % 2 > 1 ? 2 : 1)
-        else
-          line0(p1, mid)
-          line0(p2, mid)
-        end
-      end
-
-      def draw
-        @data.each {|row| row.fill(0) }
-        yield
-        @data.map {|row| row.map {|n| " ',;"[n] }.join }.join("\n")
-      end
-    end
-
-    class RubyModel
-      def initialize
-        @faces = init_ruby_model
-      end
-
-      def init_ruby_model
-        cap_vertices    = (0..5).map {|i| Vec.new(*Complex.polar(1,  i        * Math::PI / 3).rect, 1) }
-        middle_vertices = (0..5).map {|i| Vec.new(*Complex.polar(2, (i + 0.5) * Math::PI / 3).rect, 0) }
-        bottom_vertex   = Vec.new(0, 0, -2)
-
-        faces = [cap_vertices]
-        6.times do |j|
-          i = j-1
-          faces << [cap_vertices[i], middle_vertices[i], cap_vertices[j]]
-          faces << [cap_vertices[j], middle_vertices[i], middle_vertices[j]]
-          faces << [middle_vertices[i], bottom_vertex, middle_vertices[j]]
-        end
-
-        faces
-      end
-
-      def render_frame(i)
-        angle = i / 10.0
-        dir = Vec.new(*Complex.polar(1, angle).rect, Math.sin(angle)).normalize
-        dir2 = Vec.new(*Complex.polar(1, angle - Math::PI/2).rect, 0)
-        up = dir.cross(dir2)
-        nm = dir.cross(up)
-        @faces.each do |vertices|
-          v0, v1, v2, = vertices
-          if v1.sub(v0).cross(v2.sub(v0)).dot(dir) > 0
-            points = vertices.map {|p| [nm.dot(p), up.dot(p)] }
-            (points + [points[0]]).each_cons(2) do |p1, p2|
-              yield p1, p2
-            end
-          end
-        end
-      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)
-      print "\e[?1049h"
-      type ||= [:logo, :dancing].sample
-      case type
-      when :logo
-        Pager.page do |io|
-          logo_type = STDOUT.external_encoding == Encoding::UTF_8 ? :unicode_large : :ascii_large
-          io.write easter_egg_logo(logo_type)
-          STDIN.raw { STDIN.getc } if io == STDOUT
-        end
-      when :dancing
-        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)
-          end
-          ruby_model = RubyModel.new
-          print "\e[?25l" # hide cursor
-          0.step do |i| # TODO (0..).each needs Ruby 2.6 or later
-            buff = canvas.draw do
-              ruby_model.render_frame(i) do |p1, p2|
-                canvas.line(p1, p2)
-              end
-            end
-            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[?25h" # show cursor
-          trap("SIGINT", prev_trap)
-        end
-      end
-    ensure
-      print "\e[0m\e[?1049l"
-    end
-  end
-end
-
-IRB.__send__(:easter_egg, ARGV[0]&.to_sym) if $0 == __FILE__

package/lib/ruby/3.4.11/irb/ext/change-ws.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-#
-#   irb/ext/cb.rb -
-#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-
-module IRB # :nodoc:
-  class Context
-
-    # Inherited from +TOPLEVEL_BINDING+.
-    def home_workspace
-      if defined? @home_workspace
-        @home_workspace
-      else
-        @home_workspace = workspace
-      end
-    end
-
-    # Changes the current workspace to given object or binding.
-    #
-    # If the optional argument is omitted, the workspace will be
-    # #home_workspace which is inherited from +TOPLEVEL_BINDING+ or the main
-    # object, <code>IRB.conf[:MAIN_CONTEXT]</code> when irb was initialized.
-    #
-    # See IRB::WorkSpace.new for more information.
-    def change_workspace(*_main)
-      if _main.empty?
-        replace_workspace(home_workspace)
-        return main
-      end
-
-      workspace = WorkSpace.new(_main[0])
-      replace_workspace(workspace)
-      workspace.load_helper_methods_to_main
-    end
-  end
-end