bundler 1.1.pre.4 → 1.1.pre.5

data/lib/bundler/definition.rb

@@ -160,16 +160,18 @@ module Bundler
     def index
       @index ||= Index.build do |idx|
         @sources.each do |s|
-          idx.use s.specs(@dependencies)
+          s.dependencies = @dependencies if s.is_a?(Bundler::Source::Rubygems)
+          idx.add_source s.specs
         end
       end
     end
 
+    # used when frozen is enabled so we can find the bundler
+    # spec, even if (say) a git gem is not checked out.
     def rubygems_index
       @rubygems_index ||= Index.build do |idx|
-        @sources.find_all{|s| s.is_a?(Source::Rubygems) }.each do |s|
-          idx.use s.specs
-        end
+        rubygems = @sources.find{|s| s.is_a?(Source::Rubygems) }
+        idx.add_source rubygems.specs
       end
     end
 

data/lib/bundler/dependency.rb

@@ -15,6 +15,7 @@ module Bundler
       :mri      => Gem::Platform::RUBY,
       :mri_18   => Gem::Platform::RUBY,
       :mri_19   => Gem::Platform::RUBY,
+      :rbx      => Gem::Platform::RUBY,
       :jruby    => Gem::Platform::JAVA,
       :mswin    => Gem::Platform::MSWIN,
       :mingw    => Gem::Platform::MINGW,
@@ -107,6 +108,10 @@ module Bundler
       mri? && RUBY_VERSION >= "1.9"
     end
 
+    def rbx?
+      ruby? && defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx"
+    end
+
     def jruby?
       defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
     end

data/lib/bundler/dsl.rb

@@ -112,8 +112,7 @@ module Bundler
     end
 
     def to_definition(lockfile, unlock)
-      @sources << @rubygems_source
-      @sources.uniq!
+      @sources << @rubygems_source unless @sources.include?(@rubygems_source)
       Definition.new(lockfile, @dependencies, @sources, unlock)
     end
 
@@ -164,11 +163,6 @@ module Bundler
 
   private
 
-    def rubygems_source(source)
-      @rubygems_source.add_remote source
-      @sources << @rubygems_source
-    end
-
     def _normalize_hash(opts)
       # Cannot modify a hash during an iteration in 1.9
       opts.keys.each do |k|

data/lib/bundler/endpoint_specification.rb

@@ -0,0 +1,22 @@
+require 'uri'
+
+module Bundler
+  # used for Creating Specifications from the Gemcutter Endpoint
+  class EndpointSpecification < Gem::Specification
+    include MatchPlatform
+
+    attr_reader :name, :version, :platform, :dependencies
+    attr_accessor :source
+
+    def initialize(name, version, platform, dependencies)
+      @name         = name
+      @version      = version
+      @platform     = platform
+      @dependencies = dependencies
+    end
+
+    def fetch_platform
+      @plaftorm
+    end
+  end
+end

data/lib/bundler/fetcher.rb

@@ -2,12 +2,17 @@ require 'uri'
 require 'net/http/persistent'
 
 module Bundler
+  # Handles all the fetching with the rubygems server
   class Fetcher
     REDIRECT_LIMIT = 5
 
+    class << self
+      attr_accessor :disable_endpoint
+    end
+
     def initialize(remote_uri)
       @remote_uri = remote_uri
-      @@connection ||= Net::HTTP::Persistent.new
+      @@connection ||= Net::HTTP::Persistent.new nil, :ENV
     end
 
     # fetch a gem specification
@@ -21,25 +26,56 @@ module Bundler
       Marshal.load Gem.inflate(spec_rz)
     end
 
+    # return the specs in the bundler format as an index
+    def specs(gem_names, source, spec_fetch_map)
+      index = Index.new
+
+      fetch_remote_specs(gem_names)[@remote_uri].each do |name, version, platform, dependencies|
+        next if name == 'bundler'
+        spec = nil
+        if dependencies
+          spec = EndpointSpecification.new(name, version, platform, dependencies)
+        else
+          spec = RemoteSpecification.new(name, version, platform, self)
+        end
+        spec.source = source
+        spec_fetch_map[spec.full_name] = [spec, @remote_uri]
+        index << spec
+      end
+
+      index
+    end
+
     # fetch index
