bundler 1.2.5 → 1.3.0.pre

data/lib/bundler/cli.rb

@@ -1,6 +1,7 @@
 require 'bundler/vendored_thor'
 require 'rubygems/user_interaction'
 require 'rubygems/config_file'
+require 'bundler/similarity_detector'
 
 module Bundler
   class CLI < Thor
@@ -8,15 +9,18 @@ module Bundler
 
     def initialize(*)
       super
-      the_shell = (options["no-color"] ? Thor::Shell::Basic.new : shell)
-      Bundler.ui = UI::Shell.new(the_shell)
-      Bundler.ui.debug! if options["verbose"]
       Bundler.rubygems.ui = UI::RGProxy.new(Bundler.ui)
-      warn_on_incompatible_ruby_or_rubygems
+    rescue UnknownArgumentError => e
+      raise InvalidOption, e.message
+    ensure
+      Bundler.ui = UI::Shell.new(options)
+      Bundler.ui.debug! if options["verbose"]
     end
 
     check_unknown_options!(:except => [:config, :exec])
 
+    stop_on_unknown_option! :exec
+
     default_task :install
     class_option "no-color", :type => :boolean, :banner => "Disable colorization in output"
     class_option "verbose",  :type => :boolean, :banner => "Enable verbose output mode", :aliases => "-V"
@@ -219,7 +223,7 @@ module Bundler
       Bundler.settings[:no_prune] = true if opts["no-prune"]
       Bundler.settings[:disable_shared_gems] = Bundler.settings[:path] ? '1' : nil
       Bundler.settings.without = opts[:without]
-      Bundler.ui.quiet = opts[:quiet]
+      Bundler.ui.be_quiet! if opts[:quiet]
       Bundler.settings[:clean] = opts[:clean] if opts[:clean]
 
       Bundler::Fetcher.disable_endpoint = opts["full-index"]
@@ -273,12 +277,14 @@ module Bundler
         "Use the rubygems modern index instead of the API endpoint"
     def update(*gems)
       sources = Array(options[:source])
-      Bundler.ui.quiet = options[:quiet]
+      Bundler.ui.be_quiet! if options[:quiet]
 
       if gems.empty? && sources.empty?
         # We're doing a full update
         Bundler.definition(true)
       else
+        # cycle through the requested gems, just to make sure they exist
+        gems.each{ |n| gem_dependency_with_name(n) }
         Bundler.definition(:gems => gems, :sources => sources)
       end
 
@@ -346,11 +352,6 @@ module Bundler
       options["local"] ? definition.resolve_with_cache! : definition.resolve_remotely!
 
       Bundler.ui.info ""
-      if options["pre"]
-        Bundler.ui.info "Outdated gems included in the bundle (including pre-releases):"
-      else
-        Bundler.ui.info "Outdated gems included in the bundle:"
-      end
 
       out_count = 0
       # Loop through the current specs
@@ -369,6 +370,14 @@ module Bundler
         gem_outdated = Gem::Version.new(active_spec.version) > Gem::Version.new(current_spec.version)
         git_outdated = current_spec.git_version != active_spec.git_version
         if gem_outdated || git_outdated
+          if out_count == 0
+            if options["pre"]
+              Bundler.ui.info "Outdated gems included in the bundle (including pre-releases):"
+            else
+              Bundler.ui.info "Outdated gems included in the bundle:"
+            end
+          end
+
           spec_version    = "#{active_spec.version}#{active_spec.git_version}"
           current_version = "#{current_spec.version}#{current_spec.git_version}"
           Bundler.ui.info "  * #{active_spec.name} (#{spec_version} > #{current_version})"
@@ -377,7 +386,7 @@ module Bundler
         Bundler.ui.debug "from #{active_spec.loaded_from}"
       end
 
-      Bundler.ui.info "  Your bundle is up to date!" if out_count < 1
+      Bundler.ui.info "Your bundle is up to date!" if out_count < 1
       Bundler.ui.info ""
     end
 
