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

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

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "ruby-lex"
-
-module IRB
-  class SourceFinder
-    class EvaluationError < StandardError; end
-
-    class Source
-      attr_reader :file, :line
-      def initialize(file, line, ast_source = nil)
-        @file = file
-        @line = line
-        @ast_source = ast_source
-      end
-
-      def file_exist?
-        File.exist?(@file)
-      end
-
-      def binary_file?
-        # If the line is zero, it means that the target's source is probably in a binary file.
-        @line.zero?
-      end
-
-      def file_content
-        @file_content ||= File.read(@file)
-      end
-
-      def colorized_content
-        if !binary_file? && file_exist?
-          end_line = find_end
-          # To correctly colorize, we need to colorize full content and extract the relevant lines.
-          colored = IRB::Color.colorize_code(file_content)
-          colored.lines[@line - 1...end_line].join
-        elsif @ast_source
-          IRB::Color.colorize_code(@ast_source)
-        end
-      end
-
-      private
-
-      def find_end
-        lex = RubyLex.new
-        code = file_content
-        lines = code.lines[(@line - 1)..-1]
-        tokens = RubyLex.ripper_lex_without_warning(lines.join)
-        prev_tokens = []
-
-        # chunk with line number
-        tokens.chunk { |tok| tok.pos[0] }.each do |lnum, chunk|
-          code = lines[0..lnum].join
-          prev_tokens.concat chunk
-          continue = lex.should_continue?(prev_tokens)
-          syntax = lex.check_code_syntax(code, local_variables: [])
-          if !continue && syntax == :valid
-            return @line + lnum
-          end
-        end
-        @line
-      end
-    end
-
-    private_constant :Source
-
-    def initialize(irb_context)
-      @irb_context = irb_context
-    end
-
-    def find_source(signature, super_level = 0)
-      case signature
-      when /\A(::)?[A-Z]\w*(::[A-Z]\w*)*\z/ # ConstName, ::ConstName, ConstPath::ConstName
-        eval_receiver_or_owner(signature) # trigger autoload
-        *parts, name = signature.split('::', -1)
-        base =
-          if parts.empty? # ConstName
-            find_const_owner(name)
-          elsif parts == [''] # ::ConstName
-            Object
-          else # ConstPath::ConstName
-            eval_receiver_or_owner(parts.join('::'))
-          end
-        file, line = base.const_source_location(name)
-      when /\A(?<owner>[A-Z]\w*(::[A-Z]\w*)*)#(?<method>[^ :.]+)\z/ # Class#method
-        owner = eval_receiver_or_owner(Regexp.last_match[:owner])
-        method = Regexp.last_match[:method]
-        return unless owner.respond_to?(:instance_method)
-        method = method_target(owner, super_level, method, "owner")
-        file, line = method&.source_location
-      when /\A((?<receiver>.+)(\.|::))?(?<method>[^ :.]+)\z/ # method, receiver.method, receiver::method
-        receiver = eval_receiver_or_owner(Regexp.last_match[:receiver] || 'self')
-        method = Regexp.last_match[:method]
-        return unless receiver.respond_to?(method, true)
-        method = method_target(receiver, super_level, method, "receiver")
-        file, line = method&.source_location
-      end
-      return unless file && line
-
-      if File.exist?(file)
-        Source.new(file, line)
-      elsif method
-        # Method defined with eval, probably in IRB session
-        source = RubyVM::InstructionSequence.of(method)&.script_lines&.join rescue nil
-        Source.new(file, line, source)
-      end
-    rescue EvaluationError
-      nil
-    end
-
-    private
-
-    def method_target(owner_receiver, super_level, method, type)
-      case type
-      when "owner"
-        target_method = owner_receiver.instance_method(method)
-      when "receiver"
-        target_method = owner_receiver.method(method)
-      end
-      super_level.times do |s|
-        target_method = target_method.super_method if target_method
-      end
-      target_method
-    rescue NameError
-      nil
-    end
-
-    def eval_receiver_or_owner(code)
-      @irb_context.workspace.binding.eval(code)
-    rescue Exception
-      raise EvaluationError
-    end
-
-    def find_const_owner(name)
-      module_nesting = @irb_context.workspace.binding.eval('::Module.nesting')
-      module_nesting.find { |mod| mod.const_defined?(name, false) } || module_nesting.find { |mod| mod.const_defined?(name) } || Object
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module IRB
-  class Statement
-    attr_reader :code
-
-    def is_assignment?
-      raise NotImplementedError
-    end
-
-    def suppresses_echo?
-      raise NotImplementedError
-    end
-
-    def should_be_handled_by_debugger?
-      raise NotImplementedError
-    end
-
-    class EmptyInput < Statement
-      def is_assignment?
-        false
-      end
-
-      def suppresses_echo?
-        true
-      end
-
-      # Debugger takes empty input to repeat the last command
-      def should_be_handled_by_debugger?
-        true
-      end
-
-      def code
-        ""
-      end
-    end
-
-    class Expression < Statement
-      def initialize(code, is_assignment)
-        @code = code
-        @is_assignment = is_assignment
-      end
-
-      def suppresses_echo?
-        @code.match?(/;\s*\z/)
-      end
-
-      def should_be_handled_by_debugger?
-        true
-      end
-
-      def is_assignment?
-        @is_assignment
-      end
-    end
-
-    class Command < Statement
-      attr_reader :command_class, :arg
-
-      def initialize(original_code, command_class, arg)
-        @code = original_code
-        @command_class = command_class
-        @arg = arg
-      end
-
-      def is_assignment?
-        false
-      end
-
-      def suppresses_echo?
-        true
-      end
-
-      def should_be_handled_by_debugger?
-        require_relative 'command/debug'
-        IRB::Command::DebugCommand > @command_class
-      end
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-#
-#   irb/version.rb - irb version definition file
-#   	by Keiju ISHITSUKA(keiju@ishitsuka.com)
-#
-
-module IRB # :nodoc:
-  VERSION = "1.14.3"
-  @RELEASE_VERSION = VERSION
-  @LAST_UPDATE_DATE = "2024-12-18"
-end

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

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-#
-#   irb/workspace-binding.rb -
-#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-
-require_relative "helper_method"
-
-IRB::TOPLEVEL_BINDING = binding
-module IRB # :nodoc:
-  class WorkSpace
-    # Creates a new workspace.
-    #
-    # set self to main if specified, otherwise
-    # inherit main from TOPLEVEL_BINDING.
-    def initialize(*main)
-      if Binding === main[0]
-        @binding = main.shift
-      elsif IRB.conf[:SINGLE_IRB]
-        @binding = TOPLEVEL_BINDING
-      else
-        case IRB.conf[:CONTEXT_MODE]
-        when 0	# binding in proc on TOPLEVEL_BINDING
-          @binding = eval("proc{binding}.call",
-                          TOPLEVEL_BINDING,
-                          __FILE__,
-                          __LINE__)
-        when 1	# binding in loaded file
-          require "tempfile"
-          f = Tempfile.open("irb-binding")
-          f.print <<EOF
-      $binding = binding
-EOF
-          f.close
-          load f.path
-          @binding = $binding
-
-        when 2	# binding in loaded file(thread use)
-          unless defined? BINDING_QUEUE
-            IRB.const_set(:BINDING_QUEUE, Thread::SizedQueue.new(1))
-            Thread.abort_on_exception = true
-            Thread.start do
-              eval "require \"irb/ws-for-case-2\"", TOPLEVEL_BINDING, __FILE__, __LINE__
-            end
-            Thread.pass
-          end
-          @binding = BINDING_QUEUE.pop
-
-        when 3	# binding in function on TOPLEVEL_BINDING
-          @binding = eval("self.class.remove_method(:irb_binding) if defined?(irb_binding); private; def irb_binding; binding; end; irb_binding",
-                          TOPLEVEL_BINDING,
-                          __FILE__,
-                          __LINE__ - 3)
-        when 4  # binding is a copy of TOPLEVEL_BINDING (default)
-          # Note that this will typically be IRB::TOPLEVEL_BINDING
-          # This is to avoid RubyGems' local variables (see issue #17623)
-          @binding = TOPLEVEL_BINDING.dup
-        end
-      end
-
-      if main.empty?
-        @main = eval("self", @binding)
-      else
-        @main = main[0]
-      end
-      IRB.conf[:__MAIN__] = @main
-
-      unless main.empty?
-        case @main
-        when Module
-          @binding = eval("::IRB.conf[:__MAIN__].module_eval('::Kernel.binding', __FILE__, __LINE__)", @binding, __FILE__, __LINE__)
-        else
-          begin
-            @binding = eval("::IRB.conf[:__MAIN__].instance_eval('::Kernel.binding', __FILE__, __LINE__)", @binding, __FILE__, __LINE__)
-          rescue TypeError
-            fail CantChangeBinding, @main.inspect
-          end
-        end
-      end
-
-      @binding.local_variable_set(:_, nil)
-    end
-
-    # The Binding of this workspace
-    attr_reader :binding
-    # The top-level workspace of this context, also available as
-    # <code>IRB.conf[:__MAIN__]</code>
-    attr_reader :main
-
-    def load_helper_methods_to_main
-      # Do not load helper methods to frozen objects and BasicObject
-      return unless Object === @main && !@main.frozen?
-
-      ancestors = class<<main;ancestors;end
-      main.extend ExtendCommandBundle if !ancestors.include?(ExtendCommandBundle)
-      main.extend HelpersContainer if !ancestors.include?(HelpersContainer)
-    end
-
-    # Evaluate the given +statements+ within the  context of this workspace.
-    def evaluate(statements, file = __FILE__, line = __LINE__)
-      eval(statements, @binding, file, line)
-    end
-
-    def local_variable_set(name, value)
-      @binding.local_variable_set(name, value)
-    end
-
-    def local_variable_get(name)
-      @binding.local_variable_get(name)
-    end
-
-    # error message manipulator
-    # WARN: Rails patches this method to filter its own backtrace. Be cautious when changing it.
-    # See: https://github.com/rails/rails/blob/main/railties/lib/rails/commands/console/console_command.rb#L8:~:text=def,filter_backtrace
-    def filter_backtrace(bt)
-      return nil if bt =~ /\/irb\/.*\.rb/
-      return nil if bt =~ /\/irb\.rb/
-      return nil if bt =~ /tool\/lib\/.*\.rb|runner\.rb/ # for tests in Ruby repository
-      case IRB.conf[:CONTEXT_MODE]
-      when 1
-        return nil if bt =~ %r!/tmp/irb-binding!
-      when 3
-        bt = bt.sub(/:\s*in `irb_binding'/, '')
-      end
-      bt
-    end
-
-    def code_around_binding
-      file, pos = @binding.source_location
-
-      if defined?(::SCRIPT_LINES__[file]) && lines = ::SCRIPT_LINES__[file]
-        code = ::SCRIPT_LINES__[file].join('')
-      else
-        begin
-          code = File.read(file)
-        rescue SystemCallError
-          return
-        end
-      end
-
-      lines = Color.colorize_code(code).lines
-      pos -= 1
-
-      start_pos = [pos - 5, 0].max
-      end_pos   = [pos + 5, lines.size - 1].min
-
-      line_number_fmt = Color.colorize("%#{end_pos.to_s.length}d", [:BLUE, :BOLD])
-      fmt = " %2s #{line_number_fmt}: %s"
-
-      body = (start_pos..end_pos).map do |current_pos|
-        sprintf(fmt, pos == current_pos ? '=>' : '', current_pos + 1, lines[current_pos])
-      end.join("")
-
-      "\nFrom: #{file} @ line #{pos + 1} :\n\n#{body}#{Color.clear}\n"
-    end
-  end
-
-  module HelpersContainer
-    class << self
-      def install_helper_methods
-        HelperMethod.helper_methods.each do |name, helper_method_class|
-          define_method name do |*args, **opts, &block|
-            helper_method_class.instance.execute(*args, **opts, &block)
-          end unless method_defined?(name)
-        end
-      end
-    end
-
-    install_helper_methods
-  end
-end

package/lib/ruby/3.4.11/irb/ws-for-case-2.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-#
-#   irb/ws-for-case-2.rb -
-#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
-#
-
-while true
-  IRB::BINDING_QUEUE.push _ = binding
-end

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

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-#
-#   xmp.rb - irb version of gotoken xmp
-#   	by Keiju ISHITSUKA(Nippon Rational Inc.)
-#
-
-require_relative "../irb"
-require_relative "frame"
-
-# An example printer for irb.
-#
-# It's much like the standard library PrettyPrint, that shows the value of each
-# expression as it runs.
-#
-# In order to use this library, you must first require it:
-#
-#     require 'irb/xmp'
-#
-# Now, you can take advantage of the Object#xmp convenience method.
-#
-#     xmp <<END
-#       foo = "bar"
-#       baz = 42
-#     END
-#     #=> foo = "bar"
-#       #==>"bar"
-#     #=> baz = 42
-#       #==>42
-#
-# You can also create an XMP object, with an optional binding to print
-# expressions in the given binding:
-#
-#     ctx = binding
-#     x = XMP.new ctx
-#     x.puts
-#     #=> today = "a good day"
-#       #==>"a good day"
-#     ctx.eval 'today # is what?'
-#     #=> "a good day"
-class XMP
-
-  # Creates a new XMP object.
-  #
-  # The top-level binding or, optional +bind+ parameter will be used when
-  # creating the workspace. See WorkSpace.new for more information.
-  #
-  # This uses the +:XMP+ prompt mode.
-  # See {Custom Prompts}[rdoc-ref:IRB@Custom+Prompts] for more information.
-  def initialize(bind = nil)
-    IRB.init_config(nil)
-
-    IRB.conf[:PROMPT_MODE] = :XMP
-
-    bind = IRB::Frame.top(1) unless bind
-    ws = IRB::WorkSpace.new(bind)
-    @io = StringInputMethod.new
-    @irb = IRB::Irb.new(ws, @io)
-    @irb.context.ignore_sigint = false
-
-    IRB.conf[:MAIN_CONTEXT] = @irb.context
-  end
-
-  # Evaluates the given +exps+, for example:
-  #
-  #   require 'irb/xmp'
-  #   x = XMP.new
-  #
-  #   x.puts '{:a => 1, :b => 2, :c => 3}'
-  #   #=> {:a => 1, :b => 2, :c => 3}
-  #     # ==>{:a=>1, :b=>2, :c=>3}
-  #   x.puts 'foo = "bar"'
-  #   # => foo = "bar"
-  #     # ==>"bar"
-  def puts(exps)
-    @io.puts exps
-
-    if @irb.context.ignore_sigint
-      begin
-        trap_proc_b = trap("SIGINT"){@irb.signal_handle}
-        catch(:IRB_EXIT) do
-          @irb.eval_input
-        end
-      ensure
-        trap("SIGINT", trap_proc_b)
-      end
-    else
-      catch(:IRB_EXIT) do
-        @irb.eval_input
-      end
-    end
-  end
-
-  # A custom InputMethod class used by XMP for evaluating string io.
-  class StringInputMethod < IRB::InputMethod
-    # Creates a new StringInputMethod object
-    def initialize
-      super
-      @exps = []
-    end
-
-    # Whether there are any expressions left in this printer.
-    def eof?
-      @exps.empty?
-    end
-
-    # Reads the next expression from this printer.
-    #
-    # See IO#gets for more information.
-    def gets
-      while l = @exps.shift
-        next if /^\s+$/ =~ l
-        l.concat "\n"
-        print @prompt, l
-        break
-      end
-      l
-    end
-
-    # Concatenates all expressions in this printer, separated by newlines.
-    #
-    # An Encoding::CompatibilityError is raised of the given +exps+'s encoding
-    # doesn't match the previous expression evaluated.
-    def puts(exps)
-      if @encoding and exps.encoding != @encoding
-        enc = Encoding.compatible?(@exps.join("\n"), exps)
-        if enc.nil?
-          raise Encoding::CompatibilityError, "Encoding in which the passed expression is encoded is not compatible to the preceding's one"
-        else
-          @encoding = enc
-        end
-      else
-        @encoding = exps.encoding
-      end
-      @exps.concat exps.split(/\n/)
-    end
-
-    # Returns the encoding of last expression printed by #puts.
-    attr_reader :encoding
-  end
-end
-
-# A convenience method that's only available when the you require the IRB::XMP standard library.
-#
-# Creates a new XMP object, using the given expressions as the +exps+
-# parameter, and optional binding as +bind+ or uses the top-level binding. Then
-# evaluates the given expressions using the +:XMP+ prompt mode.
-#
-# For example:
-#
-#   require 'irb/xmp'
-#   ctx = binding
-#   xmp 'foo = "bar"', ctx
-#   #=> foo = "bar"
-#     #==>"bar"
-#   ctx.eval 'foo'
-#   #=> "bar"
-#
-# See XMP.new for more information.
-def xmp(exps, bind = nil)
-  bind = IRB::Frame.top(1) unless bind
-  xmp = XMP.new(bind)
-  xmp.puts exps
-  xmp
-end