bundler 1.9.10 → 1.10.0.pre

data/lib/bundler/fetcher/base.rb

@@ -0,0 +1,27 @@
+module Bundler
+  class Fetcher
+    class Base
+      attr_reader :downloader
+      attr_reader :remote_uri
+      attr_reader :fetch_uri
+      attr_reader :display_uri
+
+      def initialize(downloader, remote_uri, fetch_uri, display_uri)
+        raise 'Abstract class' if self.class == Base
+        @downloader = downloader
+        @remote_uri = remote_uri
+        @fetch_uri = fetch_uri
+        @display_uri = display_uri
+      end
+
+      def api_available?
+        api_fetcher?
+      end
+
+      def api_fetcher?
+        false
+      end
+
+    end
+  end
+end

data/lib/bundler/fetcher/dependency.rb

@@ -0,0 +1,88 @@
+require 'bundler/fetcher/base'
+
+module Bundler
+  class Fetcher
+    class Dependency < Base
+      def api_available?
+        downloader.fetch(dependency_api_uri)
+      rescue NetworkDownError => e
+        raise HTTPError, e.message
+      rescue AuthenticationRequiredError
+        # We got a 401 from the server. Just fail.
+        raise
+      rescue HTTPError
+      end
+
+      def api_fetcher?
+        true
+      end
+
+      def specs(gem_names, full_dependency_list = [], last_spec_list = [])
+        query_list = gem_names - full_dependency_list
+
+        # only display the message on the first run
+        if Bundler.ui.debug?
+          Bundler.ui.debug "Query List: #{query_list.inspect}"
+        else
+          Bundler.ui.info ".", false
+        end
+
+        return {remote_uri => last_spec_list} if query_list.empty?
+
+        remote_specs = Bundler::Retry.new("dependency api", AUTH_ERRORS).attempts do
+          dependency_specs(query_list)
+        end
+
+        spec_list, deps_list = remote_specs
+        returned_gems = spec_list.map(&:first).uniq
+        specs(deps_list, full_dependency_list + returned_gems, spec_list + last_spec_list)
+      rescue HTTPError, MarshalError, GemspecError
+        Bundler.ui.info "" unless Bundler.ui.debug? # new line now that the dots are over
+        Bundler.ui.debug "could not fetch from the dependency API, trying the full index"
+        return nil
+      end
+
+      def dependency_specs(gem_names)
+        Bundler.ui.debug "Query Gemcutter Dependency Endpoint API: #{gem_names.join(',')}"
+        gem_list = []
+        deps_list = []
+
+        gem_names.each_slice(Source::Rubygems::API_REQUEST_SIZE) do |names|
+          marshalled_deps = downloader.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(", "))
+            deps_list << dep.name
+            dep
+          end
+
+          [s[:name], Gem::Version.new(s[:number]), s[:platform], dependencies]
+        end
+
+        [spec_list, deps_list.uniq]
+      end
+
+      def dependency_api_uri(gem_names = [])
+        uri = fetch_uri + "api/v1/dependencies"
+        uri.query = "gems=#{URI.encode(gem_names.join(","))}" if gem_names.any?
+        uri
+      end
+
+      def well_formed_dependency(name, *requirements)
+        Gem::Dependency.new(name, *requirements)
+      rescue ArgumentError => e
+        illformed = 'Ill-formed requirement ["#<YAML::Syck::DefaultKey'
+        raise e unless e.message.include?(illformed)
+        puts # we shouldn't print the error message on the "fetching info" status line
+        raise GemspecError,
+          "Unfortunately, the gem #{s[:name]} (#{s[:number]}) has an invalid " \
+          "gemspec. \nPlease ask the gem author to yank the bad version to fix " \
+          "this issue. For more information, see http://bit.ly/syck-defaultkey."
+      end
+
+    end
+  end
+end

data/lib/bundler/fetcher/downloader.rb