-    def fetch_remote_specs(gem_names, full_dependency_list = [], last_spec_list = [], &blk)
-      return fetch_all_remote_specs(&blk) unless gem_names && @remote_uri.scheme != "file"
+    def fetch_remote_specs(gem_names, full_dependency_list = [], last_spec_list = [])
+      return fetch_all_remote_specs if !gem_names || @remote_uri.scheme == "file" || Bundler::Fetcher.disable_endpoint
 
       query_list = gem_names - full_dependency_list
+      # only display the message on the first run
+      if full_dependency_list.empty?
+        Bundler.ui.info "Fetching dependency information from the API at #{@remote_uri}", false
+      else
+        Bundler.ui.info ".", false
+      end
+
       Bundler.ui.debug "Query List: #{query_list.inspect}"
-      return {@remote_uri => last_spec_list}.each(&blk) if query_list.empty?
+      if query_list.empty?
+        Bundler.ui.info "\n"
+        return {@remote_uri => last_spec_list}
+      end
 
-      spec_list, deps_list = fetch_dependency_remote_specs(query_list, &blk)
+      spec_list, deps_list = fetch_dependency_remote_specs(query_list)
       returned_gems = spec_list.map {|spec| spec.first }.uniq
 
-      fetch_remote_specs(deps_list, full_dependency_list + returned_gems, spec_list + last_spec_list, &blk)
+      fetch_remote_specs(deps_list, full_dependency_list + returned_gems, spec_list + last_spec_list)
     # fall back to the legacy index in the following cases
     # 1.) Gemcutter Endpoint doesn't return a 200
     # 2.) Marshal blob doesn't load properly
     rescue HTTPError, TypeError => e
+      Bundler.ui.info "\nError using the API"
       Bundler.ui.debug "Error #{e.class} from Gemcutter Dependency Endpoint API: #{e.message}"
       Bundler.ui.debug e.backtrace
-      fetch_all_remote_specs(&blk)
+      fetch_all_remote_specs
     end
 
   private
@@ -47,13 +83,20 @@ module Bundler
     def fetch(uri, counter = 0)
       raise HTTPError, "Too many redirects" if counter >= REDIRECT_LIMIT
 
-      Bundler.ui.debug "Fetching from: #{uri}"
-      response = @@connection.request(uri)
+      begin
+        Bundler.ui.debug "Fetching from: #{uri}"
+        response = @@connection.request(uri)
+      rescue SocketError, Timeout
+        raise Bundler::HTTPError, "Network error while fetching #{uri}"
+      end
+
       case response
       when Net::HTTPRedirection
         Bundler.ui.debug("HTTP Redirection")
-        uri = URI.parse(response["location"])
-        fetch(uri, counter + 1)
+        new_uri = URI.parse(response["location"])
+        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
@@ -64,38 +107,49 @@ module Bundler
     end
 
     # fetch from Gemcutter Dependency Endpoint API
-    def fetch_dependency_remote_specs(gem_names, &blk)
+    def fetch_dependency_remote_specs(gem_names)
       Bundler.ui.debug "Query Gemcutter Dependency Endpoint API: #{gem_names.join(' ')}"
       uri = URI.parse("#{@remote_uri}api/v1/dependencies?gems=#{gem_names.join(",")}")
       marshalled_deps = fetch(uri)
       gem_list = Marshal.load(marshalled_deps)
+      deps_list = []
 
       spec_list = gem_list.map do |s|
-        [s[:name], Gem::Version.new(s[:number]), s[:platform]]
+        dependencies = s[:dependencies].map do |d|
+          name, requirement = d
+          dep = Gem::Dependency.new(name, requirement.split(", "))
+
+          deps_list << dep.name
+
+          dep
+        end
+
+        [s[:name], Gem::Version.new(s[:number]), s[:platform], dependencies]
       end
-      deps_list = gem_list.map do |s|
-        s[:dependencies].collect {|d| d.first }
-      end.flatten.uniq
 
