bundler 1.0.22 → 1.1.pre

data/lib/bundler/dependency.rb

@@ -15,7 +15,6 @@ 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,
@@ -24,8 +23,7 @@ module Bundler
     }.freeze
 
     def initialize(name, version, options = {}, &blk)
-      type = options["type"] || :runtime
-      super(name, version, type)
+      super(name, version)
 
       @autorequire = nil
       @groups      = Array(options["group"] || :default).map { |g| g.to_sym }
@@ -71,15 +69,21 @@ module Bundler
     end
 
     def to_lock
-      out = super
+      out = "  #{name}"
+
+      unless requirement == Gem::Requirement.default
+        out << " (#{requirement.to_s})"
+      end
+
       out << '!' if source
+
       out << "\n"
     end
 
   private
 
     def ruby?
-      !mswin? && (!defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby" || RUBY_ENGINE == "rbx" || RUBY_ENGINE == "maglev")
+      !mswin? && (!defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby" || RUBY_ENGINE == "rbx")
     end
 
     def ruby_18?
@@ -102,18 +106,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
 
-    def maglev?
-      defined?(RUBY_ENGINE) && RUBY_ENGINE == "maglev"
-    end
-
     def mswin?
       Bundler::WINDOWS
     end

data/lib/bundler/deployment.rb

@@ -4,11 +4,9 @@ module Bundler
       if defined?(Capistrano) && context.is_a?(Capistrano::Configuration)
         context_name = "capistrano"
         role_default = "{:except => {:no_release => true}}"
-        error_type = ::Capistrano::CommandError
       else
         context_name = "vlad"
         role_default = "[:app]"
-        error_type = ::Rake::CommandFailedError
       end
 
       roles = context.fetch(:bundle_roles, false)
@@ -41,16 +39,13 @@ module Bundler
           bundle_dir     = context.fetch(:bundle_dir, File.join(context.fetch(:shared_path), 'bundle'))
           bundle_gemfile = context.fetch(:bundle_gemfile, "Gemfile")
           bundle_without = [*context.fetch(:bundle_without, [:development, :test])].compact
-          current_release = context.fetch(:current_release)
-          if current_release.to_s.empty?
-            raise error_type.new("Cannot detect current release path - make sure you have deployed at least once.")
-          end
-          args = ["--gemfile #{File.join(current_release, bundle_gemfile)}"]
+
+          args = ["--gemfile #{File.join(context.fetch(:current_release), bundle_gemfile)}"]
           args << "--path #{bundle_dir}" unless bundle_dir.to_s.empty?
           args << bundle_flags.to_s
           args << "--without #{bundle_without.join(" ")}" unless bundle_without.empty?
 
-          run "cd #{current_release} && #{bundle_cmd} install #{args.join(' ')}"
+          run "#{bundle_cmd} install #{args.join(' ')}"
         end
       end
     end

data/lib/bundler/dsl.rb

@@ -22,7 +22,7 @@ module Bundler
 
     def gemspec(opts = nil)
       path              = opts && opts[:path] || '.'
-      name              = opts && opts[:name] || '{,*}'
+      name              = opts && opts[:name] || '*'
       development_group = opts && opts[:development_group] || :development
       path              = File.expand_path(path, Bundler.default_gemfile.dirname)
       gemspecs = Dir[File.join(path, "#{name}.gemspec")]
@@ -34,7 +34,7 @@ module Bundler
         gem spec.name, :path => path
         group(development_group) do
           spec.development_dependencies.each do |dep|
-            gem dep.name, *(dep.requirement.as_list + [:type => :development])
+            gem dep.name, *dep.requirement.as_list
           end
         end
       when 0
@@ -57,34 +57,20 @@ module Bundler
 
       dep = Dependency.new(name, version, options)
 
-      # if there's already a dependency with this name we try to prefer one
       if current = @dependencies.find { |d| d.name == dep.name }
         if current.requirement != dep.requirement
-          if current.type == :development
-            @dependencies.delete current
-          elsif dep.type == :development
-            return
-          else
-            raise DslError, "You cannot specify the same gem twice with different version requirements. " \
-                            "You specified: #{current.name} (#{current.requirement}) and " \
-                            "#{dep.name} (#{dep.requirement})"
-          end
+          raise DslError, "You cannot specify the same gem twice with different version requirements. " \
+                          "You specified: #{current.name} (#{current.requirement}) and " \
+                          "#{dep.name} (#{dep.requirement})"
         end
 
         if current.source != dep.source
-          if current.type == :development
-            @dependencies.delete current
-          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 unspecfied source'} and #{dep.source}"
-          end
+          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 unspecfied source'} and #{dep.source}"
         end
       end
-
-      @dependencies << dep
+      @dependencies << Dependency.new(name, version, options)
     end
 
     def source(source, options = {})
@@ -197,7 +183,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 path name branch ref tag require submodules platform platforms)
       if invalid_keys.any?
         plural = invalid_keys.size > 1
         message = "You passed #{invalid_keys.map{|k| ':'+k }.join(", ")} "

data/lib/bundler/fetcher.rb

@@ -0,0 +1,101 @@
+require 'uri'
+require 'net/http/persistent'
+
+module Bundler
+  class Fetcher
+    REDIRECT_LIMIT = 5
+
+    def initialize(remote_uri)
+      @remote_uri = remote_uri
+      @@connection ||= Net::HTTP::Persistent.new
+    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
+
+    # 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"
+
+      query_list = gem_names - full_dependency_list
+      Bundler.ui.debug "Query List: #{query_list.inspect}"
+      return {@remote_uri => last_spec_list}.each(&blk) if query_list.empty?
+
+      spec_list, deps_list = fetch_dependency_remote_specs(query_list, &blk)
+      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)
+    # 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.debug "Error #{e.class} from Gemcutter Dependency Endpoint API: #{e.message}"
+      Bundler.ui.debug e.backtrace
+      fetch_all_remote_specs(&blk)
+    end
+
+  private
+
+    def fetch(uri, counter = 0)
+      raise HTTPError, "Too many redirects" if counter >= REDIRECT_LIMIT
+
+      Bundler.ui.debug "Fetching from: #{uri}"
+      response = @@connection.request(uri)
+      case response
+      when Net::HTTPRedirection
+        Bundler.ui.debug("HTTP Redirection")
+        uri = URI.parse(response["location"])
+        fetch(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, &blk)
+      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)
+
+      spec_list = gem_list.map do |s|
+        [s[:name], Gem::Version.new(s[:number]), s[:platform]]
+      end
+      deps_list = gem_list.map do |s|
+        s[:dependencies].collect {|d| d.first }
+      end.flatten.uniq
+
+      [spec_list, deps_list]
+    end
+
+    # fetch from modern index: specs.4.8.gz
+    def fetch_all_remote_specs(&blk)
+      Bundler.ui.debug "Fetching modern index"
+      Gem.sources = ["#{@remote_uri}"]
+      begin
+        # Fetch all specs, minus prerelease specs
+        Gem::SpecFetcher.new.list(true, false).each(&blk)
+        # Then fetch the prerelease specs
+        begin
+          Gem::SpecFetcher.new.list(false, true).each(&blk)
+        rescue Gem::RemoteFetcher::FetchError
+          Bundler.ui.warn "Could not fetch prerelease specs from #{self}"
+        end
+      rescue Gem::RemoteFetcher::FetchError
+        Bundler.ui.warn "Could not reach #{self}"
+      end
+    end
+  end
+end

