bundler 1.10.6 → 1.11.0.pre.1

data/lib/bundler/retry.rb

@@ -15,35 +15,34 @@ module Bundler
     end
 
     def initialize(name, exceptions = nil, retries = self.class.default_retries)
-      @name        = name
-      @retries   = retries
+      @name = name
+      @retries = retries
       @exceptions = Array(exceptions) || []
-      @total_runs =  @retries + 1 # will run once, then upto attempts.times
+      @total_runs = @retries + 1 # will run once, then upto attempts.times
     end
 
     def attempt(&block)
       @current_run = 0
       @failed      = false
       @error       = nil
-      while keep_trying? do
-        run(&block)
-      end
+      run(&block) while keep_trying?
       @result
     end
-    alias :attempts :attempt
+    alias_method :attempts, :attempt
 
   private
+
     def run(&block)
       @failed      = false
       @current_run += 1
       @result = block.call
     rescue => e
-      fail(e)
+      fail_attempt(e)
     end
 
-    def fail(e)
+    def fail_attempt(e)
       @failed = true
-      raise e if last_attempt? || @exceptions.any?{ |k| e.is_a?(k) }
+      raise e if last_attempt? || @exceptions.any? {|k| e.is_a?(k) }
       return true unless name
       Bundler.ui.warn "Retrying#{" #{name}" if name} due to error (#{current_run.next}/#{total_runs}): #{e.class} #{e.message}"
     end

data/lib/bundler/ruby_dsl.rb

@@ -4,7 +4,7 @@ module Bundler
       raise GemfileError, "Please define :engine_version" if options[:engine] && options[:engine_version].nil?
       raise GemfileError, "Please define :engine" if options[:engine_version] && options[:engine].nil?
 
-      raise GemfileError, "ruby_version must match the :engine_version for MRI" if options[:engine] == "ruby" && options[:engine_version] && ruby_version != options[:engine_version]
+      raise GemfileEvalError, "ruby_version must match the :engine_version for MRI" if options[:engine] == "ruby" && options[:engine_version] && ruby_version != options[:engine_version]
       @ruby_version = RubyVersion.new(ruby_version, options[:patchlevel], options[:engine], options[:engine_version])
     end
   end

data/lib/bundler/ruby_version.rb

@@ -32,10 +32,10 @@ module Bundler
     end
 
     def ==(other)
-      version          == other.version &&
-        engine         == other.engine &&
+      version == other.version &&
+        engine == other.engine &&
         engine_version == other.engine_version &&
-        patchlevel     == other.patchlevel
+        patchlevel == other.patchlevel
     end
 
     # Returns a tuple of these things:
@@ -46,15 +46,13 @@ module Bundler
     #   3. engine_version
     def diff(other)
       if engine != other.engine && @input_engine
-        [ :engine, engine, other.engine ]
+        [:engine, engine, other.engine]
       elsif version != other.version
-        [ :version, version, other.version ]
+        [:version, version, other.version]
       elsif engine_version != other.engine_version && @input_engine
-        [ :engine_version, engine_version, other.engine_version ]
+        [:engine_version, engine_version, other.engine_version]
       elsif patchlevel != other.patchlevel && @patchlevel
-        [ :patchlevel, patchlevel, other.patchlevel ]
-      else
-        nil
+        [:patchlevel, patchlevel, other.patchlevel]
       end
     end
 
@@ -106,7 +104,6 @@ module Bundler
         JRUBY_VERSION.dup
       else
         raise BundlerError, "RUBY_ENGINE value #{RUBY_ENGINE} is not recognized"
-        nil
       end
     end
 

data/lib/bundler/rubygems_ext.rb

@@ -1,16 +1,16 @@
-require 'pathname'
+require "pathname"
 
 if defined?(Gem::QuickLoader)
   # Gem Prelude makes me a sad panda :'(
   Gem::QuickLoader.load_full_rubygems_library
 end
 
-require 'rubygems'
-require 'rubygems/specification'
-require 'bundler/match_platform'
+require "rubygems"
+require "rubygems/specification"
+require "bundler/match_platform"
 
 module Gem
