bundler 1.6.0.pre.1 → 1.6.0.pre.2

data/lib/bundler/cli/viz.rb

@@ -0,0 +1,27 @@
+module Bundler
+  class CLI::Viz
+    attr_reader :options, :gem_name
+    def initialize(options)
+      @options = options
+    end
+
+    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.viz
+    rescue LoadError => e
+      Bundler.ui.error e.inspect
+      Bundler.ui.warn "Make sure you have the graphviz ruby gem. You can install it with:"
+      Bundler.ui.warn "`gem install ruby-graphviz`"
+    rescue StandardError => e
+      if e.message =~ /GraphViz not installed or dot not in PATH/
+        Bundler.ui.error e.message
+        Bundler.ui.warn "Please install GraphViz. On a Mac with homebrew, you can run `brew install graphviz`."
+      else
+        raise
+      end
+    end
+
+  end
+end

data/lib/bundler/dsl.rb

@@ -18,11 +18,13 @@ module Bundler
     def initialize
       @source          = nil
       @sources         = []
+      @git_sources     = {}
       @dependencies    = []
       @groups          = []
       @platforms       = []
       @env             = nil
       @ruby_version    = nil
+      add_github_sources
     end
 
     def rubygems_source
@@ -75,7 +77,7 @@ module Bundler
       options = Hash === args.last ? args.pop.dup : {}
       version = args
 
-      _normalize_options(name, version, options)
+      normalize_options(name, version, options)
 
       dep = Dependency.new(name, version, options)
 
@@ -139,8 +141,21 @@ module Bundler
       @source = nil
     end
 
+    def git_source(name, &block)
+      unless block_given?
+        raise InvalidOption, "You need to pass a block to #git_source"
+      end
+
+      if valid_keys.include?(name.to_s)
+        raise InvalidOption, "You cannot use #{name} as a git source. It " \
+          "is a reserved key. Reserved keys are: #{valid_keys.join(", ")}"
+      end
+
+      @git_sources[name.to_s] = block
+    end
+
     def path(path, options = {}, source_options = {}, &blk)
-      source Source::Path.new(_normalize_hash(options).merge("path" => Pathname.new(path))), source_options, &blk
+      source Source::Path.new(normalize_hash(options).merge("path" => Pathname.new(path))), source_options, &blk
     end
 
     def git(uri, options = {}, source_options = {}, &blk)
@@ -155,7 +170,7 @@ module Bundler
         raise DeprecatedError, msg
       end
 
-      source Source::Git.new(_normalize_hash(options).merge("uri" => uri)), source_options, &blk
+      source Source::Git.new(normalize_hash(options).merge("uri" => uri)), source_options, &blk
     end
 
     def to_definition(lockfile, unlock)
@@ -193,30 +208,39 @@ module Bundler
 
   private
 
-    def _normalize_hash(opts)
-      # Cannot modify a hash during an iteration in 1.9
+    def add_github_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" }
+    end
+
+    def normalize_hash(opts)
       opts.keys.each do |k|
-        next if String === k
-        v = opts[k]
-        opts.delete(k)
-        opts[k.to_s] = v
+        opts[k.to_s] = opts.delete(k) unless k.is_a?(String)
       end
       opts
     end
 
-    def _normalize_options(name, version, opts)
-      _normalize_hash(opts)
+    def valid_keys
+      @valid_keys ||= %w(group groups git path name branch ref tag require submodules platform platforms type)
+    end
+
+    def normalize_options(name, version, opts)
+      normalize_hash(opts)
+
+      git_names = @git_sources.keys.map(&:to_s)
 
-      valid_keys = %w(group groups git gist github path name branch ref tag require submodules platform platforms type)
-      invalid_keys = opts.keys - valid_keys
+      invalid_keys = opts.keys - (valid_keys + git_names)
       if invalid_keys.any?
-        plural = invalid_keys.size > 1
         message = "You passed #{invalid_keys.map{|k| ':'+k }.join(", ")} "
