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

package/lib/ruby/3.4.11/bundler/vendor/pub_grub/lib/pub_grub/version_union.rb

@@ -1,178 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler::PubGrub
-  class VersionUnion
-    attr_reader :ranges
-
-    def self.normalize_ranges(ranges)
-      ranges = ranges.flat_map do |range|
-        range.ranges
-      end
-
-      ranges.reject!(&:empty?)
-
-      return [] if ranges.empty?
-
-      mins, ranges = ranges.partition { |r| !r.min }
-      original_ranges = mins + ranges.sort_by { |r| [r.min, r.include_min ? 0 : 1] }
-      ranges = [original_ranges.shift]
-      original_ranges.each do |range|
-        if ranges.last.contiguous_to?(range)
-          ranges << ranges.pop.span(range)
-        else
-          ranges << range
-        end
-      end
-
-      ranges
-    end
-
-    def self.union(ranges, normalize: true)
-      ranges = normalize_ranges(ranges) if normalize
-
-      if ranges.size == 0
-        VersionRange.empty
-      elsif ranges.size == 1
-        ranges[0]
-      else
-        new(ranges)
-      end
-    end
-
-    def initialize(ranges)
-      raise ArgumentError unless ranges.all? { |r| r.instance_of?(VersionRange) }
-      @ranges = ranges
-    end
-
-    def hash
-      ranges.hash
-    end
-
-    def eql?(other)
-      ranges.eql?(other.ranges)
-    end
-
-    def include?(version)
-      !!ranges.bsearch {|r| r.compare_version(version) }
-    end
-
-    def select_versions(all_versions)
-      versions = []
-      ranges.inject(all_versions) do |acc, range|
-        _, matching, higher = range.partition_versions(acc)
-        versions.concat matching
-        higher
-      end
-      versions
-    end
-
-    def intersects?(other)
-      my_ranges = ranges.dup
-      other_ranges = other.ranges.dup
-
-      my_range = my_ranges.shift
-      other_range = other_ranges.shift
-      while my_range && other_range
-        if my_range.intersects?(other_range)
-          return true
-        end
-
-        if !my_range.max || other_range.empty? || (other_range.max && other_range.max < my_range.max)
-          other_range = other_ranges.shift
-        else
-          my_range = my_ranges.shift
-        end
-      end
-    end
-    alias_method :allows_any?, :intersects?
-
-    def allows_all?(other)
-      my_ranges = ranges.dup
-
-      my_range = my_ranges.shift
-
-      other.ranges.all? do |other_range|
-        while my_range
-          break if my_range.allows_all?(other_range)
-          my_range = my_ranges.shift
-        end
-
-        !!my_range
-      end
-    end
-
-    def empty?
-      false
-    end
-
-    def any?
-      false
-    end
-
-    def intersect(other)
-      my_ranges = ranges.dup
-      other_ranges = other.ranges.dup
-      new_ranges = []
-
-      my_range = my_ranges.shift
-      other_range = other_ranges.shift
-      while my_range && other_range
-        new_ranges << my_range.intersect(other_range)
-
-        if !my_range.max || other_range.empty? || (other_range.max && other_range.max < my_range.max)
-          other_range = other_ranges.shift
-        else
-          my_range = my_ranges.shift
-        end
-      end
-      new_ranges.reject!(&:empty?)
-      VersionUnion.union(new_ranges, normalize: false)
-    end
-
-    def upper_invert
-      ranges.last.upper_invert
-    end
-
-    def invert
-      ranges.map(&:invert).inject(:intersect)
-    end
-
-    def union(other)
-      VersionUnion.union([self, other])
-    end
-
-    def to_s
-      output = []
-
-      ranges = self.ranges.dup
-      while !ranges.empty?
-        ne = []
-        range = ranges.shift
-        while !ranges.empty? && ranges[0].min.to_s == range.max.to_s
-          ne << range.max
-          range = range.span(ranges.shift)
-        end
-
-        ne.map! {|x| "!= #{x}" }
-        if ne.empty?
-          output << range.to_s
-        elsif range.any?
-          output << ne.join(', ')
-        else
-          output << "#{range}, #{ne.join(', ')}"
-        end
-      end
-
-      output.join(" OR ")
-    end
-
-    def inspect
-      "#<#{self.class} #{to_s}>"
-    end
-
-    def ==(other)
-      self.class == other.class &&
-        self.ranges == other.ranges
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/vendor/pub_grub/lib/pub_grub.rb