@@ -581,6 +590,7 @@ module Bundler
 
     desc "gem GEM", "Creates a skeleton for creating a rubygem"
     method_option :bin, :type => :boolean, :default => false, :aliases => '-b', :banner => "Generate a binary for your library."
+    method_option :test, :type => :string, :default => 'rspec', :aliases => '-t', :banner => "Generate a test directory for your library: 'rspec' is the default, but 'minitest' is also supported."
     def gem(name)
       name = name.chomp("/") # remove trailing slash if present
       target = File.join(Dir.pwd, name)
@@ -608,6 +618,15 @@ module Bundler
       if options[:bin]
         template(File.join("newgem/bin/newgem.tt"),          File.join(target, 'bin', name),              opts)
       end
+      case options[:test]
+      when 'rspec'
+        template(File.join("newgem/rspec.tt"),               File.join(target, ".rspec"),                 opts)
+        template(File.join("newgem/spec/spec_helper.rb.tt"), File.join(target, "spec/spec_helper.rb"),    opts)
+        template(File.join("newgem/spec/newgem_spec.rb.tt"), File.join(target, "spec/#{name}_spec.rb"),   opts)
+      when 'minitest'
+        template(File.join("newgem/test/minitest_helper.rb.tt"), File.join(target, "test/minitest_helper.rb"), opts)
+        template(File.join("newgem/test/test_newgem.rb.tt"),     File.join(target, "test/test_#{name}.rb"),    opts)
+      end
       Bundler.ui.info "Initializating git repo in #{target}"
       Dir.chdir(target) { `git init`; `git add .` }
     end
@@ -663,6 +682,28 @@ module Bundler
       Bundler.ui.info output.join("\n\n")
     end
 
+    desc "add GEM VERSION ...", "Add the named gem(s), with version requirements, to the resolved Gemfile"
+    def inject(name, version, *gems)
+      # The required arguments allow Thor to give useful feedback when the arguments
+      # are incorrect. This adds those first two arguments onto the list as a whole.
+      gems.unshift(version).unshift(name)
+
+      # Build an array of Dependency objects out of the arguments
+      deps = []
+      gems.each_slice(2) do |name, version|
+        deps << Bundler::Dependency.new(name, version)
+      end
+
+      added = Injector.inject(deps)
+
+      if added.any?
+        Bundler.ui.confirm "Added to Gemfile:"
+        Bundler.ui.confirm added.map{ |g| "  #{g}" }.join("\n")
+      else
+        Bundler.ui.confirm "All injected gems were already present in the Gemfile"
+      end
+    end
+
   private
 
     def setup_cache_all
@@ -681,23 +722,28 @@ module Bundler
 
     def locate_gem(name)
       spec = Bundler.load.specs.find{|s| s.name == name }
-      raise GemNotFound, "Could not find gem '#{name}' in the current bundle." unless spec
+      raise GemNotFound, not_found_message(name, Bundler.load.specs) unless spec
       if spec.name == 'bundler'
         return File.expand_path('../../../', __FILE__)
       end
       spec.full_gem_path
     end
 
-    def warn_on_incompatible_ruby_or_rubygems
-      ruby2 = "Ruby 2.0" if Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2.0.pre')
-      rg2 = "Rubygems 2.0" if Gem::Version.new(Gem::VERSION.dup) >= Gem::Version.new('2.0.pre')
-      upgrade = [ruby2, rg2].compact
+    def gem_dependency_with_name(name)
+      dep = Bundler.load.dependencies.find{|d| d.name == name }
+      raise GemNotFound, not_found_message(name, Bundler.load.dependencies) unless dep
+      dep
+    end
 
-      if upgrade.any?
-        Bundler.ui.warn "Bundler is not compatible with #{upgrade.join(' or ')}."
-        Bundler.ui.error "Please upgrade to Bundler 1.3 or higher."
-        exit 1
-      end
+    def not_found_message(missing_gem_name, alternatives)
+      message = "Could not find gem '#{missing_gem_name}'."
+
+      # This is called as the result of a GemNotFound, let's see if
+      # there's any similarly named ones we can propose instead
+      alternate_names = alternatives.map{|a| a.name}
+      suggestions = SimilarityDetector.new(alternate_names).similar_word_list(missing_gem_name)
+      message += "\nDid you mean #{suggestions}?" if suggestions
+      message
     end
 
   end

