bundler 1.10.6 → 1.11.0.pre.1

data/lib/bundler/injector.rb

@@ -40,14 +40,14 @@ module Bundler
       # return an array of the deps that we added
       return @new_deps
     ensure
-      Bundler.settings[:frozen] = '1' if frozen
+      Bundler.settings[:frozen] = "1" if frozen
     end
 
   private
 
     def new_gem_lines
       @new_deps.map do |d|
-        %|gem '#{d.name}', '#{d.requirement}'|
+        %(gem '#{d.name}', '#{d.requirement}')
       end.join("\n")
     end
 
@@ -58,7 +58,5 @@ module Bundler
         f.puts new_gem_lines
       end
     end
-
-
   end
 end

data/lib/bundler/inline.rb

@@ -28,12 +28,12 @@
 #          puts Pod::VERSION # => "0.34.4"
 #
 def gemfile(install = false, &gemfile)
-  require 'bundler'
+  require "bundler"
   old_root = Bundler.method(:root)
   def Bundler.root
-    Pathname.pwd.expand_path
+    Bundler::SharedHelpers.pwd.expand_path
   end
-  ENV['BUNDLE_GEMFILE'] ||= 'Gemfile'
+  ENV["BUNDLE_GEMFILE"] ||= "Gemfile"
 
   builder = Bundler::Dsl.new
   builder.instance_eval(&gemfile)

data/lib/bundler/installer.rb

@@ -1,6 +1,9 @@
-require 'erb'
-require 'rubygems/dependency_installer'
-require 'bundler/worker'
+require "erb"
+require "rubygems/dependency_installer"
+require "bundler/worker"
+require "bundler/installer/parallel_installer"
+require "bundler/installer/standalone"
+require "bundler/installer/gem_installer"
 
 module Bundler
   class Installer < Environment
@@ -63,83 +66,11 @@ module Bundler
         return
       end
 
-      if Bundler.default_lockfile.exist? && !options["update"]
-        local = Bundler.ui.silence do
-          begin
-            tmpdef = Definition.build(Bundler.default_gemfile, Bundler.default_lockfile, nil)
-            true unless tmpdef.new_platform? || tmpdef.missing_specs.any?
-          rescue BundlerError
-          end
-        end
-      end
-
-      # Since we are installing, we can resolve the definition
-      # using remote specs
-      unless local
-        options["local"] ? @definition.resolve_with_cache! : @definition.resolve_remotely!
-      end
-
-      force = options["force"]
-
-      # the order that the resolver provides is significant, since
-      # dependencies might actually affect the installation of a gem.
-      # that said, it's a rare situation (other than rake), and parallel
-      # installation is just SO MUCH FASTER. so we let people opt in.
-      jobs = [Bundler.settings[:jobs].to_i-1, 1].max
-      if jobs > 1 && can_install_in_parallel?
-        require 'bundler/installer/parallel_installer'
-        install_in_parallel jobs, options[:standalone], force
-      else
-        install_sequentially options[:standalone], force
-      end
+      resolve_if_need(options)
+      install(options)
 
       lock unless Bundler.settings[:frozen]
-      generate_standalone(options[:standalone]) if options[:standalone]
-    end
-
-    def install_gem_from_spec(spec, standalone = false, worker = 0, force = false)
-      # Fetch the build settings, if there are any
-      settings = Bundler.settings["build.#{spec.name}"]
-      install_options = { :force => force, :ensure_builtin_gems_cached => standalone }
-
-      post_install_message = nil
-      if settings
-        # Build arguments are global, so this is mutexed
-        Bundler.rubygems.with_build_args [settings] do
-          post_install_message = spec.source.install(spec, install_options)
-        end
-      else
-        post_install_message = spec.source.install(spec, install_options)
-      end
-
-      Bundler.ui.debug "#{worker}:  #{spec.name} (#{spec.version}) from #{spec.loaded_from}"
-
-      if Bundler.settings[:bin] && standalone
-        generate_standalone_bundler_executable_stubs(spec)
-      elsif Bundler.settings[:bin]
-        generate_bundler_executable_stubs(spec, :force => true)
-      end
-
-      post_install_message
-    rescue Errno::ENOSPC
-      raise Bundler::InstallError, "Your disk is out of space. Free some " \
-        "space to be able to install your bundle."
-    rescue Exception => e
-      # if install hook failed or gem signature is bad, just die
-      raise e if e.is_a?(Bundler::InstallHookError) || e.is_a?(Bundler::SecurityError)
-
-      # other failure, likely a native extension build failure
-      Bundler.ui.info ""
-      Bundler.ui.warn "#{e.class}: #{e.message}"
-      msg = "An error occurred while installing #{spec.name} (#{spec.version}),"
-      msg << " and Bundler cannot continue."
-
-      unless spec.source.options["git"]
-        msg << "\nMake sure that `gem install"
-        msg << " #{spec.name} -v '#{spec.version}'` succeeds before bundling."
-      end
-      Bundler.ui.debug e.backtrace.join("\n")
-      raise Bundler::InstallError, msg
+      Standalone.new(options[:standalone], @definition).generate if options[:standalone]
     end
 
     def generate_bundler_executable_stubs(spec, options = {})
