bundler 1.14.6 → 1.15.0.pre.1

data/lib/bundler/dsl.rb

@@ -384,6 +384,12 @@ module Bundler
 
     def validate_keys(command, opts, valid_keys)
       invalid_keys = opts.keys - valid_keys
+
+      git_source = opts.keys & @git_sources.keys.map(&:to_s)
+      if opts["branch"] && !(opts["git"] || opts["github"] || git_source.any?)
+        raise GemfileError, %(The `branch` option for `#{command}` is not allowed. Only gems with a git source can specify a branch)
+      end
+
       if invalid_keys.any?
         message = String.new
         message << "You passed #{invalid_keys.map {|k| ":" + k }.join(", ")} "

data/lib/bundler/endpoint_specification.rb

@@ -5,8 +5,8 @@ module Bundler
     ILLFORMED_MESSAGE = 'Ill-formed requirement ["#<YAML::Syck::DefaultKey'.freeze
     include MatchPlatform
 
-    attr_reader :name, :version, :platform, :dependencies, :required_rubygems_version, :required_ruby_version, :checksum
-    attr_accessor :source, :remote
+    attr_reader :name, :version, :platform, :required_rubygems_version, :required_ruby_version, :checksum
+    attr_accessor :source, :remote, :dependencies
 
     def initialize(name, version, platform, dependencies, metadata = nil)
       @name         = name
@@ -91,13 +91,7 @@ module Bundler
     end
 
     def __swap__(spec)
-      without_type = proc {|d| Gem::Dependency.new(d.name, d.requirements_list.sort) }
-      if (extra_deps = spec.runtime_dependencies.map(&without_type).-(dependencies.map(&without_type))) && extra_deps.any?
-        Bundler.ui.debug "#{full_name} from #{remote} has corrupted API dependencies (API returned #{dependencies}, real spec has (#{spec.runtime_dependencies}))"
-        raise APIResponseMismatchError,
-          "Downloading #{full_name} revealed dependencies not in the API (#{extra_deps.map(&:to_s).join(", ")})." \
-          "\nInstalling with `--full-index` should fix the problem."
-      end
+      SharedHelpers.ensure_same_dependencies(self, dependencies, spec.dependencies)
       @remote_specification = spec
     end
 

data/lib/bundler/env.rb

@@ -5,12 +5,12 @@ require "bundler/source/git/git_proxy"
 module Bundler
   class Env
     def write(io)
-      io.write report(:print_gemfile => true, :print_gemspecs => true)
+      io.write report
     end
 
     def report(options = {})
-      print_gemfile = options.delete(:print_gemfile)
-      print_gemspecs = options.delete(:print_gemspecs)
+      print_gemfile = options.delete(:print_gemfile) { true }
+      print_gemspecs = options.delete(:print_gemspecs) { true }
 
       out = String.new("## Environment\n\n```\n")
       out << "Bundler   #{Bundler::VERSION}\n"

data/lib/bundler/errors.rb

@@ -138,7 +138,7 @@ module Bundler
   class NoSpaceOnDeviceError < PermissionError
     def message
       "There was an error while trying to #{action} `#{@path}`. " \
-      "There was insufficent space remaining on the device."
+      "There was insufficient space remaining on the device."
     end
 
     status_code(31)

data/lib/bundler/fetcher/downloader.rb

@@ -58,9 +58,10 @@ module Bundler
         case e.message
         when /host down:/, /getaddrinfo: nodename nor servname provided/
           raise NetworkDownError, "Could not reach host #{uri.host}. Check your network " \
-          "connection and try again."
+            "connection and try again."
         else
-          raise HTTPError, "Network error while fetching #{URICredentialsFilter.credential_filtered_uri(uri)}"
+          raise HTTPError, "Network error while fetching #{URICredentialsFilter.credential_filtered_uri(uri)}" \
+            " (#{e})"
         end
       end
 

data/lib/bundler/gem_helper.rb

@@ -94,6 +94,7 @@ module Bundler
     def rubygem_push(path)
       allowed_push_host = nil
       gem_command = "gem push '#{path}'"
+      gem_command += " --key #{gem_key}" if gem_key
       if @gemspec.respond_to?(:metadata)
         allowed_push_host = @gemspec.metadata["allowed_push_host"]
         gem_command += " --host #{allowed_push_host}" if allowed_push_host
@@ -181,6 +182,10 @@ module Bundler
       end
     end
 
+    def gem_key
+      Bundler.settings["gem.push_key"].to_s.downcase if Bundler.settings["gem.push_key"]
+    end
+
     def gem_push?
       !%w(n no nil false off 0).include?(ENV["gem_push"].to_s.downcase)
     end