@@ -0,0 +1,61 @@
+module Bundler
+  class Fetcher
+    class Downloader
+      attr_reader :connection
+      attr_reader :redirect_limit
+
+      def initialize(connection, redirect_limit)
+        @connection = connection
+        @redirect_limit = redirect_limit
+      end
+
+      def fetch(uri, counter = 0)
+        raise HTTPError, "Too many redirects" if counter >= redirect_limit
+
+        response = request(uri)
+        Bundler.ui.debug("HTTP #{response.code} #{response.message}")
+
+        case response
+        when Net::HTTPRedirection
+          new_uri = URI.parse(response["location"])
+          if new_uri.host == uri.host
+            new_uri.user = uri.user
+            new_uri.password = uri.password
+          end
+          fetch(new_uri, counter + 1)
+        when Net::HTTPSuccess
+          response.body
+        when Net::HTTPRequestEntityTooLarge
+          raise FallbackError, response.body
+        when Net::HTTPUnauthorized
+          raise AuthenticationRequiredError, uri.host
+        else
+          raise HTTPError, "#{response.class}: #{response.body}"
+        end
+      end
+
+      def request(uri)
+        Bundler.ui.debug "HTTP GET #{uri}"
+        req = Net::HTTP::Get.new uri.request_uri
+        if uri.user
+          user = CGI.unescape(uri.user)
+          password = uri.password ? CGI.unescape(uri.password) : nil
+          req.basic_auth(user, password)
+        end
+        connection.request(uri, req)
+      rescue OpenSSL::SSL::SSLError
+        raise CertificateFailureError.new(uri)
+      rescue *HTTP_ERRORS => e
+        Bundler.ui.trace e
+        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
+
+    end
+  end
+end

data/lib/bundler/fetcher/index.rb

@@ -0,0 +1,31 @@
+require 'bundler/fetcher/base'
+
+module Bundler
+  class Fetcher
+    class Index < Base
+      def specs(_gem_names)
+        old_sources = Bundler.rubygems.sources
+        Bundler.rubygems.sources = [remote_uri.to_s]
+        Bundler.rubygems.fetch_all_remote_specs
+      rescue Gem::RemoteFetcher::FetchError, OpenSSL::SSL::SSLError => e
+        case e.message
+        when /certificate verify failed/
+          raise CertificateFailureError.new(display_uri)
+        when /401/
+          raise AuthenticationRequiredError, remote_uri
+        when /403/
+          if remote_uri.userinfo
+            raise BadAuthenticationError, remote_uri
+          else
+            raise AuthenticationRequiredError, remote_uri
+          end
+        else
+          Bundler.ui.trace e
+          raise HTTPError, "Could not fetch specs from #{display_uri}"
+        end
+      ensure
+        Bundler.rubygems.sources = old_sources
+      end
+    end
+  end
+end

data/lib/bundler/friendly_errors.rb

@@ -5,6 +5,9 @@ require "bundler/vendored_thor"
 module Bundler
   def self.with_friendly_errors
     yield
+  rescue Bundler::Dsl::DSLError => e
+    Bundler.ui.error e.message
+    exit e.status_code
   rescue Bundler::BundlerError => e
     Bundler.ui.error e.message, :wrap => true
     Bundler.ui.trace e

data/lib/bundler/inline.rb

