[ParallelInstaller] Wrap in the Bundler namespaceseg-parallel-installer-namespace

2 files changed, 108 insertions, 106 deletions

diff --git a/lib/bundler/installer/parallel_installer.rb b/lib/bundler/installer/parallel_installer.rb
index bd19da475b..d3ae86d174 100644
--- a/lib/bundler/installer/parallel_installer.rb
+++ b/lib/bundler/installer/parallel_installer.rb
@@ -2,124 +2,126 @@
 require "bundler/worker"
 require "bundler/installer/gem_installer"
 
-class ParallelInstaller
-  class SpecInstallation
-    attr_accessor :spec, :name, :post_install_message, :state
-    def initialize(spec)
-      @spec = spec
-      @name = spec.name
-      @state = :none
-      @post_install_message = ""
-    end
+module Bundler
+  class ParallelInstaller
+    class SpecInstallation
+      attr_accessor :spec, :name, :post_install_message, :state
+      def initialize(spec)
+        @spec = spec
+        @name = spec.name
+        @state = :none
+        @post_install_message = ""
+      end
 
-    def installed?
-      state == :installed
-    end
+      def installed?
+        state == :installed
+      end
 
-    def enqueued?
-      state == :enqueued
-    end
+      def enqueued?
+        state == :enqueued
+      end
 
-    # Only true when spec in neither installed nor already enqueued
-    def ready_to_enqueue?
-      !installed? && !enqueued?
-    end
+      # Only true when spec in neither installed nor already enqueued
+      def ready_to_enqueue?
+        !installed? && !enqueued?
+      end
 
-    def has_post_install_message?
-      !post_install_message.empty?
-    end
+      def has_post_install_message?
+        !post_install_message.empty?
+      end
 
-    def ignorable_dependency?(dep)
-      dep.type == :development || dep.name == @name
-    end
+      def ignorable_dependency?(dep)
+        dep.type == :development || dep.name == @name
+      end
 
-    # Checks installed dependencies against spec's dependencies to make
-    # sure needed dependencies have been installed.
-    def dependencies_installed?(all_specs)
-      installed_specs = all_specs.select(&:installed?).map(&:name)
-      dependencies(all_specs.map(&:name)).all? {|d| installed_specs.include? d.name }
-    end
+      # Checks installed dependencies against spec's dependencies to make
+      # sure needed dependencies have been installed.
+      def dependencies_installed?(all_specs)
+        installed_specs = all_specs.select(&:installed?).map(&:name)
+        dependencies(all_specs.map(&:name)).all? {|d| installed_specs.include? d.name }
+      end
 
-    # Represents only the non-development dependencies, the ones that are
-    # itself and are in the total list.
-    def dependencies(all_spec_names)
-      @dependencies ||= begin
-        deps = all_dependencies.reject {|dep| ignorable_dependency? dep }
-        missing = deps.reject {|dep| all_spec_names.include? dep.name }
-        unless missing.empty?
-          raise Bundler::LockfileError, "Your Gemfile.lock is corrupt. The following #{missing.size > 1 ? "gems are" : "gem is"} missing " \
-                              "from the DEPENDENCIES section: '#{missing.map(&:name).join('\' \'')}'"
+      # Represents only the non-development dependencies, the ones that are
+      # itself and are in the total list.
+      def dependencies(all_spec_names)
+        @dependencies ||= begin
+          deps = all_dependencies.reject {|dep| ignorable_dependency? dep }
+          missing = deps.reject {|dep| all_spec_names.include? dep.name }
+          unless missing.empty?
+            raise Bundler::LockfileError, "Your Gemfile.lock is corrupt. The following #{missing.size > 1 ? "gems are" : "gem is"} missing " \
+                                "from the DEPENDENCIES section: '#{missing.map(&:name).join('\' \'')}'"
+          end
+          deps
         end
-        deps
       end
-    end
 
