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

package/lib/ruby/3.4.11/timeout.gemspec

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-name = File.basename(__FILE__, ".gemspec")
-version = ["lib", Array.new(name.count("-")+1, ".").join("/")].find do |dir|
-  break File.foreach(File.join(__dir__, dir, "#{name.tr('-', '/')}.rb")) do |line|
-    /^\s*VERSION\s*=\s*"(.*)"/ =~ line and break $1
-  end rescue nil
-end
-
-Gem::Specification.new do |spec|
-  spec.name          = name
-  spec.version       = version
-  spec.authors       = ["Yukihiro Matsumoto"]
-  spec.email         = ["matz@ruby-lang.org"]
-
-  spec.summary       = %q{Auto-terminate potentially long-running operations in Ruby.}
-  spec.description   = %q{Auto-terminate potentially long-running operations in Ruby.}
-  spec.homepage      = "https://github.com/ruby/timeout"
-  spec.licenses      = ["Ruby", "BSD-2-Clause"]
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = spec.homepage + "/releases"
-
-  spec.required_ruby_version = '>= 2.6.0'
-
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features|rakelib)/|\.(?:git|travis|circleci)|appveyor|Rakefile)})
-    end
-  end
-  spec.require_paths = ["lib"]
-end

package/lib/ruby/3.4.11/timeout.rb

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-# Timeout long-running blocks
-#
-# == Synopsis
-#
-#   require 'timeout'
-#   status = Timeout.timeout(5) {
-#     # Something that should be interrupted if it takes more than 5 seconds...
-#   }
-#
-# == Description
-#
-# Timeout provides a way to auto-terminate a potentially long-running
-# operation if it hasn't finished in a fixed amount of time.
-#
-# == Copyright
-#
-# Copyright:: (C) 2000  Network Applied Communication Laboratory, Inc.
-# Copyright:: (C) 2000  Information-technology Promotion Agency, Japan
-
-module Timeout
-  # The version
-  VERSION = "0.4.3"
-
-  # Internal error raised to when a timeout is triggered.
-  class ExitException < Exception
-    def exception(*) # :nodoc:
-      self
-    end
-  end
-
-  # Raised by Timeout.timeout when the block times out.
-  class Error < RuntimeError
-    def self.handle_timeout(message) # :nodoc:
-      exc = ExitException.new(message)
-
-      begin
-        yield exc
-      rescue ExitException => e
-        raise new(message) if exc.equal?(e)
-        raise
-      end
-    end
-  end
-
-  # :stopdoc:
-  CONDVAR = ConditionVariable.new
-  QUEUE = Queue.new
-  QUEUE_MUTEX = Mutex.new
-  TIMEOUT_THREAD_MUTEX = Mutex.new
-  @timeout_thread = nil
-  private_constant :CONDVAR, :QUEUE, :QUEUE_MUTEX, :TIMEOUT_THREAD_MUTEX
-
-  class Request
-    attr_reader :deadline
-
-    def initialize(thread, timeout, exception_class, message)
-      @thread = thread
-      @deadline = GET_TIME.call(Process::CLOCK_MONOTONIC) + timeout
-      @exception_class = exception_class
-      @message = message
-
-      @mutex = Mutex.new
-      @done = false # protected by @mutex
-    end
-
-    def done?
-      @mutex.synchronize do
-        @done
-      end
-    end
-
-    def expired?(now)
-      now >= @deadline
-    end
-
-    def interrupt
-      @mutex.synchronize do
-        unless @done
-          @thread.raise @exception_class, @message
-          @done = true
-        end
-      end
-    end
-
-    def finished
-      @mutex.synchronize do
-        @done = true
-      end
-    end
-  end
-  private_constant :Request
-
-  def self.create_timeout_thread
-    watcher = Thread.new do
-      requests = []
-      while true
-        until QUEUE.empty? and !requests.empty? # wait to have at least one request
-          req = QUEUE.pop
-          requests << req unless req.done?
-        end
-        closest_deadline = requests.min_by(&:deadline).deadline
-
-        now = 0.0
-        QUEUE_MUTEX.synchronize do
-          while (now = GET_TIME.call(Process::CLOCK_MONOTONIC)) < closest_deadline and QUEUE.empty?
-            CONDVAR.wait(QUEUE_MUTEX, closest_deadline - now)
-          end
-        end
-
-        requests.each do |req|
-          req.interrupt if req.expired?(now)
-        end
-        requests.reject!(&:done?)
-      end
-    end
-    ThreadGroup::Default.add(watcher) unless watcher.group.enclosed?
-    watcher.name = "Timeout stdlib thread"
-    watcher.thread_variable_set(:"\0__detached_thread__", true)
-    watcher
-  end
-  private_class_method :create_timeout_thread
-
-  def self.ensure_timeout_thread_created
-    unless @timeout_thread and @timeout_thread.alive?
-      TIMEOUT_THREAD_MUTEX.synchronize do
-        unless @timeout_thread and @timeout_thread.alive?
-          @timeout_thread = create_timeout_thread
-        end
-      end
-    end
-  end
-
-  # We keep a private reference so that time mocking libraries won't break
-  # Timeout.
-  GET_TIME = Process.method(:clock_gettime)
-  private_constant :GET_TIME
-
-  # :startdoc:
-
-  # Perform an operation in a block, raising an error if it takes longer than
-  # +sec+ seconds to complete.
-  #
-  # +sec+:: Number of seconds to wait for the block to terminate. Any non-negative number
-  #         or nil may be used, including Floats to specify fractional seconds. A
-  #         value of 0 or +nil+ will execute the block without any timeout.
-  #         Any negative number will raise an ArgumentError.
-  # +klass+:: Exception Class to raise if the block fails to terminate
-  #           in +sec+ seconds.  Omitting will use the default, Timeout::Error
-  # +message+:: Error message to raise with Exception Class.
-  #             Omitting will use the default, "execution expired"
-  #
-  # Returns the result of the block *if* the block completed before
-  # +sec+ seconds, otherwise throws an exception, based on the value of +klass+.
-  #
-  # The exception thrown to terminate the given block cannot be rescued inside
-  # the block unless +klass+ is given explicitly. However, the block can use
-  # ensure to prevent the handling of the exception.  For that reason, this
-  # method cannot be relied on to enforce timeouts for untrusted blocks.
-  #
-  # If a scheduler is defined, it will be used to handle the timeout by invoking
-  # Scheduler#timeout_after.
-  #
-  # Note that this is both a method of module Timeout, so you can <tt>include
-  # Timeout</tt> into your classes so they have a #timeout method, as well as
-  # a module method, so you can call it directly as Timeout.timeout().
-  def timeout(sec, klass = nil, message = nil, &block)   #:yield: +sec+
-    return yield(sec) if sec == nil or sec.zero?
-    raise ArgumentError, "Timeout sec must be a non-negative number" if 0 > sec
-
-    message ||= "execution expired"
-
-    if Fiber.respond_to?(:current_scheduler) && (scheduler = Fiber.current_scheduler)&.respond_to?(:timeout_after)
-      perform = Proc.new do |exc|
-        scheduler.timeout_after(sec, exc, message, &block)
-      end
-    else
-      Timeout.ensure_timeout_thread_created
-      perform = Proc.new do |exc|
-        request = Request.new(Thread.current, sec, exc, message)
-        QUEUE_MUTEX.synchronize do
-          QUEUE << request
-          CONDVAR.signal
-        end
-        begin
-          return yield(sec)
-        ensure
-          request.finished
-        end
-      end
-    end
-
-    if klass
-      perform.call(klass)
-    else
-      Error.handle_timeout(message, &perform)
-    end
-  end
-  module_function :timeout
-end