@@ -0,0 +1,50 @@
+# Allows for declaring a Gemfile inline in a ruby script, optionally installing
+# any gems that aren't already installed on the user's system.
+#
+# @note Every gem that is specified in this 'Gemfile' will be `require`d, as if
+#       the user had manually called `Bundler.require`. To avoid a requested gem
+#       being automatically required, add the `:require => false` option to the
+#       `gem` dependency declaration.
+#
+# @param install [Boolean] whether gems that aren't already installed on the
+#                          user's system should be installed.
+#                          Defaults to `false`.
+#
+# @param gemfile [Proc]    a block that is evaluated as a `Gemfile`.
+#
+# @example Using an inline Gemfile
+#
+#          #!/usr/bin/env ruby
+#
+#          require 'bundler/inline'
+#
+#          gemfile do
+#            source 'https://rubygems.org'
+#            gem 'json', require: false
+#            gem 'nap', require: 'rest'
+#            gem 'cocoapods', '~> 0.34.1'
+#          end
+#
+#          puts Pod::VERSION => "0.34.4"
+#
+def gemfile(install = false, &gemfile)
+  require 'bundler'
+  old_root = Bundler.method(:root)
+  def Bundler.root
+    Pathname.pwd.expand_path
+  end
+  ENV['BUNDLE_GEMFILE'] ||= 'Gemfile'
+
+  builder = Bundler::Dsl.new
+  builder.instance_eval(&gemfile)
+  definition = builder.to_definition(nil, true)
+  def definition.lock(file); end
+  definition.validate_ruby!
+  Bundler::Installer.install(Bundler.root, definition, :system => true) if install
+  runtime = Bundler::Runtime.new(nil, definition)
+  runtime.setup_environment
+  runtime.setup.require
+
+  bundler_module = class << Bundler; self; end
+  bundler_module.send(:define_method, :root, old_root)
+end

data/lib/bundler/installer.rb

@@ -79,32 +79,38 @@ module Bundler
         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?
-        install_in_parallel jobs, options[:standalone]
+        require 'bundler/installer/parallel_installer'
+        install_in_parallel jobs, options[:standalone], force
       else
-        install_sequentially options[:standalone]
+        install_sequentially options[:standalone], force
       end
 
       lock unless Bundler.settings[:frozen]
       generate_standalone(options[:standalone]) if options[:standalone]
     end
 
-    def install_gem_from_spec(spec, standalone = false, worker = 0)
+    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}"]
       messages = nil
 
+      install_options = { :force => force, :ensure_builtin_gems_cached => standalone }
+
       if settings
+        # Build arguments are global, so this is mutexed
         Bundler.rubygems.with_build_args [settings] do
-          messages = spec.source.install(spec)
+          messages = spec.source.install(spec, install_options)
         end
       else
-        messages = spec.source.install(spec)
+        messages = spec.source.install(spec, install_options)
       end
 
       install_message, post_install_message, debug_message = *messages
@@ -264,68 +270,17 @@ module Bundler
       end
     end
 
-    def install_sequentially(standalone)
+    def install_sequentially(standalone, force = false)
       specs.each do |spec|
-        message = install_gem_from_spec spec, standalone, 0
+        message = install_gem_from_spec spec, standalone, 0, force
         if message
           Installer.post_install_messages[spec.name] = message
         end
       end
     end
 
-    def install_in_parallel(size, standalone)
-      name2spec = {}
-      remains = {}
-      enqueued = {}
-      specs.each do |spec|
-        name2spec[spec.name] = spec
-        remains[spec.name] = true
-      end
-
-      worker_pool = Worker.new size, lambda { |name, worker_num|
-        spec = name2spec[name]
-        message = install_gem_from_spec spec, standalone, worker_num
-        { :name => spec.name, :post_install => message }
-      }
-
-      # Keys in the remains hash represent uninstalled gems specs.
-      # We enqueue all gem specs that do not have any dependencies.
-      # Later we call this lambda again to install specs that depended on
-      # previously installed specifications. We continue until all specs
-      # are installed.
-      enqueue_remaining_specs = lambda do
-        remains.keys.each do |name|
-          next if enqueued[name]
-          spec = name2spec[name]
-          if ready_to_install?(spec, remains)
-            worker_pool.enq name
-            enqueued[name] = true
-          end
-        end
-      end
-      enqueue_remaining_specs.call
-
-      until remains.empty?
-        message = worker_pool.deq
-        remains.delete message[:name]
-        if message[:post_install]
-          Installer.post_install_messages[message[:name]] = message[:post_install]
-        end
-        enqueue_remaining_specs.call
-      end
-      message
-    ensure
-      worker_pool && worker_pool.stop
-    end
-
-    # We only want to install a gem spec if all its dependencies are met.
-    # If the dependency is no longer in the `remains` hash then it has been met.
-    # If a dependency is only development or is self referential it can be ignored.
-    def ready_to_install?(spec, remains)
-      spec.dependencies.none? do |dep|
-        next if dep.type == :development || dep.name == spec.name
-        remains[dep.name]
-      end
+    def install_in_parallel(size, standalone, force = false)
+      ParallelInstaller.call(self, specs, size, standalone, force)
     end
 
     def create_bundle_path