data/lib/bundler/gem_helper.rb

@@ -4,8 +4,6 @@ require 'bundler'
 
 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
@@ -16,7 +14,7 @@ module Bundler
     def initialize(base, name = nil)
       Bundler.ui = UI::Shell.new(Thor::Base.shell.new)
       @base = base
-      gemspecs = name ? [File.join(base, "#{name}.gemspec")] : Dir[File.join(base, "{,*}.gemspec")]
+      gemspecs = name ? [File.join(base, "#{name}.gemspec")] : Dir[File.join(base, "*.gemspec")]
       raise "Unable to determine name from existing gemspec. Use :name => 'gemname' in #install_tasks to manually set it." unless gemspecs.size == 1
       @spec_path = gemspecs.first
       @gemspec = Bundler.load_gemspec(@spec_path)
@@ -41,7 +39,7 @@ module Bundler
 
     def build_gem
       file_name = nil
-      sh("gem build -V '#{spec_path}'") { |out, code|
+      sh("gem build #{spec_path}") { |out, code|
         raise out unless out[/Successfully/]
         file_name = File.basename(built_gem_path)
         FileUtils.mkdir_p(File.join(base, 'pkg'))
@@ -53,7 +51,7 @@ module Bundler
 
     def install_gem
       built_gem_path = build_gem
-      out, _ = sh_with_code("gem install '#{built_gem_path}'")
+      out, _ = sh_with_code("gem install #{built_gem_path}")
       raise "Couldn't install gem, run `gem install #{built_gem_path}' for more detailed output" unless out[/Successfully installed/]
       Bundler.ui.confirm "#{name} (#{version}) installed"
     end
@@ -70,12 +68,9 @@ module Bundler
 
     protected
     def rubygem_push(path)
-      if Pathname.new("~/.gem/credentials").expand_path.exist?
-        sh("gem push '#{path}'")
-        Bundler.ui.confirm "Pushed #{name} #{version} to rubygems.org"
-      else
-        raise "Your rubygems.org credentials aren't set. Run `gem push` to set them."
-      end
+      out, _ = sh("gem push #{path}")
+      raise "Gem push failed due to lack of RubyGems.org credentials." if out[/Enter your RubyGems.org credentials/]
+      Bundler.ui.confirm "Pushed #{name} #{version} to rubygems.org"
     end
 
     def built_gem_path

data/lib/bundler/index.rb

@@ -78,13 +78,10 @@ module Bundler
       end
     end
 
-    def use(other, override_dupes = false)
+    def use(other)
       return unless other
       other.each do |s|
-        if (dupes = search_by_spec(s)) && dupes.any?
-          next unless override_dupes
-          @specs[s.name] -= dupes
-        end
+        next if search_by_spec(s).any?
         @specs[s.name] << s
       end
       self
@@ -104,15 +101,10 @@ module Bundler
       end
     end
 
-    if RUBY_VERSION < '1.9'
-      def same_version?(a, b)
-        regex = /^(.*?)(?:\.0)*$/
-        a.to_s[regex, 1] == b.to_s[regex, 1]
-      end
-    else
-      def same_version?(a, b)
-        a == b
-      end
+    def same_version?(a, b)
+      regex = /^(.*?)(?:\.0)*$/
+
+      a.to_s[regex, 1] == b.to_s[regex, 1]
     end
 
     def spec_satisfies_dependency?(spec, dep)
@@ -123,10 +115,11 @@ module Bundler
     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? }
+        found = specs.select { |spec| dependency.matches_spec?(spec) && Gem::Platform.match(spec.platform) }
+
         unless wants_prerelease || only_prerelease
           found.reject! { |spec| spec.version.prerelease? }
         end

data/lib/bundler/installer.rb

@@ -10,16 +10,8 @@ module Bundler
     end
 
     def run(options)
-      # Create the BUNDLE_PATH directory
-      begin
-        Bundler.bundle_path.mkpath unless Bundler.bundle_path.exist?
-      rescue Errno::EEXIST
-        raise PathError, "Could not install to path `#{Bundler.settings[:path]}` " +
-          "because of an invalid symlink. Remove the symlink so the directory can be created."
-      end
-
       if Bundler.settings[:frozen]
-        @definition.ensure_equivalent_gemfile_and_lockfile(options[:deployment])
+        @definition.ensure_equivalent_gemfile_and_lockfile
       end
 
       if dependencies.empty?
@@ -43,43 +35,40 @@ module Bundler
           @definition.resolve_remotely!
       end
 
+      # Ensure that BUNDLE_PATH exists
+      Bundler.mkdir_p(Bundler.bundle_path) unless File.exist?(Bundler.bundle_path)
+
       # Must install gems in the order that the resolver provides
       # as dependencies might actually affect the installation of
       # the gem.
       specs.each do |spec|
-        install_gem_from_spec(spec)
-      end
-
-      lock
-    end
+        spec.source.fetch(spec) if spec.source.respond_to?(:fetch)
 
-  private
+        # unless requested_specs.include?(spec)
+        #   Bundler.ui.debug "  * Not in requested group; skipping."
+        #   next
+        # end
 
-    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)
+        begin
+          old_args = Gem::Command.build_args
+          Gem::Command.build_args = [Bundler.settings["build.#{spec.name}"]]
+          spec.source.install(spec)
+          Bundler.ui.debug "from #{spec.loaded_from} "
+        ensure
+          Gem::Command.build_args = old_args
+        end
 
