bundler 1.9.0 → 1.17.3

data/lib/bundler/cli/package.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bundler
   class CLI::Package
     attr_reader :options
@@ -8,22 +10,22 @@ module Bundler
 
     def run
       Bundler.ui.level = "error" if options[:quiet]
-      Bundler.settings[:path] = File.expand_path(options[:path]) if options[:path]
-      Bundler.settings[:cache_all_platforms] = options["all-platforms"] if options.key?("all-platforms")
-      Bundler.settings[:cache_path] = options["cache-path"] if options.key?("cache-path")
+      Bundler.settings.set_command_option_if_given :path, options[:path]
+      Bundler.settings.set_command_option_if_given :cache_all_platforms, options["all-platforms"]
+      Bundler.settings.set_command_option_if_given :cache_path, options["cache-path"]
 
       setup_cache_all
       install
 
       # TODO: move cache contents here now that all bundles are locked
-      custom_path = Pathname.new(options[:path]) if options[:path]
+      custom_path = Bundler.settings[:path] if options[:path]
       Bundler.load.cache(custom_path)
     end
 
   private
 
     def install
-      require 'bundler/cli/install'
+      require "bundler/cli/install"
       options = self.options.dup
       if Bundler.settings[:cache_all_platforms]
         options["local"] = false
@@ -33,9 +35,11 @@ module Bundler
     end
 
     def setup_cache_all
-      Bundler.settings[:cache_all] = options[:all] if options.key?("all")
+      all = options.fetch(:all, Bundler.feature_flag.cache_command_is_package? || nil)
+
+      Bundler.settings.set_command_option_if_given :cache_all, all
 
-      if Bundler.definition.has_local_dependencies? && !Bundler.settings[:cache_all]
+      if Bundler.definition.has_local_dependencies? && !Bundler.feature_flag.cache_all?
         Bundler.ui.warn "Your Gemfile contains path and git dependencies. If you want "    \
           "to package them as well, please pass the --all flag. This will be the default " \
           "on Bundler 2.0."

data/lib/bundler/cli/platform.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bundler
   class CLI::Platform
     attr_reader :options
@@ -7,8 +9,10 @@ module Bundler
 
     def run
       platforms, ruby_version = Bundler.ui.silence do
-        [ Bundler.definition.platforms.map {|p| "* #{p}" },
-          Bundler.definition.ruby_version ]
+        locked_ruby_version = Bundler.locked_gems && Bundler.locked_gems.ruby_version
+        gemfile_ruby_version = Bundler.definition.ruby_version && Bundler.definition.ruby_version.single_version_string
+        [Bundler.definition.platforms.map {|p| "* #{p}" },
+         locked_ruby_version || gemfile_ruby_version]
       end
       output = []
 
@@ -26,7 +30,7 @@ module Bundler
           output << "Your Gemfile specifies a Ruby version requirement:\n* #{ruby_version}"
 
           begin
-            Bundler.definition.validate_ruby!
+            Bundler.definition.validate_runtime!
             output << "Your current platform satisfies the Ruby version requirement."
           rescue RubyVersionMismatch => e
             output << e.message
@@ -38,6 +42,5 @@ module Bundler
 
       Bundler.ui.info output.join("\n\n")
     end
-
   end
 end

data/lib/bundler/cli/plugin.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "bundler/vendored_thor"
+module Bundler
+  class CLI::Plugin < Thor
+    desc "install PLUGINS", "Install the plugin from the source"
+    long_desc <<-D
+      Install plugins either from the rubygems source provided (with --source option) or from a git source provided with (--git option). If no sources are provided, it uses Gem.sources
+   D
+    method_option "source", :type => :string, :default => nil, :banner =>
+      "URL of the RubyGems source to fetch the plugin from"
+    method_option "version", :type => :string, :default => nil, :banner =>
+      "The version of the plugin to fetch"
+    method_option "git", :type => :string, :default => nil, :banner =>
+      "URL of the git repo to fetch from"
+    method_option "branch", :type => :string, :default => nil, :banner =>
+      "The git branch to checkout"
+    method_option "ref", :type => :string, :default => nil, :banner =>
+      "The git revision to check out"
+    def install(*plugins)
+      Bundler::Plugin.install(plugins, options)
+    end
+  end
+end

