gel 0.3.0 → 0.8.0.pre1

data/vendor/pub_grub/lib/pub_grub/failure_writer.rb

@@ -0,0 +1,182 @@
+module Gel::Vendor::PubGrub
+  class FailureWriter
+    def initialize(root)
+      @root = root
+
+      # { Incompatibility => Integer }
+      @derivations = {}
+
+      # [ [ String, Integer or nil ] ]
+      @lines = []
+
+      # { Incompatibility => Integer }
+      @line_numbers = {}
+
+      count_derivations(root)
+    end
+
+    def write
+      return @root.to_s unless @root.conflict?
+
+      visit(@root)
+
+      padding = @line_numbers.empty? ? 0 : "(#{@line_numbers.values.last}) ".length
+
+      @lines.map do |message, number|
+        next "" if message.empty?
+
+        lead = number ? "(#{number}) " : ""
+        lead = lead.ljust(padding)
+        message = message.gsub("\n", "\n" + " " * (padding + 2))
+        "#{lead}#{message}"
+      end.join("\n")
+    end
+
+    private
+
+    def write_line(incompatibility, message, numbered:)
+      if numbered
+        number = @line_numbers.length + 1
+        @line_numbers[incompatibility] = number
+      end
+
+      @lines << [message, number]
+    end
+
+    def visit(incompatibility, conclusion: false)
+      raise unless incompatibility.conflict?
+
+      numbered = conclusion || @derivations[incompatibility] > 1;
+      conjunction = conclusion || incompatibility == @root ? "So," : "And"
+
+      cause = incompatibility.cause
+
+      if cause.conflict.conflict? && cause.other.conflict?
+        conflict_line = @line_numbers[cause.conflict]
+        other_line = @line_numbers[cause.other]
+
+        if conflict_line && other_line
+          write_line(
+            incompatibility,
+            "Because #{cause.conflict} (#{conflict_line})\nand #{cause.other} (#{other_line}),\n#{incompatibility}.",
+            numbered: numbered
+          )
+        elsif conflict_line || other_line
+          with_line    = conflict_line ? cause.conflict : cause.other
+          without_line = conflict_line ? cause.other : cause.conflict
+          line = @line_numbers[with_line]
+
+          visit(without_line);
+          write_line(
+            incompatibility,
+            "#{conjunction} because #{with_line} (#{line}),\n#{incompatibility}.",
+            numbered: numbered
+          )
+        else
+          single_line_conflict = single_line?(cause.conflict.cause)
+          single_line_other    = single_line?(cause.other.cause)
+
+          if single_line_conflict || single_line_other
+            first  = single_line_other ? cause.conflict : cause.other
+            second = single_line_other ? cause.other : cause.conflict
+            visit(first)
+            visit(second)
+            write_line(
+              incompatibility,
+              "Thus, #{incompatibility}.",
+              numbered: numbered
+            )
+          else
+            visit(cause.conflict, conclusion: true)
+            @lines << ["", nil]
+            visit(cause.other)
+
+            write_line(
+              incompatibility,
+              "#{conjunction} because #{cause.conflict} (#{@line_numbers[cause.conflict]}),\n#{incompatibility}.",
+              numbered: numbered
+            )
+          end
+        end
+      elsif cause.conflict.conflict? || cause.other.conflict?
+        derived = cause.conflict.conflict? ? cause.conflict : cause.other
+        ext     = cause.conflict.conflict? ? cause.other : cause.conflict
+
+        derived_line = @line_numbers[derived]
+        if derived_line
+          write_line(
+            incompatibility,
+            "Because #{ext}\nand #{derived} (#{derived_line}),\n#{incompatibility}.",
+            numbered: numbered
+          )
+        elsif collapsible?(derived)
+          derived_cause = derived.cause
+          if derived_cause.conflict.conflict?
+            collapsed_derived = derived_cause.conflict
+            collapsed_ext = derived_cause.other
+          else
+            collapsed_derived = derived_cause.other
+            collapsed_ext = derived_cause.conflict
+          end
+
+          visit(collapsed_derived)
+
+          write_line(
+            incompatibility,
+            "#{conjunction} because #{collapsed_ext}\nand #{ext},\n#{incompatibility}.",
+            numbered: numbered
+          )
+        else
+          visit(derived)
+          write_line(
+            incompatibility,
+            "#{conjunction} because #{ext},\n#{incompatibility}.",
+            numbered: numbered
+          )
+        end
+      else
+        write_line(
+          incompatibility,
+          "Because #{cause.conflict}\nand #{cause.other},\n#{incompatibility}.",
+          numbered: numbered
+        )
+      end
+    end
+
+    def single_line?(cause)
+      !cause.conflict.conflict? && !cause.other.conflict?
+    end
+
+    def collapsible?(incompatibility)
+      return false if @derivations[incompatibility] > 1
+
+      cause = incompatibility.cause
+      # If incompatibility is derived from two derived incompatibilities,
+      # there are too many transitive causes to display concisely.
+      return false if cause.conflict.conflict? && cause.other.conflict?
+
+      # If incompatibility is derived from two external incompatibilities, it
+      # tends to be confusing to collapse it.
+      return false unless cause.conflict.conflict? || cause.other.conflict?
+
+      # If incompatibility's internal cause is numbered, collapsing it would
+      # get too noisy.
+      complex = cause.conflict.conflict? ? cause.conflict : cause.other
+
+      !@line_numbers.has_key?(complex)
+    end
+
+    def count_derivations(incompatibility)
+      if @derivations.has_key?(incompatibility)
+        @derivations[incompatibility] += 1
+      else
+        @derivations[incompatibility] = 1
+        if incompatibility.conflict?
+          cause = incompatibility.cause
+          count_derivations(cause.conflict)
+          count_derivations(cause.other)
+        end
+      end
+    end
+  end
+end

