bundler 1.13.0.rc.1 → 1.13.0.rc.2

data/lib/bundler/fetcher/base.rb

@@ -36,6 +36,16 @@ module Bundler
       def api_fetcher?
         false
       end
+
+    private
+
+      def log_specs(debug_msg)
+        if Bundler.ui.debug?
+          Bundler.ui.debug debug_msg
+        else
+          Bundler.ui.info ".", false
+        end
+      end
     end
   end
 end

data/lib/bundler/fetcher/compact_index.rb

@@ -36,7 +36,7 @@ module Bundler
         remaining_gems = gem_names.dup
 
         until remaining_gems.empty?
-          Bundler.ui.debug "Looking up gems #{remaining_gems.inspect}"
+          log_specs "Looking up gems #{remaining_gems.inspect}"
 
           deps = compact_index_client.dependencies(remaining_gems)
           next_gems = deps.map {|d| d[3].map(&:first).flatten(1) }.flatten(1).uniq
@@ -44,6 +44,8 @@ module Bundler
           complete_gems.concat(deps.map(&:first)).uniq!
           remaining_gems = next_gems - complete_gems
         end
+        @bundle_worker.stop if @bundle_worker
+        @bundle_worker = nil # reset it.  Not sure if necessary
 
         gem_info
       end
@@ -76,28 +78,44 @@ module Bundler
     private
 
       def compact_index_client
-        @compact_index_client ||= begin
-          compact_fetcher = lambda do |path, headers|
-            downloader.fetch(fetch_uri + path, headers)
-          end
-
+        @compact_index_client ||=
           SharedHelpers.filesystem_access(cache_path) do
             CompactIndexClient.new(cache_path, compact_fetcher)
           end.tap do |client|
             client.in_parallel = lambda do |inputs, &blk|
               func = lambda {|object, _index| blk.call(object) }
-              worker_name = "Compact Index (#{display_uri.host})"
-              worker = Bundler::Worker.new(25, worker_name, func)
+              worker = bundle_worker(func)
               inputs.each {|input| worker.enq(input) }
-              inputs.map { worker.deq }.tap { worker.stop }
+              inputs.map { worker.deq }
             end
           end
+      end
+
+      def bundle_worker(func = nil)
+        @bundle_worker ||= begin
+          worker_name = "Compact Index (#{display_uri.host})"
+          Bundler::Worker.new(25, worker_name, func)
+        end
+        @bundle_worker.tap do |worker|
+          worker.instance_variable_set(:@func, func) if func
         end
       end
 
       def cache_path
         Bundler.user_cache.join("compact_index", remote.cache_slug)
       end
+
+      def compact_fetcher
+        lambda do |path, headers|
+          begin
+            downloader.fetch(fetch_uri + path, headers)
+          rescue NetworkDownError => e
+            raise unless Bundler.settings[:allow_offline_install] && headers["If-None-Match"]
+            Bundler.ui.warn "Using the cached data for the new index because of a network error: #{e}"
+            Net::HTTPNotModified.new(nil, nil, nil)
+          end
+        end
+      end
     end
   end
 end

data/lib/bundler/fetcher/dependency.rb

@@ -23,7 +23,7 @@ module Bundler
       def specs(gem_names, full_dependency_list = [], last_spec_list = [])
         query_list = gem_names.uniq - full_dependency_list
 
-        log_specs(query_list)
+        log_specs "Query List: #{query_list.inspect}"
 
         return last_spec_list if query_list.empty?
 
@@ -76,17 +76,6 @@ module Bundler
         uri.query = "gems=#{CGI.escape(gem_names.join(","))}" if gem_names.any?
         uri
       end
-
-    private
-
-      def log_specs(query_list)
-        # only display the message on the first run
-        if Bundler.ui.debug?
-          Bundler.ui.debug "Query List: #{query_list.inspect}"
-        else
-          Bundler.ui.info ".", false
-        end
-      end
     end
   end
 end

data/lib/bundler/fetcher/downloader.rb

@@ -14,7 +14,7 @@ module Bundler
         raise HTTPError, "Too many redirects" if counter >= redirect_limit
 
         response = request(uri, options)