data/lib/bundler/cli/pristine.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Pristine
+    def initialize(gems)
+      @gems = gems
+    end
+
+    def run
+      CLI::Common.ensure_all_gems_in_lockfile!(@gems)
+      definition = Bundler.definition
+      definition.validate_runtime!
+      installer = Bundler::Installer.new(Bundler.root, definition)
+
+      Bundler.load.specs.each do |spec|
+        next if spec.name == "bundler" # Source::Rubygems doesn't install bundler
+        next if !@gems.empty? && !@gems.include?(spec.name)
+
+        gem_name = "#{spec.name} (#{spec.version}#{spec.git_version})"
+        gem_name += " (#{spec.platform})" if !spec.platform.nil? && spec.platform != Gem::Platform::RUBY
+
+        case source = spec.source
+        when Source::Rubygems
+          cached_gem = spec.cache_file
+          unless File.exist?(cached_gem)
+            Bundler.ui.error("Failed to pristine #{gem_name}. Cached gem #{cached_gem} does not exist.")
+            next
+          end
+
+          FileUtils.rm_rf spec.full_gem_path
+        when Source::Git
+          source.remote!
+          if extension_cache_path = source.extension_cache_path(spec)
+            FileUtils.rm_rf extension_cache_path
+          end
+          FileUtils.rm_rf spec.extension_dir if spec.respond_to?(:extension_dir)
+          FileUtils.rm_rf spec.full_gem_path
+        else
+          Bundler.ui.warn("Cannot pristine #{gem_name}. Gem is sourced from local path.")
+          next
+        end
+
+        Bundler::GemInstaller.new(spec, installer, false, 0, true).install_from_spec
+      end
+    end
+  end
+end

data/lib/bundler/cli/remove.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Remove
+    def initialize(gems, options)
+      @gems = gems
+      @options = options
+    end
+
+    def run
+      raise InvalidOption, "Please specify gems to remove." if @gems.empty?
+
+      Injector.remove(@gems, {})
+
+      Installer.install(Bundler.root, Bundler.definition) if @options["install"]
+    end
+  end
+end

data/lib/bundler/cli/show.rb

@@ -1,4 +1,4 @@
-require 'bundler/cli/common'
+# frozen_string_literal: true
 
 module Bundler
   class CLI::Show
@@ -12,7 +12,7 @@ module Bundler
 
     def run
       Bundler.ui.silence do
-        Bundler.definition.validate_ruby!
+        Bundler.definition.validate_runtime!
         Bundler.load.lock
       end
 
@@ -23,7 +23,7 @@ module Bundler
           spec = Bundler::CLI::Common.select_spec(gem_name, :regex_match)
           return unless spec
           path = spec.full_gem_path
-          if !File.directory?(path)
+          unless File.directory?(path)
             Bundler.ui.warn "The gem #{gem_name} has been deleted. It was installed at:"
           end
         end
@@ -31,19 +31,19 @@ module Bundler
       end
 
       if options[:paths]
-        Bundler.load.specs.sort_by { |s| s.name }.map do |s|
+        Bundler.load.specs.sort_by(&:name).map do |s|
           Bundler.ui.info s.full_gem_path
         end
       else
         Bundler.ui.info "Gems included by the bundle:"
-        Bundler.load.specs.sort_by { |s| s.name }.each do |s|
+        Bundler.load.specs.sort_by(&:name).each do |s|
           desc = "  * #{s.name} (#{s.version}#{s.git_version})"
           if @verbose
-            latest = latest_specs.find { |l| l.name == s.name }
-            Bundler.ui.info <<-END.gsub(/^ +/, '')
+            latest = latest_specs.find {|l| l.name == s.name }
+            Bundler.ui.info <<-END.gsub(/^ +/, "")
               #{desc}
-              \tSummary:  #{s.summary || 'No description available.'}
-              \tHomepage: #{s.homepage || 'No website available.'}
+              \tSummary:  #{s.summary || "No description available."}
+              \tHomepage: #{s.homepage || "No website available."}
               \tStatus:   #{outdated?(s, latest) ? "Outdated - #{s.version} < #{latest.version}" : "Up to date"}
             END
           else
@@ -53,7 +53,7 @@ module Bundler
       end
     end
 
-    private
+  private
 
     def fetch_latest_specs
       definition = Bundler.definition(true)
@@ -63,6 +63,7 @@ module Bundler
       else
         definition.resolve_with_cache!
       end