data/vendor/pub_grub/lib/pub_grub/incompatibility.rb

@@ -0,0 +1,143 @@
+module Gel::Vendor::PubGrub
+  class Incompatibility
+    ConflictCause = Struct.new(:incompatibility, :satisfier) do
+      alias_method :conflict, :incompatibility
+      alias_method :other, :satisfier
+    end
+
+    InvalidDependency = Struct.new(:package, :constraint) do
+    end
+
+    NoVersions = Struct.new(:constraint) do
+    end
+
+    attr_reader :terms, :cause
+
+    def initialize(terms, cause:)
+      @cause = cause
+      @terms = cleanup_terms(terms)
+
+      if cause == :dependency && @terms.length != 2
+        raise ArgumentError, "a dependency Incompatibility must have exactly two terms. Got #{@terms.inspect}"
+      end
+    end
+
+    def hash
+      cause.hash ^ terms.hash
+    end
+
+    def eql?(other)
+      cause.eql?(other.cause) &&
+        terms.eql?(other.terms)
+    end
+
+    def failure?
+      terms.empty? || (terms.length == 1 && terms[0].package == Package.root && terms[0].positive?)
+    end
+
+    def conflict?
+      ConflictCause === cause
+    end
+
+    # Returns all external incompatibilities in this incompatibility's
+    # derivation graph
+    def external_incompatibilities
+      if conflict?
+        [
+          cause.conflict,
+          cause.other
+        ].flat_map(&:external_incompatibilities)
+      else
+        [this]
+      end
+    end
+
+    def to_s
+      case cause
+      when :root
+        "(root dependency)"
+      when :dependency
+        "#{terms[0].to_s(allow_every: true)} depends on #{terms[1].invert}"
+      when Gel::Vendor::PubGrub::Incompatibility::InvalidDependency
+        "#{terms[0].to_s(allow_every: true)} depends on unknown package #{cause.package}"
+      when Gel::Vendor::PubGrub::Incompatibility::NoVersions
+        "no versions satisfy #{cause.constraint}"
+      when Gel::Vendor::PubGrub::Incompatibility::ConflictCause
+        if failure?
+          "version solving has failed"
+        elsif terms.length == 1
+          term = terms[0]
+          if term.positive?
+            "#{terms[0].to_s(allow_every: true)} is forbidden"
+          else
+            "#{terms[0].invert} is required"
+          end
+        else
+          if terms.all?(&:positive?)
+            if terms.length == 2
+              "#{terms[0].to_s(allow_every: true)} is incompatible with #{terms[1]}"
+            else
+              "one of #{terms.map(&:to_s).join(" or ")} must be false"
+            end
+          elsif terms.all?(&:negative?)
+            if terms.length == 2
+              "either #{terms[0].invert} or #{terms[1].invert}"
+            else
+              "one of #{terms.map(&:invert).join(" or ")} must be true";
+            end
+          else
+            positive = terms.select(&:positive?)
+            negative = terms.select(&:negative?).map(&:invert)
+
+            if positive.length == 1
+              "#{positive[0].to_s(allow_every: true)} requires #{negative.join(" or ")}"
+            else
+              "if #{positive.join(" and ")} then #{negative.join(" or ")}"
+            end
+          end
+        end
+      else
+        raise "unhandled cause: #{cause.inspect}"
+      end
+    end
+
+    def inspect
+      "#<#{self.class} #{to_s}>"
+    end
+
+    def pretty_print(q)
+      q.group 2, "#<#{self.class}", ">" do
+        q.breakable
+        q.text to_s
+
+        q.breakable
+        q.text " caused by "
+        q.pp @cause
+      end
+    end
+
+    private
+
+    def cleanup_terms(terms)
+      terms.each do |term|
+        raise "#{term.inspect} must be a term" unless term.is_a?(Term)
+      end
+
+      if terms.length != 1 && ConflictCause === cause
+        terms = terms.reject do |term|
+          term.positive? && term.package == Package.root
+        end
+      end
+
+      # Optimized simple cases
+      return terms if terms.length <= 1
+      return terms if terms.length == 2 && terms[0].package != terms[1].package
+
+      terms.group_by(&:package).map do |package, common_terms|
+        common_terms.inject do |acc, term|
+          acc.intersect(term)
+        end
+      end
+    end
+  end
+end