@@ -150,9 +81,9 @@ module Bundler
           options[dep.name] = bins unless bins.empty?
         end
         if options.any?
-          Bundler.ui.warn "#{spec.name} has no executables, but you may want " +
+          Bundler.ui.warn "#{spec.name} has no executables, but you may want " \
             "one from a gem it depends on."
-          options.each{|name,bins| Bundler.ui.warn "  #{name} has: #{bins.join(', ')}" }
+          options.each {|name, bins| Bundler.ui.warn "  #{name} has: #{bins.join(", ")}" }
         else
           Bundler.ui.warn "There are no executables for the gem #{spec.name}."
         end
@@ -161,7 +92,7 @@ module Bundler
 
       # double-assignment to avoid warnings about variables that will be used by ERB
       bin_path = bin_path = Bundler.bin_path
-      template = template = File.read(File.expand_path('../templates/Executable', __FILE__))
+      template = template = File.read(File.expand_path("../templates/Executable", __FILE__))
       relative_gemfile_path = relative_gemfile_path = Bundler.default_gemfile.relative_path_from(bin_path)
       ruby_command = ruby_command = Thor::Util.ruby_command
 
@@ -175,8 +106,8 @@ module Bundler
           next
         end
 
-        File.open(binstub_path, 'w', 0777 & ~File.umask) do |f|
-          f.puts ERB.new(template, nil, '-').result(binding)
+        File.open(binstub_path, "w", 0777 & ~File.umask) do |f|
+          f.puts ERB.new(template, nil, "-").result(binding)
         end
       end
 
@@ -185,88 +116,53 @@ module Bundler
         when 1
           Bundler.ui.warn "Skipped #{exists[0]} since it already exists."
         when 2
-          Bundler.ui.warn "Skipped #{exists.join(' and ')} since they already exist."
+          Bundler.ui.warn "Skipped #{exists.join(" and ")} since they already exist."
         else
-          items = exists[0...-1].empty? ? nil : exists[0...-1].join(', ')
-          skipped = [items, exists[-1]].compact.join(' and ')
+          items = exists[0...-1].empty? ? nil : exists[0...-1].join(", ")
+          skipped = [items, exists[-1]].compact.join(" and ")
           Bundler.ui.warn "Skipped #{skipped} since they already exist."
         end
         Bundler.ui.warn "If you want to overwrite skipped stubs, use --force."
       end
     end
 
-  private
-
-    def can_install_in_parallel?
-      if Bundler.rubygems.provides?(">= 2.1.0")
-        true
-      else
-        Bundler.ui.warn "Rubygems #{Gem::VERSION} is not threadsafe, so your "\
-          "gems must be installed one at a time. Upgrade to Rubygems 2.1.0 " \
-          "or higher to enable parallel gem installation."
-        false
-      end
-    end
-
     def generate_standalone_bundler_executable_stubs(spec)
       # double-assignment to avoid warnings about variables that will be used by ERB
       bin_path = Bundler.bin_path
-      template = File.read(File.expand_path('../templates/Executable.standalone', __FILE__))
+      template = File.read(File.expand_path("../templates/Executable.standalone", __FILE__))
       ruby_command = ruby_command = Thor::Util.ruby_command
 
       spec.executables.each do |executable|
         next if executable == "bundle"
         standalone_path = standalone_path = Pathname(Bundler.settings[:path]).expand_path.relative_path_from(bin_path)
         executable_path = executable_path = Pathname(spec.full_gem_path).join(spec.bindir, executable).relative_path_from(bin_path)