data/lib/bundler/index.rb

@@ -58,17 +58,23 @@ module Bundler
     # Search this index's specs, and any source indexes that this index knows
     # about, returning all of the results.
     def search(query, base = nil)
+      sort_specs(unsorted_search(query, base))
+    end
+
+    def unsorted_search(query, base)
       results = local_search(query, base)
-      seen = results.map(&:full_name).to_set
+
+      seen = results.map(&:full_name).to_set unless @sources.empty?
 
       @sources.each do |source|
-        source.search(query, base).each do |spec|
+        source.unsorted_search(query, base).each do |spec|
           results << spec if seen.add?(spec.full_name)
         end
       end
 
-      sort_specs(results)
+      results
     end
+    protected :unsorted_search
 
     def self.sort_specs(specs)
       specs.sort_by do |s|

data/lib/bundler/injector.rb

@@ -27,17 +27,18 @@ module Bundler
       @new_deps -= builder.dependencies
 
       # add new deps to the end of the in-memory Gemfile
-      builder.eval_gemfile("injected gems", new_gem_lines) if @new_deps.any?
+      # Set conservative versioining to false because we want to let the resolver resolve the version first
+      builder.eval_gemfile("injected gems", build_gem_lines(false)) if @new_deps.any?
 
       # resolve to see if the new deps broke anything
-      definition = builder.to_definition(lockfile_path, {})
-      definition.resolve_remotely!
+      @definition = builder.to_definition(lockfile_path, {})
+      @definition.resolve_remotely!
 
       # since nothing broke, we can add those gems to the gemfile
-      append_to(gemfile_path) if @new_deps.any?
+      append_to(gemfile_path, build_gem_lines(@options[:conservative_versioning])) if @new_deps.any?
 
       # since we resolved successfully, write out the lockfile
-      definition.lock(Bundler.default_lockfile)
+      @definition.lock(Bundler.default_lockfile)
 
       # return an array of the deps that we added
       return @new_deps
@@ -47,17 +48,37 @@ module Bundler
 
   private
 
-    def new_gem_lines
+    def conservative_version(spec)
+      version = spec.version
+      return ">= 0" if version.nil?
+      segments = version.segments
+      seg_end_index = version >= Gem::Version.new("1.0") ? 1 : 2
+
+      prerelease_suffix = version.to_s.gsub(version.release.to_s, "") if version.prerelease?
+      "~> #{segments[0..seg_end_index].join(".")}#{prerelease_suffix}"
+    end
+
+    def build_gem_lines(conservative_versioning)
       @new_deps.map do |d|
-        name = "'#{d.name}'"
-        requirement = ", '#{d.requirement}'"
-        group = ", :group => #{d.groups.inspect}" if d.groups != Array(:default)
-        source = ", :source => '#{d.source}'" unless d.source.nil?
+        name = d.name.dump
+
+        requirement = if conservative_versioning
+          ", \"#{conservative_version(@definition.specs[d.name][0])}\""
+        else
+          ", #{d.requirement.as_list.map(&:dump).join(", ")}"
+        end
+
+        if d.groups != Array(:default)
+          group = d.groups.size == 1 ? ", :group => #{d.groups.inspect}" : ", :groups => #{d.groups.inspect}"
+        end
+
+        source = ", :source => \"#{d.source}\"" unless d.source.nil?
+
         %(gem #{name}#{requirement}#{group}#{source})
       end.join("\n")
     end
 
-    def append_to(gemfile_path)
+    def append_to(gemfile_path, new_gem_lines)
       gemfile_path.open("a") do |f|
         f.puts
         if @options["timestamp"] || @options["timestamp"].nil?

data/lib/bundler/installer.rb

@@ -49,7 +49,7 @@ module Bundler
     # Bundler returns a warning message stating so and this method returns.
     #
     # Fourthly, Bundler checks if the default lockfile (Gemfile.lock) exists, and if so
-    # then proceeds to set up a defintion based on the default gemfile (Gemfile) and the
+    # then proceeds to set up a definition based on the default gemfile (Gemfile) and the
     # default lock file (Gemfile.lock). However, this is not the case if the platform is different
     # to that which is specified in Gemfile.lock, or if there are any missing specs for the gems.
     #

data/lib/bundler/installer/parallel_installer.rb

@@ -90,6 +90,7 @@ module Bundler
       @standalone = standalone
       @force = force
       @specs = all_specs.map {|s| SpecInstallation.new(s) }
+      @spec_set = all_specs
     end
 
     def call
@@ -116,7 +117,7 @@ module Bundler
           spec_install.post_install_message = message
         elsif !success
           spec_install.state = :failed
-          spec_install.error = message
+          spec_install.error = "#{message}\n\n#{require_tree_for_spec(spec_install.spec)}"
         end
         spec_install
       }