-        Bundler.ui.debug("HTTP #{response.code} #{response.message}")
+        Bundler.ui.debug("HTTP #{response.code} #{response.message} #{uri}")
 
         case response
         when Net::HTTPSuccess, Net::HTTPNotModified

data/lib/bundler/friendly_errors.rb

@@ -12,7 +12,7 @@ module Bundler
       when YamlSyntaxError
         Bundler.ui.error error.message
         Bundler.ui.trace error.orig_exception
-      when Dsl::DSLError
+      when Dsl::DSLError, GemspecError
         Bundler.ui.error error.message
       when GemRequireError
         Bundler.ui.error error.message
@@ -89,8 +89,10 @@ module Bundler
     end
 
     def issues_url(exception)
+      message = exception.message.lines.first.tr(":", " ").chomp
+      message = message.split("-").first if exception.is_a?(Errno)
       "https://github.com/bundler/bundler/search?q=" \
-        "#{CGI.escape(exception.message.lines.first.chomp)}&type=Issues"
+        "#{CGI.escape(message)}&type=Issues"
     end
   end
 

data/lib/bundler/gem_helper.rb

@@ -140,7 +140,7 @@ module Bundler
     end
 
     def tag_version
-      sh "git tag -a -m \"Version #{version}\" #{version_tag}"
+      sh "git tag -m \"Version #{version}\" #{version_tag}"
       Bundler.ui.confirm "Tagged #{version_tag}."
       yield if block_given?
     rescue
@@ -182,7 +182,7 @@ module Bundler
     end
 
     def gem_push?
-      ! %w(n no nil false off 0).include?(ENV["gem_push"].to_s.downcase)
+      !%w(n no nil false off 0).include?(ENV["gem_push"].to_s.downcase)
     end
   end
 end