data/lib/bundler/installer/parallel_installer.rb

@@ -0,0 +1,117 @@
+require 'bundler/worker'
+
+
+class ParallelInstaller
+
+  class SpecInstallation
+
+    attr_accessor :spec, :name, :post_install_message, :state
+    def initialize(spec)
+      @spec, @name = spec, spec.name
+      @state = :none
+      @post_install_message = ""
+    end
+
+    def installed?
+      state == :installed
+    end
+
+    def enqueued?
+      state == :enqueued
+    end
+
+    # Only true when spec in neither installed nor already enqueued
+    def ready_to_enqueue?
+      !installed? && !enqueued?
+    end
+
+    def has_post_install_message?
+      !post_install_message.empty?
+    end
+
+    def ignorable_dependency?(dep)
+      dep.type == :development || dep.name == @name
+    end
+
+    # Checks installed dependencies against spec's dependencies to make
+    # sure needed dependencies have been installed.
+    def dependencies_installed?(remaining_specs)
+      installed_specs = remaining_specs.reject(&:installed?).map(&:name)
+      already_installed = lambda {|dep| installed_specs.include? dep.name }
+      dependencies.all? {|d| already_installed[d] }
+    end
+
+    # Represents only the non-development dependencies and the ones that
+    # are itself.
+    def dependencies
+      @dependencies ||= all_dependencies.reject {|dep| ignorable_dependency? dep }
+    end
+
+    # Represents all dependencies
+    def all_dependencies
+      @spec.dependencies
+    end
+  end
+
+  def self.call(*args)
+    new(*args).call
+  end
+
+  # 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
+  end
+
+  def initialize(installer, all_specs, size, standalone, force)
+    @installer = installer
+    @size = size
+    @standalone = standalone
+    @force = force
+    @specs = all_specs.map { |s| SpecInstallation.new(s) }
+  end
+
+  def call
+    enqueue_specs
+    process_specs until @specs.all?(&:installed?)
+  ensure
+    worker_pool && worker_pool.stop
+  end
+
+  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
+      spec_install.post_install_message = message unless message.nil?
+      spec_install
+    }
+  end
+
+  # Dequeue a spec and save its post-install message and then enqueue the
+  # remaining specs.
+  # Some specs might've had to wait til this spec was installed to be
+  # processed so the call to `enqueue_specs` is important after every
+  # dequeue.
+  def process_specs
+    spec = worker_pool.deq
+    spec.state = :installed
+    collect_post_install_message spec if spec.has_post_install_message?
+    enqueue_specs
+  end
+
+  def collect_post_install_message(spec)
+    Bundler::Installer.post_install_messages[spec.name] = spec.post_install_message
+  end
+
+  # Keys in the remains hash represent uninstalled gems specs.
+  # We enqueue all gem specs that do not have any dependencies.
+  # Later we call this lambda again to install specs that depended on
+  # previously installed specifications. We continue until all specs
+  # are installed.
+  def enqueue_specs
+    @specs.select(&:ready_to_enqueue?).each do |spec|
+      if spec.dependencies_installed? @specs
+        worker_pool.enq spec
+        spec.state = :enqueued
+      end
+    end
+  end
+end