data/vendor/pub_grub/lib/pub_grub/package.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Gel::Vendor::PubGrub
+  class Package
+
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def inspect
+      "#<#{self.class} #{name.inspect}>"
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    ROOT = Package.new(:root)
+    ROOT_VERSION = 0
+
+    def self.root
+      ROOT
+    end
+
+    def self.root_version
+      ROOT_VERSION
+    end
+
+    def to_s
+      name.to_s
+    end
+  end
+end

data/vendor/pub_grub/lib/pub_grub/partial_solution.rb

@@ -0,0 +1,121 @@
+require_relative '../pub_grub/assignment'
+
+module Gel::Vendor::PubGrub
+  class PartialSolution
+    attr_reader :assignments, :decisions
+    attr_reader :attempted_solutions
+
+    def initialize
+      reset!
+
+      @attempted_solutions = 1
+      @backtracking = false
+    end
+
+    def decision_level
+      @decisions.length
+    end
+
+    def relation(term)
+      package = term.package
+      return :overlap if !@terms.key?(package)
+
+      @relation_cache[package][term] ||=
+        @terms[package].relation(term)
+    end
+
+    def satisfies?(term)
+      relation(term) == :subset
+    end
+
+    def derive(term, cause)
+      add_assignment(Assignment.new(term, cause, decision_level, assignments.length))
+    end
+
+    def satisfier(term)
+      assignment =
+        @assignments_by[term.package].bsearch do |assignment_by|
+          @cumulative_assignments[assignment_by].satisfies?(term)
+        end
+
+      assignment || raise("#{term} unsatisfied")
+    end
+
+    # A list of unsatisfied terms
+    def unsatisfied
+      @required.keys.reject do |package|
+        @decisions.key?(package)
+      end.map do |package|
+        @terms[package]
+      end
+    end
+
+    def decide(package, version)
+      @attempted_solutions += 1 if @backtracking
+      @backtracking = false;
+
+      decisions[package] = version
+      assignment = Assignment.decision(package, version, decision_level, assignments.length)
+      add_assignment(assignment)
+    end
+
+    def backtrack(previous_level)
+      @backtracking = true
+
+      new_assignments = assignments.select do |assignment|
+        assignment.decision_level <= previous_level
+      end
+
+      new_decisions = Hash[decisions.first(previous_level)]
+
+      reset!
+
+      @decisions = new_decisions
+
+      new_assignments.each do |assignment|
+        add_assignment(assignment)
+      end
+    end
+
+    private
+
+    def reset!
+      # { Array<Assignment> }
+      @assignments = []
+
+      # { Package => Array<Assignment> }
+      @assignments_by = Hash.new { |h,k| h[k] = [] }
+      @cumulative_assignments = {}.compare_by_identity
+
+      # { Package => Package::Version }
+      @decisions = {}
+
+      # { Package => Term }
+      @terms = {}
+      @relation_cache = Hash.new { |h,k| h[k] = {} }
+
+      # { Package => Boolean }
+      @required = {}
+    end
+
+    def add_assignment(assignment)
+      term = assignment.term
+      package = term.package
+
+      @assignments << assignment
+      @assignments_by[package] << assignment
+
+      @required[package] = true if term.positive?
+
+      if @terms.key?(package)
+        old_term = @terms[package]
+        @terms[package] = old_term.intersect(term)
+      else
+        @terms[package] = term
+      end
+      @relation_cache[package].clear
+
+      @cumulative_assignments[assignment] = @terms[package]
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Gel::Vendor::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)
+      Gel::Vendor::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)
+      Gel::Vendor::PubGrub::VersionConstraint.new(package, range: range)
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require_relative '../pub_grub/failure_writer'
+
+module Gel::Vendor::PubGrub
+  class SolveFailure < StandardError
+    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/vendor/pub_grub/lib/pub_grub/static_package_source.rb

@@ -0,0 +1,53 @@
+require_relative '../pub_grub/package'
+require_relative '../pub_grub/version_constraint'
+require_relative '../pub_grub/incompatibility'
+require_relative '../pub_grub/basic_package_source'
+
+module Gel::Vendor::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] = deps
+      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)
+
+      Gel::Vendor::PubGrub::RubyGems.parse_constraint(package, dependency)
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+module Gel::Vendor::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/vendor/pub_grub/lib/pub_grub/version.rb

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