-    # Represents all dependencies
-    def all_dependencies
-      @spec.dependencies
+      # Represents all dependencies
+      def all_dependencies
+        @spec.dependencies
+      end
     end
-  end
 
-  def self.call(*args)
-    new(*args).call
-  end
+    def self.call(*args)
+      new(*args).call
+    end
 
-  # Returns max number of threads machine can handle with a min of 1
-  def self.max_threads
-    [Bundler.settings[:jobs].to_i - 1, 1].max
-  end
+    # Returns max number of threads machine can handle with a min of 1
+    def self.max_threads
+      [Bundler.settings[:jobs].to_i - 1, 1].max
+    end
 
-  def initialize(installer, all_specs, size, standalone, force)
-    @installer = installer
-    @size = size
-    @standalone = standalone
-    @force = force
-    @specs = all_specs.map {|s| SpecInstallation.new(s) }
-  end
+    def initialize(installer, all_specs, size, standalone, force)
+      @installer = installer
+      @size = size
+      @standalone = standalone
+      @force = force
+      @specs = all_specs.map {|s| SpecInstallation.new(s) }
+    end
 
-  def call
-    enqueue_specs
-    process_specs until @specs.all?(&:installed?)
-  ensure
-    worker_pool && worker_pool.stop
-  end
+    def call
+      enqueue_specs
+      process_specs until @specs.all?(&:installed?)
+    ensure
+      worker_pool && worker_pool.stop
+    end
 
-  def worker_pool
-    @worker_pool ||= Bundler::Worker.new @size, "Parallel Installer", lambda { |spec_install, worker_num|
-      message = Bundler::GemInstaller.new(
-        spec_install.spec, @installer, @standalone, worker_num, @force
-      ).install_from_spec
-      spec_install.post_install_message = message unless message.nil?
-      spec_install
-    }
-  end
+    def worker_pool
+      @worker_pool ||= Bundler::Worker.new @size, "Parallel Installer", lambda { |spec_install, worker_num|
+        message = Bundler::GemInstaller.new(
+          spec_install.spec, @installer, @standalone, worker_num, @force
+        ).install_from_spec
+        spec_install.post_install_message = message unless message.nil?
+        spec_install
+      }
+    end
 
-  # Dequeue a spec and save its post-install message and then enqueue the
-  # remaining specs.
-  # Some specs might've had to wait til this spec was installed to be
-  # processed so the call to `enqueue_specs` is important after every
-  # dequeue.
-  def process_specs
-    spec = worker_pool.deq
-    spec.state = :installed
-    collect_post_install_message spec if spec.has_post_install_message?
-    enqueue_specs
-  end
+    # Dequeue a spec and save its post-install message and then enqueue the
+    # remaining specs.
+    # Some specs might've had to wait til this spec was installed to be
+    # processed so the call to `enqueue_specs` is important after every
+    # dequeue.
+    def process_specs
+      spec = worker_pool.deq
+      spec.state = :installed
+      collect_post_install_message spec if spec.has_post_install_message?
+      enqueue_specs
+    end
 
-  def collect_post_install_message(spec)
-    Bundler::Installer.post_install_messages[spec.name] = spec.post_install_message
-  end
+    def collect_post_install_message(spec)
+      Bundler::Installer.post_install_messages[spec.name] = spec.post_install_message
+    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
-  # previously installed specifications. We continue until all specs
-  # are installed.
-  def enqueue_specs
-    @specs.select(&:ready_to_enqueue?).each do |spec|
-      if spec.dependencies_installed? @specs
-        worker_pool.enq spec
-        spec.state = :enqueued
+    # 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
+    # previously installed specifications. We continue until all specs
+    # are installed.
+    def enqueue_specs
+      @specs.select(&:ready_to_enqueue?).each do |spec|
+        if spec.dependencies_installed? @specs
+          worker_pool.enq spec
+          spec.state = :enqueued
+        end
       end
     end
   end