-        if plural
-          message << "as options for gem '#{name}', but they are invalid."
-        else
-          message << "as an option for gem '#{name}', but it is invalid."
-        end
+        message << if invalid_keys.size > 1
+                     "as options for gem '#{name}', but they are invalid."
+                   else
+                     "as an option for gem '#{name}', but it is invalid."
+                   end
 
         message << " Valid options are: #{valid_keys.join(", ")}"
         raise InvalidOption, message
@@ -236,13 +260,9 @@ module Bundler
         raise GemfileError, "`#{p}` is not a valid platform. The available options are: #{VALID_PLATFORMS.inspect}"
       end
 
-      if github = opts.delete("github")
-        github = "#{github}/#{github}" unless github.include?("/")
-        opts["git"] = "git://github.com/#{github}.git"
-      end
-
-      if gist = opts.delete("gist")
-        opts["git"] = "https://gist.github.com/#{gist}.git"
+      git_name = (git_names & opts.keys).last
+      if @git_sources[git_name]
+        opts["git"] = @git_sources[git_name].call(opts[git_name])
       end
 
       ["git", "path"].each do |type|

data/lib/bundler/fetcher.rb

@@ -1,5 +1,6 @@
 require 'bundler/vendored_persistent'
 require 'securerandom'
+require 'cgi'
 
 module Bundler
 
@@ -27,6 +28,25 @@ module Bundler
             "using RVM are available at rvm.io/packages/openssl."
       end
     end
+    # This error is raised if HTTP authentication is required, but not provided.
+    class AuthenticationRequiredError < HTTPError
+      def initialize(remote_uri)
+        super "Authentication is required for #{remote_uri}.\n" \
+          "Please supply credentials for this source. You can do this by running:\n" \
+          " bundle config #{remote_uri} username:password"
+      end
+    end
+    # This error is raised if HTTP authentication is provided, but incorrect.
+    class BadAuthenticationError < HTTPError
+      def initialize(remote_uri)
+        super "Bad username or password for #{remote_uri}.\n" \
+          "Please double-check your credentials and correct them."
+      end
+    end
+
+    # Exceptions classes that should bypass retry attempts. If your password didn't work the
+    # first time, it's not going to the third time.
+    AUTH_ERRORS = [AuthenticationRequiredError, BadAuthenticationError]
 
     class << self
       attr_accessor :disable_endpoint, :api_timeout, :redirect_limit, :max_retries
@@ -156,7 +176,7 @@ module Bundler
         # API errors mean we should treat this as a non-API source
         @use_api = false
 
-        specs = Bundler::Retry.new("source fetch").attempts do
+        specs = Bundler::Retry.new("source fetch", AUTH_ERRORS).attempts do
           fetch_all_remote_specs
         end
       end
@@ -193,7 +213,7 @@ module Bundler
 
       return {@remote_uri => last_spec_list} if query_list.empty?
 
-      remote_specs = Bundler::Retry.new("dependency api").attempts do
+      remote_specs = Bundler::Retry.new("dependency api", AUTH_ERRORS).attempts do
         fetch_dependency_remote_specs(query_list)
       end
 
@@ -258,8 +278,14 @@ module Bundler
     def request(uri)
       Bundler.ui.debug "Fetching from: #{uri}"
       req = Net::HTTP::Get.new uri.request_uri
-      req.basic_auth(uri.user, uri.password) if uri.user
+      if uri.user
+        user = CGI.unescape(uri.user)
+        password = uri.password ? CGI.unescape(uri.password) : nil
+        req.basic_auth(user, password)
+      end
       response = connection.request(uri, req)
+    rescue Net::HTTPUnauthorized, Net::HTTPForbidden
+      retry_with_auth { request(uri) }
     rescue OpenSSL::SSL::SSLError
       raise CertificateFailureError.new(uri)
     rescue *HTTP_ERRORS
@@ -297,8 +323,13 @@ module Bundler
       Bundler.rubygems.sources = ["#{@remote_uri}"]
       Bundler.rubygems.fetch_all_remote_specs
     rescue Gem::RemoteFetcher::FetchError, OpenSSL::SSL::SSLError => e