-        File.open "#{bin_path}/#{executable}", 'w', 0755 do |f|
-          f.puts ERB.new(template, nil, '-').result(binding)
+        File.open "#{bin_path}/#{executable}", "w", 0755 do |f|
+          f.puts ERB.new(template, nil, "-").result(binding)
         end
       end
     end
 
-    def generate_standalone(groups)
-      standalone_path = Bundler.settings[:path]
-      bundler_path = File.join(standalone_path, "bundler")
-      FileUtils.mkdir_p(bundler_path)
-
-      paths = []
-
-      if groups.empty?
-        specs = @definition.requested_specs
-      else
-        specs = @definition.specs_for groups.map { |g| g.to_sym }
-      end
-
-      specs.each do |spec|
-        next if spec.name == "bundler"
-        next if spec.require_paths.nil? # builtin gems
-
-        spec.require_paths.each do |path|
-          full_path = File.join(spec.full_gem_path, path)
-          gem_path = Pathname.new(full_path).relative_path_from(Bundler.root.join(bundler_path))
-          paths << gem_path.to_s.sub("#{Bundler.ruby_version.engine}/#{RbConfig::CONFIG['ruby_version']}", '#{ruby_engine}/#{ruby_version}')
-        end
-      end
-
+  private
 
-      File.open File.join(bundler_path, "setup.rb"), "w" do |file|
-        file.puts "require 'rbconfig'"
-        file.puts "# ruby 1.8.7 doesn't define RUBY_ENGINE"
-        file.puts "ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'"
-        file.puts "ruby_version = RbConfig::CONFIG[\"ruby_version\"]"
-        file.puts "path = File.expand_path('..', __FILE__)"
-        paths.each do |path|
-          file.puts %{$:.unshift "\#{path}/#{path}"}
-        end
-      end
+    # the order that the resolver provides is significant, since
+    # dependencies might actually affect the installation of a gem.
+    # that said, it's a rare situation (other than rake), and parallel
+    # installation is just SO MUCH FASTER. so we let people opt in.
+    def install(options)
+      force = options["force"]
+      jobs = 1
+      jobs = [Bundler.settings[:jobs].to_i - 1, 1].max if can_install_in_parallel?
+      install_in_parallel jobs, options[:standalone], force
     end
 
-    def install_sequentially(standalone, force = false)
-      specs.each do |spec|
-        message = install_gem_from_spec spec, standalone, 0, force
-        if message
-          Installer.post_install_messages[spec.name] = message
-        end
+    def can_install_in_parallel?
+      if Bundler.rubygems.provides?(">= 2.1.0")
+        true
+      else
+        Bundler.ui.warn "Rubygems #{Gem::VERSION} is not threadsafe, so your "\
+          "gems will be installed one at a time. Upgrade to Rubygems 2.1.0 " \
+          "or higher to enable parallel gem installation."
+        false
       end
     end
 
@@ -275,11 +171,28 @@ module Bundler
     end
 
     def create_bundle_path
-      Bundler.mkdir_p(Bundler.bundle_path.to_s) unless Bundler.bundle_path.exist?
+      SharedHelpers.filesystem_access(Bundler.bundle_path.to_s) do |p|
+        Bundler.mkdir_p(p)
+      end unless Bundler.bundle_path.exist?
     rescue Errno::EEXIST
-      raise PathError, "Could not install to path `#{Bundler.settings[:path]}` " +
+      raise PathError, "Could not install to path `#{Bundler.settings[:path]}` " \
         "because of an invalid symlink. Remove the symlink so the directory can be created."
     end
 
+    def resolve_if_need(options)
+      if Bundler.default_lockfile.exist? && !options["update"]
+        local = Bundler.ui.silence do
+          begin
+            tmpdef = Definition.build(Bundler.default_gemfile, Bundler.default_lockfile, nil)
+            true unless tmpdef.new_platform? || tmpdef.missing_specs.any?
+          rescue BundlerError
+          end
+        end
+      end
+
+      unless local
+        options["local"] ? @definition.resolve_with_cache! : @definition.resolve_remotely!
+      end
+    end
   end
 end

data/lib/bundler/installer/gem_installer.rb