-  @loaded_stacks = Hash.new { |h,k| h[k] = [] }
+  @loaded_stacks = Hash.new {|h, k| h[k] = [] }
 
   class Specification
     attr_accessor :remote, :location, :relative_loaded_from
@@ -22,15 +22,19 @@ module Gem
     alias_method :rg_loaded_from,   :loaded_from
 
     def full_gem_path
-      source.respond_to?(:path) ?
-        Pathname.new(loaded_from).dirname.expand_path(Bundler.root).to_s.untaint :
+      if source.respond_to?(:path)
+        Pathname.new(loaded_from).dirname.expand_path(Bundler.root).to_s.untaint
+      else
         rg_full_gem_path
+      end
     end
 
     def loaded_from
-      relative_loaded_from ?
-        source.path.join(relative_loaded_from).to_s :
+      if relative_loaded_from
+        source.path.join(relative_loaded_from).to_s
+      else
         rg_loaded_from
+      end
     end
 
     def load_paths
@@ -48,9 +52,11 @@ module Gem
     if method_defined?(:extension_dir)
       alias_method :rg_extension_dir, :extension_dir
       def extension_dir
-        @extension_dir ||= source.respond_to?(:extension_dir_name) ?
-          File.expand_path(File.join(extensions_dir, source.extension_dir_name)) :
+        @extension_dir ||= if source.respond_to?(:extension_dir_name)
+          File.expand_path(File.join(extensions_dir, source.extension_dir_name))
+        else
           rg_extension_dir
+        end
       end
     end
 
@@ -88,43 +94,42 @@ module Gem
   private
 
     def dependencies_to_gemfile(dependencies, group = nil)
-      gemfile = ''
+      gemfile = ""
       if dependencies.any?
         gemfile << "group :#{group} do\n" if group
         dependencies.each do |dependency|
-          gemfile << '  ' if group
-          gemfile << %|gem "#{dependency.name}"|
+          gemfile << "  " if group
+          gemfile << %(gem "#{dependency.name}")
           req = dependency.requirements_list.first
-          gemfile << %|, "#{req}"| if req
+          gemfile << %(, "#{req}") if req
           gemfile << "\n"
         end
         gemfile << "end\n" if group
       end
       gemfile
     end
-
   end
 
   class Dependency
     attr_accessor :source, :groups
 
-    alias eql? ==
+    alias_method :eql?, :==
 
     def encode_with(coder)
       to_yaml_properties.each do |ivar|
-        coder[ivar.to_s.sub(/^@/, '')] = instance_variable_get(ivar)
+        coder[ivar.to_s.sub(/^@/, "")] = instance_variable_get(ivar)
       end
     end
 
     def to_yaml_properties
-      instance_variables.reject { |p| ["@source", "@groups"].include?(p.to_s) }
+      instance_variables.reject {|p| ["@source", "@groups"].include?(p.to_s) }
     end
 
     def to_lock
       out = "  #{name}"
       unless requirement == Gem::Requirement.default
-        reqs = requirement.requirements.map{|o,v| "#{o} #{v}" }.sort.reverse
-        out << " (#{reqs.join(', ')})"
+        reqs = requirement.requirements.map {|o, v| "#{o} #{v}" }.sort.reverse
+        out << " (#{reqs.join(", ")})"
       end
       out
     end
@@ -147,11 +152,11 @@ module Gem
   end
 
   class Platform
-    JAVA  = Gem::Platform.new('java') unless defined?(JAVA)
-    MSWIN = Gem::Platform.new('mswin32') unless defined?(MSWIN)
-    MSWIN64 = Gem::Platform.new('mswin64') unless defined?(MSWIN64)
-    MINGW = Gem::Platform.new('x86-mingw32') unless defined?(MINGW)
-    X64_MINGW = Gem::Platform.new('x64-mingw32') unless defined?(X64_MINGW)
+    JAVA  = Gem::Platform.new("java") unless defined?(JAVA)
+    MSWIN = Gem::Platform.new("mswin32") unless defined?(MSWIN)
+    MSWIN64 = Gem::Platform.new("mswin64") unless defined?(MSWIN64)
+    MINGW = Gem::Platform.new("x86-mingw32") unless defined?(MINGW)
+    X64_MINGW = Gem::Platform.new("x64-mingw32") unless defined?(X64_MINGW)
 
     undef_method :hash if method_defined? :hash
     def hash
