[WIP]Add pristine command and spec

lib/bundler/cli.rb

@@ -491,6 +491,17 @@ def doctor
       Doctor.new(options).run
     end
 
+    desc "pristine [GEMNAME ...] [OPTIONS]", "Restores installed gems to pristine condition from your "
+    method_option "skip", :type => :array, :default => [], :banner => "Used on --all, skip if name == gem_name"
+    method_option "extensions", :type => :boolean, :default => false, :banner =>
+        "If –extensions is given (but not –all or gem names) only gems with extensions will be restored."
+    method_option "no-extensions", :type => :boolean, :default => false, :banner =>
+        "If –no-extensions is provided pristine will not attempt to restore a gem with an extension."
+    def pristine(*gem_list)
+      require "bundler/cli/pristine"
+      Pristine.new(options, gem_list).run
+    end
+
     if Bundler.settings[:plugins]
       require "bundler/cli/plugin"
       desc "plugin SUBCOMMAND ...ARGS", "manage the bundler plugins"

lib/bundler/cli/pristine.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+require "bundler/cli/exec"
+module Bundler
+  class CLI::Pristine
+    class ConflictingGems < PristineError
+    end
+    class AmbiguousOption < PristineError
+    end
+    attr_reader :options, :gem_list
+
+    def initialize(options, gem_list)
+      @options = options
+      @gem_list = gem_list
+    end
+
+    def run
+      # Determine if -extensions and --no-extensions or  are conflict
+      if options["extensions"] && options["no-extensions"]
+        Bundler.ui.error "You can't use --extensions and --no-extensions at the same time"
+        raise AmbiguousOption
+      end
+
+      # Raise error when Gemfile is not present
+      definition = begin
+        Bundler.definition
+      rescue GemfileNotFound
+        Bundler.ui.error "You can't pristine without a Gemfile. Please consider add Gemfile then run `bundle install` before pristine"
+        raise
+      end
+      # Raise error when lockfile is not present
+      unless Bundler.default_lockfile.exist?
+        Bundler.ui.error "You can't pristine without a Gemfile.lock. Please consider run `bundle install` before pristine"
+        raise GemfileLockNotFound, "Could not locate Gemfile.lock"
+      end
+
+      # Find the path gems and exclude them from calling gem pristine
+      # If gem list is empty, we need to add everything to pristine_gems, else we can use things from the gem_list
+      if gem_list.empty?
+        pristine_gems = definition.calculate_non_path_gem_list
+        git_gems = definition.calculate_git_gems
+        path_gems = definition.calculate_path_only_gems
+        warn_path_gems(path_gems)
+        pristine(pristine_gems, git_gems, true)
+      else
+        check_conflicting(gem_list, options[:skip])
+        pristine(gem_list)
+      end
+    end
+
+  private
+
+    def check_conflicting(gem_list, skip_gems)
+      conflicting_gems = skip_gems & gem_list
+      return if conflicting_gems.empty?
+      Bundler.ui.error "You can't list a gem in both GEMLIST and --skip." \
+          "The offending gems are: #{conflicting_gems.join(", ")}."
+      raise ConflictingGems
+    end
+
+    def pristine(gems, git_gems = nil, lazy_spec_provided = false)
+      gem_list = lazy_spec_provided ? gems.map(&:name) : gems
+      skip_gems = options[:skip]
+      pristine_gems = compute_pristine_gems(gem_list, skip_gems)
+      binding.pry
+      pristine_gems.each do |gem|
+        command = String.new("gem pristine #{gem}")
+        command << " -v #{gem.version}" if lazy_spec_provided && gem.respond_to?(:version)
+        command << " --extensions" if options["extensions"]
+        command << " --no-extensions" if options["no-extensions"]
+        CLI.start(command.split)
+      end
+      pristine_git_gems(git_gems)
+    end
+
+    def warn_path_gems(path_gems)
+      # Warn about the path gems
+      return if path_gems.empty?
+      message = String.new
+      message << "At this moment, Bundler cannot prstine the following gems:"
+      path_gems.each do |gem|
+        message << "* #{gem.name} at #{gem.source.path}"
+      end
+      Bundler.ui.warn(message)
+    end
+
+    def pristine_git_gems(gems)
+      # Pristine git gems
+    end
+
+    def compute_pristine_gems(gems, skip_gems)
+      if gems.is_a?(SpecSet)
+        gems.reject {|gem| skip_gems.include? gem.name }
+      else
+        gems - skip_gems
+      end
+    end
+  end
+end

