bundler 1.7.15 → 1.8.0.pre

data/lib/bundler/cli/package.rb

@@ -9,6 +9,8 @@ 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")
 
       setup_cache_all
       install
@@ -22,7 +24,12 @@ module Bundler
 
     def install
       require 'bundler/cli/install'
-      Bundler::CLI::Install.new(options.dup).run
+      options = self.options.dup
+      if Bundler.settings[:cache_all_platforms]
+        options["local"] = false
+        options["update"] = true
+      end
+      Bundler::CLI::Install.new(options).run
     end
 
     def setup_cache_all

data/lib/bundler/cli/show.rb

@@ -2,10 +2,12 @@ require 'bundler/cli/common'
 
 module Bundler
   class CLI::Show
-    attr_reader :options, :gem_name
+    attr_reader :options, :gem_name, :latest_specs
     def initialize(options, gem_name)
       @options = options
       @gem_name = gem_name
+      @verbose = options[:verbose] || options[:outdated]
+      @latest_specs = fetch_latest_specs if @verbose
     end
 
     def run
@@ -36,13 +38,37 @@ module Bundler
         Bundler.ui.info "Gems included by the bundle:"
         Bundler.load.specs.sort_by { |s| s.name }.each do |s|
           desc = "  * #{s.name} (#{s.version}#{s.git_version})"
-          if @options[:verbose]
-            Bundler.ui.info "#{desc} - #{s.summary || 'No description available.'}"
+          if @verbose
+            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.'}
+              \tStatus:   #{outdated?(s, latest) ? "Outdated - #{s.version} < #{latest.version}" : "Up to date"}
+            END
           else
             Bundler.ui.info desc
           end
         end
       end
     end
+
+    private
+
+    def fetch_latest_specs
+      definition = Bundler.definition(true)
+      if options[:outdated]
+        Bundler.ui.info "Fetching remote specs for outdated check...\n\n"
+        Bundler.ui.silence { definition.resolve_remotely! }
+      else
+        definition.resolve_with_cache!
+      end
+      definition.specs
+    end
+
+    def outdated?(current, latest)
+      return false unless latest
+      Gem::Version.new(current.version) < Gem::Version.new(latest.version)
+    end
   end
 end

data/lib/bundler/cli/update.rb

@@ -49,14 +49,14 @@ module Bundler
 
       Bundler.definition.validate_ruby!
       Installer.install Bundler.root, Bundler.definition, opts
-      Bundler.load.cache if Bundler.root.join("vendor/cache").exist?
+      Bundler.load.cache if Bundler.app_cache.exist?
 
       if Bundler.settings[:clean] && Bundler.settings[:path]
         require "bundler/cli/clean"
         Bundler::CLI::Clean.new(options).run
       end
 
-      Bundler.ui.confirm "Your bundle is updated!"
+      Bundler.ui.confirm "Bundle updated!"
       without_groups_messages
     end
 

data/lib/bundler/cli/viz.rb

@@ -8,7 +8,7 @@ module Bundler
     def run
       require 'graphviz'
       output_file = File.expand_path(options[:file])
-      graph = Graph.new(Bundler.load, output_file, options[:version], options[:requirements], options[:format])
+      graph = Graph.new(Bundler.load, output_file, options[:version], options[:requirements], options[:format], options[:without])
       graph.viz
     rescue LoadError => e
       Bundler.ui.error e.inspect

data/lib/bundler/definition.rb

@@ -129,7 +129,7 @@ module Bundler
     # @return [Bundler::SpecSet]
     def specs
       @specs ||= begin
-        specs = resolve.materialize(requested_dependencies)
+        specs = resolve.materialize(Bundler.settings[:cache_all_platforms] ? dependencies : requested_dependencies)
 
         unless specs["bundler"].any?
           local = Bundler.settings[:frozen] ? rubygems_index : index
@@ -184,10 +184,11 @@ module Bundler
     # @return [SpecSet] resolved dependencies
     def resolve
       @resolve ||= begin