-      if e.message.match("certificate verify failed")
+      case e.message
+      when /certificate verify failed/
         raise CertificateFailureError.new(uri)
+      when /401|403/
+        # Gemfury uses a 403 for unauthenticated requests instead of a 401, so retry auth
+        # on both.
+        retry_with_auth { fetch_all_remote_specs }
       else
         Bundler.ui.trace e
         raise HTTPError, "Could not fetch specs from #{uri}"
@@ -333,5 +364,20 @@ module Bundler
       store
     end
 
+    # Attempt to retry with HTTP authentication, if it's appropriate to do so. Yields to a block;
+    # the caller should use this to re-attempt the failing request with the altered `@remote_uri`.
+    def retry_with_auth
+      # Authentication has already been attempted and failed.
+      raise BadAuthenticationError.new(uri) if @remote_uri.user
+
+      auth = Bundler.settings[@remote_uri.to_s]
+
+      # Authentication isn't provided at all, by "bundle config" or in the URI.
+      raise AuthenticationRequiredError.new(uri) if auth.nil?
+
+      @remote_uri.user, @remote_uri.password = *auth.split(":", 2)
+      yield
+    end
+
   end
 end

data/lib/bundler/installer.rb

@@ -90,7 +90,7 @@ module Bundler
       # 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].max
+      jobs = [Bundler.settings[:jobs].to_i-1, 1].max
       if jobs > 1 && can_install_parallely?
         install_in_parallel jobs, options[:standalone]
       else

data/lib/bundler/parallel_workers/worker.rb

@@ -22,7 +22,7 @@ module Bundler
         trap("INT") { @threads.each {|i| i.exit }; stop_workers; exit 1 }
       end
 
-      # Enque a request to be executed in the worker pool
+      # Enqueue a request to be executed in the worker pool
       #
       # @param obj [String] mostly it is name of spec that should be downloaded
       def enq(obj)

data/lib/bundler/remote_specification.rb

@@ -5,7 +5,7 @@ module Bundler
   # Represents a lazily loaded gem specification, where the full specification
   # is on the source server in rubygems' "quick" index. The proxy object is to
   # be seeded with what we're given from the source's abbreviated index - the
-  # full specification will only be fetched when necesary.
+  # full specification will only be fetched when necessary.
   class RemoteSpecification
     include MatchPlatform
 

data/lib/bundler/resolver.rb

@@ -171,15 +171,23 @@ module Bundler
       end
     end
 
-    def handle_conflict(current, states)
-      return unless current
-      parent = current
-      state = states.detect { |i| i.name == parent.name }
-      until (state && state.possibles.any?) || parent.required_by.empty?
-        parent = parent.required_by.last
-        state = states.detect { |i| i.name == parent.name }
+    def handle_conflict(current, states, existing=nil)
+      until current.nil? && existing.nil?
+        current_state = find_state(current, states)
+        existing_state = find_state(existing, states)
+        return current if state_any?(current_state)
+        return existing if state_any?(existing_state)
+        existing = existing.required_by.last if existing
+        current = current.required_by.last if current
       end
-      return parent, state
+    end
+
+    def state_any?(state)
+      state && state.possibles.any?
+    end
+
+    def find_state(current, states)
+      states.detect { |i| current && current.name == i.name }
     end
 
     def other_possible?(conflict, states)
@@ -189,6 +197,7 @@ module Bundler
     end
 
     def find_conflict_state(conflict, states)
+      return unless conflict
       until states.empty? do
         state = states.pop
         return state if conflict.name == state.name
@@ -227,20 +236,19 @@ module Bundler
     end
 
     def resolve_conflict(current, states)
-      # Return a requirment/gem which has other possibles states
+      # Return a requirement/gem which has other possibles states
       # Given the set of constraints placed by requrired_by
-      parent, _ = handle_conflict(current, states)
 
-      debug { "    -> Going to: #{parent.name} state" }
+      debug { "    -> Going to: #{current.name} state" }
 