@@ -159,7 +164,7 @@ module Gem
     end
 
     undef_method :eql? if method_defined? :eql?
-    alias eql? ==
+    alias_method :eql?, :==
   end
 end
 

data/lib/bundler/{gem_installer.rb → rubygems_gem_installer.rb}

@@ -1,7 +1,7 @@
-require 'rubygems/installer'
+require "rubygems/installer"
 
 module Bundler
-  class GemInstaller < Gem::Installer
+  class RubyGemsGemInstaller < Gem::Installer
     def check_executable_overwrite(filename)
       # Bundler needs to install gems regardless of binstub overwriting
     end

data/lib/bundler/rubygems_integration.rb

@@ -1,6 +1,7 @@
-require 'monitor'
-require 'rubygems'
-require 'rubygems/config_file'
+require "monitor"
+require "rubygems"
+require "rubygems/config_file"
+require "bundler/psyched_yaml"
 
 module Bundler
   class RubygemsIntegration
@@ -66,7 +67,10 @@ module Bundler
     rescue Gem::SystemExitException => e
       Bundler.ui.error "#{e.class}: #{e.message}"
       Bundler.ui.trace e
-      raise Gem::SystemExitException
+      raise
+    rescue YamlSyntaxError => e
+      raise YAMLSyntaxError.new(e, "Your RubyGems configuration, which is " \
+        "usually located in ~/.gemrc, contains invalid YAML syntax.")
     end
 
     def ruby_engine
@@ -111,14 +115,14 @@ module Bundler
     end
 
     def gem_cache
-      gem_path.map{|p| File.expand_path("cache", p) }
+      gem_path.map {|p| File.expand_path("cache", p) }
     end
 
     def spec_cache_dirs
       @spec_cache_dirs ||= begin
-        dirs = gem_path.map {|dir| File.join(dir, 'specifications')}
+        dirs = gem_path.map {|dir| File.join(dir, "specifications") }
         dirs << Gem.spec_cache_dir if Gem.respond_to?(:spec_cache_dir) # Not in Rubygems 2.0.3 or earlier
-        dirs.uniq.select {|dir| File.directory? dir}
+        dirs.uniq.select {|dir| File.directory? dir }
       end
     end
 
@@ -131,7 +135,7 @@ module Bundler
     end
 
     def repository_subdirectories
-      %w[cache doc gems specifications]
+      %w(cache doc gems specifications)
     end
 
     def clear_paths
@@ -151,11 +155,11 @@ module Bundler
       # RubyGems 2.2+ can put binary extension into dedicated folders,
       # therefore use RubyGems facilities to obtain their load paths.
       if Gem::Specification.method_defined? :full_require_paths
-        loaded_gem_paths = Gem.loaded_specs.map {|n, s| s.full_require_paths}
+        loaded_gem_paths = Gem.loaded_specs.map {|_, s| s.full_require_paths }
         loaded_gem_paths.flatten
       else
         $LOAD_PATH.select do |p|