data/lib/bundler/gem_version_promoter.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+module Bundler
+  # This class contains all of the logic for determining the next version of a
+  # Gem to update to based on the requested level (patch, minor, major).
+  # Primarily designed to work with Resolver which will provide it the list of
+  # available dependency versions as found in its index, before returning it to
+  # to the resolution engine to select the best version.
+  class GemVersionPromoter
+    attr_reader :level, :locked_specs, :unlock_gems
+
+    # By default, strict is false, meaning every available version of a gem
+    # is returned from sort_versions. The order gives preference to the
+    # requested level (:patch, :minor, :major) but in complicated requirement
+    # cases some gems will by necessity by promoted past the requested level,
+    # or even reverted to older versions.
+    #
+    # If strict is set to true, the results from sort_versions will be
+    # truncated, eliminating any version outside the current level scope.
+    # This can lead to unexpected outcomes or even VersionConflict exceptions
+    # that report a version of a gem not existing for versions that indeed do
+    # existing in the referenced source.
+    attr_accessor :strict
+
+    # Given a list of locked_specs and a list of gems to unlock creates a
+    # GemVersionPromoter instance.
+    #
+    # @param locked_specs [SpecSet] All current locked specs. Unlike Definition
+    #   where this list is empty if all gems are being updated, this should
+    #   always be populated for all gems so this class can properly function.
+    # @param unlock_gems [String] List of gem names being unlocked. If empty,
+    #   all gems will be considered unlocked.
+    # @return [GemVersionPromoter]
+    def initialize(locked_specs = SpecSet.new([]), unlock_gems = [])
+      @level = :major
+      @strict = false
+      @locked_specs = locked_specs
+      @unlock_gems = unlock_gems
+      @sort_versions = {}
+    end
+
+    # @param value [Symbol] One of three Symbols: :major, :minor or :patch.
+    def level=(value)
+      v = case value
+          when String, Symbol
+            value.to_sym
+      end
+
+      raise ArgumentError, "Unexpected level #{v}. Must be :major, :minor or :patch" unless [:major, :minor, :patch].include?(v)
+      @level = v
+    end
+
+    # Given a Dependency and an Array of SpecGroups of available versions for a
+    # gem, this method will return the Array of SpecGroups sorted (and possibly
+    # truncated if strict is true) in an order to give preference to the current
+    # level (:major, :minor or :patch) when resolution is deciding what versions
+    # best resolve all dependencies in the bundle.
+    # @param dep [Dependency] The Dependency of the gem.
+    # @param spec_groups [SpecGroup] An array of SpecGroups for the same gem
+    #    named in the @dep param.
+    # @return [SpecGroup] A new instance of the SpecGroup Array sorted and
+    #    possibly filtered.
+    def sort_versions(dep, spec_groups)
+      before_result = "before sort_versions: #{debug_format_result(dep, spec_groups).inspect}" if ENV["DEBUG_RESOLVER"]
+
+      @sort_versions[dep] ||= begin
+        gem_name = dep.name
+
+        # An Array per version returned, different entries for different platforms.
+        # We only need the version here so it's ok to hard code this to the first instance.
+        locked_spec = locked_specs[gem_name].first
+
+        if strict
+          filter_dep_specs(spec_groups, locked_spec)
+        else
+          sort_dep_specs(spec_groups, locked_spec)
+        end.tap do |specs|
+          if ENV["DEBUG_RESOLVER"]
+            STDERR.puts before_result
+            STDERR.puts " after sort_versions: #{debug_format_result(dep, specs).inspect}"
+          end
+        end
+      end
+    end
+
+    # @return [bool] Convenience method for testing value of level variable.
+    def major?
+      level == :major
+    end
+
+    # @return [bool] Convenience method for testing value of level variable.
+    def minor?
+      level == :minor
+    end
+
+  private
+
+    def filter_dep_specs(spec_groups, locked_spec)
+      res = spec_groups.select do |spec_group|
+        if locked_spec && !major?
+          gsv = spec_group.version
+          lsv = locked_spec.version
+
+          must_match = minor? ? [0] : [0, 1]
+
+          matches = must_match.map {|idx| gsv.segments[idx] == lsv.segments[idx] }
+          (matches.uniq == [true]) ? (gsv >= lsv) : false
+        else
+          true
+        end
+      end
+
+      sort_dep_specs(res, locked_spec)
+    end
+
+    def sort_dep_specs(spec_groups, locked_spec)
+      return spec_groups unless locked_spec
+      @gem_name = locked_spec.name
+      @locked_version = locked_spec.version
+
+      result = spec_groups.sort do |a, b|
+        @a_ver = a.version
+        @b_ver = b.version
+        if major?
+          @a_ver <=> @b_ver
+        elsif either_version_older_than_locked
+          @a_ver <=> @b_ver
+        elsif segments_do_not_match(:major)
+          @b_ver <=> @a_ver
+        elsif !minor? && segments_do_not_match(:minor)
+          @b_ver <=> @a_ver
+        else
+          @a_ver <=> @b_ver
+        end
+      end
+      post_sort(result)
+    end
+
+    def either_version_older_than_locked
+      @a_ver < @locked_version || @b_ver < @locked_version
+    end
+
+    def segments_do_not_match(level)
+      index = [:major, :minor].index(level)
+      @a_ver.segments[index] != @b_ver.segments[index]
+    end
+
+    def unlocking_gem?
+      unlock_gems.empty? || unlock_gems.include?(@gem_name)
+    end
+
+    # Specific version moves can't always reliably be done during sorting
+    # as not all elements are compared against each other.
+    def post_sort(result)
+      # default :major behavior in Bundler does not do this
+      return result if major?
+      if unlocking_gem?
+        result
+      else
+        move_version_to_end(result, @locked_version)
+      end
+    end
+
+    def move_version_to_end(result, version)
+      move, keep = result.partition {|s| s.version.to_s == version.to_s }
+      keep.concat(move)
+    end
+
+    def debug_format_result(dep, spec_groups)
+      a = [dep.to_s,
+           spec_groups.map {|sg| [sg.version, sg.dependencies_for_activated_platforms.map {|dp| [dp.name, dp.requirement.to_s] }] }]
+      last_map = a.last.map {|sg_data| [sg_data.first.version, sg_data.last.map {|aa| aa.join(" ") }] }
+      [a.first, last_map, level, strict ? :strict : :not_strict]
+    end
+  end
+end

