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

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

@@ -1,63 +0,0 @@
-require 'shellwords'
-
-require_relative "../color"
-require_relative "../source_finder"
-
-module IRB
-  # :stopdoc:
-
-  module Command
-    class Edit < Base
-      include RubyArgsExtractor
-
-      category "Misc"
-      description 'Open a file or source location.'
-      help_message <<~HELP_MESSAGE
-        Usage: edit [FILE or constant or method signature]
-
-        Open a file in the editor specified in #{highlight('ENV["VISUAL"]')} or #{highlight('ENV["EDITOR"]')}
-
-        - If no arguments are provided, IRB will attempt to open the file the current context was defined in.
-        - If FILE is provided, IRB will open the file.
-        - If a constant or method signature is provided, IRB will attempt to locate the source file and open it.
-
-        Examples:
-
-          edit
-          edit foo.rb
-          edit Foo
-          edit Foo#bar
-      HELP_MESSAGE
-
-      def execute(arg)
-        # Accept string literal for backward compatibility
-        path = unwrap_string_literal(arg)
-
-        if path.nil?
-          path = @irb_context.irb_path
-        elsif !File.exist?(path)
-          source = SourceFinder.new(@irb_context).find_source(path)
-
-          if source&.file_exist? && !source.binary_file?
-            path = source.file
-          end
-        end
-
-        unless File.exist?(path)
-          puts "Can not find file: #{path}"
-          return
-        end
-
-        if editor = (ENV['VISUAL'] || ENV['EDITOR'])
-          puts "command: '#{editor}'"
-          puts "   path: #{path}"
-          system(*Shellwords.split(editor), path)
-        else
-          puts "Can not find editor setting: ENV['VISUAL'] or ENV['EDITOR']"
-        end
-      end
-    end
-  end
-
-  # :startdoc:
-end

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

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module IRB
-  # :stopdoc:
-
-  module Command
-    class Exit < Base
-      category "IRB"
-      description "Exit the current irb session."
-
-      def execute(_arg)
-        IRB.irb_exit
-      end
-    end
-  end
-
-  # :startdoc:
-end

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

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

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

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module IRB
-  # :stopdoc:
-
-  module Command
-    class ForceExit < Base
-      category "IRB"
-      description "Exit the current process."
-
-      def execute(_arg)
-        throw :IRB_EXIT, true
-      end
-    end
-  end
-
-  # :startdoc:
-end

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

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module IRB
-  module Command
-    class Help < Base
-      category "Help"
-      description "List all available commands. Use `help <command>` to get information about a specific command."
-
-      def execute(command_name)
-        content =
-          if command_name.empty?
-            help_message
-          else
-            if command_class = Command.load_command(command_name)
-              command_class.help_message || command_class.description
-            else
-              "Can't find command `#{command_name}`. Please check the command name and try again.\n\n"
-            end
-          end
-        Pager.page_content(content)
-      end
-
-      private
-
-      def help_message
-        commands_info = IRB::Command.all_commands_info
-        helper_methods_info = IRB::HelperMethod.all_helper_methods_info
-        commands_grouped_by_categories = commands_info.group_by { |cmd| cmd[:category] }
-        commands_grouped_by_categories["Helper methods"] = helper_methods_info
-
-        if irb_context.with_debugger
-          # Remove the original "Debugging" category
-          commands_grouped_by_categories.delete("Debugging")
-        end
-
-        longest_cmd_name_length = commands_info.map { |c| c[:display_name].length }.max
-
-        output = StringIO.new
-
-        help_cmds = commands_grouped_by_categories.delete("Help")
-        no_category_cmds = commands_grouped_by_categories.delete("No category")
-        aliases = irb_context.instance_variable_get(:@command_aliases).map do |alias_name, target|
-          { display_name: alias_name, description: "Alias for `#{target}`" }
-        end
-
-        # Display help commands first
-        add_category_to_output("Help", help_cmds, output, longest_cmd_name_length)
-
-        # Display the rest of the commands grouped by categories
-        commands_grouped_by_categories.each do |category, cmds|
-          add_category_to_output(category, cmds, output, longest_cmd_name_length)
-        end
-
-        # Display commands without a category
-        if no_category_cmds
-          add_category_to_output("No category", no_category_cmds, output, longest_cmd_name_length)
-        end
-
-        # Display aliases
-        add_category_to_output("Aliases", aliases, output, longest_cmd_name_length)
-
-        # Append the debugger help at the end
-        if irb_context.with_debugger
-          # Add "Debugging (from debug.gem)" category as title
-          add_category_to_output("Debugging (from debug.gem)", [], output, longest_cmd_name_length)
-          output.puts DEBUGGER__.help
-        end
-
-        output.string
-      end
-
-      def add_category_to_output(category, cmds, output, longest_cmd_name_length)
-        output.puts Color.colorize(category, [:BOLD])
-
-        cmds.each do |cmd|
-          output.puts "  #{cmd[:display_name].to_s.ljust(longest_cmd_name_length)}    #{cmd[:description]}"
-        end
-
-        output.puts
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require "stringio"
-
-require_relative "../pager"
-
-module IRB
-  # :stopdoc:
-
-  module Command
-    class History < Base
-      category "IRB"
-      description "Shows the input history. `-g [query]` or `-G [query]` allows you to filter the output."
-
-      def execute(arg)
-
-        if (match = arg&.match(/(-g|-G)\s+(?<grep>.+)\s*\n\z/))
-          grep = Regexp.new(match[:grep])
-        end
-
-        formatted_inputs = irb_context.io.class::HISTORY.each_with_index.reverse_each.filter_map do |input, index|
-          next if grep && !input.match?(grep)
-
-          header = "#{index}: "
-
-          first_line, *other_lines = input.split("\n")
-          first_line = "#{header}#{first_line}"
-
-          truncated_lines = other_lines.slice!(1..) # Show 1 additional line (2 total)
-          other_lines << "..." if truncated_lines&.any?
-
-          other_lines.map! do |line|
-            " " * header.length + line
-          end
-
-          [first_line, *other_lines].join("\n") + "\n"
-        end
-
-        Pager.page_content(formatted_inputs.join)
-      end
-    end
-  end
-
-  # :startdoc:
-end

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

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

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module IRB
-  module Command
-    # Internal use only, for default command's backward compatibility.
-    module RubyArgsExtractor # :nodoc:
-      def unwrap_string_literal(str)
-        return if str.empty?
-
-        sexp = Ripper.sexp(str)
-        if sexp && sexp.size == 2 && sexp.last&.first&.first == :string_literal
-          @irb_context.workspace.binding.eval(str).to_s
-        else
-          str
-        end
-      end
-
-      def ruby_args(arg)
-        # Use throw and catch to handle arg that includes `;`
-        # For example: "1, kw: (2; 3); 4" will be parsed to [[1], { kw: 3 }]
-        catch(:EXTRACT_RUBY_ARGS) do
-          @irb_context.workspace.binding.eval "::IRB::Command.extract_ruby_args #{arg}"
-        end || [[], {}]
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module IRB
-  # :stopdoc:
-
-  module Command
-    class IrbInfo < Base
-      category "IRB"
-      description "Show information about IRB."
-
-      def execute(_arg)
-        str  = "Ruby version: #{RUBY_VERSION}\n"
-        str += "IRB version: #{IRB.version}\n"
-        str += "InputMethod: #{IRB.CurrentContext.io.inspect}\n"
-        str += "Completion: #{IRB.CurrentContext.io.respond_to?(:completion_info) ? IRB.CurrentContext.io.completion_info : 'off'}\n"
-        rc_files = IRB.irbrc_files
-        str += ".irbrc paths: #{rc_files.join(", ")}\n" if rc_files.any?
-        str += "RUBY_PLATFORM: #{RUBY_PLATFORM}\n"
-        str += "LANG env: #{ENV["LANG"]}\n" if ENV["LANG"] && !ENV["LANG"].empty?
-        str += "LC_ALL env: #{ENV["LC_ALL"]}\n" if ENV["LC_ALL"] && !ENV["LC_ALL"].empty?
-        str += "East Asian Ambiguous Width: #{Reline.ambiguous_width.inspect}\n"
-        if RbConfig::CONFIG['host_os'] =~ /mswin|msys|mingw|cygwin|bccwin|wince|emc/
-          codepage = `chcp`.b.sub(/.*: (\d+)\n/, '\1')
-          str += "Code page: #{codepage}\n"
-        end
-        puts str
-        nil
-      end
-    end
-  end
-
-  # :startdoc:
-end

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

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-#
-#   load.rb -
-#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-require_relative "../ext/loader"
-
-module IRB
-  # :stopdoc:
-
-  module Command
-    class LoaderCommand < Base
-      include RubyArgsExtractor
-      include IrbLoader
-
-      def raise_cmd_argument_error
-        raise CommandArgumentError.new("Please specify the file name.")
-      end
-    end
-
-    class Load < LoaderCommand
-      category "IRB"
-      description "Load a Ruby file."
-
-      def execute(arg)
-        args, kwargs = ruby_args(arg)
-        execute_internal(*args, **kwargs)
-      end
-
-      def execute_internal(file_name = nil, priv = nil)
-        raise_cmd_argument_error unless file_name
-        irb_load(file_name, priv)
-      end
-    end
-
-    class Require < LoaderCommand
-      category "IRB"
-      description "Require a Ruby file."
-
-      def execute(arg)
-        args, kwargs = ruby_args(arg)
-        execute_internal(*args, **kwargs)
-      end
-
-      def execute_internal(file_name = nil)
-        raise_cmd_argument_error unless file_name
-
-        rex = Regexp.new("#{Regexp.quote(file_name)}(\.o|\.rb)?")
-        return false if $".find{|f| f =~ rex}
-
-        case file_name
-        when /\.rb$/
-          begin
-            if irb_load(file_name)
-              $".push file_name
-              return true
-            end
-          rescue LoadError
-          end
-        when /\.(so|o|sl)$/
-          return ruby_require(file_name)
-        end
-
-        begin
-          irb_load(f = file_name + ".rb")
-          $".push f
-          return true
-        rescue LoadError
-          return ruby_require(file_name)
-        end
-      end
-    end
-
-    class Source < LoaderCommand
-      category "IRB"
-      description "Loads a given file in the current session."
-
-      def execute(arg)
-        args, kwargs = ruby_args(arg)
-        execute_internal(*args, **kwargs)
-      end
-
-      def execute_internal(file_name = nil)
-        raise_cmd_argument_error unless file_name
-
-        source_file(file_name)
-      end
-    end
-  end
-  # :startdoc:
-end

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

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-require "reline"
-require "stringio"
-
-require_relative "../pager"
-require_relative "../color"
-
-module IRB
-  # :stopdoc:
-
-  module Command
-    class Ls < Base
-      class EvaluationError < StandardError; end
-
-      category "Context"
-      description "Show methods, constants, and variables."
-
-      help_message <<~HELP_MESSAGE
-        Usage: ls [obj] [-g [query]]
-
-          -g [query]  Filter the output with a query.
-      HELP_MESSAGE
-
-      def evaluate(code)
-        @irb_context.workspace.binding.eval(code)
-      rescue Exception => e
-        puts "#{e.class}: #{e.message}"
-        raise EvaluationError
-      end
-
-      def execute(arg)
-        if match = arg.match(/\A(?<target>.+\s|)(-g|-G)\s+(?<grep>.+)$/)
-          target = match[:target]
-          grep = Regexp.new(match[:grep])
-        elsif match = arg.match(/\A((?<target>.+),|)\s*grep:(?<grep>.+)/)
-          # Legacy style `ls obj, grep: /regexp/`
-          # Evaluation order should be eval(target) then eval(grep)
-          target = match[:target] || ''
-          grep_regexp_code = match[:grep]
-        else
-          target = arg.strip
-        end
-
-        if target.empty?
-          obj = irb_context.workspace.main
-          locals = irb_context.workspace.binding.local_variables
-        else
-          obj = evaluate(target)
-        end
-
-        if grep_regexp_code
-          grep = evaluate(grep_regexp_code)
-        end
-
-        o = Output.new(grep: grep)
-
-        klass  = (obj.class == Class || obj.class == Module ? obj : obj.class)
-
-        o.dump("constants", obj.constants) if obj.respond_to?(:constants)
-        dump_methods(o, klass, obj)
-        o.dump("instance variables", obj.instance_variables)
-        o.dump("class variables", klass.class_variables)
-        o.dump("locals", locals) if locals
-        o.print_result
-      rescue EvaluationError
-      end
-
-      def dump_methods(o, klass, obj)
-        singleton_class = begin obj.singleton_class; rescue TypeError; nil end
-        dumped_mods = Array.new
-        ancestors = klass.ancestors
-        ancestors = ancestors.reject { |c| c >= Object } if klass < Object
-        singleton_ancestors = (singleton_class&.ancestors || []).reject { |c| c >= Class }
-
-        # singleton_class' ancestors should be at the front
-        maps = class_method_map(singleton_ancestors, dumped_mods) + class_method_map(ancestors, dumped_mods)
-        maps.each do |mod, methods|
-          name = mod == singleton_class ? "#{klass}.methods" : "#{mod}#methods"
-          o.dump(name, methods)
-        end
-      end
-
-      def class_method_map(classes, dumped_mods)
-        dumped_methods = Array.new
-        classes.map do |mod|
-          next if dumped_mods.include? mod
-
-          dumped_mods << mod
-
-          methods = mod.public_instance_methods(false).select do |method|
-            if dumped_methods.include? method
-              false
-            else
-              dumped_methods << method
-              true
-            end
-          end
-
-          [mod, methods]
-        end.compact
-      end
-
-      class Output
-        MARGIN = "  "
-
-        def initialize(grep: nil)
-          @grep = grep
-          @line_width = screen_width - MARGIN.length # right padding
-          @io = StringIO.new
-        end
-
-        def print_result
-          Pager.page_content(@io.string)
-        end
-
-        def dump(name, strs)
-          strs = strs.grep(@grep) if @grep
-          strs = strs.sort
-          return if strs.empty?
-
-          # Attempt a single line
-          @io.print "#{Color.colorize(name, [:BOLD, :BLUE])}: "
-          if fits_on_line?(strs, cols: strs.size, offset: "#{name}: ".length)
-            @io.puts strs.join(MARGIN)
-            return
-          end
-          @io.puts
-
-          # Dump with the largest # of columns that fits on a line
-          cols = strs.size
-          until fits_on_line?(strs, cols: cols, offset: MARGIN.length) || cols == 1
-            cols -= 1
-          end
-          widths = col_widths(strs, cols: cols)
-          strs.each_slice(cols) do |ss|
-            @io.puts ss.map.with_index { |s, i| "#{MARGIN}%-#{widths[i]}s" % s }.join
-          end
-        end
-
-        private
-
-        def fits_on_line?(strs, cols:, offset: 0)
-          width = col_widths(strs, cols: cols).sum + MARGIN.length * (cols - 1)
-          width <= @line_width - offset
-        end
-
-        def col_widths(strs, cols:)
-          cols.times.map do |col|
-            (col...strs.size).step(cols).map do |i|
-              strs[i].length
-            end.max
-          end
-        end
-
-        def screen_width
-          Reline.get_screen_size.last
-        rescue Errno::EINVAL # in `winsize': Invalid argument - <STDIN>
-          80
-        end
-      end
-      private_constant :Output
-    end
-  end
-
-  # :startdoc:
-end

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

