bundler 1.0.21 → 1.1.rc

data/lib/bundler/dsl.rb

@@ -20,6 +20,8 @@ module Bundler
       @env             = nil
     end
 
+    attr_accessor :dependencies
+
     def gemspec(opts = nil)
       path              = opts && opts[:path] || '.'
       name              = opts && opts[:name] || '{,*}'
@@ -90,18 +92,18 @@ module Bundler
     def source(source, options = {})
       case source
       when :gemcutter, :rubygems, :rubyforge then
-        rubygems_source "http://rubygems.org"
+        @rubygems_source.add_remote "http://rubygems.org"
         return
       when String
-        rubygems_source source
+        @rubygems_source.add_remote source
         return
-      end
-
-      @source = source
-      options[:prepend] ? @sources.unshift(@source) : @sources << @source
+      else
+        @source = source
+        options[:prepend] ? @sources.unshift(@source) : @sources << @source
 
-      yield if block_given?
-      @source
+        yield if block_given?
+        return @source
+      end
     ensure
       @source = nil
     end
@@ -126,8 +128,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
 
@@ -168,21 +169,8 @@ module Bundler
       end
     end
 
-    deprecate :only, :group
-    deprecate :except
-    deprecate :disable_system_gems
-    deprecate :disable_rubygems
-    deprecate :clear_sources
-    deprecate :bundle_path
-    deprecate :bin_path
-
   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|
@@ -197,7 +185,7 @@ module Bundler
     def _normalize_options(name, version, opts)
       _normalize_hash(opts)
 
-      invalid_keys = opts.keys - %w(group groups git path name branch ref tag require submodules platform platforms type)
+      invalid_keys = opts.keys - %w(group groups git github path name branch ref tag require submodules platform platforms type)
       if invalid_keys.any?
         plural = invalid_keys.size > 1
         message = "You passed #{invalid_keys.map{|k| ':'+k }.join(", ")} "
@@ -223,7 +211,11 @@ module Bundler
         raise DslError, "`#{p}` is not a valid platform. The available options are: #{VALID_PLATFORMS.inspect}"
       end
 
-      # Normalize git and path options
+      if github = opts.delete("github")
+        github = "#{github}/#{github}" unless github.include?("/")
+        opts["git"] = "git://github.com/#{github}.git"
+      end
+
       ["git", "path"].each do |type|
         if param = opts[type]
           if version.first && version.first =~ /^\s*=?\s*(\d[^\s]*)\s*$/
@@ -243,15 +235,6 @@ module Bundler
     end
 
     def _deprecated_options(options)
-      if options.include?(:require_as)
-        raise DeprecatedError, "Please replace :require_as with :require"
-      elsif options.include?(:vendored_at)
-        raise DeprecatedError, "Please replace :vendored_at with :path"
-      elsif options.include?(:only)
-        raise DeprecatedError, "Please replace :only with :group"
-      elsif options.include?(:except)
-        raise DeprecatedError, "The :except option is no longer supported"
-      end
     end
   end
 end

data/lib/bundler/endpoint_specification.rb

@@ -0,0 +1,69 @@
+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
+
+    # needed for standalone, load required_paths from local gemspec
+    # after the gem in installed
+    def require_paths
+      if @remote_specification
+        @remote_specification.require_paths
+      elsif _local_specification
+        _local_specification.require_paths
+      else
+        super
+      end
+    end
+
+    # needed for binstubs
+    def executables
+      if @remote_specification
+        @remote_specification.executables
+      elsif _local_specification
+        _local_specification.executables
+      else
+        super
+      end
+    end
+
+    # needed for bundle clean
+    def bindir
+      if @remote_specification
+        @remote_specification.bindir
+      elsif _local_specification
+        _local_specification.bindir
+      else
+        super
+      end
+    end
+
+    def _local_specification
+      eval(File.read(local_specification_path)) if @loaded_from && File.exists?(local_specification_path)
+    end
+
+    def __swap__(spec)
+      @remote_specification = spec
+    end
+
+    private
+    def local_specification_path
+      "#{base_dir}/specifications/#{full_name}.gemspec"
+    end
+  end
+end