-        last_resolve = converge_locked_specs
         if Bundler.settings[:frozen] || (!@unlocking && nothing_changed?)
-          last_resolve
+          @locked_specs
         else
+          last_resolve = converge_locked_specs
+
           # Run a resolve against the locally available gems
           last_resolve.merge Resolver.resolve(expanded_dependencies, index, source_requirements, last_resolve)
         end
@@ -198,15 +199,11 @@ module Bundler
       @index ||= Index.build do |idx|
         dependency_names = @dependencies.map { |d| d.name }
 
-        sources.all_sources.each do |source|
-          source.dependency_names = dependency_names.dup
-          idx.add_source source.specs
-
-          if source.is_a?(Source::Git) || source.is_a?(Source::Path)
-            dependency_names -= source.specs.map{|s| s.name }.uniq
-          end
-
-          dependency_names.push(*source.unmet_deps).uniq!
+        sources.all_sources.each do |s|
+          s.dependency_names = dependency_names.dup
+          idx.add_source s.specs
+          s.specs.each { |spec| dependency_names.delete(spec.name) }
+          dependency_names.push(*s.unmet_deps).uniq!
         end
       end
     end
@@ -275,7 +272,7 @@ module Bundler
           each do |spec|
             next if spec.name == 'bundler'
             out << spec.to_lock
-          end
+        end
         out << "\n"
       end
 
@@ -517,9 +514,7 @@ module Bundler
 
       converged = []
       @locked_specs.each do |s|
-        # Replace the locked dependency's source with the equivalent source from the Gemfile
-        dep = @dependencies.find { |dep| s.satisfies?(dep) }
-        s.source = (dep && dep.source) || sources.get(s.source)
+        s.source = sources.get(s.source)
 
         # Don't add a spec to the list if its source is expired. For example,
         # if you change a Git gem to Rubygems.
@@ -559,15 +554,12 @@ module Bundler
       resolve
     end
 
-    def in_locked_deps?(dep, locked_dep)
-      # Because the lockfile can't link a dep to a specific remote, we need to
-      # treat sources as equivalent anytime the locked dep has all the remotes
-      # that the Gemfile dep does.
-      locked_dep && locked_dep.source && dep.source && locked_dep.source.include?(dep.source)
+    def in_locked_deps?(dep, d)
+      d && dep.source == d.source
     end
 
     def satisfies_locked_spec?(dep)
-      @locked_specs.any? { |s| s.satisfies?(dep) && (!dep.source || s.source.include?(dep.source)) }
+      @locked_specs.any? { |s| s.satisfies?(dep) && (!dep.source || s.source == dep.source) }
     end
 
     def expanded_dependencies

data/lib/bundler/dependency.rb

@@ -26,6 +26,14 @@ module Bundler
       :jruby_18 => Gem::Platform::JAVA,
       :jruby_19 => Gem::Platform::JAVA,
       :mswin    => Gem::Platform::MSWIN,
+      :mswin_18 => Gem::Platform::MSWIN,
+      :mswin_19 => Gem::Platform::MSWIN,
+      :mswin_20 => Gem::Platform::MSWIN,
+      :mswin_21 => Gem::Platform::MSWIN,
+      :mswin64    => Gem::Platform::MSWIN64,
+      :mswin64_19 => Gem::Platform::MSWIN64,
+      :mswin64_20 => Gem::Platform::MSWIN64,
+      :mswin64_21 => Gem::Platform::MSWIN64,
       :mingw    => Gem::Platform::MINGW,
       :mingw_18 => Gem::Platform::MINGW,
       :mingw_19 => Gem::Platform::MINGW,
@@ -93,7 +101,6 @@ module Bundler
       out << "\n"
     end
 
-
     def specific?
       super
     rescue NoMethodError

data/lib/bundler/dsl.rb

@@ -24,14 +24,14 @@ module Bundler
       @platforms       = []
       @env             = nil
       @ruby_version    = nil