-      # Fetch the build settings, if there are any
-      settings = Bundler.settings["build.#{spec.name}"]
-      Bundler.rubygems.with_build_args [settings] do
-        spec.source.install(spec)
-        Bundler.ui.debug "from #{spec.loaded_from} "
+        Bundler.ui.info ""
+        generate_bundler_executable_stubs(spec) if Bundler.settings[:bin]
+        FileUtils.rm_rf(Bundler.tmp)
       end
 
-      # newline comes after installing, some gems say "with native extensions"
-      Bundler.ui.info ""
-      generate_bundler_executable_stubs(spec) if Bundler.settings[:bin]
-      FileUtils.rm_rf(Bundler.tmp)
-    rescue Exception => e
-      Bundler.ui.info ""
-      Bundler.ui.warn "#{e.class}: #{e.message}"
-      msg = "An error occured while installing #{spec.name} (#{spec.version}),"
-      msg << " and Bundler cannot continue.\nMake sure that `gem install"
-      msg << " #{spec.name} -v '#{spec.version}'` succeeds before bundling."
-      raise Bundler::InstallError, msg
+      lock
+      generate_standalone(options[:standalone]) if options[:standalone]
     end
 
+  private
+
     def generate_bundler_executable_stubs(spec)
       bin_path = Bundler.bin_path
       template = File.read(File.expand_path('../templates/Executable', __FILE__))
@@ -93,5 +82,36 @@ module Bundler
         end
       end
     end
+
+    def generate_standalone(groups)
+      path = Bundler.settings[:path]
+      bundler_path = File.join(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("bundle/bundler"))
+        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