bundler 2.2.29 → 2.5.16

data/lib/bundler/vendor/molinillo/lib/molinillo/resolver.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'dependency_graph'
-
-module Bundler::Molinillo
-  # This class encapsulates a dependency resolver.
-  # The resolver is responsible for determining which set of dependencies to
-  # activate, with feedback from the {#specification_provider}
-  #
-  #
-  class Resolver
-    require_relative 'resolution'
-
-    # @return [SpecificationProvider] the specification provider used
-    #   in the resolution process
-    attr_reader :specification_provider
-
-    # @return [UI] the UI module used to communicate back to the user
-    #   during the resolution process
-    attr_reader :resolver_ui
-
-    # Initializes a new resolver.
-    # @param  [SpecificationProvider] specification_provider
-    #   see {#specification_provider}
-    # @param  [UI] resolver_ui
-    #   see {#resolver_ui}
-    def initialize(specification_provider, resolver_ui)
-      @specification_provider = specification_provider
-      @resolver_ui = resolver_ui
-    end
-
-    # Resolves the requested dependencies into a {DependencyGraph},
-    # locking to the base dependency graph (if specified)
-    # @param [Array] requested an array of 'requested' dependencies that the
-    #   {#specification_provider} can understand
-    # @param [DependencyGraph,nil] base the base dependency graph to which
-    #   dependencies should be 'locked'
-    def resolve(requested, base = DependencyGraph.new)
-      Resolution.new(specification_provider,
-                     resolver_ui,
-                     requested,
-                     base).
-        resolve
-    end
-  end
-end

data/lib/bundler/vendor/molinillo/lib/molinillo/state.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler::Molinillo
-  # A state that a {Resolution} can be in
-  # @attr [String] name the name of the current requirement
-  # @attr [Array<Object>] requirements currently unsatisfied requirements
-  # @attr [DependencyGraph] activated the graph of activated dependencies
-  # @attr [Object] requirement the current requirement
-  # @attr [Object] possibilities the possibilities to satisfy the current requirement
-  # @attr [Integer] depth the depth of the resolution
-  # @attr [Hash] conflicts unresolved conflicts, indexed by dependency name
-  # @attr [Array<UnwindDetails>] unused_unwind_options unwinds for previous conflicts that weren't explored
-  ResolutionState = Struct.new(
-    :name,
-    :requirements,
-    :activated,
-    :requirement,
-    :possibilities,
-    :depth,
-    :conflicts,
-    :unused_unwind_options
-  )
-
-  class ResolutionState
-    # Returns an empty resolution state
-    # @return [ResolutionState] an empty state
-    def self.empty
-      new(nil, [], DependencyGraph.new, nil, nil, 0, {}, [])
-    end
-  end
-
-  # A state that encapsulates a set of {#requirements} with an {Array} of
-  # possibilities
-  class DependencyState < ResolutionState
-    # Removes a possibility from `self`
-    # @return [PossibilityState] a state with a single possibility,
-    #  the possibility that was removed from `self`
-    def pop_possibility_state
-      PossibilityState.new(
-        name,
-        requirements.dup,
-        activated,
-        requirement,
-        [possibilities.pop],
-        depth + 1,
-        conflicts.dup,
-        unused_unwind_options.dup
-      ).tap do |state|
-        state.activated.tag(state)
-      end
-    end
-  end
-
-  # A state that encapsulates a single possibility to fulfill the given
-  # {#requirement}
-  class PossibilityState < ResolutionState
-  end
-end

data/lib/bundler/vendor/molinillo/lib/molinillo.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'molinillo/gem_metadata'
-require_relative 'molinillo/errors'
-require_relative 'molinillo/resolver'
-require_relative 'molinillo/modules/ui'
-require_relative 'molinillo/modules/specification_provider'
-
-# Bundler::Molinillo is a generic dependency resolution algorithm.
-module Bundler::Molinillo
-end