lib/bundler/definition.rb

@@ -12,6 +12,7 @@ class Definition
       :gem_version_promoter,
       :locked_deps,
       :locked_gems,
+      :locked_specs,
       :platforms,
       :requires,
       :ruby_version
@@ -413,8 +414,8 @@ def ensure_equivalent_gemfile_and_lockfile(explicit_flag = false)
 
       # Check if it is possible that the source is only changed thing
       if (new_deps.empty? && deleted_deps.empty?) && (!new_sources.empty? && !deleted_sources.empty?)
-        new_sources.reject! {|source| source.is_a_path? && source.path.exist? }
-        deleted_sources.reject! {|source| source.is_a_path? && source.path.exist? }
+        new_sources.reject! {|source| source.a_path? && source.path.exist? }
+        deleted_sources.reject! {|source| source.a_path? && source.path.exist? }
       end
 
       if @locked_sources != gemfile_sources
@@ -486,6 +487,26 @@ def remove_platform(platform)
       raise InvalidOption, "Unable to remove the platform `#{platform}` since the only platforms are #{@platforms.join ", "}"
     end
 
+    def any_path_sources?
+      !sources.path_sources.empty?
+    end
+
+    def any_git_sources?
+      !sources.git_sources.empty?
+    end
+
+    def calculate_non_path_gem_list
+      SpecSet.new(@locked_specs.reject {|locked_spec| locked_spec.source && locked_spec.source.a_path? })
+    end
+
+    def calculate_git_gems
+      @locked_deps.select {|locked_spec| locked_spec.source && locked_spec.source.a_git? }
+    end
+
+    def calculate_path_only_gems
+      @locked_deps.select {|locked_spec| locked_spec.source && locked_spec.source.a_path? && !locked_spec.source.a_git? }
+    end
+
     attr_reader :sources
     private :sources
 

lib/bundler/errors.rb

@@ -52,6 +52,7 @@ class LockfileError < BundlerError; status_code(20); end
   class CyclicDependencyError < BundlerError; status_code(21); end
   class GemfileLockNotFound < BundlerError; status_code(22); end
   class PluginError < BundlerError; status_code(29); end
+  class PristineError < BundlerError; status_code(30); end
   class GemfileEvalError < GemfileError; end
   class MarshalError < StandardError; end
 

lib/bundler/source.rb

@@ -33,5 +33,13 @@ def can_lock?(spec)
     def include?(other)
       other == self
     end
+
+    def a_path?
+      instance_of?(Path)
+    end
+
+    def a_git?
+      instance_of?(Git)
+    end
   end
 end

lib/bundler/source/path.rb

@@ -111,10 +111,6 @@ def root
         Bundler.root
       end
 
-      def is_a_path?
-        instance_of?(Path)
-      end
-
     private
 
       def expanded_path

spec/commands/pristine_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require "spec_helper"
+describe "bundle pristine" do
+  context "when the Gemfile is missing" do
+    it "should provide useful information" do
+      bundle "pristine"
+      expect(out).to include "You can't pristine without a Gemfile. Please consider add Gemfile"
+      expect(out).to include "Could not locate Gemfile"
+    end
+  end
+
+  context "when the Gemfile is present and Gemfile.lock is missing" do
+    before :each do
+      gemfile <<-G
+        source "file://#{gem_repo1}"
+        gem "rack", "1.0.0"
+        gem "foo", "1.2.3"
+      G
+    end
+    it "should provide useful information" do
+      bundle "pristine"
+      expect(out).to include "You can't pristine without a Gemfile.lock. Please consider run `bundle install`"
+      expect(out).to include "Could not locate Gemfile.lock"
+    end
+  end
+
+  context "when both the Gemfile and the Gemfile.lock is present" do
+    before :each do
+      install_gemfile <<-G
+        source "file://#{gem_repo1}"
+        gem "rack", "1.0.0"
+        gem "foo", "1.2.3"
+      G
+    end
+  end
+end