data/lib/bundler/definition.rb

@@ -5,7 +5,8 @@ module Bundler
   class Definition
     include GemHelpers
 
-    attr_reader :dependencies, :platforms, :sources, :ruby_version
+    attr_reader :dependencies, :platforms, :sources, :ruby_version,
+      :locked_deps
 
     def self.build(gemfile, lockfile, unlock)
       unlock ||= {}
@@ -225,7 +226,7 @@ module Bundler
       return if @lockfile_contents == contents
 
       if Bundler.settings[:frozen]
-        # TODO: Warn here if we got here.
+        Bundler.ui.error "Cannot write a changed lockfile while frozen."
         return
       end
 

data/lib/bundler/deprecate.rb

@@ -0,0 +1,15 @@
+module Bundler
+
+  if defined? ::Deprecate
+    Deprecate = ::Deprecate
+  elsif defined? Gem::Deprecate
+    Deprecate = Gem::Deprecate
+  else
+    class Deprecate; end
+  end
+
+  unless Deprecate.respond_to?(:skip_during)
+    def Deprecate.skip_during; yield; end
+  end
+
+end

data/lib/bundler/dsl.rb

@@ -6,11 +6,6 @@ module Bundler
       builder = new
       builder.eval_gemfile(gemfile)
       builder.to_definition(lockfile, unlock)
-    rescue ScriptError, RegexpError, NameError, ArgumentError => e
-      e.backtrace[0] = "#{e.backtrace[0]}: #{e.message} (#{e.class})"
-      Bundler.ui.info e.backtrace.join("\n       ")
-      raise GemfileError, "There was an error in your Gemfile," \
-        " and Bundler cannot continue."
     end
 
     VALID_PLATFORMS = Bundler::Dependency::PLATFORM_MAP.keys.freeze
@@ -28,11 +23,17 @@ module Bundler
       @ruby_version    = nil
     end
 
-    def eval_gemfile(gemfile)
-      instance_eval(Bundler.read_file(gemfile.to_s), gemfile.to_s, 1)
+    def eval_gemfile(gemfile, contents = nil)
+      contents ||= Bundler.read_file(gemfile.to_s)
+      instance_eval(contents, gemfile.to_s, 1)
     rescue SyntaxError => e
       bt = e.message.split("\n")[1..-1]
       raise GemfileError, ["Gemfile syntax error:", *bt].join("\n")
+    rescue ScriptError, RegexpError, NameError, ArgumentError => e
+      e.backtrace[0] = "#{e.backtrace[0]}: #{e.message} (#{e.class})"
+      Bundler.ui.warn e.backtrace.join("\n       ")
+      raise GemfileError, "There was an error in your Gemfile," \
+        " and Bundler cannot continue."
     end
 
     def gemspec(opts = nil)
@@ -79,9 +80,9 @@ module Bundler
           elsif dep.type == :development
             return
           else
-            raise DslError, "You cannot specify the same gem twice with different version requirements. " \
+            raise DslError, "You cannot specify the same gem twice with different version requirements. \n" \
                             "You specified: #{current.name} (#{current.requirement}) and " \
-                            "#{dep.name} (#{dep.requirement})"
+                            "#{dep.name} (#{dep.requirement})\n"
           end
         end
 
@@ -91,9 +92,9 @@ module Bundler
           elsif dep.type == :development
             return
           else
-            raise DslError, "You cannot specify the same gem twice coming from different sources. You " \
-                            "specified that #{dep.name} (#{dep.requirement}) should come from " \
-                            "#{current.source || 'an unspecified source'} and #{dep.source}"
+            raise DslError, "You cannot specify the same gem twice coming from different sources.\n" \
+                            "You specified that #{dep.name} (#{dep.requirement}) should come from " \
+                            "#{current.source || 'an unspecified source'} and #{dep.source}\n"
           end
         end
       end