@@ -166,6 +167,19 @@ module Bundler
       Bundler.ui.warn(warning.join("\n"))
     end
 
+    def require_tree_for_spec(spec)
+      tree = @spec_set.what_required(spec)
+      t = String.new("In #{File.basename(SharedHelpers.default_gemfile)}:\n")
+      tree.each_with_index do |s, depth|
+        t << "  " * depth.succ << s.name
+        unless tree.last == s
+          t << %( was resolved to #{s.version}, which depends on)
+        end
+        t << %(\n)
+      end
+      t
+    end
+
     # Keys in the remains hash represent uninstalled gems specs.
     # We enqueue all gem specs that do not have any dependencies.
     # Later we call this lambda again to install specs that depended on

data/lib/bundler/lazy_specification.rb

@@ -79,6 +79,7 @@ module Bundler
             "To use the platform-specific version of the gem, run `bundle config specific_platform true` and install again."
           search = source.specs.search(self).last
         end
+        search.dependencies = dependencies if search.is_a?(RemoteSpecification) || search.is_a?(EndpointSpecification)
         search
       end
     end
@@ -99,6 +100,11 @@ module Bundler
       @__identifier ||= Identifier.new(name, version, source, platform, dependencies)
     end
 
+    def git_version
+      return unless source.is_a?(Bundler::Source::Git)
+      " #{source.revision[0..6]}"
+    end
+
   private
 
     def to_ary

data/lib/bundler/lockfile_parser.rb

@@ -61,7 +61,7 @@ module Bundler
     def initialize(lockfile)
       @platforms    = []
       @sources      = []
-      @dependencies = []
+      @dependencies = {}
       @state        = nil
       @specs        = {}
 
@@ -171,43 +171,53 @@ module Bundler
       end
     end
 
-    NAME_VERSION = '(?! )(.*?)(?: \(([^-]*)(?:-(.*))?\))?'.freeze
-    NAME_VERSION_2 = /^ {2}#{NAME_VERSION}(!)?$/
-    NAME_VERSION_4 = /^ {4}#{NAME_VERSION}$/
-    NAME_VERSION_6 = /^ {6}#{NAME_VERSION}$/
+    space = / /
+    NAME_VERSION = /
+      ^(#{space}{2}|#{space}{4}|#{space}{6})(?!#{space}) # Exactly 2, 4, or 6 spaces at the start of the line
+      (.*?)                                              # Name
+      (?:#{space}\(([^-]*)                               # Space, followed by version
+      (?:-(.*))?\))?                                     # Optional platform
+      (!)?                                               # Optional pinned marker
+      $                                                  # Line end
+    /xo
 
     def parse_dependency(line)
-      if line =~ NAME_VERSION_2
-        name = $1
-        version = $2
-        pinned = $4
-        version = version.split(",").map(&:strip) if version
-
-        dep = Bundler::Dependency.new(name, version)
-
-        if pinned && dep.name != "bundler"
-          spec = @specs.find {|_, v| v.name == dep.name }
-          dep.source = spec.last.source if spec
-
-          # Path sources need to know what the default name / version
-          # to use in the case that there are no gemspecs present. A fake
-          # gemspec is created based on the version set on the dependency
-          # TODO: Use the version from the spec instead of from the dependency
-          if version && version.size == 1 && version.first =~ /^\s*= (.+)\s*$/ && dep.source.is_a?(Bundler::Source::Path)
-            dep.source.name    = name
-            dep.source.version = $1
-          end
+      return unless line =~ NAME_VERSION
+      spaces = $1
+      return unless spaces.size == 2
+      name = $2
+      version = $3
+      pinned = $5
+
+      version = version.split(",").map(&:strip) if version
+
+      dep = Bundler::Dependency.new(name, version)
+
+      if pinned && dep.name != "bundler"
+        spec = @specs.find {|_, v| v.name == dep.name }
+        dep.source = spec.last.source if spec
+
+        # Path sources need to know what the default name / version
+        # to use in the case that there are no gemspecs present. A fake
+        # gemspec is created based on the version set on the dependency
+        # TODO: Use the version from the spec instead of from the dependency
+        if version && version.size == 1 && version.first =~ /^\s*= (.+)\s*$/ && dep.source.is_a?(Bundler::Source::Path)
+          dep.source.name    = name
+          dep.source.version = $1
         end
-
-        @dependencies << dep
       end
+
+      @dependencies[dep.name] = dep
     end
 
     def parse_spec(line)
-      if line =~ NAME_VERSION_4
-        name = $1
-        version = $2
-        platform = $3
+      return unless line =~ NAME_VERSION
+      spaces = $1
+      name = $2
+      version = $3
+      platform = $4
+
+      if spaces.size == 4
         version = Gem::Version.new(version)
         platform = platform ? Gem::Platform.new(platform) : Gem::Platform::RUBY
         @current_spec = LazySpecification.new(name, version, platform)
@@ -216,9 +226,7 @@ module Bundler
         # Avoid introducing multiple copies of the same spec (caused by
         # duplicate GIT sections)
         @specs[@current_spec.identifier] ||= @current_spec
-      elsif line =~ NAME_VERSION_6
-        name = $1
-        version = $2
+      elsif spaces.size == 6
         version = version.split(",").map(&:strip) if version
         dep = Gem::Dependency.new(name, version)
         @current_spec.dependencies << dep

data/lib/bundler/mirror.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require "socket"
+
 module Bundler
   class Settings
     # Class used to build the mirror set and then find a mirror for a given URI

data/lib/bundler/plugin.rb

@@ -37,7 +37,11 @@ module Bundler
 
       save_plugins names, specs
     rescue PluginError => e
-      specs.values.map {|spec| Bundler.rm_rf(spec.full_gem_path) } if specs
+      if specs
+        specs_to_delete = Hash[specs.select {|k, _v| names.include?(k) && !index.commands.values.include?(k) }]
+        specs_to_delete.values.each {|spec| Bundler.rm_rf(spec.full_gem_path) }
+      end
+
       Bundler.ui.error "Failed to install plugin #{name}: #{e.message}\n  #{e.backtrace.join("\n ")}"
     end
 

data/lib/bundler/plugin/api/source.rb

@@ -6,7 +6,7 @@ module Bundler
   module Plugin
     class API
       # This class provides the base to build source plugins
-      # All the method here are require to build a source plugin (except
+      # All the method here are required to build a source plugin (except
       # `uri_hash`, `gem_install_dir`; they are helpers).
       #
       # Defaults for methods, where ever possible are provided which is

data/lib/bundler/plugin/index.rb

@@ -20,6 +20,8 @@ module Bundler
         end
       end
 
+      attr_reader :commands
+
       def initialize
         @plugin_paths = {}
         @commands = {}

data/lib/bundler/remote_specification.rb

@@ -11,6 +11,7 @@ module Bundler
     include Comparable
 
     attr_reader :name, :version, :platform
+    attr_writer :dependencies
     attr_accessor :source, :remote
 
     def initialize(name, version, platform, spec_fetcher)
@@ -18,6 +19,7 @@ module Bundler
       @version      = Gem::Version.create version
       @platform     = platform
       @spec_fetcher = spec_fetcher
+      @dependencies = nil
     end
 
     # Needed before installs, since the arch matters then and quick
@@ -49,13 +51,7 @@ module Bundler
     # once the remote gem is downloaded, the backend specification will
     # be swapped out.
     def __swap__(spec)
-      without_type = proc {|d| Gem::Dependency.new(d.name, d.requirements_list) }
-      if (extra_deps = spec.runtime_dependencies.map(&without_type).-(dependencies.map(&without_type))) && extra_deps.any?
-        Bundler.ui.debug "#{full_name} from #{remote} has corrupted API dependencies (API returned #{dependencies}, real spec has (#{spec.runtime_dependencies}))"
-        raise APIResponseMismatchError,
-          "Downloading #{full_name} revealed dependencies not in the API (#{extra_deps.map(&without_type).map(&:to_s).join(", ")})." \
-          "\nInstalling with `--full-index` should fix the problem."
-      end
+      SharedHelpers.ensure_same_dependencies(self, dependencies, spec.dependencies)
       @_remote_specification = spec
     end
 
@@ -76,8 +72,21 @@ module Bundler
       "#<#{self.class} name=#{name} version=#{version} platform=#{platform}>"
     end
 
+    def dependencies
+      @dependencies || method_missing(:dependencies)
+    end
+
+    def git_version
+      return unless loaded_from && source.is_a?(Bundler::Source::Git)
+      " #{source.revision[0..6]}"
+    end
+
   private
 
+    def to_ary
+      nil
+    end
+
     def _remote_specification
       @_remote_specification ||= @spec_fetcher.fetch_spec([@name, @version, @platform])
       @_remote_specification || raise(GemspecError, "Gemspec data for #{full_name} was" \