data/lib/bundler/fetcher.rb

@@ -0,0 +1,221 @@
+require 'uri'
+require 'net/http/persistent'
+
+module Bundler
+  # Handles all the fetching with the rubygems server
+  class Fetcher
+    REDIRECT_LIMIT = 5
+
+    attr_reader :has_api
+
+    class << self
+      attr_accessor :disable_endpoint
+
+      @@spec_fetch_map ||= {}
+
+      def fetch(spec)
+        spec, uri = @@spec_fetch_map[spec.full_name]
+        if spec
+          path = download_gem_from_uri(spec, uri)
+          s = Bundler.rubygems.spec_from_gem(path)
+          spec.__swap__(s)
+        end
+      end
+
+      def download_gem_from_uri(spec, uri)
+        spec.fetch_platform
+
+        download_path = Bundler.requires_sudo? ? Bundler.tmp : Bundler.rubygems.gem_dir
+        gem_path = "#{Bundler.rubygems.gem_dir}/cache/#{spec.full_name}.gem"
+
+        FileUtils.mkdir_p("#{download_path}/cache")
+        Bundler.rubygems.download_gem(spec, uri, download_path)
+
+        if Bundler.requires_sudo?
+          Bundler.mkdir_p "#{Bundler.rubygems.gem_dir}/cache"
+          Bundler.sudo "mv #{Bundler.tmp}/cache/#{spec.full_name}.gem #{gem_path}"
+        end
+
+        gem_path
+      end
+    end
+
+    def initialize(remote_uri)
+      @remote_uri = remote_uri
+      @has_api    = true # will be set to false if the rubygems index is ever fetched
+      @@connection ||= Net::HTTP::Persistent.new nil, :ENV
+    end
+
+    # fetch a gem specification
+    def fetch_spec(spec)
+      spec = spec - [nil, 'ruby', '']
+      spec_file_name = "#{spec.join '-'}.gemspec.rz"
+
+      uri = URI.parse("#{@remote_uri}#{Gem::MARSHAL_SPEC_DIR}#{spec_file_name}")
+
+      spec_rz = (uri.scheme == "file") ? Gem.read_binary(uri.path) : fetch(uri)
+      Marshal.load Gem.inflate(spec_rz)
+    end
+
+    # return the specs in the bundler format as an index
+    def specs(gem_names, source)
+      index = Index.new
+
+      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
+        Bundler.ui.info "Fetching gem metadata from #{strip_user_pass_from_uri(@remote_uri)}", Bundler.ui.debug?
+        begin
+          specs = fetch_remote_specs(gem_names)
+        # 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
+        # 3. One of the YAML gemspecs has the Syck::DefaultKey problem
+        rescue HTTPError, TypeError => e
+          # new line now that the dots are over
+          Bundler.ui.info "" unless Bundler.ui.debug?
+
+          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
+        else
+          # new line now that the dots are over
+          Bundler.ui.info "" unless Bundler.ui.debug?
+        end
+      end
+
+      specs[@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 = [])
+      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?
+
+      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)
+    end
+
+  private
+
+    def fetch(uri, counter = 0)
+      raise HTTPError, "Too many redirects" if counter >= REDIRECT_LIMIT
+
+      begin
+        Bundler.ui.debug "Fetching from: #{uri}"
+        response = @@connection.request(uri)
+      rescue SocketError, Timeout, Net::HTTP::Persistent::Error
+        raise Bundler::HTTPError, "Network error while fetching #{uri}"
+      end
+
+      case response
+      when Net::HTTPRedirection
+        Bundler.ui.debug("HTTP Redirection")
+        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
+      else
+        Bundler.ui.debug("HTTP Error")
+        raise HTTPError
+      end
+    end
+
+    # fetch from Gemcutter Dependency Endpoint API
+    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|
+        dependencies = s[:dependencies].map do |d|
+          begin
+            name, requirement = d
+            dep = Gem::Dependency.new(name, requirement.split(", "))
+          rescue ArgumentError => e
+            if e.message.include?('Illformed requirement ["#<YAML::Syck::DefaultKey')
+              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. As a result, Bundler cannot install this Gemfile. } +
+                %{Please ask the gem author to yank the bad version to fix this issue. For } +
+                %{more information, see http://bit.ly/illformed-requirement.}
+            else
+              raise e
+            end
+          end
+
+          deps_list << dep.name
+
+          dep
+        end
+
+        [s[:name], Gem::Version.new(s[:number]), s[:platform], dependencies]
+      end
+
+      [spec_list, deps_list.uniq]
+    end
+
+    # fetch from modern index: specs.4.8.gz
+    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
+        raise Bundler::HTTPError, "Could not reach #{strip_user_pass_from_uri(@remote_uri)}"
+      end
+
+      return spec_list
+    end
+
+    def strip_user_pass_from_uri(uri)
+      uri_dup = uri.dup
+      uri_dup.user = "****" if uri_dup.user
+      uri_dup.password = "****" if uri_dup.password
+
+      uri_dup
+    end
+  end
+end

data/lib/bundler/gem_helper.rb

@@ -42,7 +42,6 @@ module Bundler
     def build_gem
       file_name = nil
       sh("gem build -V '#{spec_path}'") { |out, code|
-        raise out unless out[/Successfully/]
         file_name = File.basename(built_gem_path)
         FileUtils.mkdir_p(File.join(base, 'pkg'))
         FileUtils.mv(built_gem_path, 'pkg')

data/lib/bundler/gem_helpers.rb

@@ -0,0 +1,23 @@
+module Bundler
+  module GemHelpers
+
+    GENERIC_CACHE = {}
+    GENERICS = [
+      Gem::Platform.new('java'),
+      Gem::Platform.new('mswin32'),
+      Gem::Platform.new('x86-mingw32'),
+      Gem::Platform::RUBY
+    ]
+
+    def generic(p)
+      return p if p == Gem::Platform::RUBY
+
+      GENERIC_CACHE[p] ||= begin
+        found = GENERICS.find do |p2|
+          p2.is_a?(Gem::Platform) && p.os == p2.os
+        end
+        found || Gem::Platform::RUBY
+      end
+    end
+  end
+end

data/lib/bundler/index.rb

@@ -8,16 +8,18 @@ module Bundler
       i
     end
 
-    attr_reader :specs
+    attr_reader :specs, :sources
     protected   :specs
 
     def initialize
+      @sources = []
       @cache = {}
       @specs = Hash.new { |h,k| h[k] = [] }
     end
 
     def initialize_copy(o)
       super
+      @sources = @sources.dup
       @cache = {}
       @specs = Hash.new { |h,k| h[k] = [] }
 
@@ -26,43 +28,43 @@ module Bundler
       end
     end
 
+    def inspect
+      "<Index sources=#{sources.map{|s| s.inspect}} specs.size=#{specs.size}>"
+    end
+
     def empty?
       each { return false }
       true
     end
 
-    def search(query)
-      case query
-      when Gem::Specification, RemoteSpecification, LazySpecification then search_by_spec(query)
-      when String then @specs[query]
-      else search_by_dependency(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 search_for_all_platforms(dependency, base = [])
-      specs = @specs[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? }
+    def local_search(query, base = nil)
+      case 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, base)
+      else
+        raise "You can't search for a #{query.inspect}."
       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.class }
-      end.flatten.uniq
+    def source_types
+      sources.map{|s| s.class }.uniq
     end
 
     alias [] search
 
     def <<(spec)
-      arr = @specs[spec.name]
+      arr = specs_by_name(spec.name)
 
       arr.delete_if do |s|
         same_version?(s.version, spec.version) && s.platform == spec.platform
@@ -73,11 +75,21 @@ module Bundler
     end
 
     def each(&blk)
-      @specs.values.each do |specs|
+      specs.values.each do |specs|
         specs.each(&blk)
       end
     end
 
+    # returns a list of the dependencies
+    def unmet_dependency_names
+      dependency_names = specs.values.map do |array_of_s|
+        array_of_s.map do |s|
+          s.dependencies.map{|d| d.name }
+        end
+      end.flatten.uniq
+      dependency_names.select{|name| specs_by_name(name).empty? }
+    end
+
     def use(other, override_dupes = false)
       return unless other
       other.each do |s|
@@ -90,16 +102,57 @@ module Bundler
       self
     end
 
+    def size
+      @sources.inject(@specs.size) do |size, source|
+        size += source.size
+      end
+    end
+
     def ==(o)
       all? do |s|
         s2 = o[s].first and (s.dependencies & s2.dependencies).empty?
       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^base.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[spec.name].select do |s|
+      specs_by_name(spec.name).select do |s|
         same_version?(s.version, spec.version) && Gem::Platform.new(s.platform) == Gem::Platform.new(spec.platform)
       end
     end
@@ -120,19 +173,5 @@ module Bundler
       dep.requirement.satisfied_by?(spec.version)
     end
 
-    def search_by_dependency(dependency)
-      @cache[dependency.hash] ||= begin
-        specs = @specs[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)
@@ -24,6 +28,7 @@ module Bundler
 
       if dependencies.empty?
         Bundler.ui.warn "The Gemfile specifies no dependencies"
+        lock
         return
       end
 
@@ -46,11 +51,13 @@ 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|
         install_gem_from_spec(spec)
       end
 
       lock
+      generate_standalone(options[:standalone]) if options[:standalone]
     end
 
   private
@@ -58,7 +65,7 @@ module Bundler
     def install_gem_from_spec(spec)
       # Download the gem to get the spec, because some specs that are returned
       # by rubygems.org are broken and wrong.
-      spec.source.fetch(spec) if spec.source.respond_to?(:fetch)
+      Bundler::Fetcher.fetch(spec) if spec.source.is_a?(Bundler::Source::Rubygems)
 
       # Fetch the build settings, if there are any
       settings = Bundler.settings["build.#{spec.name}"]
@@ -72,6 +79,10 @@ module Bundler
       generate_bundler_executable_stubs(spec) if Bundler.settings[:bin]
       FileUtils.rm_rf(Bundler.tmp)
     rescue Exception => e
+      # install hook failed
+      raise e if e.is_a?(Gem::InstallError)
+
+      # other failure, likely a native extension build failure
       Bundler.ui.info ""
       Bundler.ui.warn "#{e.class}: #{e.message}"
       msg = "An error occured while installing #{spec.name} (#{spec.version}),"
@@ -93,5 +104,36 @@ module Bundler
         end
       end
     end
+
+    def generate_standalone(groups)
+      standalone_path = Bundler.settings[:path]
+      bundler_path = File.join(standalone_path, "bundler")
+      FileUtils.mkdir_p(bundler_path)
+
+      paths = []
+
+      if groups.empty?
+        specs = Bundler.definition.requested_specs
+      else
+        specs = Bundler.definition.specs_for groups.map { |g| g.to_sym }
+      end
+
+      specs.each do |spec|
+        next if spec.name == "bundler"
+
+        spec.require_paths.each do |path|
+          full_path = File.join(spec.full_gem_path, path)
+          paths << Pathname.new(full_path).relative_path_from(Bundler.root.join(bundler_path))
+        end
+      end
+
+
+      File.open File.join(bundler_path, "setup.rb"), "w" do |file|
+        file.puts "path = File.expand_path('..', __FILE__)"
+        paths.each do |path|
+          file.puts %{$:.unshift File.expand_path("\#{path}/#{path}")}
+        end
+      end
+    end
   end
 end