-      # Find the state where the conlict has occured
-      state = find_conflict_state(parent, states)
+      # Find the state where the conflict has occurred
+      state = find_conflict_state(current, states)
 
       # Resolve the conflicts by rewinding the state
       # when the conflicted gem was activated
       reqs, activated, depth = resolve_for_conflict(state)
 
-      # Keep the state around if it still has other possiblities
+      # Keep the state around if it still has other possibilities
       states << state unless state.possibles.empty?
       clear_search_cache
 
@@ -303,8 +311,11 @@ module Bundler
             @errors[existing.name] = [existing, current]
 
             parent = current.required_by.last
-            parent, state = handle_conflict(existing.required_by[-2], states) if !other_possible?(parent, states) && existing.respond_to?(:required_by)
-            parent = current unless state && state.possibles.any?
+            if existing.respond_to?(:required_by)
+              parent = handle_conflict(current, states, existing.required_by[-2]) unless other_possible?(parent, states)
+            else
+              parent = handle_conflict(current, states) unless other_possible?(parent, states)
+            end
 
             raise version_conflict if parent.nil? || parent.name == 'bundler'
 
@@ -345,7 +356,8 @@ module Bundler
               # This is not a top-level Gemfile requirement
             else
               @errors[current.name] = [nil, current]
-              reqs, activated, depth = resolve_conflict(current, states)
+              parent = handle_conflict(current, states)
+              reqs, activated, depth = resolve_conflict(parent, states)
               next
             end
           end
@@ -501,7 +513,7 @@ module Bundler
     private
 
     # Indicates progress by writing a '.' every iteration_rate time which is
-    # aproximately every second. iteration_rate is calculated in the first
+    # approximately every second. iteration_rate is calculated in the first
     # second of resolve running.
     def indicate_progress
       @iteration_counter += 1

data/lib/bundler/source/git.rb

@@ -136,10 +136,6 @@ module Bundler
 
       # TODO: actually cache git specs
       def specs(*)
-        if has_app_cache? && !local?
-          set_local!(app_cache_path)
-        end
-
         if requires_checkout? && !@copied
           git_proxy.checkout
           git_proxy.copy_to(install_path, submodules)

data/lib/bundler/source/git/git_proxy.rb

@@ -27,8 +27,8 @@ module Bundler
         end
       end
 
-      # The GitProxy is responsible to iteract with git repositories.
-      # All actions required by the Git source is encapsualted in this
+      # The GitProxy is responsible to interact with git repositories.
+      # All actions required by the Git source is encapsulated in this
       # object.
       class GitProxy
         attr_accessor :path, :uri, :ref

data/lib/bundler/source/rubygems.rb

@@ -4,7 +4,6 @@ require 'rubygems/spec_fetcher'
 
 module Bundler
   class Source
-    # TODO: Refactor this class
     class Rubygems < Source
       API_REQUEST_LIMIT = 100 # threshold for switching back to the modern index instead of fetching every spec
 
@@ -68,9 +67,7 @@ module Bundler
       end
 
       def install(spec)
-        if installed_specs[spec].any? && gem_dir_exists?(spec)
-          return ["Using #{version_message(spec)}", nil]
-        end
+        return ["Using #{version_message(spec)}", nil] if installed_specs[spec].any?
 
         # Download the gem to get the spec, because some specs that are returned
         # by rubygems.org are broken and wrong.
@@ -276,16 +273,6 @@ module Bundler
         end
       end
 
-      def gem_dir_exists?(spec)
-        return true if spec.name == "bundler"
-        # Ruby 2 default gems
-        return true if spec.loaded_from.include?("specifications/default/")
-        # Ruby 1.9 default gems
-        return true if spec.summary =~ /is bundled with Ruby/
-
-        File.directory?(spec.full_gem_path)
-      end
     end
-
   end
 end

data/lib/bundler/templates/newgem/spec/newgem_spec.rb.tt

@@ -6,6 +6,6 @@ describe <%= config[:constant_name] %> do
   end
 
   it 'should do something useful' do
-    expect(false).to be true
+    expect(false).to eq(true)
   end
 end