data/lib/bundler/vendor/tmpdir/lib/tmpdir.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-#
-# tmpdir - retrieve temporary directory path
-#
-# $Id$
-#
-
-require_relative '../../fileutils/lib/fileutils'
-begin
-  require 'etc.so'
-rescue LoadError # rescue LoadError for miniruby
-end
-
-class Bundler::Dir < Dir
-
-  @systmpdir ||= defined?(Etc.systmpdir) ? Etc.systmpdir : '/tmp'
-
-  ##
-  # Returns the operating system's temporary file path.
-
-  def self.tmpdir
-    tmp = nil
-    ['TMPDIR', 'TMP', 'TEMP', ['system temporary path', @systmpdir], ['/tmp']*2, ['.']*2].each do |name, dir = ENV[name]|
-      next if !dir
-      dir = File.expand_path(dir)
-      stat = File.stat(dir) rescue next
-      case
-      when !stat.directory?
-        warn "#{name} is not a directory: #{dir}"
-      when !stat.writable?
-        warn "#{name} is not writable: #{dir}"
-      when stat.world_writable? && !stat.sticky?
-        warn "#{name} is world-writable: #{dir}"
-      else
-        tmp = dir
-        break
-      end
-    end
-    raise ArgumentError, "could not find a temporary directory" unless tmp
-    tmp
-  end
-
-  # Bundler::Dir.mktmpdir creates a temporary 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.
-  #
-  #  Bundler::Dir.mktmpdir {|dir| dir is ".../d..." }
-  #  Bundler::Dir.mktmpdir("foo") {|dir| dir is ".../foo..." }
-  #  Bundler::Dir.mktmpdir(["foo", "bar"]) {|dir| dir is ".../foo...bar" }
-  #
-  # The directory is created under Bundler::Dir.tmpdir or
-  # the optional second argument <i>tmpdir</i> if non-nil value is given.
-  #
-  #  Bundler::Dir.mktmpdir {|dir| dir is "#{Bundler::Dir.tmpdir}/d..." }
-  #  Bundler::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 Bundler::FileUtils.remove_entry before Bundler::Dir.mktmpdir returns.
-  # The value of the block is returned.
-  #
-  #  Bundler::Dir.mktmpdir {|dir|
-  #    # use the directory...
-  #    open("#{dir}/foo", "w") { ... }
-  #  }
-  #
-  # If a block is not given,
-  # The path of the directory is returned.
-  # In this case, Bundler::Dir.mktmpdir doesn't remove the directory.
-  #
-  #  dir = Bundler::Dir.mktmpdir
-  #  begin
-  #    # use the directory...
-  #    open("#{dir}/foo", "w") { ... }
-  #  ensure
-  #    # remove the directory.
-  #    Bundler::FileUtils.remove_entry dir
-  #  end
-  #
-  def self.mktmpdir(prefix_suffix=nil, *rest, **options)
-    base = nil
-    path = Tmpname.create(prefix_suffix || "d", *rest, **options) {|p, _, _, d|
-      base = d
-      mkdir(p, 0700)
-    }
-    if block_given?
-      begin
-        yield path.dup
-      ensure
-        unless base
-          stat = File.stat(File.dirname(path))
-          if stat.world_writable? and !stat.sticky?
-            raise ArgumentError, "parent directory is world writable but not sticky"
-          end
-        end
-        Bundler::FileUtils.remove_entry path
-      end
-    else
-      path
-    end
-  end
-
-  module Tmpname # :nodoc:
-    module_function
-
-    def tmpdir
-      Bundler::Dir.tmpdir
-    end
-
-    UNUSABLE_CHARS = "^,-.0-9A-Z_a-z~"
-
-    class << (RANDOM = Random.new)
-      MAX = 36**6 # < 0x100000000
-      def next
-        rand(MAX).to_s(36)
-      end
-    end
-    private_constant :RANDOM
-
-    def create(basename, tmpdir=nil, max_try: nil, **opts)
-      origdir = tmpdir
-      tmpdir ||= tmpdir()
-      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

