bundler-clone 4.0.15

data/lib/bundler/vendor/pub_grub/lib/pub_grub/rubygems.rb

@@ -0,0 +1,45 @@
+module Bundler::PubGrub
+  module RubyGems
+    extend self
+
+    def requirement_to_range(requirement)
+      ranges = requirement.requirements.map do |(op, ver)|
+        case op
+        when "~>"
+          name = "~> #{ver}"
+          bump = ver.class.new(ver.bump.to_s + ".A")
+          VersionRange.new(name: name, min: ver, max: bump, include_min: true)
+        when ">"
+          VersionRange.new(min: ver)
+        when ">="
+          VersionRange.new(min: ver, include_min: true)
+        when "<"
+          VersionRange.new(max: ver)
+        when "<="
+          VersionRange.new(max: ver, include_max: true)
+        when "="
+          VersionRange.new(min: ver, max: ver, include_min: true, include_max: true)
+        when "!="
+          VersionRange.new(min: ver, max: ver, include_min: true, include_max: true).invert
+        else
+          raise "bad version specifier: #{op}"
+        end
+      end
+
+      ranges.inject(&:intersect)
+    end
+
+    def requirement_to_constraint(package, requirement)
+      Bundler::PubGrub::VersionConstraint.new(package, range: requirement_to_range(requirement))
+    end
+
+    def parse_range(dep)
+      requirement_to_range(Gem::Requirement.new(dep))
+    end
+
+    def parse_constraint(package, dep)
+      range = parse_range(dep)
+      Bundler::PubGrub::VersionConstraint.new(package, range: range)
+    end
+  end
+end

data/lib/bundler/vendor/pub_grub/lib/pub_grub/solve_failure.rb

@@ -0,0 +1,19 @@
+require_relative 'failure_writer'
+
+module Bundler::PubGrub
+  class SolveFailure < StandardError
+    attr_reader :incompatibility
+
+    def initialize(incompatibility)
+      @incompatibility = incompatibility
+    end
+
+    def to_s
+      "Could not find compatible versions\n\n#{explanation}"
+    end
+
+    def explanation
+      @explanation ||= FailureWriter.new(@incompatibility).write
+    end
+  end
+end

data/lib/bundler/vendor/pub_grub/lib/pub_grub/static_package_source.rb

@@ -0,0 +1,61 @@
+require_relative 'package'
+require_relative 'rubygems'
+require_relative 'version_constraint'
+require_relative 'incompatibility'
+require_relative 'basic_package_source'
+
+module Bundler::PubGrub
+  class StaticPackageSource < BasicPackageSource
+    class DSL
+      def initialize(packages, root_deps)
+        @packages = packages
+        @root_deps = root_deps
+      end
+
+      def root(deps:)
+        @root_deps.update(deps)
+      end
+
+      def add(name, version, deps: {})
+        version = Gem::Version.new(version)
+        @packages[name] ||= {}
+        raise ArgumentError, "#{name} #{version} declared twice" if @packages[name].key?(version)
+        @packages[name][version] = clean_deps(name, version, deps)
+      end
+
+      private
+
+      # Exclude redundant self-referencing dependencies
+      def clean_deps(name, version, deps)
+        deps.reject {|dep_name, req| name == dep_name && Bundler::PubGrub::RubyGems.parse_range(req).include?(version) }
+      end
+    end
+
+    def initialize
+      @root_deps = {}
+      @packages = {}
+
+      yield DSL.new(@packages, @root_deps)
+
+      super()
+    end
+
+    def all_versions_for(package)
+      @packages[package].keys
+    end
+
+    def root_dependencies
+      @root_deps
+    end
+
+    def dependencies_for(package, version)
+      @packages[package][version]
+    end
+
+    def parse_dependency(package, dependency)
+      return false unless @packages.key?(package)
+
+      Bundler::PubGrub::RubyGems.parse_constraint(package, dependency)
+    end
+  end
+end

data/lib/bundler/vendor/pub_grub/lib/pub_grub/strategy.rb

@@ -0,0 +1,42 @@
+module Bundler::PubGrub
+  class Strategy
+    def initialize(source)
+      @source = source
+
+      @root_package = Package.root
+      @root_version = Package.root_version
+
+      @version_indexes = Hash.new do |h,k|
+        if k == @root_package
+          h[k] = { @root_version => 0 }
+        else
+          h[k] = @source.all_versions_for(k).each.with_index.to_h
+        end
+      end
+    end
+
+    def next_package_and_version(unsatisfied)
+      package, range = next_term_to_try_from(unsatisfied)
+
+      [package, most_preferred_version_of(package, range)]
+    end
+
+    private
+
+    def most_preferred_version_of(package, range)
+      versions = @source.versions_for(package, range)
+
+      indexes = @version_indexes[package]
+      versions.min_by { |version| indexes[version] }
+    end
+
+    def next_term_to_try_from(unsatisfied)
+      unsatisfied.min_by do |package, range|
+        matching_versions = @source.versions_for(package, range)
+        higher_versions = @source.versions_for(package, range.upper_invert)
+
+        [matching_versions.count <= 1 ? 0 : 1, higher_versions.count]
+      end
+    end
+  end
+end

data/lib/bundler/vendor/pub_grub/lib/pub_grub/term.rb