@@ -104,9 +105,6 @@ module Bundler
     def source(source, options = {})
       case source
       when :gemcutter, :rubygems, :rubyforge then
-        Bundler.ui.warn "The source :#{source} is deprecated because HTTP " \
-          "requests are insecure.\nPlease change your source to 'https://" \
-          "rubygems.org' if possible, or 'http://rubygems.org' if not."
         @rubygems_source.add_remote "http://rubygems.org"
         return
       when String
@@ -233,7 +231,7 @@ module Bundler
       end
 
       if github = opts.delete("github")
-        github = "#{github}/#{github}" unless github.include?("/")
+        github = "#{github}/#{name}" unless github.include?("/")
         opts["git"] = "git://github.com/#{github}.git"
       end
 

data/lib/bundler/environment.rb

@@ -14,11 +14,6 @@ module Bundler
       @definition.to_lock.inspect
     end
 
-    # TODO: Remove this method. It's used in cli.rb still
-    def index
-      @definition.index
-    end
-
     def requested_specs
       @definition.requested_specs
     end

data/lib/bundler/fetcher.rb

@@ -1,27 +1,13 @@
 require 'uri'
 require 'bundler/vendored_persistent'
+require 'openssl' if defined?(JRUBY_VERSION)
 
 module Bundler
   # Handles all the fetching with the rubygems server
   class Fetcher
-    # How many redirects to allew in one request
     REDIRECT_LIMIT = 5
     # how long to wait for each gemcutter API call
-    API_TIMEOUT = 10
-
-    # 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
-    class CertificateFailureError < HTTPError
-      def initialize(remote_uri)
-        super "Could not verify the SSL certificate for #{remote_uri}.\nThere" \
-          " is a chance you are experiencing a man-in-the-middle attack, but" \
-          " most likely your system doesn't have the CA certificates needed" \
-          " for verification. For information about OpenSSL certificates, see" \
-          " bit.ly/ssl-certs. To connect without using SSL, edit your Gemfile" \
-          " sources and change 'https' to 'http'."
-      end
-    end
+    API_TIMEOUT    = 10
 
     attr_reader :has_api
 
@@ -60,21 +46,8 @@ module Bundler
     def initialize(remote_uri)
       @remote_uri = remote_uri
       @has_api    = true # will be set to false if the rubygems index is ever fetched
-
-      if USE_PERSISTENT
-        @connection ||= Net::HTTP::Persistent.new 'bundler', :ENV
-      else
-        if @remote_uri.scheme == "https"
-          raise Bundler::HTTPError, "Could not load OpenSSL.\n" \
-            "You must recompile Ruby with OpenSSL support or change the sources in your " \
-            "Gemfile from 'https' to 'http'. Instructions for compiling with OpenSSL " \
-            "using RVM are available at rvm.io/packages/openssl."
-        end
-        @connection ||= Net::HTTP.new(@remote_uri.host, @remote_uri.port)
-      end
-      @connection.read_timeout = API_TIMEOUT
-
-      Socket.do_not_reverse_lookup = true
+      @@connection ||= Net::HTTP::Persistent.new nil, :ENV
+      @@connection.read_timeout = API_TIMEOUT
     end
 
     # fetch a gem specification
@@ -91,9 +64,10 @@ module Bundler
     # return the specs in the bundler format as an index
     def specs(gem_names, source)
       index = Index.new
-      use_full_source_index = !gem_names || @remote_uri.scheme == "file" || Bundler::Fetcher.disable_endpoint
 
-      if use_full_source_index
+      specs = nil
+
+      if !gem_names || @remote_uri.scheme == "file" || Bundler::Fetcher.disable_endpoint
         Bundler.ui.info "Fetching source index from #{strip_user_pass_from_uri(@remote_uri)}"
         specs = fetch_all_remote_specs
       else
@@ -108,11 +82,11 @@ module Bundler
           # new line now that the dots are over
           Bundler.ui.info "" unless Bundler.ui.debug?
 
