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

package/lib/ruby/3.4.11/irb/cmd/nop.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-# This file is just a placeholder for backward-compatibility.
-# Please require 'irb' and inherit your command from `IRB::Command::Base` instead.

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

@@ -1,262 +0,0 @@
-# frozen_string_literal: true
-require 'reline'
-require 'ripper'
-require_relative 'ruby-lex'
-
-module IRB # :nodoc:
-  module Color
-    CLEAR     = 0
-    BOLD      = 1
-    UNDERLINE = 4
-    REVERSE   = 7
-    BLACK     = 30
-    RED       = 31
-    GREEN     = 32
-    YELLOW    = 33
-    BLUE      = 34
-    MAGENTA   = 35
-    CYAN      = 36
-    WHITE     = 37
-
-    TOKEN_KEYWORDS = {
-      on_kw: ['nil', 'self', 'true', 'false', '__FILE__', '__LINE__', '__ENCODING__'],
-      on_const: ['ENV'],
-    }
-    private_constant :TOKEN_KEYWORDS
-
-    # A constant of all-bit 1 to match any Ripper's state in #dispatch_seq
-    ALL = -1
-    private_constant :ALL
-
-    begin
-      # Following pry's colors where possible, but sometimes having a compromise like making
-      # backtick and regexp as red (string's color, because they're sharing tokens).
-      TOKEN_SEQ_EXPRS = {
-        on_CHAR:            [[BLUE, BOLD],            ALL],
-        on_backtick:        [[RED, BOLD],             ALL],
-        on_comment:         [[BLUE, BOLD],            ALL],
-        on_const:           [[BLUE, BOLD, UNDERLINE], ALL],
-        on_embexpr_beg:     [[RED],                   ALL],
-        on_embexpr_end:     [[RED],                   ALL],
-        on_embvar:          [[RED],                   ALL],
-        on_float:           [[MAGENTA, BOLD],         ALL],
-        on_gvar:            [[GREEN, BOLD],           ALL],
-        on_heredoc_beg:     [[RED],                   ALL],
-        on_heredoc_end:     [[RED],                   ALL],
-        on_ident:           [[BLUE, BOLD],            Ripper::EXPR_ENDFN],
-        on_imaginary:       [[BLUE, BOLD],            ALL],
-        on_int:             [[BLUE, BOLD],            ALL],
-        on_kw:              [[GREEN],                 ALL],
-        on_label:           [[MAGENTA],               ALL],
-        on_label_end:       [[RED, BOLD],             ALL],
-        on_qsymbols_beg:    [[RED, BOLD],             ALL],
-        on_qwords_beg:      [[RED, BOLD],             ALL],
-        on_rational:        [[BLUE, BOLD],            ALL],
-        on_regexp_beg:      [[RED, BOLD],             ALL],
-        on_regexp_end:      [[RED, BOLD],             ALL],
-        on_symbeg:          [[YELLOW],                ALL],
-        on_symbols_beg:     [[RED, BOLD],             ALL],
-        on_tstring_beg:     [[RED, BOLD],             ALL],
-        on_tstring_content: [[RED],                   ALL],
-        on_tstring_end:     [[RED, BOLD],             ALL],
-        on_words_beg:       [[RED, BOLD],             ALL],
-        on_parse_error:     [[RED, REVERSE],          ALL],
-        compile_error:      [[RED, REVERSE],          ALL],
-        on_assign_error:    [[RED, REVERSE],          ALL],
-        on_alias_error:     [[RED, REVERSE],          ALL],
-        on_class_name_error:[[RED, REVERSE],          ALL],
-        on_param_error:     [[RED, REVERSE],          ALL],
-        on___end__:         [[GREEN],                 ALL],
-      }
-    rescue NameError
-      # Give up highlighting Ripper-incompatible older Ruby
-      TOKEN_SEQ_EXPRS = {}
-    end
-    private_constant :TOKEN_SEQ_EXPRS
-
-    ERROR_TOKENS = TOKEN_SEQ_EXPRS.keys.select { |k| k.to_s.end_with?('error') }
-    private_constant :ERROR_TOKENS
-
-    class << self
-      def colorable?
-        supported = $stdout.tty? && (/mswin|mingw/.match?(RUBY_PLATFORM) || (ENV.key?('TERM') && ENV['TERM'] != 'dumb'))
-
-        # because ruby/debug also uses irb's color module selectively,
-        # irb won't be activated in that case.
-        if IRB.respond_to?(:conf)
-          supported && !!IRB.conf.fetch(:USE_COLORIZE, true)
-        else
-          supported
-        end
-      end
-
-      def inspect_colorable?(obj, seen: {}.compare_by_identity)
-        case obj
-        when String, Symbol, Regexp, Integer, Float, FalseClass, TrueClass, NilClass
-          true
-        when Hash
-          without_circular_ref(obj, seen: seen) do
-            obj.all? { |k, v| inspect_colorable?(k, seen: seen) && inspect_colorable?(v, seen: seen) }
-          end
-        when Array
-          without_circular_ref(obj, seen: seen) do
-            obj.all? { |o| inspect_colorable?(o, seen: seen) }
-          end
-        when Range
-          inspect_colorable?(obj.begin, seen: seen) && inspect_colorable?(obj.end, seen: seen)
-        when Module
-          !obj.name.nil?
-        else
-          false
-        end
-      end
-
-      def clear(colorable: colorable?)
-        return '' unless colorable
-        "\e[#{CLEAR}m"
-      end
-
-      def colorize(text, seq, colorable: colorable?)
-        return text unless colorable
-        seq = seq.map { |s| "\e[#{const_get(s)}m" }.join('')
-        "#{seq}#{text}#{clear(colorable: colorable)}"
-      end
-
-      # If `complete` is false (code is incomplete), this does not warn compile_error.
-      # This option is needed to avoid warning a user when the compile_error is happening
-      # because the input is not wrong but just incomplete.
-      def colorize_code(code, complete: true, ignore_error: false, colorable: colorable?, local_variables: [])
-        return code unless colorable
-
-        symbol_state = SymbolState.new
-        colored = +''
-        lvars_code = RubyLex.generate_local_variables_assign_code(local_variables)
-        code_with_lvars = lvars_code ? "#{lvars_code}\n#{code}" : code
-
-        scan(code_with_lvars, allow_last_error: !complete) do |token, str, expr|
-          # handle uncolorable code
-          if token.nil?
-            colored << Reline::Unicode.escape_for_print(str)
-            next
-          end
-
-          # IRB::ColorPrinter skips colorizing fragments with any invalid token
-          if ignore_error && ERROR_TOKENS.include?(token)
-            return Reline::Unicode.escape_for_print(code)
-          end
-
-          in_symbol = symbol_state.scan_token(token)
-          str.each_line do |line|
-            line = Reline::Unicode.escape_for_print(line)
-            if seq = dispatch_seq(token, expr, line, in_symbol: in_symbol)
-              colored << seq.map { |s| "\e[#{s}m" }.join('')
-              colored << line.sub(/\Z/, clear(colorable: colorable))
-            else
-              colored << line
-            end
-          end
-        end
-
-        if lvars_code
-          raise "#{lvars_code.dump} should have no \\n" if lvars_code.include?("\n")
-          colored.sub!(/\A.+\n/, '') # delete_prefix lvars_code with colors
-        end
-        colored
-      end
-
-      private
-
-      def without_circular_ref(obj, seen:, &block)
-        return false if seen.key?(obj)
-        seen[obj] = true
-        block.call
-      ensure
-        seen.delete(obj)
-      end
-
-      def scan(code, allow_last_error:)
-        verbose, $VERBOSE = $VERBOSE, nil
-        RubyLex.compile_with_errors_suppressed(code) do |inner_code, line_no|
-          lexer = Ripper::Lexer.new(inner_code, '(ripper)', line_no)
-          byte_pos = 0
-          line_positions = [0]
-          inner_code.lines.each do |line|
-            line_positions << line_positions.last + line.bytesize
-          end
-
-          on_scan = proc do |elem|
-            start_pos = line_positions[elem.pos[0] - 1] + elem.pos[1]
-
-            # yield uncolorable code
-            if byte_pos < start_pos
-              yield(nil, inner_code.byteslice(byte_pos...start_pos), nil)
-            end
-
-            if byte_pos <= start_pos
-              str = elem.tok
-              yield(elem.event, str, elem.state)
-              byte_pos = start_pos + str.bytesize
-            end
-          end
-
-          lexer.scan.each do |elem|
-            next if allow_last_error and /meets end of file|unexpected end-of-input/ =~ elem.message
-            on_scan.call(elem)
-          end
-          # yield uncolorable DATA section
-          yield(nil, inner_code.byteslice(byte_pos...inner_code.bytesize), nil) if byte_pos < inner_code.bytesize
-        end
-      ensure
-        $VERBOSE = verbose
-      end
-
-      def dispatch_seq(token, expr, str, in_symbol:)
-        if ERROR_TOKENS.include?(token)
-          TOKEN_SEQ_EXPRS[token][0]
-        elsif in_symbol
-          [YELLOW]
-        elsif TOKEN_KEYWORDS.fetch(token, []).include?(str)
-          [CYAN, BOLD]
-        elsif (seq, exprs = TOKEN_SEQ_EXPRS[token]; (expr & (exprs || 0)) != 0)
-          seq
-        else
-          nil
-        end
-      end
-    end
-
-    # A class to manage a state to know whether the current token is for Symbol or not.
-    class SymbolState
-      def initialize
-        # Push `true` to detect Symbol. `false` to increase the nest level for non-Symbol.
-        @stack = []
-      end
-
-      # Return true if the token is a part of Symbol.
-      def scan_token(token)
-        prev_state = @stack.last
-        case token
-        when :on_symbeg, :on_symbols_beg, :on_qsymbols_beg
-          @stack << true
-        when :on_ident, :on_op, :on_const, :on_ivar, :on_cvar, :on_gvar, :on_kw, :on_backtick
-          if @stack.last # Pop only when it's Symbol
-            @stack.pop
-            return prev_state
-          end
-        when :on_tstring_beg
-          @stack << false
-        when :on_embexpr_beg
-          @stack << false
-          return prev_state
-        when :on_tstring_end # :on_tstring_end may close Symbol
-          @stack.pop
-          return prev_state
-        when :on_embexpr_end
-          @stack.pop
-        end
-        @stack.last
-      end
-    end
-    private_constant :SymbolState
-  end
-end

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-require 'pp'
-require_relative 'color'
-
-module IRB
-  class ColorPrinter < ::PP
-    METHOD_RESPOND_TO = Object.instance_method(:respond_to?)
-    METHOD_INSPECT = Object.instance_method(:inspect)
-
-    class << self
-      def pp(obj, out = $>, width = screen_width)
-        q = ColorPrinter.new(out, width)
-        q.guard_inspect_key {q.pp obj}
-        q.flush
-        out << "\n"
-      end
-
-      private
-
-      def screen_width
-        Reline.get_screen_size.last
-      rescue Errno::EINVAL # in `winsize': Invalid argument - <STDIN>
-        79
-      end
-    end
-
-    def pp(obj)
-      if String === obj
-        # Avoid calling Ruby 2.4+ String#pretty_print that splits a string by "\n"
-        text(obj.inspect)
-      elsif !METHOD_RESPOND_TO.bind(obj).call(:inspect)
-        text(METHOD_INSPECT.bind(obj).call)
-      else
-        super
-      end
-    end
-
-    def text(str, width = nil)
-      unless str.is_a?(String)
-        str = str.inspect
-      end
-      width ||= str.length
-
-      case str
-      when ''
-      when ',', '=>', '[', ']', '{', '}', '..', '...', /\A@\w+\z/
-        super(str, width)
-      when /\A#</, '=', '>'
-        super(Color.colorize(str, [:GREEN]), width)
-      else
-        super(Color.colorize_code(str, ignore_error: true), width)
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/irb/command/backtrace.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "debug"
-
-module IRB
-  # :stopdoc:
-
-  module Command
-    class Backtrace < DebugCommand
-      def execute(arg)
-        execute_debug_command(pre_cmds: "backtrace #{arg}")
-      end
-    end
-  end
-
-  # :startdoc:
-end