@@ -0,0 +1,105 @@
+module Bundler::PubGrub
+  class Term
+    attr_reader :package, :constraint, :positive
+
+    def initialize(constraint, positive)
+      @constraint = constraint
+      @package = @constraint.package
+      @positive = positive
+    end
+
+    def to_s(allow_every: false)
+      if positive
+        @constraint.to_s(allow_every: allow_every)
+      else
+        "not #{@constraint}"
+      end
+    end
+
+    def hash
+      constraint.hash ^ positive.hash
+    end
+
+    def eql?(other)
+      positive == other.positive &&
+        constraint.eql?(other.constraint)
+    end
+
+    def invert
+      self.class.new(@constraint, !@positive)
+    end
+    alias_method :inverse, :invert
+
+    def intersect(other)
+      raise ArgumentError, "packages must match" if package != other.package
+
+      if positive? && other.positive?
+        self.class.new(constraint.intersect(other.constraint), true)
+      elsif negative? && other.negative?
+        self.class.new(constraint.union(other.constraint), false)
+      else
+        positive = positive? ? self : other
+        negative = negative? ? self : other
+        self.class.new(positive.constraint.intersect(negative.constraint.invert), true)
+      end
+    end
+
+    def difference(other)
+      intersect(other.invert)
+    end
+
+    def relation(other)
+      if positive? && other.positive?
+        constraint.relation(other.constraint)
+      elsif negative? && other.positive?
+        if constraint.allows_all?(other.constraint)
+          :disjoint
+        else
+          :overlap
+        end
+      elsif positive? && other.negative?
+        if !other.constraint.allows_any?(constraint)
+          :subset
+        elsif other.constraint.allows_all?(constraint)
+          :disjoint
+        else
+          :overlap
+        end
+      elsif negative? && other.negative?
+        if constraint.allows_all?(other.constraint)
+          :subset
+        else
+          :overlap
+        end
+      else
+        raise
+      end
+    end
+
+    def normalized_constraint
+      @normalized_constraint ||= positive ? constraint : constraint.invert
+    end
+
+    def satisfies?(other)
+      raise ArgumentError, "packages must match" unless package == other.package
+
+      relation(other) == :subset
+    end
+
+    def positive?
+      @positive
+    end
+
+    def negative?
+      !positive?
+    end
+
+    def empty?
+      @empty ||= normalized_constraint.empty?
+    end
+
+    def inspect
+      "#<#{self.class} #{self}>"
+    end
+  end
+end

data/lib/bundler/vendor/pub_grub/lib/pub_grub/version.rb

@@ -0,0 +1,3 @@
+module Bundler::PubGrub
+  VERSION = "0.5.0"
+end

data/lib/bundler/vendor/pub_grub/lib/pub_grub/version_constraint.rb

@@ -0,0 +1,129 @@
+require_relative 'version_range'
+
+module Bundler::PubGrub
+  class VersionConstraint
+    attr_reader :package, :range
+
+    # @param package [Bundler::PubGrub::Package]
+    # @param range [Bundler::PubGrub::VersionRange]
+    def initialize(package, range: nil)
+      @package = package
+      @range = range
+    end
+
+    def hash
+      package.hash ^ range.hash
+    end
+
+    def ==(other)
+      package == other.package &&
+        range == other.range
+    end
+
+    def eql?(other)
+      package.eql?(other.package) &&
+        range.eql?(other.range)
+    end
+
+    class << self
+      def exact(package, version)
+        range = VersionRange.new(min: version, max: version, include_min: true, include_max: true)
+        new(package, range: range)
+      end
+
+      def any(package)
+        new(package, range: VersionRange.any)
+      end
+
+      def empty(package)
+        new(package, range: VersionRange.empty)
+      end
+    end
+
+    def intersect(other)
+      unless package == other.package
+        raise ArgumentError, "Can only intersect between VersionConstraint of the same package"
+      end
+
+      self.class.new(package, range: range.intersect(other.range))
+    end
+
+    def union(other)
+      unless package == other.package
+        raise ArgumentError, "Can only intersect between VersionConstraint of the same package"
+      end
+
+      self.class.new(package, range: range.union(other.range))
+    end
+
+    def invert
+      new_range = range.invert
+      self.class.new(package, range: new_range)
+    end
+
+    def difference(other)
+      intersect(other.invert)
+    end
+
+    def allows_all?(other)
+      range.allows_all?(other.range)
+    end
+
+    def allows_any?(other)
+      range.intersects?(other.range)
+    end
+
+    def subset?(other)
+      other.allows_all?(self)
+    end
+
+    def overlap?(other)
+      other.allows_any?(self)
+    end
+
+    def disjoint?(other)
+      !overlap?(other)
+    end
+
+    def relation(other)
+      if subset?(other)
+        :subset
+      elsif overlap?(other)
+        :overlap
+      else
+        :disjoint
+      end
+    end
+
+    def to_s(allow_every: false)
+      if Package.root?(package)
+        package.to_s
+      elsif allow_every && any?
+        "every version of #{package}"
+      else
+        "#{package} #{constraint_string}"
+      end
+    end
+
+    def constraint_string
+      if any?
+        ">= 0"
+      else
+        range.to_s
+      end
+    end
+
+    def empty?
+      range.empty?
+    end
+
+    # Does this match every version of the package
+    def any?
+      range.any?
+    end
+
+    def inspect
+      "#<#{self.class} #{self}>"
+    end
+  end
+end