-      add_github_sources
+      add_git_sources
     end
 
     def eval_gemfile(gemfile, contents = nil)
       contents ||= Bundler.read_file(gemfile.to_s)
       instance_eval(contents, gemfile.to_s, 1)
     rescue SyntaxError => e
-      syntax_msg = e.message.gsub("#{gemfile.to_s}:", 'on line ')
+      syntax_msg = e.message.gsub("#{gemfile}:", 'on line ')
       raise GemfileError, "Gemfile syntax error #{syntax_msg}"
     rescue ScriptError, RegexpError, NameError, ArgumentError => e
       e.backtrace[0] = "#{e.backtrace[0]}: #{e.message} (#{e.class})"
@@ -148,6 +148,10 @@ module Bundler
       with_source(@sources.add_git_source(normalize_hash(options).merge("uri" => uri)), &blk)
     end
 
+    def github(repo, options = {}, &blk)
+      with_source(@sources.add_git_source(normalize_hash(options).merge("github" => repo)), &blk)
+    end
+
     def to_definition(lockfile, unlock)
       Definition.new(lockfile, @dependencies, @sources, unlock, @ruby_version)
     end
@@ -182,13 +186,19 @@ module Bundler
 
   private
 
-    def add_github_sources
+    def add_git_sources
       git_source(:github) do |repo_name|
         repo_name = "#{repo_name}/#{repo_name}" unless repo_name.include?("/")
         "git://github.com/#{repo_name}.git"
       end
 
       git_source(:gist){ |repo_name| "https://gist.github.com/#{repo_name}.git" }
+
+      git_source(:bitbucket) do |repo_name|
+        user_name, repo_name = repo_name.split '/'
+        repo_name ||= user_name
+        "https://#{user_name}@bitbucket.org/#{user_name}/#{repo_name}.git"
+      end
     end
 
     def with_source(source)
@@ -214,7 +224,10 @@ module Bundler
 
     def normalize_options(name, version, opts)
       if name.is_a?(Symbol)
-        raise GemfileError, %{You need to specify gem names as Strings. Use 'gem "#{name.to_s}"' instead.}
+        raise GemfileError, %{You need to specify gem names as Strings. Use 'gem "#{name}"' instead.}
+      end
+      if name =~ /\s/
+        raise GemfileError, %{'#{name}' is not a valid gem name because it contains whitespace.}
       end
 
       normalize_hash(opts)

data/lib/bundler/endpoint_specification.rb

@@ -18,7 +18,7 @@ module Bundler
     end
 
     # needed for standalone, load required_paths from local gemspec
-    # after the gem in installed
+    # after the gem is installed
     def require_paths
       if @remote_specification
         @remote_specification.require_paths

data/lib/bundler/env.rb

@@ -1,43 +1,44 @@
+require 'bundler/rubygems_integration'
+require 'bundler/source/git/git_proxy'
+
 module Bundler
   class Env
 
     def write(io)
-      io.write(report)
+      io.write report(:print_gemfile => true)
     end
 
-    def report
-      out = "Bundler #{Bundler::VERSION}\n"
-
-      out << "Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}"
-      out << " patchlevel #{RUBY_PATCHLEVEL}" if defined? RUBY_PATCHLEVEL
-      out << ") [#{RUBY_PLATFORM}]\n"
-
-      out << "Rubygems #{Gem::VERSION}\n"
-
-      out << "rvm #{ENV['rvm_version']}\n" if ENV['rvm_version']
-
-      out << "GEM_HOME #{ENV['GEM_HOME']}\n"
-
-      out << "GEM_PATH #{ENV['GEM_PATH']}\n" unless ENV['GEM_PATH'] == ENV['GEM_HOME']
+    def report(options = {})
+      print_gemfile = options.delete(:print_gemfile)
 
