bundler 1.11.2 → 1.12.0.pre.1

data/lib/bundler/ui/silent.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Bundler
   module UI
     class Silent

data/lib/bundler/vendor/compact_index_client/lib/compact_index_client.rb

@@ -0,0 +1,78 @@
+require "pathname"
+require "set"
+
+class Bundler::CompactIndexClient
+  class Error < StandardError; end
+
+  require "bundler/vendor/compact_index_client/lib/compact_index_client/cache"
+  require "bundler/vendor/compact_index_client/lib/compact_index_client/updater"
+  require "bundler/vendor/compact_index_client/lib/compact_index_client/version"
+
+  attr_reader :directory
+
+  # @return [Lambda] A lambda that takes an array of inputs and a block, and
+  #         maps the inputs with the block in parallel.
+  #
+  attr_accessor :in_parallel
+
+  def initialize(directory, fetcher)
+    @directory = Pathname.new(directory)
+    @updater = Updater.new(fetcher)
+    @cache = Cache.new(@directory)
+    @endpoints = Set.new
+    @info_checksums_by_name = {}
+    @in_parallel = lambda do |inputs, &blk|
+      inputs.map(&blk)
+    end
+  end
+
+  def names
+    update(@cache.names_path, "names")
+    @cache.names
+  end
+
+  def versions
+    update(@cache.versions_path, "versions")
+    versions, @info_checksums_by_name = @cache.versions
+    versions
+  end
+
+  def dependencies(names)
+    in_parallel.call(names) do |name|
+      update_info(name)
+      @cache.dependencies(name).map {|d| d.unshift(name) }
+    end.flatten(1)
+  end
+
+  def spec(name, version, platform = nil)
+    update_info(name)
+    @cache.specific_dependency(name, version, platform)
+  end
+
+  def update_and_parse_checksums!
+    return @info_checksums_by_name if @parsed_checksums
+    update(@cache.versions_path, "versions")
+    @info_checksums_by_name = @cache.checksums
+    @parsed_checksums = true
+  end
+
+private
+
+  def update(local_path, remote_path)
+    return if @endpoints.include?(remote_path)
+    @updater.update(local_path, url(remote_path))
+    @endpoints << remote_path
+  end
+
+  def update_info(name)
+    path = @cache.info_path(name)
+    checksum = @updater.checksum_for_file(path)
+    return unless existing = @info_checksums_by_name[name]
+    return if checksum == existing
+    update(path, "info/#{name}")
+  end
+
+  def url(path)
+    path
+  end
+end

data/lib/bundler/vendor/compact_index_client/lib/compact_index_client/cache.rb

