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

package/lib/ruby/3.4.11/rubygems/vendor/molinillo/lib/molinillo/errors.rb

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-module Gem::Molinillo
-  # An error that occurred during the resolution process
-  class ResolverError < StandardError; end
-
-  # An error caused by searching for a dependency that is completely unknown,
-  # i.e. has no versions available whatsoever.
-  class NoSuchDependencyError < ResolverError
-    # @return [Object] the dependency that could not be found
-    attr_accessor :dependency
-
-    # @return [Array<Object>] the specifications that depended upon {#dependency}
-    attr_accessor :required_by
-
-    # Initializes a new error with the given missing dependency.
-    # @param [Object] dependency @see {#dependency}
-    # @param [Array<Object>] required_by @see {#required_by}
-    def initialize(dependency, required_by = [])
-      @dependency = dependency
-      @required_by = required_by.uniq
-      super()
-    end
-
-    # The error message for the missing dependency, including the specifications
-    # that had this dependency.
-    def message
-      sources = required_by.map { |r| "`#{r}`" }.join(' and ')
-      message = "Unable to find a specification for `#{dependency}`"
-      message += " depended upon by #{sources}" unless sources.empty?
-      message
-    end
-  end
-
-  # An error caused by attempting to fulfil a dependency that was circular
-  #
-  # @note This exception will be thrown if and only if a {Vertex} is added to a
-  #   {DependencyGraph} that has a {DependencyGraph::Vertex#path_to?} an
-  #   existing {DependencyGraph::Vertex}
-  class CircularDependencyError < ResolverError
-    # [Set<Object>] the dependencies responsible for causing the error
-    attr_reader :dependencies
-
-    # Initializes a new error with the given circular vertices.
-    # @param [Array<DependencyGraph::Vertex>] vertices the vertices in the dependency
-    #   that caused the error
-    def initialize(vertices)
-      super "There is a circular dependency between #{vertices.map(&:name).join(' and ')}"
-      @dependencies = vertices.map { |vertex| vertex.payload.possibilities.last }.to_set
-    end
-  end
-
-  # An error caused by conflicts in version
-  class VersionConflict < ResolverError
-    # @return [{String => Resolution::Conflict}] the conflicts that caused
-    #   resolution to fail
-    attr_reader :conflicts
-
-    # @return [SpecificationProvider] the specification provider used during
-    #   resolution
-    attr_reader :specification_provider
-
-    # Initializes a new error with the given version conflicts.
-    # @param [{String => Resolution::Conflict}] conflicts see {#conflicts}
-    # @param [SpecificationProvider] specification_provider see {#specification_provider}
-    def initialize(conflicts, specification_provider)
-      pairs = []
-      conflicts.values.flat_map(&:requirements).each do |conflicting|
-        conflicting.each do |source, conflict_requirements|
-          conflict_requirements.each do |c|
-            pairs << [c, source]
-          end
-        end
-      end
-
-      super "Unable to satisfy the following requirements:\n\n" \
-        "#{pairs.map { |r, d| "- `#{r}` required by `#{d}`" }.join("\n")}"
-
-      @conflicts = conflicts
-      @specification_provider = specification_provider
-    end
-
-    require_relative 'delegates/specification_provider'
-    include Delegates::SpecificationProvider
-
-    # @return [String] An error message that includes requirement trees,
-    #   which is much more detailed & customizable than the default message
-    # @param [Hash] opts the options to create a message with.
-    # @option opts [String] :solver_name The user-facing name of the solver
-    # @option opts [String] :possibility_type The generic name of a possibility
-    # @option opts [Proc] :reduce_trees A proc that reduced the list of requirement trees
-    # @option opts [Proc] :printable_requirement A proc that pretty-prints requirements
-    # @option opts [Proc] :additional_message_for_conflict A proc that appends additional
-    #   messages for each conflict
-    # @option opts [Proc] :version_for_spec A proc that returns the version number for a
-    #   possibility
-    def message_with_trees(opts = {})
-      solver_name = opts.delete(:solver_name) { self.class.name.split('::').first }
-      possibility_type = opts.delete(:possibility_type) { 'possibility named' }
-      reduce_trees = opts.delete(:reduce_trees) { proc { |trees| trees.uniq.sort_by(&:to_s) } }
-      printable_requirement = opts.delete(:printable_requirement) { proc { |req| req.to_s } }
-      additional_message_for_conflict = opts.delete(:additional_message_for_conflict) { proc {} }
-      version_for_spec = opts.delete(:version_for_spec) { proc(&:to_s) }
-      incompatible_version_message_for_conflict = opts.delete(:incompatible_version_message_for_conflict) do
-        proc do |name, _conflict|
-          %(#{solver_name} could not find compatible versions for #{possibility_type} "#{name}":)
-        end
-      end
-
-      full_message_for_conflict = opts.delete(:full_message_for_conflict) do
-        proc do |name, conflict|
-          o = "\n".dup << incompatible_version_message_for_conflict.call(name, conflict) << "\n"
-          if conflict.locked_requirement
-            o << %(  In snapshot (#{name_for_locking_dependency_source}):\n)
-            o << %(    #{printable_requirement.call(conflict.locked_requirement)}\n)
-            o << %(\n)
-          end
-          o << %(  In #{name_for_explicit_dependency_source}:\n)
-          trees = reduce_trees.call(conflict.requirement_trees)
-
-          o << trees.map do |tree|
-            t = ''.dup
-            depth = 2
-            tree.each do |req|
-              t << '  ' * depth << printable_requirement.call(req)
-              unless tree.last == req
-                if spec = conflict.activated_by_name[name_for(req)]
-                  t << %( was resolved to #{version_for_spec.call(spec)}, which)
-                end
-                t << %( depends on)
-              end
-              t << %(\n)
-              depth += 1
-            end
-            t
-          end.join("\n")
-
-          additional_message_for_conflict.call(o, name, conflict)
-
-          o
-        end
-      end
-
-      conflicts.sort.reduce(''.dup) do |o, (name, conflict)|
-        o << full_message_for_conflict.call(name, conflict)
-      end.strip
-    end
-  end
-end

package/lib/ruby/3.4.11/rubygems/vendor/molinillo/lib/molinillo/gem_metadata.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module Gem::Molinillo
-  # The version of Gem::Molinillo.
-  VERSION = '0.8.0'.freeze
-end

package/lib/ruby/3.4.11/rubygems/vendor/molinillo/lib/molinillo/modules/specification_provider.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module Gem::Molinillo
-  # Provides information about specifications and dependencies to the resolver,
-  # allowing the {Resolver} class to remain generic while still providing power
-  # and flexibility.
-  #
-  # This module contains the methods that users of Gem::Molinillo must to implement,
-  # using knowledge of their own model classes.
-  module SpecificationProvider
-    # Search for the specifications that match the given dependency.
-    # The specifications in the returned array will be considered in reverse
-    # order, so the latest version ought to be last.
-    # @note This method should be 'pure', i.e. the return value should depend
-    #   only on the `dependency` parameter.
-    #
-    # @param [Object] dependency
-    # @return [Array<Object>] the specifications that satisfy the given
-    #   `dependency`.
-    def search_for(dependency)
-      []
-    end
-
-    # Returns the dependencies of `specification`.
-    # @note This method should be 'pure', i.e. the return value should depend
-    #   only on the `specification` parameter.
-    #
-    # @param [Object] specification
-    # @return [Array<Object>] the dependencies that are required by the given
-    #   `specification`.
-    def dependencies_for(specification)
-      []
-    end
-
-    # Determines whether the given `requirement` is satisfied by the given
-    # `spec`, in the context of the current `activated` dependency graph.
-    #
-    # @param [Object] requirement
-    # @param [DependencyGraph] activated the current dependency graph in the
-    #   resolution process.
-    # @param [Object] spec
-    # @return [Boolean] whether `requirement` is satisfied by `spec` in the
-    #   context of the current `activated` dependency graph.
-    def requirement_satisfied_by?(requirement, activated, spec)
-      true
-    end
-
-    # Determines whether two arrays of dependencies are equal, and thus can be
-    # grouped.
-    #
-    # @param [Array<Object>] dependencies
-    # @param [Array<Object>] other_dependencies
-    # @return [Boolean] whether `dependencies` and `other_dependencies` should
-    #   be considered equal.
-    def dependencies_equal?(dependencies, other_dependencies)
-      dependencies == other_dependencies
-    end
-
-    # Returns the name for the given `dependency`.
-    # @note This method should be 'pure', i.e. the return value should depend
-    #   only on the `dependency` parameter.
-    #
-    # @param [Object] dependency
-    # @return [String] the name for the given `dependency`.
-    def name_for(dependency)
-      dependency.to_s
-    end
-
-    # @return [String] the name of the source of explicit dependencies, i.e.
-    #   those passed to {Resolver#resolve} directly.
-    def name_for_explicit_dependency_source
-      'user-specified dependency'
-    end
-
-    # @return [String] the name of the source of 'locked' dependencies, i.e.
-    #   those passed to {Resolver#resolve} directly as the `base`
-    def name_for_locking_dependency_source
-      'Lockfile'
-    end
-
-    # Sort dependencies so that the ones that are easiest to resolve are first.
-    # Easiest to resolve is (usually) defined by:
-    #   1) Is this dependency already activated?
-    #   2) How relaxed are the requirements?
-    #   3) Are there any conflicts for this dependency?
-    #   4) How many possibilities are there to satisfy this dependency?
-    #
-    # @param [Array<Object>] dependencies
-    # @param [DependencyGraph] activated the current dependency graph in the
-    #   resolution process.
-    # @param [{String => Array<Conflict>}] conflicts
-    # @return [Array<Object>] a sorted copy of `dependencies`.
-    def sort_dependencies(dependencies, activated, conflicts)
-      dependencies.sort_by do |dependency|
-        name = name_for(dependency)
-        [
-          activated.vertex_named(name).payload ? 0 : 1,
-          conflicts[name] ? 0 : 1,
-        ]
-      end
-    end
-
-    # Returns whether this dependency, which has no possible matching
-    # specifications, can safely be ignored.
-    #
-    # @param [Object] dependency
-    # @return [Boolean] whether this dependency can safely be skipped.
-    def allow_missing?(dependency)
-      false
-    end
-  end
-end

package/lib/ruby/3.4.11/rubygems/vendor/molinillo/lib/molinillo/modules/ui.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module Gem::Molinillo
-  # Conveys information about the resolution process to a user.
-  module UI
-    # The {IO} object that should be used to print output. `STDOUT`, by default.
-    #
-    # @return [IO]
-    def output
-      STDOUT
-    end
-
-    # Called roughly every {#progress_rate}, this method should convey progress
-    # to the user.
-    #
-    # @return [void]
-    def indicate_progress
-      output.print '.' unless debug?
-    end
-
-    # How often progress should be conveyed to the user via
-    # {#indicate_progress}, in seconds. A third of a second, by default.
-    #
-    # @return [Float]
-    def progress_rate
-      0.33
-    end
-
-    # Called before resolution begins.
-    #
-    # @return [void]
-    def before_resolution
-      output.print 'Resolving dependencies...'
-    end
-
-    # Called after resolution ends (either successfully or with an error).
-    # By default, prints a newline.
-    #
-    # @return [void]
-    def after_resolution
-      output.puts
-    end
-
-    # Conveys debug information to the user.
-    #
-    # @param [Integer] depth the current depth of the resolution process.
-    # @return [void]
-    def debug(depth = 0)
-      if debug?
-        debug_info = yield
-        debug_info = debug_info.inspect unless debug_info.is_a?(String)
-        debug_info = debug_info.split("\n").map { |s| ":#{depth.to_s.rjust 4}: #{s}" }
-        output.puts debug_info
-      end
-    end
-
-    # Whether or not debug messages should be printed.
-    # By default, whether or not the `MOLINILLO_DEBUG` environment variable is
-    # set.
-    #
-    # @return [Boolean]
-    def debug?
-      return @debug_mode if defined?(@debug_mode)
-      @debug_mode = ENV['MOLINILLO_DEBUG']
-    end
-  end
-end