-      [spec_list, deps_list]
+      [spec_list, deps_list.uniq]
     end
 
     # fetch from modern index: specs.4.8.gz
-    def fetch_all_remote_specs(&blk)
+    def fetch_all_remote_specs
+      Bundler.ui.info "Fetching source index for #{@remote_uri}"
       Bundler.ui.debug "Fetching modern index"
       Gem.sources = ["#{@remote_uri}"]
+      spec_list = Hash.new { |h,k| h[k] = [] }
       begin
         # Fetch all specs, minus prerelease specs
-        Gem::SpecFetcher.new.list(true, false).each(&blk)
+        spec_list = Gem::SpecFetcher.new.list(true, false)
         # Then fetch the prerelease specs
         begin
-          Gem::SpecFetcher.new.list(false, true).each(&blk)
+          Gem::SpecFetcher.new.list(false, true).each {|k, v| spec_list[k] += v }
         rescue Gem::RemoteFetcher::FetchError
-          Bundler.ui.warn "Could not fetch prerelease specs from #{self}"
+          Bundler.ui.warn "Could not fetch prerelease specs from #{@remote_uri}"
         end
       rescue Gem::RemoteFetcher::FetchError
-        Bundler.ui.warn "Could not reach #{self}"
+        raise Bundler::HTTPError, "Could not reach #{@remote_uri}"
       end
+
+      return spec_list
     end
   end
 end

data/lib/bundler/gem_helper.rb

@@ -2,15 +2,10 @@ $:.unshift File.expand_path('../vendor', __FILE__)
 require 'thor'
 require 'bundler'
 
-begin
-  # Support Rake > 0.8.7
-  require 'rake/dsl_definition'
-  include Rake::DSL
-rescue LoadError
-end
-
 module Bundler
   class GemHelper
+    include Rake::DSL if defined? Rake::DSL
+
     def self.install_tasks(opts = {})
       dir = opts[:dir] || Dir.pwd
       self.new(dir, opts[:name]).install

data/lib/bundler/gem_tasks.rb

@@ -0,0 +1,2 @@
+require 'bundler/gem_helper'
+Bundler::GemHelper.install_tasks

data/lib/bundler/index.rb

@@ -33,40 +33,26 @@ module Bundler
       true
     end
 
-    def search(query)
+    # Search this index's specs, and any source indexes that this index knows
+    # about, returning all of the results.
+    def search(query, base = nil)
+      results = local_search(query, base)
+      @sources.each do |source|
+        results += source.search(query, base)
+      end
+      results
+    end
+
+    def local_search(query, base = nil)
       case query
-      when Gem::Specification, RemoteSpecification, LazySpecification then search_by_spec(query)
+      when Gem::Specification, RemoteSpecification, LazySpecification, EndpointSpecification then search_by_spec(query)
       when String then specs_by_name(query)
-      when Gem::Dependency then search_by_dependency(query)
+      when Gem::Dependency then search_by_dependency(query, base)
       else
         raise "You can't search for a #{query.inspect}."
       end
     end
 
-    def specs_by_name(name)
-      @specs[name]
-    end
-
-    def search_for_all_platforms(dependency, base = [])
-      specs = specs_by_name(dependency.name) + base
-
-      wants_prerelease = dependency.requirement.prerelease?
-      only_prerelease  = specs.all? {|spec| spec.version.prerelease? }
-      found = specs.select { |spec| dependency.matches_spec?(spec) }
-
-      unless wants_prerelease || only_prerelease
-        found.reject! { |spec| spec.version.prerelease? }
-      end
-
-      found.sort_by {|s| [s.version, s.platform.to_s == 'ruby' ? "\0" : s.platform.to_s] }
-    end
-
-    def sources
-      specs.values.map do |specs|
-        specs.map{|s| s.source }
-      end.flatten.uniq
-    end
-
     def source_types
       sources.map{|s| s.class }.uniq
     end
@@ -105,8 +91,43 @@ module Bundler
       end
     end
 