+      out = "Environment\n\n"
+      out << "    Bundler   #{Bundler::VERSION}\n"
+      out << "    Rubygems  #{Gem::VERSION}\n"
+      out << "    Ruby      #{ruby_version}"
+      out << "    GEM_HOME  #{ENV['GEM_HOME']}\n" unless ENV['GEM_HOME'].nil? || ENV['GEM_HOME'].empty?
+      out << "    GEM_PATH  #{ENV['GEM_PATH']}\n" unless ENV['GEM_PATH'] == ENV['GEM_HOME']
+      out << "    RVM       #{ENV['rvm_version']}\n" if ENV['rvm_version']
+      out << "    Git       #{git_version}\n"
       %w(rubygems-bundler open_gem).each do |name|
-        specs = Gem::Specification.find_all{|s| s.name == name }
-        out << "#{name} (#{specs.map(&:version).join(',')})\n" unless specs.empty?
+        specs = Bundler.rubygems.find_name(name)
+        out << "    #{name} (#{specs.map(&:version).join(',')})\n" unless specs.empty?
       end
 
-      out << "\nBundler settings\n" unless Bundler.settings.all.empty?
+      out << "\nBundler settings\n\n" unless Bundler.settings.all.empty?
       Bundler.settings.all.each do |setting|
-        out << "  #{setting}\n"
+        out << "    " << setting << "\n"
         Bundler.settings.pretty_values_for(setting).each do |line|
-          out << "    " << line << "\n"
+          out << "      " << line << "\n"
         end
       end
 
-      out << "\n\n" << "Gemfile\n"
-      out << read_file("Gemfile") << "\n"
+      if print_gemfile
+        out << "\nGemfile\n\n"
+        out << "    " << read_file(Bundler.default_gemfile).gsub(/\n/, "\n    ") << "\n"
 
-      out << "\n\n" << "Gemfile.lock\n"
-      out << read_file("Gemfile.lock") << "\n"
+        out << "\n" << "Gemfile.lock\n\n"
+        out << "    " << read_file(Bundler.default_lockfile).gsub(/\n/, "\n    ") << "\n"
+      end
 
       out
     end
@@ -45,12 +46,30 @@ module Bundler
   private
 
     def read_file(filename)
-      File.read(filename).strip
+      File.read(filename.to_s).strip
     rescue Errno::ENOENT
       "<No #{filename} found>"
     rescue => e
       "#{e.class}: #{e.message}"
     end
 
+    def ruby_version
+      str = "#{RUBY_VERSION}"
+      if RUBY_VERSION < '1.9'
+        str << " (#{RUBY_RELEASE_DATE}"
+        str << " patchlevel #{RUBY_PATCHLEVEL}" if defined? RUBY_PATCHLEVEL
+        str << ") [#{RUBY_PLATFORM}]\n"
+      else
+        str << "p#{RUBY_PATCHLEVEL}" if defined? RUBY_PATCHLEVEL
+        str << " (#{RUBY_RELEASE_DATE} revision #{RUBY_REVISION}) [#{RUBY_PLATFORM}]\n"
+      end
+    end
+
+    def git_version
+      Bundler::Source::Git::GitProxy.new(nil, nil, nil).version
+    rescue Bundler::Source::Git::GitNotInstalledError
+      "not installed"
+    end
+
   end
 end

data/lib/bundler/fetcher.rb

@@ -6,6 +6,8 @@ module Bundler
 
   # Handles all the fetching with the rubygems server
   class Fetcher
+    # This error is raised when it looks like the network is down
+    class NetworkDownError < HTTPError; end
     # This error is raised if the API returns a 413 (only printed in verbose)
     class FallbackError < HTTPError; end
     # This is the error raised if OpenSSL fails the cert verification
@@ -73,18 +75,27 @@ module Bundler
           ruby = Bundler.ruby_version
 
           agent = "bundler/#{Bundler::VERSION}"
-          agent += " rubygems/#{Gem::VERSION}"
-          agent += " ruby/#{ruby.version}"
-          agent += " (#{ruby.host})"
-          agent += " command/#{ARGV.first}"
+          agent << " rubygems/#{Gem::VERSION}"
+          agent << " ruby/#{ruby.version}"
+          agent << " (#{ruby.host})"
+          agent << " command/#{ARGV.first}"
 
           if ruby.engine != "ruby"
             # engine_version raises on unknown engines
             engine_version = ruby.engine_version rescue "???"