@@ -1,49 +0,0 @@
-module IRB
-  # :stopdoc:
-
-  module Command
-    class Measure < Base
-      include RubyArgsExtractor
-
-      category "Misc"
-      description "`measure` enables the mode to measure processing time. `measure :off` disables it."
-
-      def initialize(*args)
-        super(*args)
-      end
-
-      def execute(arg)
-        if arg&.match?(/^do$|^do[^\w]|^\{/)
-          warn 'Configure IRB.conf[:MEASURE_PROC] to add custom measure methods.'
-          return
-        end
-        args, kwargs = ruby_args(arg)
-        execute_internal(*args, **kwargs)
-      end
-
-      def execute_internal(type = nil, arg = nil)
-        # Please check IRB.init_config in lib/irb/init.rb that sets
-        # IRB.conf[:MEASURE_PROC] to register default "measure" methods,
-        # "measure :time" (abbreviated as "measure") and "measure :stackprof".
-
-        case type
-        when :off
-          IRB.unset_measure_callback(arg)
-        when :list
-          IRB.conf[:MEASURE_CALLBACKS].each do |type_name, _, arg_val|
-            puts "- #{type_name}" + (arg_val ? "(#{arg_val.inspect})" : '')
-          end
-        when :on
-          added = IRB.set_measure_callback(arg)
-          puts "#{added[0]} is added." if added
-        else
-          added = IRB.set_measure_callback(type, arg)
-          puts "#{added[0]} is added." if added
-        end
-        nil
-      end
-    end
-  end
-
-  # :startdoc:
-end

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

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