@@ -1,31 +0,0 @@
-require_relative "pub_grub/package"
-require_relative "pub_grub/static_package_source"
-require_relative "pub_grub/term"
-require_relative "pub_grub/version_range"
-require_relative "pub_grub/version_constraint"
-require_relative "pub_grub/version_union"
-require_relative "pub_grub/version_solver"
-require_relative "pub_grub/incompatibility"
-require_relative 'pub_grub/solve_failure'
-require_relative 'pub_grub/failure_writer'
-require_relative 'pub_grub/version'
-
-module Bundler::PubGrub
-  class << self
-    attr_writer :logger
-
-    def logger
-      @logger || default_logger
-    end
-
-    private
-
-    def default_logger
-      require "logger"
-
-      logger = ::Logger.new(STDERR)
-      logger.level = $DEBUG ? ::Logger::DEBUG : ::Logger::WARN
-      @logger = logger
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/vendor/securerandom/.document

@@ -1 +0,0 @@
-# Vendored files do not need to be documented

package/lib/ruby/3.4.11/bundler/vendor/securerandom/lib/securerandom.rb

@@ -1,102 +0,0 @@
-# -*- coding: us-ascii -*-
-# frozen_string_literal: true
-
-require 'random/formatter'
-
-# == Secure random number generator interface.
-#
-# This library is an interface to secure random number generators which are
-# suitable for generating session keys in HTTP cookies, etc.
-#
-# You can use this library in your application by requiring it:
-#
-#   require 'bundler/vendor/securerandom/lib/securerandom'
-#
-# It supports the following secure random number generators:
-#
-# * openssl
-# * /dev/urandom
-# * Win32
-#
-# Bundler::SecureRandom is extended by the Random::Formatter module which
-# defines the following methods:
-#
-# * alphanumeric
-# * base64
-# * choose
-# * gen_random
-# * hex
-# * rand
-# * random_bytes
-# * random_number
-# * urlsafe_base64
-# * uuid
-#
-# These methods are usable as class methods of Bundler::SecureRandom such as
-# +Bundler::SecureRandom.hex+.
-#
-# If a secure random number generator is not available,
-# +NotImplementedError+ is raised.
-
-module Bundler::SecureRandom
-
-  # The version
-  VERSION = "0.4.1"
-
-  class << self
-    # Returns a random binary string containing +size+ bytes.
-    #
-    # See Random.bytes
-    def bytes(n)
-      return gen_random(n)
-    end
-
-    # Compatibility methods for Ruby 3.2, we can remove this after dropping to support Ruby 3.2
-    def alphanumeric(n = nil, chars: ALPHANUMERIC)
-      n = 16 if n.nil?
-      choose(chars, n)
-    end if RUBY_VERSION < '3.3'
-
-    private
-
-    # :stopdoc:
-
-    # Implementation using OpenSSL
-    def gen_random_openssl(n)
-      return OpenSSL::Random.random_bytes(n)
-    end
-
-    # Implementation using system random device
-    def gen_random_urandom(n)
-      ret = Random.urandom(n)
-      unless ret
-        raise NotImplementedError, "No random device"
-      end
-      unless ret.length == n
-        raise NotImplementedError, "Unexpected partial read from random device: only #{ret.length} for #{n} bytes"
-      end
-      ret
-    end
-
-    begin
-      # Check if Random.urandom is available
-      Random.urandom(1)
-      alias gen_random gen_random_urandom
-    rescue RuntimeError
-      begin
-        require 'openssl'
-      rescue NoMethodError
-        raise NotImplementedError, "No random device"
-      else
-        alias gen_random gen_random_openssl
-      end
-    end
-
-    # :startdoc:
-
-    # Generate random data bytes for Random::Formatter
-    public :gen_random
-  end
-end
-
-Bundler::SecureRandom.extend(Random::Formatter)

package/lib/ruby/3.4.11/bundler/vendor/thor/.document

@@ -1 +0,0 @@
-# Vendored files do not need to be documented

package/lib/ruby/3.4.11/bundler/vendor/thor/lib/thor/actions/create_file.rb