data/lib/bundler/version_ranges.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler
-  module VersionRanges
-    NEq = Struct.new(:version)
-    ReqR = Struct.new(:left, :right)
-    class ReqR
-      Endpoint = Struct.new(:version, :inclusive) do
-        def <=>(other)
-          if version.equal?(INFINITY)
-            return 0 if other.version.equal?(INFINITY)
-            return 1
-          elsif other.version.equal?(INFINITY)
-            return -1
-          end
-
-          comp = version <=> other.version
-          return comp unless comp.zero?
-
-          if inclusive && !other.inclusive
-            1
-          elsif !inclusive && other.inclusive
-            -1
-          else
-            0
-          end
-        end
-      end
-
-      def to_s
-        "#{left.inclusive ? "[" : "("}#{left.version}, #{right.version}#{right.inclusive ? "]" : ")"}"
-      end
-      INFINITY = begin
-        inf = Object.new
-        def inf.to_s
-          "∞"
-        end
-        def inf.<=>(other)
-          return 0 if other.equal?(self)
-          1
-        end
-        inf.freeze
-      end
-      ZERO = Gem::Version.new("0.a")
-
-      def cover?(v)
-        return false if left.inclusive && left.version > v
-        return false if !left.inclusive && left.version >= v
-
-        if right.version != INFINITY
-          return false if right.inclusive && right.version < v
-          return false if !right.inclusive && right.version <= v
-        end
-
-        true
-      end
-
-      def empty?
-        left.version == right.version && !(left.inclusive && right.inclusive)
-      end
-
-      def single?
-        left.version == right.version
-      end
-
-      def <=>(other)
-        return -1 if other.equal?(INFINITY)
-
-        comp = left <=> other.left
-        return comp unless comp.zero?
-
-        right <=> other.right
-      end
-
-      UNIVERSAL = ReqR.new(ReqR::Endpoint.new(Gem::Version.new("0.a"), true), ReqR::Endpoint.new(ReqR::INFINITY, false)).freeze
-    end
-
-    def self.for_many(requirements)
-      requirements = requirements.map(&:requirements).flatten(1).map {|r| r.join(" ") }
-      requirements << ">= 0.a" if requirements.empty?
-      requirement = Gem::Requirement.new(requirements)
-      self.for(requirement)
-    end
-
-    def self.for(requirement)
-      ranges = requirement.requirements.map do |op, v|
-        case op
-        when "=" then ReqR.new(ReqR::Endpoint.new(v, true), ReqR::Endpoint.new(v, true))
-        when "!=" then NEq.new(v)
-        when ">=" then ReqR.new(ReqR::Endpoint.new(v, true), ReqR::Endpoint.new(ReqR::INFINITY, false))
-        when ">" then ReqR.new(ReqR::Endpoint.new(v, false), ReqR::Endpoint.new(ReqR::INFINITY, false))
-        when "<" then ReqR.new(ReqR::Endpoint.new(ReqR::ZERO, true), ReqR::Endpoint.new(v, false))
-        when "<=" then ReqR.new(ReqR::Endpoint.new(ReqR::ZERO, true), ReqR::Endpoint.new(v, true))
-        when "~>" then ReqR.new(ReqR::Endpoint.new(v, true), ReqR::Endpoint.new(v.bump, false))
-        else raise "unknown version op #{op} in requirement #{requirement}"
-        end
-      end.uniq
-      ranges, neqs = ranges.partition {|r| !r.is_a?(NEq) }
-
-      [ranges.sort, neqs.map(&:version)]
-    end
-
-    def self.empty?(ranges, neqs)
-      !ranges.reduce(ReqR::UNIVERSAL) do |last_range, curr_range|
-        next false unless last_range
-        next false if curr_range.single? && neqs.include?(curr_range.left.version)
-        next curr_range if last_range.right.version == ReqR::INFINITY
-        case last_range.right.version <=> curr_range.left.version
-        # higher
-        when 1 then next ReqR.new(curr_range.left, last_range.right)
-        # equal
-        when 0
-          if last_range.right.inclusive && curr_range.left.inclusive && !neqs.include?(curr_range.left.version)
-            ReqR.new(curr_range.left, [curr_range.right, last_range.right].max)
-          end
-        # lower
-        when -1 then next false
-        end
-      end
-    end
-  end
-end