+    def add_source(index)
+      if index.is_a?(Index)
+        @sources << index
+        @sources.uniq! # need to use uniq! here instead of checking for the item before adding
+      else
+        raise ArgumentError, "Source must be an index, not #{index.class}"
+      end
+    end
+
   private
 
+    def specs_by_name(name)
+      @specs[name]
+    end
+
+    def search_by_dependency(dependency, base = nil)
+      @cache[dependency.hash] ||= begin
+        specs = specs_by_name(dependency.name) + (base || [])
+        found = specs.select do |spec|
+          if base # allow all platforms when searching from a lockfile
+            dependency.matches_spec?(spec)
+          else
+            dependency.matches_spec?(spec) && Gem::Platform.match(spec.platform)
+          end
+        end
+
+        wants_prerelease = dependency.requirement.prerelease?
+        only_prerelease  = specs.all? {|spec| spec.version.prerelease? }
+
+        unless wants_prerelease || only_prerelease
+          found.reject! { |spec| spec.version.prerelease? }
+        end
+
+        found.sort_by {|s| [s.version, s.platform.to_s == 'ruby' ? "\0" : s.platform.to_s] }
+      end
+    end
+
     def search_by_spec(spec)
       specs_by_name(spec.name).select do |s|
         same_version?(s.version, spec.version) && Gem::Platform.new(s.platform) == Gem::Platform.new(spec.platform)
@@ -124,19 +145,5 @@ module Bundler
       dep.requirement.satisfied_by?(spec.version)
     end
 
-    def search_by_dependency(dependency)
-      @cache[dependency.hash] ||= begin
-        specs = specs_by_name(dependency.name)
-        found = specs.select { |spec| dependency.matches_spec?(spec) && Gem::Platform.match(spec.platform) }
-
-        wants_prerelease = dependency.requirement.prerelease?
-        only_prerelease  = specs.all? {|spec| spec.version.prerelease? }
-        unless wants_prerelease || only_prerelease
-          found.reject! { |spec| spec.version.prerelease? }
-        end
-
-        found.sort_by {|s| [s.version, s.platform.to_s == 'ruby' ? "\0" : s.platform.to_s] }
-      end
-    end
   end
 end

data/lib/bundler/installer.rb

@@ -3,6 +3,10 @@ require 'rubygems/dependency_installer'
 
 module Bundler
   class Installer < Environment
+    class << self
+      attr_accessor :post_install_messages
+    end
+
     def self.install(root, definition, options = {})
       installer = new(root, definition)
       installer.run(options)
@@ -46,6 +50,7 @@ module Bundler
       # Must install gems in the order that the resolver provides
       # as dependencies might actually affect the installation of
       # the gem.
+      Installer.post_install_messages = {}
       specs.each do |spec|
         spec.source.fetch(spec) if spec.source.respond_to?(:fetch)
 

data/lib/bundler/lazy_specification.rb

@@ -59,12 +59,13 @@ module Bundler
   private
 
     def method_missing(method, *args, &blk)
-      if Gem::Specification.new.respond_to?(method)
-        raise "LazySpecification has not been materialized yet (calling :#{method} #{args.inspect})" unless @specification
-        @specification.send(method, *args, &blk)
-      else
-        super
-      end
+      return super if method == :to_ary
+
+      raise "LazySpecification has not been materialized yet (calling :#{method} #{args.inspect})" unless @specification
+
+      return super unless respond_to?(method)
+
+      @specification.send(method, *args, &blk)
     end
 
   end

data/lib/bundler/resolver.rb

@@ -361,7 +361,7 @@ module Bundler
         d = dep.dep
       end
       index = @source_requirements[d.name] || @index
-      results = index.search_for_all_platforms(d, @base[d.name])
+      results = index.search(d, @base[d.name])
 
       if results.any?
         version = results.first.version

data/lib/bundler/rubygems_ext.rb

@@ -19,7 +19,7 @@ module Gem
 
     def full_gem_path
       source.respond_to?(:path) ?
-        Pathname.new(loaded_from).dirname.expand_path.to_s :
+        Pathname.new(loaded_from).dirname.expand_path(Bundler.root).to_s :
         rg_full_gem_path
     end