-          Bundler.rubygems.gem_path.any?{|gp| p =~ /^#{Regexp.escape(gp)}/ }
+          Bundler.rubygems.gem_path.any? {|gp| p =~ /^#{Regexp.escape(gp)}/ }
         end
       end
     end
@@ -180,18 +184,26 @@ module Bundler
       [] # if we can't download them, there aren't any
     end
 
-    def fetch_all_remote_specs
+    # TODO: This is for older versions of Rubygems... should we support the
+    # X-Gemfile-Source header on these old versions?
+    # Maybe the newer implementation will work on older Rubygems?
+    # It seems difficult to keep this implementation and still send the header.
+    def fetch_all_remote_specs(remote)
+      old_sources = Bundler.rubygems.sources
+      Bundler.rubygems.sources = [remote.uri.to_s]
       # Fetch all specs, minus prerelease specs
       spec_list = fetch_specs(true, false)
       # Then fetch the prerelease specs
       fetch_prerelease_specs.each {|k, v| spec_list[k] += v }
 
-      return spec_list
+      spec_list
+    ensure
+      Bundler.rubygems.sources = old_sources
     end
 
     def with_build_args(args)
       ext_lock.synchronize do
-        old_args = self.build_args
+        old_args = build_args
         begin
           self.build_args = args
           yield
@@ -202,12 +214,12 @@ module Bundler
     end
 
     def gem_from_path(path, policy = nil)
-      require 'rubygems/format'
+      require "rubygems/format"
       Gem::Format.from_file_by_path(path, policy)
     end
 
     def spec_from_gem(path, policy = nil)
-      require 'rubygems/security'
+      require "rubygems/security"
       gem_from_path(path, security_policies[policy]).spec
     rescue Gem::Package::FormatError
       raise GemspecError, "Could not read gem at #{path}. It may be corrupted."
@@ -216,7 +228,7 @@ module Bundler
           e.message =~ /unknown trust policy|unsigned gem/i ||
           e.message =~ /couldn't verify (meta)?data signature/i
         raise SecurityError,
-          "The gem #{File.basename(path, '.gem')} can't be installed because " \
+          "The gem #{File.basename(path, ".gem")} can't be installed because " \
           "the security policy didn't allow it, with the message: #{e.message}"
       else
         raise e
@@ -224,12 +236,12 @@ module Bundler
     end
 
     def build(spec, skip_validation = false)
-      require 'rubygems/builder'
+      require "rubygems/builder"
       Gem::Builder.new(spec).build
     end
 
     def build_gem(gem_dir, spec)
-       build(spec)
+      build(spec)
     end
 
     def download_gem(spec, uri, path)
@@ -239,12 +251,12 @@ module Bundler
     end
 
     def security_policy_keys
-      %w{High Medium Low AlmostNo No}.map { |level| "#{level}Security" }
+      %w(High Medium Low AlmostNo No).map {|level| "#{level}Security" }
     end
 
     def security_policies
       @security_policies ||= begin
-        require 'rubygems/security'
+        require "rubygems/security"
         Gem::Security::Policies
       rescue LoadError, NameError
         {}
@@ -255,8 +267,8 @@ module Bundler
       # Disable rubygems' gem activation system
       ::Kernel.class_eval do
         if private_method_defined?(:gem_original_require)
-          alias rubygems_require require
-          alias require gem_original_require
+          alias_method :rubygems_require, :require
+          alias_method :require, :gem_original_require
         end
 
         undef gem
@@ -266,11 +278,11 @@ module Bundler
     def replace_gem(specs)
       reverse_rubygems_kernel_mixin
 
-      executables = specs.map { |s| s.executables }.flatten
+      executables = specs.map(&:executables).flatten
 
       ::Kernel.send(:define_method, :gem) do |dep, *reqs|
-        if executables.include? File.basename(caller.first.split(':').first)
-          return
+        if executables.include? File.basename(caller.first.split(":").first)
+          break
         end
         reqs.pop if reqs.last.is_a?(Hash)
 
@@ -278,7 +290,7 @@ module Bundler
           dep = Gem::Dependency.new(dep, reqs)
         end
 
-        spec = specs.find  { |s| s.name == dep.name }
+        spec = specs.find {|s| s.name == dep.name }
 
         if spec.nil?
 
@@ -330,27 +342,25 @@ module Bundler
     # under bundler. The new Gem.bin_path only considers gems in
     # +specs+
     def replace_bin_path(specs)
-      gem_class = (class << Gem ; self ; end)
+      gem_class = (class << Gem; self; end)
       redefine_method(gem_class, :bin_path) do |name, *args|
         exec_name = args.first
 
-        if exec_name == 'bundle'
-          return ENV['BUNDLE_BIN_PATH']
-        end
+        return ENV["BUNDLE_BIN_PATH"] if exec_name == "bundle"
 
         spec = nil
 
         if exec_name
-          spec = specs.find { |s| s.executables.include?(exec_name) }
-          spec or raise Gem::Exception, "can't find executable #{exec_name}"
+          spec = specs.find {|s| s.executables.include?(exec_name) }
+          raise(Gem::Exception, "can't find executable #{exec_name}") unless spec
           unless spec.name == name
             warn "Bundler is using a binstub that was created for a different gem.\n" \
               "This is deprecated, in future versions you may need to `bundle binstub #{name}` " \
               "to work around a system/bundle conflict."
           end
         else
-          spec = specs.find  { |s| s.name == name }
-          exec_name = spec.default_executable or raise Gem::Exception, "no default executable for #{spec.full_name}"
+          spec = specs.find {|s| s.name == name }
+          raise Gem::Exception, "no default executable for #{spec.full_name}" unless exec_name = spec.default_executable
         end
 
         gem_bin = File.join(spec.full_gem_path, spec.bindir, exec_name)
@@ -362,8 +372,8 @@ module Bundler
     # Because Bundler has a static view of what specs are available,
     # we don't #refresh, so stub it out.
     def replace_refresh
-      gem_class = (class << Gem ; self ; end)
-      redefine_method(gem_class, :refresh) { }
+      gem_class = (class << Gem; self; end)
+      redefine_method(gem_class, :refresh) {}
     end
 
     # Replace or hook into Rubygems to provide a bundlerized view
@@ -391,8 +401,8 @@ module Bundler
 
     # This backport fixes the marshaling of @segments.
     def backport_yaml_initialize
-      redefine_method(Gem::Version, :yaml_initialize) do |tag, map|
-        @version = map['version']
+      redefine_method(Gem::Version, :yaml_initialize) do |_, map|
+        @version = map["version"]
         @segments = nil
         @hash = nil
       end
@@ -446,7 +456,7 @@ module Bundler
 
       def stub_rubygems(specs)
         # Rubygems versions lower than 1.7 use SourceIndex#from_gems_in
-        source_index_class = (class << Gem::SourceIndex ; self ; end)
+        source_index_class = (class << Gem::SourceIndex; self; end)
         source_index_class.send(:define_method, :from_gems_in) do |*args|
           source_index = Gem::SourceIndex.new
           source_index.spec_dirs = *args
@@ -499,9 +509,9 @@ module Bundler
       def stub_rubygems(specs)
         Gem::Specification.all = specs
 
-        Gem.post_reset {
+        Gem.post_reset do
           Gem::Specification.all = specs
-        }
+        end
 
         stub_source_index(specs)
       end
@@ -521,7 +531,8 @@ module Bundler
       # you call Gem::Installer#install with an :install_dir set. We have to
       # change it back for our sudo mode to work.
       def preserve_paths
-        old_dir, old_path = gem_dir, gem_path
+        old_dir = gem_dir
+        old_path = gem_path
         yield
         Gem.use_paths(old_dir, old_path)
       end
@@ -532,7 +543,7 @@ module Bundler
       # Rubygems 1.8.20 and adds the skip_validation parameter, so that's
       # when we start passing it through.
       def build(spec, skip_validation = false)
-        require 'rubygems/builder'
+        require "rubygems/builder"
         Gem::Builder.new(spec).build(skip_validation)
       end
     end
@@ -555,48 +566,55 @@ module Bundler
         Gem::Specification.find_all_by_name name
       end
 
-      def fetch_specs(source, name)
+      def fetch_specs(source, remote, name)
         path = source + "#{name}.#{Gem.marshal_version}.gz"
-        string = Gem::RemoteFetcher.fetcher.fetch_path(path)
+        fetcher = gem_remote_fetcher
+        fetcher.headers = { "X-Gemfile-Source" => remote.original_uri.to_s } if remote.original_uri
+        string = fetcher.fetch_path(path)
         Bundler.load_marshal(string)
       rescue Gem::RemoteFetcher::FetchError => e
         # it's okay for prerelease to fail
         raise e unless name == "prerelease_specs"
       end
 
-      def fetch_all_remote_specs
+      def fetch_all_remote_specs(remote)
         # Since SpecFetcher now returns NameTuples, we just fetch directly
         # and unmarshal the array ourselves.
         hash = {}
 
-        Gem.sources.each do |source|
-          source = URI.parse(source.to_s) unless source.is_a?(URI)
-          hash[source] = fetch_specs(source, "specs")
+        source = remote.uri
+        source = URI.parse(source.to_s) unless source.is_a?(URI)
+        hash[source] = fetch_specs(source, remote, "specs")
 
-          pres = fetch_specs(source, "prerelease_specs")
-          hash[source].push(*pres) if pres && !pres.empty?
-        end
+        pres = fetch_specs(source, remote, "prerelease_specs")
+        hash[source].push(*pres) if pres && !pres.empty?
 
         hash
       end
 
       def download_gem(spec, uri, path)
-        require 'resolv'
         uri = Bundler.settings.mirror_for(uri)
-        proxy, dns = configuration[:http_proxy], Resolv::DNS.new
-        fetcher = Gem::RemoteFetcher.new(proxy, dns)
+        fetcher = gem_remote_fetcher
+        fetcher.headers = { "X-Gemfile-Source" => spec.remote.original_uri.to_s } if spec.remote.original_uri
         fetcher.download(spec, uri, path)
       end
 
+      def gem_remote_fetcher
+        require "resolv"
+        proxy = configuration[:http_proxy]
+        dns = Resolv::DNS.new
+        Bundler::GemRemoteFetcher.new(proxy, dns)
+      end
+
       def gem_from_path(path, policy = nil)
-        require 'rubygems/package'
+        require "rubygems/package"
         p = Gem::Package.new(path)
         p.security_policy = policy if policy
-        return p
+        p
       end
 
       def build(spec, skip_validation = false)
-        require 'rubygems/package'
+        require "rubygems/package"
         Gem::Package.build(spec, skip_validation)
       end
 
@@ -613,23 +631,21 @@ module Bundler
       end
 
       def all_specs
-        require 'bundler/remote_specification'
+        require "bundler/remote_specification"
         Gem::Specification.stubs.map do |stub|
           StubSpecification.from_stub(stub)
         end
       end
 
       def backport_ext_builder_monitor
-        require 'rubygems/ext'
+        require "rubygems/ext"
 
         Gem::Ext::Builder.class_eval do
-          if !const_defined?(:CHDIR_MONITOR)
+          unless const_defined?(:CHDIR_MONITOR)
             const_set(:CHDIR_MONITOR, EXT_LOCK)
           end
 
-          if const_defined?(:CHDIR_MUTEX)
-            remove_const(:CHDIR_MUTEX)
-          end
+          remove_const(:CHDIR_MUTEX) if const_defined?(:CHDIR_MUTEX)
           const_set(:CHDIR_MUTEX, const_get(:CHDIR_MONITOR))
         end
       end
@@ -646,22 +662,21 @@ module Bundler
         end
       end
     end
-
   end
 
   if RubygemsIntegration.provides?(">= 2.1.0")
     @rubygems = RubygemsIntegration::MoreFuture.new
   elsif RubygemsIntegration.provides?(">= 1.99.99")
     @rubygems = RubygemsIntegration::Future.new
-  elsif RubygemsIntegration.provides?('>= 1.8.20')
+  elsif RubygemsIntegration.provides?(">= 1.8.20")
     @rubygems = RubygemsIntegration::MoreModern.new
-  elsif RubygemsIntegration.provides?('>= 1.8.5')
+  elsif RubygemsIntegration.provides?(">= 1.8.5")
     @rubygems = RubygemsIntegration::Modern.new
-  elsif RubygemsIntegration.provides?('>= 1.8.0')
+  elsif RubygemsIntegration.provides?(">= 1.8.0")
     @rubygems = RubygemsIntegration::AlmostModern.new
-  elsif RubygemsIntegration.provides?('>= 1.7.0')
+  elsif RubygemsIntegration.provides?(">= 1.7.0")
     @rubygems = RubygemsIntegration::Transitional.new
-  elsif RubygemsIntegration.provides?('>= 1.4.0')
+  elsif RubygemsIntegration.provides?(">= 1.4.0")
     @rubygems = RubygemsIntegration::Legacy.new
   else # Rubygems 1.3.6 and 1.3.7
     @rubygems = RubygemsIntegration::Ancient.new