package/lib/ruby/3.4.11/tmpdir.gemspec

@@ -1,30 +0,0 @@
-Gem::Specification.new do |spec|
-  spec.name          = "tmpdir"
-  spec.version       = "0.3.1"
-  spec.authors       = ["Yukihiro Matsumoto"]
-  spec.email         = ["matz@ruby-lang.org"]
-
-  spec.summary       = %q{Extends the Dir class to manage the OS temporary file path.}
-  spec.description   = %q{Extends the Dir class to manage the OS temporary file path.}
-  spec.homepage      = "https://github.com/ruby/tmpdir"
-  spec.licenses      = ["Ruby", "BSD-2-Clause"]
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  gemspec = File.basename(__FILE__)
-  spec.files = IO.popen(%w[git ls-files -z], chdir: __dir__, err: IO::NULL, exception: false) do |ls|
-    ls.readlines("\x0", chomp: true).reject do |f|
-      (f == gemspec) ||
-        f.start_with?(*%w[bin/ test/ spec/ features/ .git Gemfile])
-    end
-  end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_dependency "fileutils"
-end

package/lib/ruby/3.4.11/tmpdir.rb

@@ -1,189 +0,0 @@
-# frozen_string_literal: true
-#
-# tmpdir - retrieve temporary directory path
-#
-# $Id$
-#
-
-require 'fileutils'
-begin
-  require 'etc.so'
-rescue LoadError # rescue LoadError for miniruby
-end
-
-class Dir
-
-  # Class variables are inaccessible from non-main Ractor.
-  # And instance variables too, in Ruby 3.0.
-
-  ##
-  # Returns the operating system's temporary file path.
-  #
-  #   require 'tmpdir'
-  #   Dir.tmpdir # => "/tmp"
-
-  def self.tmpdir
-    Tmpname::TMPDIR_CANDIDATES.find do |name, dir|
-      unless dir
-        next if !(dir = ENV[name] rescue next) or dir.empty?
-      end
-      dir = File.expand_path(dir)
-      stat = File.stat(dir) rescue next
-      case
-      when !stat.directory?
-        warn "#{name} is not a directory: #{dir}"
-      when !File.writable?(dir)
-        # We call File.writable?, not stat.writable?, because you can't tell if a dir is actually
-        # writable just from stat; OS mechanisms other than user/group/world bits can affect this.
-        warn "#{name} is not writable: #{dir}"
-      when stat.world_writable? && !stat.sticky?
-        warn "#{name} is world-writable: #{dir}"
-      else
-        break dir
-      end
-    end or raise ArgumentError, "could not find a temporary directory"
-  end
-
-  # Dir.mktmpdir creates a temporary directory.
-  #
-  #   require 'tmpdir'
-  #   Dir.mktmpdir {|dir|
-  #     # use the directory
-  #   }
-  #
-  # The directory is created with 0700 permission.
-  # Application should not change the permission to make the temporary directory accessible from other users.
-  #
-  # The prefix and suffix of the name of the directory is specified by
-  # the optional first argument, <i>prefix_suffix</i>.
-  # - If it is not specified or nil, "d" is used as the prefix and no suffix is used.
-  # - If it is a string, it is used as the prefix and no suffix is used.
-  # - If it is an array, first element is used as the prefix and second element is used as a suffix.
-  #
-  #  Dir.mktmpdir {|dir| dir is ".../d..." }
-  #  Dir.mktmpdir("foo") {|dir| dir is ".../foo..." }
-  #  Dir.mktmpdir(["foo", "bar"]) {|dir| dir is ".../foo...bar" }
-  #
-  # The directory is created under Dir.tmpdir or
-  # the optional second argument <i>tmpdir</i> if non-nil value is given.
-  #
-  #  Dir.mktmpdir {|dir| dir is "#{Dir.tmpdir}/d..." }
-  #  Dir.mktmpdir(nil, "/var/tmp") {|dir| dir is "/var/tmp/d..." }
-  #
-  # If a block is given,
-  # it is yielded with the path of the directory.
-  # The directory and its contents are removed
-  # using FileUtils.remove_entry before Dir.mktmpdir returns.
-  # The value of the block is returned.
-  #
-  #  Dir.mktmpdir {|dir|
-  #    # use the directory...
-  #    open("#{dir}/foo", "w") { something using the file }
-  #  }
-  #
-  # If a block is not given,
-  # The path of the directory is returned.
-  # In this case, Dir.mktmpdir doesn't remove the directory.
-  #
-  #  dir = Dir.mktmpdir
-  #  begin
-  #    # use the directory...
-  #    open("#{dir}/foo", "w") { something using the file }
-  #  ensure
-  #    # remove the directory.
-  #    FileUtils.remove_entry dir
-  #  end
-  #
-  def self.mktmpdir(prefix_suffix=nil, *rest, **options, &block)
-    base = nil
-    path = Tmpname.create(prefix_suffix || "d", *rest, **options) {|path, _, _, d|
-      base = d
-      mkdir(path, 0700)
-    }
-    if block
-      begin
-        yield path.dup
-      ensure
-        unless base
-          base = File.dirname(path)
-          stat = File.stat(base)
-          if stat.world_writable? and !stat.sticky?
-            raise ArgumentError, "parent directory is world writable but not sticky: #{base}"
-          end
-        end
-        FileUtils.remove_entry path
-      end
-    else
-      path
-    end
-  end
-
-  # Temporary name generator
-  module Tmpname # :nodoc:
-    module_function
-
-    # System-wide temporary directory path
-    systmpdir = (defined?(Etc.systmpdir) ? Etc.systmpdir.freeze : '/tmp')
-
-    # Temporary directory candidates consisting of environment variable
-    # names or description and path pairs.
-    TMPDIR_CANDIDATES = [
-      'TMPDIR', 'TMP', 'TEMP',
-      ['system temporary path', systmpdir],
-      %w[/tmp /tmp],
-      %w[. .],
-    ].each(&:freeze).freeze
-
-    def tmpdir
-      Dir.tmpdir
-    end
-
-    # Unusable characters as path name
-    UNUSABLE_CHARS = "^,-.0-9A-Z_a-z~"
-
-    # Dedicated random number generator
-    RANDOM = Object.new
-    class << RANDOM # :nodoc:
-      # Maximum random number
-      MAX = 36**6 # < 0x100000000
-
-      # Returns new random string upto 6 bytes
-      def next
-        (::Random.urandom(4).unpack1("L")%MAX).to_s(36)
-      end
-    end
-    RANDOM.freeze
-    private_constant :RANDOM
-
-    # Generates and yields random names to create a temporary name
-    def create(basename, tmpdir=nil, max_try: nil, **opts)
-      if tmpdir
-        origdir = tmpdir = File.path(tmpdir)
-        raise ArgumentError, "empty parent path" if tmpdir.empty?
-      else
-        tmpdir = tmpdir()
-      end
-      n = nil
-      prefix, suffix = basename
-      prefix = (String.try_convert(prefix) or
-                raise ArgumentError, "unexpected prefix: #{prefix.inspect}")
-      prefix = prefix.delete(UNUSABLE_CHARS)
-      suffix &&= (String.try_convert(suffix) or
-                  raise ArgumentError, "unexpected suffix: #{suffix.inspect}")
-      suffix &&= suffix.delete(UNUSABLE_CHARS)
-      begin
-        t = Time.now.strftime("%Y%m%d")
-        path = "#{prefix}#{t}-#{$$}-#{RANDOM.next}"\
-               "#{n ? %[-#{n}] : ''}#{suffix||''}"
-        path = File.join(tmpdir, path)
-        yield(path, n, opts, origdir)
-      rescue Errno::EEXIST
-        n ||= 0
-        n += 1
-        retry if !max_try or n < max_try
-        raise "cannot generate temporary name using '#{basename}' under '#{tmpdir}'"
-      end
-      path
-    end
-  end
-end

package/lib/ruby/3.4.11/tsort.gemspec

@@ -1,29 +0,0 @@
-name = File.basename(__FILE__, ".gemspec")
-version = ["lib", Array.new(name.count("-")+1).join("/")].find do |dir|
-  break File.foreach(File.join(__dir__, dir, "#{name.tr('-', '/')}.rb")) do |line|
-    /^\s*VERSION\s*=\s*"(.*)"/ =~ line and break $1
-  end rescue nil
-end
-
-Gem::Specification.new do |spec|
-  spec.name          = name
-  spec.version       = version
-  spec.authors       = ["Tanaka Akira"]
-  spec.email         = ["akr@fsij.org"]
-
-  spec.summary       = %q{Topological sorting using Tarjan's algorithm}
-  spec.description   = %q{Topological sorting using Tarjan's algorithm}
-  spec.homepage      = "https://github.com/ruby/tsort"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
-  spec.licenses      = ["Ruby", "BSD-2-Clause"]
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-end