+      Bundler.reset!
       definition.specs
     end
 

data/lib/bundler/cli/update.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bundler
   class CLI::Update
     attr_reader :options, :gems
@@ -9,10 +11,23 @@ module Bundler
     def run
       Bundler.ui.level = "error" if options[:quiet]
 
+      Plugin.gemfile_install(Bundler.default_gemfile) if Bundler.feature_flag.plugins?
+
       sources = Array(options[:source])
       groups  = Array(options[:group]).map(&:to_sym)
 
-      if gems.empty? && sources.empty? && groups.empty?
+      full_update = gems.empty? && sources.empty? && groups.empty? && !options[:ruby] && !options[:bundler]
+
+      if full_update && !options[:all]
+        if Bundler.feature_flag.update_requires_all_flag?
+          raise InvalidOption, "To update everything, pass the `--all` flag."
+        end
+        SharedHelpers.major_deprecation 2, "Pass --all to `bundle update` to update everything"
+      elsif !full_update && options[:all]
+        raise InvalidOption, "Cannot specify --all along with specific options."
+      end
+
+      if full_update
         # We're doing a full update
         Bundler.definition(true)
       else
@@ -20,54 +35,57 @@ module Bundler
           raise GemfileLockNotFound, "This Bundle hasn't been installed yet. " \
             "Run `bundle install` to update and install the bundled gems."
         end
-        # cycle through the requested gems, just to make sure they exist
-        names = Bundler.locked_gems.specs.map{ |s| s.name }
-        gems.each do |g|
-          next if names.include?(g)
-          require "bundler/cli/common"
-          raise GemNotFound, Bundler::CLI::Common.gem_not_found_message(g, names)
-        end
+        Bundler::CLI::Common.ensure_all_gems_in_lockfile!(gems)
 
         if groups.any?
-          specs = Bundler.definition.specs_for groups
-          sources.concat(specs.map(&:name))
+          deps = Bundler.definition.dependencies.select {|d| (d.groups & groups).any? }
+          gems.concat(deps.map(&:name))
         end
 
-        Bundler.definition(:gems => gems, :sources => sources)
+        Bundler.definition(:gems => gems, :sources => sources, :ruby => options[:ruby],
+                           :lock_shared_dependencies => options[:conservative],
+                           :bundler => options[:bundler])
       end
 
+      Bundler::CLI::Common.configure_gem_version_promoter(Bundler.definition, options)
+
       Bundler::Fetcher.disable_endpoint = options["full-index"]
 
       opts = options.dup
       opts["update"] = true
       opts["local"] = options[:local]
 
-      Bundler.settings[:jobs] = opts["jobs"] if opts["jobs"]
-
-      # rubygems plugins sometimes hook into the gem install process
-      Gem.load_env_plugins if Gem.respond_to?(:load_env_plugins)
+      Bundler.settings.set_command_option_if_given :jobs, opts["jobs"]
 
-      Bundler.definition.validate_ruby!
-      Installer.install Bundler.root, Bundler.definition, opts
+      Bundler.definition.validate_runtime!
+      installer = Installer.install Bundler.root, Bundler.definition, opts
       Bundler.load.cache if Bundler.app_cache.exist?
 
-      if Bundler.settings[:clean] && Bundler.settings[:path]
+      if CLI::Common.clean_after_install?
         require "bundler/cli/clean"
         Bundler::CLI::Clean.new(options).run
       end
 
-      Bundler.ui.confirm "Bundle updated!"
-      without_groups_messages
-    end
-
-  private
-
-    def without_groups_messages
-      if Bundler.settings.without.any?
-        require "bundler/cli/common"
-        Bundler.ui.confirm Bundler::CLI::Common.without_groups_message
+      if locked_gems = Bundler.definition.locked_gems
+        gems.each do |name|
+          locked_version = locked_gems.specs.find {|s| s.name == name }
+          locked_version &&= locked_version.version
+          next unless locked_version
+          new_version = Bundler.definition.specs[name].first
+          new_version &&= new_version.version
+          if !new_version
+            Bundler.ui.warn "Bundler attempted to update #{name} but it was removed from the bundle"
+          elsif new_version < locked_version
+            Bundler.ui.warn "Note: #{name} version regressed from #{locked_version} to #{new_version}"
+          elsif new_version == locked_version
+            Bundler.ui.warn "Bundler attempted to update #{name} but its version stayed the same"
+          end
+        end
       end