package/lib/ruby/3.4.11/irb/command/base.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-#
-#   nop.rb -
-#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-
-module IRB
-  module Command
-    class CommandArgumentError < StandardError; end # :nodoc:
-
-    class << self
-      def extract_ruby_args(*args, **kwargs) # :nodoc:
-        throw :EXTRACT_RUBY_ARGS, [args, kwargs]
-      end
-    end
-
-    class Base
-      class << self
-        def category(category = nil)
-          @category = category if category
-          @category || "No category"
-        end
-
-        def description(description = nil)
-          @description = description if description
-          @description || "No description provided."
-        end
-
-        def help_message(help_message = nil)
-          @help_message = help_message if help_message
-          @help_message
-        end
-
-        def execute(irb_context, arg)
-          new(irb_context).execute(arg)
-        rescue CommandArgumentError => e
-          puts e.message
-        end
-
-        private
-
-        def highlight(text)
-          Color.colorize(text, [:BOLD, :BLUE])
-        end
-      end
-
-      def initialize(irb_context)
-        @irb_context = irb_context
-      end
-
-      attr_reader :irb_context
-
-      def execute(arg)
-        #nop
-      end
-    end
-
-    Nop = Base # :nodoc:
-  end
-end

package/lib/ruby/3.4.11/irb/command/break.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "debug"
-
-module IRB
-  # :stopdoc:
-
-  module Command
-    class Break < DebugCommand
-      def execute(arg)
-        execute_debug_command(pre_cmds: "break #{arg}")
-      end
-    end
-  end
-
-  # :startdoc:
-end

