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

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

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

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

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

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

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

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

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

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

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

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

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

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

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