@@ -0,0 +1,97 @@
+class Bundler::CompactIndexClient
+  class Cache
+    attr_reader :directory
+
+    def initialize(directory)
+      @directory = Pathname.new(directory).expand_path
+      FileUtils.mkdir_p info_path(nil)
+    end
+
+    def names
+      lines(names_path)
+    end
+
+    def names_path
+      directory.join("names")
+    end
+
+    def versions
+      versions_by_name = Hash.new {|hash, key| hash[key] = [] }
+      info_checksums_by_name = {}
+
+      lines(versions_path).each do |line|
+        name, versions_string, info_checksum = line.split(" ", 3)
+        info_checksums_by_name[name] = info_checksum || ""
+        versions_string.split(",").each do |version|
+          if version.start_with?("-")
+            version = version[1..-1].split("-", 2).unshift(name)
+            versions_by_name[name].delete(version)
+          else
+            version = version.split("-", 2).unshift(name)
+            versions_by_name[name] << version
+          end
+        end
+      end
+
+      [versions_by_name, info_checksums_by_name]
+    end
+
+    def versions_path
+      directory.join("versions")
+    end
+
+    def checksums
+      checksums = {}
+
+      lines(versions_path).each do |line|
+        name, _, checksum = line.split(" ", 3)
+        checksums[name] = checksum
+      end
+
+      checksums
+    end
+
+    def dependencies(name)
+      lines(info_path(name)).map do |line|
+        parse_gem(line)
+      end
+    end
+
+    def info_path(name)
+      directory.join("info", name.to_s)
+    end
+
+    def specific_dependency(name, version, platform)
+      pattern = [version, platform].compact.join("-")
+      return nil if pattern.empty?
+
+      gem_lines = info_path(name).read
+      gem_line = gem_lines[/^#{Regexp.escape(pattern)}\b.*/, 0]
+      gem_line ? parse_gem(gem_line) : nil
+    end
+
+  private
+
+    def lines(path)
+      return [] unless path.file?
+      lines = path.read.split("\n")
+      header = lines.index("---")
+      lines = header ? lines[header + 1..-1] : lines
+    end
+
+    def parse_gem(string)
+      version_and_platform, rest = string.split(" ", 2)
+      version, platform = version_and_platform.split("-", 2)
+      dependencies, requirements = rest.split("|", 2).map {|s| s.split(",") } if rest
+      dependencies = dependencies ? dependencies.map {|d| parse_dependency(d) } : []
+      requirements = requirements ? requirements.map {|r| parse_dependency(r) } : []
+      [version, platform, dependencies, requirements]
+    end
+
+    def parse_dependency(string)
+      dependency = string.split(":")
+      dependency[-1] = dependency[-1].split("&") if dependency.size > 1
+      dependency
+    end
+  end
+end

data/lib/bundler/vendor/compact_index_client/lib/compact_index_client/updater.rb

@@ -0,0 +1,55 @@
+require "stringio"
+require "zlib"
+
+class Bundler::CompactIndexClient
+  class Updater
+    class MisMatchedChecksumError < Error; end
+
+    def initialize(fetcher)
+      @fetcher = fetcher
+    end
+
+    def update(local_path, remote_path, retrying = nil)
+      headers = {}
+
+      if local_path.file?
+        headers["If-None-Match"] = etag_for(local_path)
+        headers["Range"] = "bytes=#{local_path.size}-"
+      else
+        # Fastly ignores Range when Accept-Encoding: gzip is set
+        headers["Accept-Encoding"] = "gzip"
+      end
+
+      response = @fetcher.call(remote_path, headers)
+      return if response.is_a?(Net::HTTPNotModified)
+
+      content = response.body
+      if response["Content-Encoding"] == "gzip"
+        content = Zlib::GzipReader.new(StringIO.new(content)).read
+      end
+
+      mode = response.is_a?(Net::HTTPPartialContent) ? "a" : "w"
+      local_path.open(mode) {|f| f << content }
+
+      return if etag_for(local_path) == response["ETag"]
+
+      if retrying.nil?
+        local_path.delete
+        update(local_path, remote_path, :retrying)
+      else
+        raise MisMatchedChecksumError, "Checksum of /#{remote_path} " \
+          "does not match the checksum provided by server! Something is wrong."
+      end
+    end
+
+    def etag_for(path)
+      sum = checksum_for_file(path)
+      sum ? '"' << sum << '"' : nil
+    end
+
+    def checksum_for_file(path)
+      return nil unless path.file?
+      Digest::MD5.file(path).hexdigest
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+class Bundler::CompactIndexClient
+  VERSION = "0.1.0"
+end

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

@@ -3,3 +3,7 @@ require 'bundler/vendor/molinillo/lib/molinillo/errors'
 require 'bundler/vendor/molinillo/lib/molinillo/resolver'
 require 'bundler/vendor/molinillo/lib/molinillo/modules/ui'
 require 'bundler/vendor/molinillo/lib/molinillo/modules/specification_provider'
+
+# Bundler::Molinillo is a generic dependency resolution algorithm.
+module Bundler::Molinillo
+end

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

@@ -14,8 +14,10 @@ module Bundler::Molinillo
 
     include TSort
 
+    # @visibility private
     alias_method :tsort_each_node, :each
 
+    # @visibility private
     def tsort_each_child(vertex, &block)
       vertex.successors.each(&block)
     end
@@ -41,12 +43,14 @@ module Bundler::Molinillo
     #   by {Vertex#name}
     attr_reader :vertices
 
+    # Initializes an empty dependency graph
     def initialize
       @vertices = {}
     end
 
     # Initializes a copy of a {DependencyGraph}, ensuring that all {#vertices}
     # are properly copied.
+    # @param [DependencyGraph] other the graph to copy.
     def initialize_copy(other)
       super
       @vertices = {}
@@ -100,6 +104,7 @@ module Bundler::Molinillo
       vertex
     end
 
+    # Adds a vertex with the given name, or updates the existing one.
     # @param [String] name
     # @param [Object] payload
     # @return [Vertex] the vertex that was added to `self`
@@ -121,6 +126,10 @@ module Bundler::Molinillo
         v.incoming_edges.delete(e)
         detach_vertex_named(v.name) unless v.root? || v.predecessors.any?
       end
+      vertex.incoming_edges.each do |e|
+        v = e.origin
+        v.outgoing_edges.delete(e)
+      end
     end
 
     # @param [String] name
@@ -150,6 +159,8 @@ module Bundler::Molinillo
 
     private
 
+    # Adds a new {Edge} to the dependency graph without checking for
+    # circularity.
     def add_edge_no_circular(origin, destination, requirement)
       edge = Edge.new(origin, destination, requirement)
       origin.outgoing_edges << edge
@@ -174,6 +185,7 @@ module Bundler::Molinillo
       attr_accessor :root
       alias_method :root?, :root
 
+      # Initializes a vertex with the given name and payload.
       # @param [String] name see {#name}
       # @param [Object] payload see {#payload}
       def initialize(name, payload)
@@ -240,6 +252,7 @@ module Bundler::Molinillo
           successors.to_set == other.successors.to_set
       end
 
+      # @param  [Vertex] other the other vertex to compare to
       # @return [Boolean] whether the two vertices are equal, determined
       #   solely by {#name} and {#payload} equality
       def shallow_eql?(other)

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

@@ -11,6 +11,7 @@ module Bundler::Molinillo
     # @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 = [])
@@ -19,6 +20,8 @@ module Bundler::Molinillo
       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}`"
@@ -36,6 +39,7 @@ module Bundler::Molinillo
     # [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>] nodes the nodes in the dependency
     #   that caused the error
     def initialize(nodes)
@@ -50,6 +54,7 @@ module Bundler::Molinillo
     #   resolution to fail
     attr_reader :conflicts
 
+    # Initializes a new error with the given version conflicts.
     # @param [{String => Resolution::Conflict}] conflicts see {#conflicts}
     def initialize(conflicts)
       pairs = []

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

@@ -1,3 +1,4 @@
 module Bundler::Molinillo
-  VERSION = '0.4.0'
+  # The version of Bundler::Molinillo.
+  VERSION = '0.4.2'.freeze
 end

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

@@ -57,7 +57,8 @@ module Bundler::Molinillo
     #
     # @return [Boolean]
     def debug?
-      @debug_mode ||= ENV['MOLINILLO_DEBUG']
+      return @debug_mode if defined?(@debug_mode)
+      @debug_mode = ENV['MOLINILLO_DEBUG']
     end
   end
 end

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

@@ -38,6 +38,7 @@ module Bundler::Molinillo
       # @return [Array] the dependencies that were explicitly required
       attr_reader :original_requested
 
+      # Initializes a new resolution.
       # @param [SpecificationProvider] specification_provider
       #   see {#specification_provider}
       # @param [UI] resolver_ui see {#resolver_ui}
@@ -340,26 +341,36 @@ module Bundler::Molinillo
       # @return [Boolean] Whether the possibility was swapped into {#activated}
       def attempt_to_swap_possibility
         swapped = activated.dup
-        swapped.vertex_named(name).payload = possibility
-        return unless swapped.vertex_named(name).requirements.
+        vertex = swapped.vertex_named(name)
+        vertex.payload = possibility
+        return unless vertex.requirements.
             all? { |r| requirement_satisfied_by?(r, swapped, possibility) }
-        attempt_to_activate_new_spec
+        return unless new_spec_satisfied?
+        actual_vertex = activated.vertex_named(name)
+        actual_vertex.payload = possibility
+        fixup_swapped_children(actual_vertex)
+        activate_spec
+      end
+
+      # Ensures there are no orphaned successors to the given {vertex}.
+      # @param [DependencyGraph::Vertex] vertex the vertex to fix up.
+      # @return [void]
+      def fixup_swapped_children(vertex)
+        payload = vertex.payload
+        dep_names = dependencies_for(payload).map(&method(:name_for))
+        vertex.successors.each do |succ|
+          if !dep_names.include?(succ.name) && !succ.root? && succ.predecessors.to_a == [vertex]
+            debug(depth) { "Removing orphaned spec #{succ.name} after swapping #{name}" }
+            activated.detach_vertex_named(succ.name)
+          end
+        end
       end
 
       # Attempts to activate the current {#possibility} (given that it hasn't
       # already been activated)
       # @return [void]
       def attempt_to_activate_new_spec
-        satisfied = begin
-          locked_requirement = locked_requirement_named(name)
-          requested_spec_satisfied = requirement_satisfied_by?(requirement, activated, possibility)
-          locked_spec_satisfied = !locked_requirement ||
-            requirement_satisfied_by?(locked_requirement, activated, possibility)
-          debug(depth) { 'Unsatisfied by requested spec' } unless requested_spec_satisfied
-          debug(depth) { 'Unsatisfied by locked spec' } unless locked_spec_satisfied
-          requested_spec_satisfied && locked_spec_satisfied
-        end
-        if satisfied
+        if new_spec_satisfied?
           activate_spec
         else
           create_conflict
@@ -367,6 +378,18 @@ module Bundler::Molinillo
         end
       end
 
+      # @return [Boolean] whether the current spec is satisfied as a new
+      # possibility.
+      def new_spec_satisfied?
+        locked_requirement = locked_requirement_named(name)
+        requested_spec_satisfied = requirement_satisfied_by?(requirement, activated, possibility)
+        locked_spec_satisfied = !locked_requirement ||
+          requirement_satisfied_by?(locked_requirement, activated, possibility)
+        debug(depth) { 'Unsatisfied by requested spec' } unless requested_spec_satisfied
+        debug(depth) { 'Unsatisfied by locked spec' } unless locked_spec_satisfied
+        requested_spec_satisfied && locked_spec_satisfied
+      end
+
       # @param [String] requirement_name the spec name to search for
       # @return [Object] the locked spec named `requirement_name`, if one
       #   is found on {#base}
@@ -392,7 +415,7 @@ module Bundler::Molinillo
       # @return [void]
       def require_nested_dependencies_for(activated_spec)
         nested_dependencies = dependencies_for(activated_spec)
-        debug(depth) { "Requiring nested dependencies (#{nested_dependencies.map(&:to_s).join(', ')})" }
+        debug(depth) { "Requiring nested dependencies (#{nested_dependencies.join(', ')})" }
         nested_dependencies.each { |d| activated.add_child_vertex(name_for(d), nil, [name_for(activated_spec)], d) }
 
         push_state_for_requirements(requirements + nested_dependencies, nested_dependencies.size > 0)