package/lib/ruby/3.4.11/irb/command/catch.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "debug"
-
-module IRB
-  # :stopdoc:
-
-  module Command
-    class Catch < DebugCommand
-      def execute(arg)
-        execute_debug_command(pre_cmds: "catch #{arg}")
-      end
-    end
-  end
-
-  # :startdoc:
-end

package/lib/ruby/3.4.11/irb/command/cd.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module IRB
-  module Command
-    class CD < Base
-      category "Workspace"
-      description "Move into the given object or leave the current context."
-
-      help_message(<<~HELP)
-        Usage: cd ([target]|..)
-
-        IRB uses a stack of workspaces to keep track of context(s), with `pushws` and `popws` commands to manipulate the stack.
-        The `cd` command is an attempt to simplify the operation and will be subject to change.
-
-        When given:
-        - an object, cd will use that object as the new context by pushing it onto the workspace stack.
-        - "..", cd will leave the current context by popping the top workspace off the stack.
-        - no arguments, cd will move to the top workspace on the stack by popping off all workspaces.
-
-        Examples:
-
-          cd Foo
-          cd Foo.new
-          cd @ivar
-          cd ..
-          cd
-      HELP
-
-      def execute(arg)
-        case arg
-        when ".."
-          irb_context.pop_workspace
-        when ""
-          # TODO: decide what workspace commands should be kept, and underlying APIs should look like,
-          # and perhaps add a new API to clear the workspace stack.
-          prev_workspace = irb_context.pop_workspace
-          while prev_workspace
-            prev_workspace = irb_context.pop_workspace
-          end
-        else
-          begin
-            obj = eval(arg, irb_context.workspace.binding)
-            irb_context.push_workspace(obj)
-          rescue StandardError => e
-            warn "Error: #{e}"
-          end
-        end
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/irb/command/chws.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-#
-#   change-ws.rb -
-#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-require_relative "../ext/change-ws"
-
-module IRB
-  # :stopdoc:
-
-  module Command
-
-    class CurrentWorkingWorkspace < Base
-      category "Workspace"
-      description "Show the current workspace."
-
-      def execute(_arg)
-        puts "Current workspace: #{irb_context.main}"
-      end
-    end
-
-    class ChangeWorkspace < Base
-      category "Workspace"
-      description "Change the current workspace to an object."
-
-      def execute(arg)
-        if arg.empty?
-          irb_context.change_workspace
-        else
-          obj = eval(arg, irb_context.workspace.binding)
-          irb_context.change_workspace(obj)
-        end
-
-        puts "Current workspace: #{irb_context.main}"
-      end
-    end
-  end
-
-  # :startdoc:
-end