@@ -1,105 +0,0 @@
-require_relative "empty_directory"
-
-class Bundler::Thor
-  module Actions
-    # Create a new file relative to the destination root with the given data,
-    # which is the return value of a block or a data string.
-    #
-    # ==== Parameters
-    # destination<String>:: the relative path to the destination root.
-    # data<String|NilClass>:: the data to append to the file.
-    # config<Hash>:: give :verbose => false to not log the status.
-    #
-    # ==== Examples
-    #
-    #   create_file "lib/fun_party.rb" do
-    #     hostname = ask("What is the virtual hostname I should use?")
-    #     "vhost.name = #{hostname}"
-    #   end
-    #
-    #   create_file "config/apache.conf", "your apache config"
-    #
-    def create_file(destination, *args, &block)
-      config = args.last.is_a?(Hash) ? args.pop : {}
-      data = args.first
-      action CreateFile.new(self, destination, block || data.to_s, config)
-    end
-    alias_method :add_file, :create_file
-
-    # CreateFile is a subset of Template, which instead of rendering a file with
-    # ERB, it gets the content from the user.
-    #
-    class CreateFile < EmptyDirectory #:nodoc:
-      attr_reader :data
-
-      def initialize(base, destination, data, config = {})
-        @data = data
-        super(base, destination, config)
-      end
-
-      # Checks if the content of the file at the destination is identical to the rendered result.
-      #
-      # ==== Returns
-      # Boolean:: true if it is identical, false otherwise.
-      #
-      def identical?
-        # binread uses ASCII-8BIT, so to avoid false negatives, the string must use the same
-        exists? && File.binread(destination) == String.new(render).force_encoding("ASCII-8BIT")
-      end
-
-      # Holds the content to be added to the file.
-      #
-      def render
-        @render ||= if data.is_a?(Proc)
-          data.call
-        else
-          data
-        end
-      end
-
-      def invoke!
-        invoke_with_conflict_check do
-          require "fileutils"
-          FileUtils.mkdir_p(File.dirname(destination))
-          File.open(destination, "wb", config[:perm]) { |f| f.write render }
-        end
-        given_destination
-      end
-
-    protected
-
-      # Now on conflict we check if the file is identical or not.
-      #
-      def on_conflict_behavior(&block)
-        if identical?
-          say_status :identical, :blue
-        else
-          options = base.options.merge(config)
-          force_or_skip_or_conflict(options[:force], options[:skip], &block)
-        end
-      end
-
-      # If force is true, run the action, otherwise check if it's not being
-      # skipped. If both are false, show the file_collision menu, if the menu
-      # returns true, force it, otherwise skip.
-      #
-      def force_or_skip_or_conflict(force, skip, &block)
-        if force
-          say_status :force, :yellow
-          yield unless pretend?
-        elsif skip
-          say_status :skip, :yellow
-        else
-          say_status :conflict, :red
-          force_or_skip_or_conflict(force_on_collision?, true, &block)
-        end
-      end
-
-      # Shows the file collision menu to the user and gets the result.
-      #
-      def force_on_collision?
-        base.shell.file_collision(destination) { render }
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/vendor/thor/lib/thor/actions/create_link.rb

@@ -1,61 +0,0 @@
-require_relative "create_file"
-
-class Bundler::Thor
-  module Actions
-    # Create a new file relative to the destination root from the given source.
-    #
-    # ==== Parameters
-    # destination<String>:: the relative path to the destination root.
-    # source<String|NilClass>:: the relative path to the source root.
-    # config<Hash>:: give :verbose => false to not log the status.
-    #   :: give :symbolic => false for hard link.
-    #
-    # ==== Examples
-    #
-    #   create_link "config/apache.conf", "/etc/apache.conf"
-    #
-    def create_link(destination, *args)
-      config = args.last.is_a?(Hash) ? args.pop : {}
-      source = args.first
-      action CreateLink.new(self, destination, source, config)
-    end
-    alias_method :add_link, :create_link
-
-    # CreateLink is a subset of CreateFile, which instead of taking a block of
-    # data, just takes a source string from the user.
-    #
-    class CreateLink < CreateFile #:nodoc:
-      attr_reader :data
-
-      # Checks if the content of the file at the destination is identical to the rendered result.
-      #
-      # ==== Returns
-      # Boolean:: true if it is identical, false otherwise.
-      #
-      def identical?
-        source = File.expand_path(render, File.dirname(destination))
-        exists? && File.identical?(source, destination)
-      end
-
-      def invoke!
-        invoke_with_conflict_check do
-          require "fileutils"
-          FileUtils.mkdir_p(File.dirname(destination))
-          # Create a symlink by default
-          config[:symbolic] = true if config[:symbolic].nil?
-          File.unlink(destination) if exists?
-          if config[:symbolic]
-            File.symlink(render, destination)
-          else
-            File.link(render, destination)
-          end
-        end
-        given_destination
-      end
-
-      def exists?
-        super || File.symlink?(destination)
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/vendor/thor/lib/thor/actions/directory.rb