-            agent += " #{ruby.engine}/#{engine_version}"
+            agent << " #{ruby.engine}/#{engine_version}"
           end
+
+          agent << " options/#{Bundler.settings.all.join(",")}"
+
           # add a random ID so we can consolidate runs server-side
           agent << " " << SecureRandom.hex(8)
+
+          # add any user agent strings set in the config
+          extra_ua = Bundler.settings[:user_agent]
+          agent << " " << extra_ua if extra_ua
+
+          agent
         end
       end
 
@@ -95,7 +106,7 @@ module Bundler
       @api_timeout    = 10 # How long to wait for each API call
       @max_retries    = 3  # How many retries for the API call
 
-      @anonymizable_uri = resolve_remote_uri(remote_uri)
+      @anonymizable_uri = configured_uri_for(remote_uri)
 
       Socket.do_not_reverse_lookup = true
       connection # create persistent connection
@@ -231,6 +242,8 @@ module Bundler
       elsif fetch(dependency_api_uri)
         @use_api = true
       end
+    rescue NetworkDownError => e
+      raise HTTPError, e.message
     rescue AuthenticationRequiredError
       # We got a 401 from the server. Don't fall back to the full index, just fail.
       raise
@@ -270,7 +283,7 @@ module Bundler
       when Net::HTTPRequestEntityTooLarge
         raise FallbackError, response.body
       when Net::HTTPUnauthorized
-        raise AuthenticationRequiredError, remote_uri
+        raise AuthenticationRequiredError, remote_uri.host
       else
         raise HTTPError, "#{response.class}: #{response.body}"
       end
@@ -289,7 +302,13 @@ module Bundler
       raise CertificateFailureError.new(uri)
     rescue *HTTP_ERRORS => e
       Bundler.ui.trace e
-      raise HTTPError, "Network error while fetching #{uri}"
+      case e.message
+      when /host down:/, /getaddrinfo: nodename nor servname provided/
+        raise NetworkDownError, "Could not reach host #{uri.host}. Check your network " \
+        "connection and try again."
+      else
+        raise HTTPError, "Network error while fetching #{uri}"
+      end
     end
 
     def dependency_api_uri(gem_names = [])
@@ -301,14 +320,10 @@ module Bundler
     # fetch from Gemcutter Dependency Endpoint API
     def fetch_dependency_remote_specs(gem_names)
       Bundler.ui.debug "Query Gemcutter Dependency Endpoint API: #{gem_names.join(',')}"
-      gem_list = []
+      marshalled_deps = fetch dependency_api_uri(gem_names)
+      gem_list = Bundler.load_marshal(marshalled_deps)
       deps_list = []
 
-      gem_names.each_slice(Source::Rubygems::API_REQUEST_LIMIT) do |names|
-        marshalled_deps = fetch dependency_api_uri(names)
-        gem_list += Bundler.load_marshal(marshalled_deps)
-      end
-
       spec_list = gem_list.map do |s|
         dependencies = s[:dependencies].map do |name, requirement|
           dep = well_formed_dependency(name, requirement.split(", "))
@@ -377,17 +392,10 @@ module Bundler
 
   private
 
-    def resolve_remote_uri(uri)
-      add_configured_credentials(Bundler::Source.mirror_for(uri))
-    end
-
-    def add_configured_credentials(uri)
-      auth = Bundler.settings[uri.to_s]
-      if auth
-        uri = uri.dup
-        uri.user, uri.password = *auth.split(":", 2)
-      end
-      AnonymizableURI.new(uri)
+    def configured_uri_for(uri)
+      uri = Bundler::Source.mirror_for(uri)
+      config_auth = Bundler.settings[uri.to_s] || Bundler.settings[uri.host]
+      AnonymizableURI.new(uri, config_auth)
     end
 
     def fetch_uri