package/lib/ruby/3.4.11/irb/command/context.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module IRB
-  module Command
-    class Context < Base
-      category "IRB"
-      description "Displays current configuration."
-
-      def execute(_arg)
-        # This command just displays the configuration.
-        # Modifying the configuration is achieved by sending a message to IRB.conf.
-        Pager.page_content(IRB.CurrentContext.inspect)
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/irb/command/continue.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "debug"
-
-module IRB
-  # :stopdoc:
-
-  module Command
-    class Continue < DebugCommand
-      def execute(arg)
-        execute_debug_command(do_cmds: "continue #{arg}")
-      end
-    end
-  end
-
-  # :startdoc:
-end

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

@@ -1,73 +0,0 @@
-require_relative "../debug"
-
-module IRB
-  # :stopdoc:
-
-  module Command
-    class Debug < Base
-      category "Debugging"
-      description "Start the debugger of debug.gem."
-
-      def execute(_arg)
-        execute_debug_command
-      end
-
-      def execute_debug_command(pre_cmds: nil, do_cmds: nil)
-        pre_cmds = pre_cmds&.rstrip
-        do_cmds = do_cmds&.rstrip
-
-        if irb_context.with_debugger
-          # If IRB is already running with a debug session, throw the command and IRB.debug_readline will pass it to the debugger.
-          if cmd = pre_cmds || do_cmds
-            throw :IRB_EXIT, cmd
-          else
-            puts "IRB is already running with a debug session."
-            return
-          end
-        else
-          # If IRB is not running with a debug session yet, then:
-          # 1. Check if the debugging command is run from a `binding.irb` call.
-          # 2. If so, try setting up the debug gem.
-          # 3. Insert a debug breakpoint at `Irb#debug_break` with the intended command.
-          # 4. Exit the current Irb#run call via `throw :IRB_EXIT`.
-          # 5. `Irb#debug_break` will be called and trigger the breakpoint, which will run the intended command.
-          unless irb_context.from_binding?
-            puts "Debugging commands are only available when IRB is started with binding.irb"
-            return
-          end
-
-          if IRB.respond_to?(:JobManager)
-            warn "Can't start the debugger when IRB is running in a multi-IRB session."
-            return
-          end
-
-          unless IRB::Debug.setup(irb_context.irb)
-            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
-
-          IRB::Debug.insert_debug_break(pre_cmds: pre_cmds, do_cmds: do_cmds)
-
-          # exit current Irb#run call
-          throw :IRB_EXIT
-        end
-      end
-    end
-
-    class DebugCommand < Debug
-      class << self
-        def category
-          "Debugging"
-        end
-
-        def description
-          command_name = self.name.split("::").last.downcase
-          "Start the debugger of debug.gem and run its `#{command_name}` command."
-        end
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/irb/command/delete.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "debug"
-
-module IRB
-  # :stopdoc:
-
-  module Command
-    class Delete < DebugCommand
-      def execute(arg)
-        execute_debug_command(pre_cmds: "delete #{arg}")
-      end
-    end
-  end
-
-  # :startdoc:
-end

package/lib/ruby/3.4.11/irb/command/disable_irb.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module IRB
-  # :stopdoc:
-
-  module Command
-    class DisableIrb < Base
-      category "IRB"
-      description "Disable binding.irb."
-
-      def execute(*)
-        ::Binding.define_method(:irb) {}
-        IRB.irb_exit
-      end
-    end
-  end
-
-  # :startdoc:
-end