diff --git a/spec/install/parallel/spec_installation_spec.rb b/spec/install/parallel/spec_installation_spec.rb
index 9a8e1cad31..7bbd2bd0e6 100644
--- a/spec/install/parallel/spec_installation_spec.rb
+++ b/spec/install/parallel/spec_installation_spec.rb
@@ -2,7 +2,7 @@
 require "spec_helper"
 require "bundler/installer/parallel_installer"
 
-describe ParallelInstaller::SpecInstallation do
+describe Bundler::ParallelInstaller::SpecInstallation do
   let!(:dep) do
     a_spec = Object.new
     def a_spec.name
@@ -14,7 +14,7 @@ describe ParallelInstaller::SpecInstallation do
   describe "#ready_to_enqueue?" do
     context "when in enqueued state" do
       it "is falsey" do
-        spec = ParallelInstaller::SpecInstallation.new(dep)
+        spec = described_class.new(dep)
         spec.state = :enqueued
         expect(spec.ready_to_enqueue?).to be_falsey
       end
@@ -22,14 +22,14 @@ describe ParallelInstaller::SpecInstallation do
 
     context "when in installed state" do
       it "returns falsey" do
-        spec = ParallelInstaller::SpecInstallation.new(dep)
+        spec = described_class.new(dep)
         spec.state = :installed
         expect(spec.ready_to_enqueue?).to be_falsey
       end
     end
 
     it "returns truthy" do
-      spec = ParallelInstaller::SpecInstallation.new(dep)
+      spec = described_class.new(dep)
       expect(spec.ready_to_enqueue?).to be_truthy
     end
   end
@@ -41,7 +41,7 @@ describe ParallelInstaller::SpecInstallation do
         dependencies << instance_double("SpecInstallation", :spec => "alpha", :name => "alpha", :installed? => true, :all_dependencies => [], :type => :production)
         dependencies << instance_double("SpecInstallation", :spec => "beta", :name => "beta", :installed? => true, :all_dependencies => [], :type => :production)
         all_specs = dependencies + [instance_double("SpecInstallation", :spec => "gamma", :name => "gamma", :installed? => false, :all_dependencies => [], :type => :production)]
-        spec = ParallelInstaller::SpecInstallation.new(dep)
+        spec = described_class.new(dep)
         allow(spec).to receive(:all_dependencies).and_return(dependencies)
         expect(spec.dependencies_installed?(all_specs)).to be_truthy
       end
@@ -53,7 +53,7 @@ describe ParallelInstaller::SpecInstallation do
         dependencies << instance_double("SpecInstallation", :spec => "alpha", :name => "alpha", :installed? => false, :all_dependencies => [], :type => :production)
         dependencies << instance_double("SpecInstallation", :spec => "beta", :name => "beta", :installed? => true, :all_dependencies => [], :type => :production)
         all_specs = dependencies + [instance_double("SpecInstallation", :spec => "gamma", :name => "gamma", :installed? => false, :all_dependencies => [], :type => :production)]
-        spec = ParallelInstaller::SpecInstallation.new(dep)
+        spec = described_class.new(dep)
         allow(spec).to receive(:all_dependencies).and_return(dependencies)
         expect(spec.dependencies_installed?(all_specs)).to be_falsey
       end
@@ -67,7 +67,7 @@ describe ParallelInstaller::SpecInstallation do
         # Add dependency which is not in all_specs
         dependencies << instance_double("SpecInstallation", :spec => "beta", :name => "beta", :installed? => false, :all_dependencies => [], :type => :production)
         dependencies << instance_double("SpecInstallation", :spec => "delta", :name => "delta", :installed? => false, :all_dependencies => [], :type => :production)
-        spec = ParallelInstaller::SpecInstallation.new(dep)
+        spec = described_class.new(dep)
         allow(spec).to receive(:all_dependencies).and_return(dependencies)
         expect { spec.dependencies_installed?(all_specs) }.
           to raise_error(Bundler::LockfileError, /Your Gemfile.lock is corrupt\. The following.*'beta' 'delta'/)