@@ -1,108 +0,0 @@
-require_relative "empty_directory"
-
-class Bundler::Thor
-  module Actions
-    # Copies recursively the files from source directory to root directory.
-    # If any of the files finishes with .tt, it's considered to be a template
-    # and is placed in the destination without the extension .tt. If any
-    # empty directory is found, it's copied and all .empty_directory files are
-    # ignored. If any file name is wrapped within % signs, the text within
-    # the % signs will be executed as a method and replaced with the returned
-    # value. Let's suppose a doc directory with the following files:
-    #
-    #   doc/
-    #     components/.empty_directory
-    #     README
-    #     rdoc.rb.tt
-    #     %app_name%.rb
-    #
-    # When invoked as:
-    #
-    #   directory "doc"
-    #
-    # It will create a doc directory in the destination with the following
-    # files (assuming that the `app_name` method returns the value "blog"):
-    #
-    #   doc/
-    #     components/
-    #     README
-    #     rdoc.rb
-    #     blog.rb
-    #
-    # <b>Encoded path note:</b> Since Bundler::Thor internals use Object#respond_to? to check if it can
-    # expand %something%, this `something` should be a public method in the class calling
-    # #directory. If a method is private, Bundler::Thor stack raises PrivateMethodEncodedError.
-    #
-    # ==== Parameters
-    # source<String>:: the relative path to the source root.
-    # destination<String>:: the relative path to the destination root.
-    # config<Hash>:: give :verbose => false to not log the status.
-    #                If :recursive => false, does not look for paths recursively.
-    #                If :mode => :preserve, preserve the file mode from the source.
-    #                If :exclude_pattern => /regexp/, prevents copying files that match that regexp.
-    #
-    # ==== Examples
-    #
-    #   directory "doc"
-    #   directory "doc", "docs", :recursive => false
-    #
-    def directory(source, *args, &block)
-      config = args.last.is_a?(Hash) ? args.pop : {}
-      destination = args.first || source
-      action Directory.new(self, source, destination || source, config, &block)
-    end
-
-    class Directory < EmptyDirectory #:nodoc:
-      attr_reader :source
-
-      def initialize(base, source, destination = nil, config = {}, &block)
-        @source = File.expand_path(Dir[Util.escape_globs(base.find_in_source_paths(source.to_s))].first)
-        @block  = block
-        super(base, destination, {recursive: true}.merge(config))
-      end
-
-      def invoke!
-        base.empty_directory given_destination, config
-        execute!
-      end
-
-      def revoke!
-        execute!
-      end
-
-    protected
-
-      def execute!
-        lookup = Util.escape_globs(source)
-        lookup = config[:recursive] ? File.join(lookup, "**") : lookup
-        lookup = file_level_lookup(lookup)
-
-        files(lookup).sort.each do |file_source|
-          next if File.directory?(file_source)
-          next if config[:exclude_pattern] && file_source.match(config[:exclude_pattern])
-          file_destination = File.join(given_destination, file_source.gsub(source, "."))
-          file_destination.gsub!("/./", "/")
-
-          case file_source
-          when /\.empty_directory$/
-            dirname = File.dirname(file_destination).gsub(%r{/\.$}, "")
-            next if dirname == given_destination
-            base.empty_directory(dirname, config)
-          when /#{TEMPLATE_EXTNAME}$/
-            base.template(file_source, file_destination[0..-4], config, &@block)
-          else
-            base.copy_file(file_source, file_destination, config, &@block)
-          end
-        end
-      end
-
-      def file_level_lookup(previous_lookup)
-        File.join(previous_lookup, "*")
-      end
-
-      def files(lookup)
-        Dir.glob(lookup, File::FNM_DOTMATCH)
-      end
-    end
-  end
-end