data/lib/bundler/graph.rb

@@ -17,7 +17,6 @@ module Bundler
       @node_options      = {}
       @edge_options      = {}
 
-      _patching_gem_dependency_class
       _populate_relations
     end
 
@@ -36,10 +35,7 @@ module Bundler
 
         tmp = Set.new
         parent_dependencies.each do |dependency|
-          # if the dependency is a prerelease, allow to_spec to be non-nil
-          dependency.prerelease = true
-
-          child_dependencies = dependency.to_spec.runtime_dependencies.to_set
+          child_dependencies = spec_for_dependency(dependency).runtime_dependencies.to_set
           @relations[dependency.name] += child_dependencies.map(&:name).to_set
           tmp += child_dependencies
 
@@ -74,7 +70,7 @@ module Bundler
       when :node
         if symbol_or_string_or_dependency.is_a?(Gem::Dependency)
           label = symbol_or_string_or_dependency.name.dup
-          label << "\n#{symbol_or_string_or_dependency.to_spec.version}" if @show_version
+          label << "\n#{spec_for_dependency(symbol_or_string_or_dependency).version}" if @show_version
         else
           label = symbol_or_string_or_dependency.to_s
         end
@@ -90,25 +86,8 @@ module Bundler
       label.nil? ? {} : { :label => label }
     end
 
-    def _patching_gem_dependency_class
-      # method borrow from rubygems/dependency.rb
-      # redefinition of matching_specs will also redefine to_spec and to_specs
-      Gem::Dependency.class_eval do
-        def matching_specs(platform_only = false)
-          matches = Bundler.load.specs.select do |spec|
-            name == spec.name &&
-              requirement.satisfied_by?(spec.version)
-          end
-
-          if platform_only
-            matches.select! do |spec|
-              Gem::Platform.match spec.platform
-            end
-          end
-
-          matches = matches.sort_by(&:sort_obj) # HACK: shouldn't be needed
-        end
-      end
+    def spec_for_dependency(dependency)
+      @env.requested_specs.find {|s| s.name == dependency.name }
     end
 
     class GraphVizClient

data/lib/bundler/index.rb

@@ -67,12 +67,20 @@ module Bundler
         end
       end
 
-      results.sort_by do |s|
+      sort_specs(results)
+    end
+
+    def self.sort_specs(specs)
+      specs.sort_by do |s|
         platform_string = s.platform.to_s
         [s.version, platform_string == RUBY ? NULL : platform_string]
       end
     end
 
+    def sort_specs(specs)
+      self.class.sort_specs(specs)
+    end
+
     def local_search(query, base = nil)
       case query
       when Gem::Specification, RemoteSpecification, LazySpecification, EndpointSpecification then search_by_spec(query)

data/lib/bundler/injector.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 module Bundler
   class Injector
-    def self.inject(new_deps)
-      injector = new(new_deps)
+    def self.inject(new_deps, options = {})
+      injector = new(new_deps, options)
       injector.inject(Bundler.default_gemfile, Bundler.default_lockfile)
     end
 
-    def initialize(new_deps)
+    def initialize(new_deps, options = {})
       @new_deps = new_deps
+      @options = options
     end
 
     def inject(gemfile_path, lockfile_path)
@@ -48,14 +49,20 @@ module Bundler
 
     def new_gem_lines
       @new_deps.map do |d|
-        %(gem '#{d.name}', '#{d.requirement}')
+        name = "'#{d.name}'"
+        requirement = ", '#{d.requirement}'"
+        group = ", :group => #{d.groups.inspect}" if d.groups != Array(:default)
+        source = ", :source => '#{d.source}'" unless d.source.nil?
+        %(gem #{name}#{requirement}#{group}#{source})
       end.join("\n")
     end
 
     def append_to(gemfile_path)
       gemfile_path.open("a") do |f|
         f.puts
-        f.puts "# Added at #{Time.now} by #{`whoami`.chomp}:"
+        if @options["timestamp"] || @options["timestamp"].nil?
+          f.puts "# Added at #{Time.now} by #{`whoami`.chomp}:"
+        end
         f.puts new_gem_lines
       end
     end