-          if FallbackError === e
-            Bundler.ui.debug "API refused request: #{e.message}"
-          else
-            Bundler.ui.debug "Error during API request. #{e.class}: #{e.message}"
+          if @remote_uri.to_s.include?("rubygems.org")
+            Bundler.ui.info "Error #{e.class} during request to dependency API"
           end
+          Bundler.ui.debug e.message
+          Bundler.ui.debug e.backtrace
 
           Bundler.ui.info "Fetching full source index from #{strip_user_pass_from_uri(@remote_uri)}"
           specs = fetch_all_remote_specs
@@ -136,9 +110,6 @@ module Bundler
       end
 
       index
-    rescue OpenSSL::SSL::SSLError
-      Bundler.ui.info "" if !use_full_source_index # newline after dots
-      raise CertificateFailureError.new(strip_user_pass_from_uri(@remote_uri))
     end
 
     # fetch index
@@ -162,25 +133,15 @@ module Bundler
 
   private
 
-    HTTP_ERRORS = [
-      Timeout::Error, EOFError, SocketError,
-      Errno::EINVAL, Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::EAGAIN,
-      Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError
-    ]
-    HTTP_ERRORS << Net::HTTP::Persistent::Error if defined?(Net::HTTP::Persistent)
-
     def fetch(uri, counter = 0)
       raise HTTPError, "Too many redirects" if counter >= REDIRECT_LIMIT
 
       begin
         Bundler.ui.debug "Fetching from: #{uri}"
-        if USE_PERSISTENT
-          response = @connection.request(uri)
-        else
-          req = Net::HTTP::Get.new uri.request_uri
-          response = @connection.request(req)
-        end
-      rescue *HTTP_ERRORS
+        response = @@connection.request(uri)
+      rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, Errno::ETIMEDOUT,
+             EOFError, SocketError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
+             Errno::EAGAIN, Net::HTTP::Persistent::Error, Net::ProtocolError => e
         raise HTTPError, "Network error while fetching #{uri}"
       end
 
@@ -188,18 +149,15 @@ module Bundler
       when Net::HTTPRedirection
         Bundler.ui.debug("HTTP Redirection")
         new_uri = URI.parse(response["location"])
-        if new_uri.host == uri.host
-          new_uri.user = uri.user
-          new_uri.password = uri.password
-        end
+        new_uri.user = uri.user
+        new_uri.password = uri.password
         fetch(new_uri, counter + 1)
       when Net::HTTPSuccess
         Bundler.ui.debug("HTTP Success")
         response.body
-      when Net::HTTPRequestEntityTooLarge
-        raise FallbackError, response.body
       else
-        raise HTTPError, "#{response.class}: #{response.body}"
+        Bundler.ui.debug("HTTP Error")
+        raise HTTPError, "Don't know how to process #{response.class}"
       end
     end
 
@@ -244,25 +202,12 @@ module Bundler
     def fetch_all_remote_specs
       @has_api = false
       Gem.sources = ["#{@remote_uri}"]
-      spec_list = Hash.new { |h,k| h[k] = [] }
+
       begin
-        # Fetch all specs, minus prerelease specs
-        spec_list = Gem::SpecFetcher.new.list(true, false)
-        # Then fetch the prerelease specs
-        begin
-          Gem::SpecFetcher.new.list(false, true).each {|k, v| spec_list[k] += v }
-        rescue Gem::RemoteFetcher::FetchError
-          Bundler.ui.debug "Could not fetch prerelease specs from #{strip_user_pass_from_uri(@remote_uri)}"
-        end
-      rescue Gem::RemoteFetcher::FetchError => e
-        if e.message.match("certificate verify failed")
-          raise CertificateFailureError.new(strip_user_pass_from_uri(@remote_uri))
-        else
-          raise HTTPError, "Could not fetch specs from #{strip_user_pass_from_uri(@remote_uri)}"
-        end
+        Bundler.rubygems.fetch_all_remote_specs
+      rescue Gem::RemoteFetcher::FetchError
+        raise HTTPError, "Could not reach #{strip_user_pass_from_uri(@remote_uri)}"
       end
-
-      return spec_list
     end
 
     def strip_user_pass_from_uri(uri)