-    end
 
+      Bundler.ui.confirm "Bundle updated!"
+      Bundler::CLI::Common.output_without_groups_message
+      Bundler::CLI::Common.output_post_install_messages installer.post_install_messages
+    end
   end
 end

data/lib/bundler/cli/viz.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bundler
   class CLI::Viz
     attr_reader :options, :gem_name
@@ -6,8 +8,14 @@ module Bundler
     end
 
     def run
-      require 'graphviz'
+      # make sure we get the right `graphviz`. There is also a `graphviz`
+      # gem we're not built to support
+      gem "ruby-graphviz"
+      require "graphviz"
+
+      options[:without] = options[:without].join(":").tr(" ", ":").split(":")
       output_file = File.expand_path(options[:file])
+
       graph = Graph.new(Bundler.load, output_file, options[:version], options[:requirements], options[:format], options[:without])
       graph.viz
     rescue LoadError => e
@@ -15,13 +23,9 @@ module Bundler
       Bundler.ui.warn "Make sure you have the graphviz ruby gem. You can install it with:"
       Bundler.ui.warn "`gem install ruby-graphviz`"
     rescue StandardError => e
-      if e.message =~ /GraphViz not installed or dot not in PATH/
-        Bundler.ui.error e.message
-        Bundler.ui.warn "Please install GraphViz. On a Mac with homebrew, you can run `brew install graphviz`."
-      else
-        raise
-      end
+      raise unless e.message =~ /GraphViz not installed or dot not in PATH/
+      Bundler.ui.error e.message
+      Bundler.ui.warn "Please install GraphViz. On a Mac with Homebrew, you can run `brew install graphviz`."
     end
-
   end
 end

data/lib/bundler/compact_index_client.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "set"
+
+module Bundler
+  class CompactIndexClient
+    DEBUG_MUTEX = Mutex.new
+    def self.debug
+      return unless ENV["DEBUG_COMPACT_INDEX"]
+      DEBUG_MUTEX.synchronize { warn("[#{self}] #{yield}") }
+    end
+
+    class Error < StandardError; end
+
+    require "bundler/compact_index_client/cache"
+    require "bundler/compact_index_client/updater"
+
+    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 = {}
+      @parsed_checksums = false
+      @mutex = Mutex.new
+      @in_parallel = lambda do |inputs, &blk|
+        inputs.map(&blk)
+      end
+    end
+
+    def names
+      Bundler::CompactIndexClient.debug { "/names" }
+      update(@cache.names_path, "names")
+      @cache.names
+    end
+
+    def versions
+      Bundler::CompactIndexClient.debug { "/versions" }
+      update(@cache.versions_path, "versions")
+      versions, @info_checksums_by_name = @cache.versions
+      versions
+    end
+
+    def dependencies(names)
+      Bundler::CompactIndexClient.debug { "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)
+      Bundler::CompactIndexClient.debug { "spec(name = #{name}, version = #{version}, platform = #{platform})" }
+      update_info(name)
+      @cache.specific_dependency(name, version, platform)
+    end
+
+    def update_and_parse_checksums!
+      Bundler::CompactIndexClient.debug { "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)
+      Bundler::CompactIndexClient.debug { "update(#{local_path}, #{remote_path})" }
+      unless synchronize { @endpoints.add?(remote_path) }
+        Bundler::CompactIndexClient.debug { "already fetched #{remote_path}" }
+        return
+      end
+      @updater.update(local_path, url(remote_path))
+    end
+
+    def update_info(name)
+      Bundler::CompactIndexClient.debug { "update_info(#{name})" }
+      path = @cache.info_path(name)
+      checksum = @updater.checksum_for_file(path)
+      unless existing = @info_checksums_by_name[name]
+        Bundler::CompactIndexClient.debug { "skipping updating info for #{name} since it is missing from versions" }
+        return
+      end
+      if checksum == existing
+        Bundler::CompactIndexClient.debug { "skipping updating info for #{name} since the versions checksum matches the local checksum" }
+        return
+      end
+      Bundler::CompactIndexClient.debug { "updating info for #{name} since the versions checksum #{existing} != the local checksum #{checksum}" }
+      update(path, "info/#{name}")
+    end
+
+    def url(path)
+      path
+    end
+
+    def synchronize
+      @mutex.synchronize { yield }
+    end
+  end
+end