@@ -0,0 +1,76 @@
+module Bundler
+  class GemInstaller
+    attr_reader :spec, :standalone, :worker, :force, :installer
+
+    def initialize(spec, installer, standalone = false, worker = 0, force = false)
+      @spec = spec
+      @installer = installer
+      @standalone = standalone
+      @worker = worker
+      @force = force
+    end
+
+    def install_from_spec
+      post_install_message = spec_settings ? install_with_settings : install
+      Bundler.ui.debug "#{worker}:  #{spec.name} (#{spec.version}) from #{spec.loaded_from}"
+      generate_executable_stubs
+      post_install_message
+
+    rescue Errno::ENOSPC
+      raise Bundler::InstallError, out_of_space_message
+    rescue => e
+      handle_exception(e)
+    end
+
+  private
+
+    def failure_message
+      return install_error_message if spec.source.options["git"]
+      "#{install_error_message}\n#{gem_install_message}"
+    end
+
+    def install_error_message
+      "An error occurred while installing #{spec.name} (#{spec.version}), and Bundler cannot continue."
+    end
+
+    def gem_install_message
+      "Make sure that `gem install #{spec.name} -v '#{spec.version}'` succeeds before bundling."
+    end
+
+    def handle_exception(e)
+      # if install hook failed or gem signature is bad, just die
+      raise e if e.is_a?(Bundler::InstallHookError) || e.is_a?(Bundler::SecurityError)
+      # other failure, likely a native extension build failure
+      Bundler.ui.info ""
+      Bundler.ui.warn "#{e.class}: #{e.message}"
+      Bundler.ui.debug e.backtrace.join("\n")
+      raise Bundler::InstallError, failure_message
+    end
+
+    def spec_settings
+      # Fetch the build settings, if there are any
+      Bundler.settings["build.#{spec.name}"]
+    end
+
+    def install
+      spec.source.install(spec, :force => force, :ensure_builtin_gems_cached => standalone)
+    end
+
+    def install_with_settings
+      # Build arguments are global, so this is mutexed
+      Bundler.rubygems.with_build_args([spec_settings]) { install }
+    end
+
+    def out_of_space_message
+      "Your disk is out of space. Free some space to be able to install your bundle."
+    end
+
+    def generate_executable_stubs
+      if Bundler.settings[:bin] && standalone
+        installer.generate_standalone_bundler_executable_stubs(spec)
+      elsif Bundler.settings[:bin]
+        installer.generate_bundler_executable_stubs(spec, :force => true)
+      end
+    end
+  end
+end

data/lib/bundler/installer/parallel_installer.rb

@@ -1,13 +1,12 @@
-require 'bundler/worker'
-
+require "bundler/worker"
+require "bundler/installer/gem_installer"
 
 class ParallelInstaller
-
   class SpecInstallation
-
     attr_accessor :spec, :name, :post_install_message, :state
     def initialize(spec)
-      @spec, @name = spec, spec.name
+      @spec = spec
+      @name = spec.name
       @state = :none
       @post_install_message = ""
     end
@@ -37,13 +36,21 @@ class ParallelInstaller
     # sure needed dependencies have been installed.
     def dependencies_installed?(all_specs)
       installed_specs = all_specs.select(&:installed?).map(&:name)
-      dependencies.all? {|d| installed_specs.include? d.name }
+      dependencies(all_specs.map(&:name)).all? {|d| installed_specs.include? d.name }
     end
 
-    # Represents only the non-development dependencies and the ones that
-    # are itself.
-    def dependencies
-      @dependencies ||= all_dependencies.reject {|dep| ignorable_dependency? dep }
+    # 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 }
+        if missing.size > 0
+          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
     end
 
     # Represents all dependencies
@@ -58,7 +65,7 @@ class ParallelInstaller
 
   # 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
+    [Bundler.settings[:jobs].to_i - 1, 1].max
   end
 
   def initialize(installer, all_specs, size, standalone, force)
@@ -66,7 +73,7 @@ class ParallelInstaller
     @size = size
     @standalone = standalone
     @force = force
-    @specs = all_specs.map { |s| SpecInstallation.new(s) }
+    @specs = all_specs.map {|s| SpecInstallation.new(s) }
   end
 
   def call
@@ -78,7 +85,9 @@ class ParallelInstaller
 
   def worker_pool
     @worker_pool ||= Bundler::Worker.new @size, lambda { |spec_install, worker_num|
-      message = @installer.install_gem_from_spec spec_install.spec, @standalone, worker_num, @force
+      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
     }