bundler 1.2.5 → 1.3.0.pre

data/lib/bundler/friendly_errors.rb

@@ -4,11 +4,11 @@ module Bundler
       yield
     rescue Bundler::BundlerError => e
       Bundler.ui.error e.message
-      Bundler.ui.debug e.backtrace.join("\n")
+      Bundler.ui.trace e
       exit e.status_code
     rescue Interrupt => e
       Bundler.ui.error "\nQuitting..."
-      Bundler.ui.debug e.backtrace.join("\n")
+      Bundler.ui.trace e
       exit 1
     rescue SystemExit => e
       exit e.status
@@ -19,8 +19,7 @@ module Bundler
         Bundler.ui.warn "You must recompile Ruby with OpenSSL support or change the sources in your" \
           "\nGemfile from 'https' to 'http'. Instructions for compiling with OpenSSL" \
           "\nusing RVM are available at rvm.io/packages/openssl."
-        Bundler.ui.debug "#{e.class}: #{e.message}"
-        Bundler.ui.debug e.backtrace.join("\n")
+        Bundler.ui.trace e
         exit 1
       else
         raise e
@@ -28,7 +27,7 @@ module Bundler
     rescue Exception => e
       Bundler.ui.error(
         "Unfortunately, a fatal error has occurred. Please see the Bundler \n" \
-        "troubleshooting documentation at http://bit.ly/bundler-issues. Thanks! \n")
+        "troubleshooting documentation at http://bit.ly/bundler-issues. Thanks!\n")
       raise e
     end
   end

data/lib/bundler/gem_helper.rb

@@ -24,7 +24,7 @@ module Bundler
     attr_reader :spec_path, :base, :gemspec
 
     def initialize(base = nil, name = nil)
-      Bundler.ui = UI::Shell.new(Thor::Base.shell.new)
+      Bundler.ui = UI::Shell.new
       @base = (base ||= Dir.pwd)
       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
@@ -33,12 +33,12 @@ module Bundler
     end
 
     def install
-      desc "Build #{name}-#{version}.gem into the pkg directory"
+      desc "Build #{name}-#{version}.gem into the pkg directory."
       task 'build' do
         build_gem
       end
 
-      desc "Build and install #{name}-#{version}.gem into system gems"
+      desc "Build and install #{name}-#{version}.gem into system gems."
       task 'install' do
         install_gem
       end
@@ -57,7 +57,7 @@ module Bundler
         file_name = File.basename(built_gem_path)
         FileUtils.mkdir_p(File.join(base, 'pkg'))
         FileUtils.mv(built_gem_path, 'pkg')
-        Bundler.ui.confirm "#{name} #{version} built to pkg/#{file_name}"
+        Bundler.ui.confirm "#{name} #{version} built to pkg/#{file_name}."
       }
       File.join(base, 'pkg', file_name)
     end
@@ -66,24 +66,21 @@ module Bundler
       built_gem_path = build_gem
       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"
+      Bundler.ui.confirm "#{name} (#{version}) installed."
     end
 
     def release_gem
       guard_clean
-      guard_already_tagged
       built_gem_path = build_gem
-      tag_version {
-        git_push
-        rubygem_push(built_gem_path)
-      }
+      tag_version { git_push } unless already_tagged?
+      rubygem_push(built_gem_path)
     end
 
     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"
+        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
@@ -96,7 +93,7 @@ module Bundler
     def git_push
       perform_git_push
       perform_git_push ' --tags'
-      Bundler.ui.confirm "Pushed git commits and tags"
+      Bundler.ui.confirm "Pushed git commits and tags."
     end
 
     def perform_git_push(options = '')
@@ -105,9 +102,10 @@ module Bundler
       raise "Couldn't git push. `#{cmd}' failed with the following output:\n\n#{out}\n" unless code == 0
     end
 
-    def guard_already_tagged
+    def already_tagged?
       if sh('git tag').split(/\n/).include?(version_tag)
-        raise("This tag has already been committed to the repo.")
+        Bundler.ui.confirm "Tag #{version_tag} has already been created."
+        true
       end
     end
 
@@ -121,10 +119,10 @@ module Bundler
 
     def tag_version
       sh "git tag -a -m \"Version #{version}\" #{version_tag}"
-      Bundler.ui.confirm "Tagged #{version_tag}"
+      Bundler.ui.confirm "Tagged #{version_tag}."
       yield if block_given?
     rescue
-      Bundler.ui.error "Untagged #{version_tag} due to error"
+      Bundler.ui.error "Untagging #{version_tag} due to error."
       sh_with_code "git tag -d #{version_tag}"
       raise
     end

data/lib/bundler/injector.rb

@@ -0,0 +1,64 @@
+module Bundler
+  class Injector
+    def self.inject(new_deps)
+      injector = new(new_deps)
+      injector.inject(Bundler.default_gemfile, Bundler.default_lockfile)
+    end
+
+    def initialize(new_deps)
+      @new_deps = new_deps
+    end
+
+    def inject(gemfile_path, lockfile_path)
+      if Bundler.settings[:frozen]
+        # ensure the lock and Gemfile are synced
+        Bundler.definition.ensure_equivalent_gemfile_and_lockfile(true)
+        # temporarily remove frozen while we inject
+        frozen = Bundler.settings.delete(:frozen)
+      end
+
+      # evaluate the Gemfile we have now
+      builder = Dsl.new
+      builder.eval_gemfile(gemfile_path)
+
+      # don't inject any gems that are already in the Gemfile
+      @new_deps -= builder.dependencies
+
+      # add new deps to the end of the in-memory Gemfile
+      builder.eval_gemfile("injected gems", new_gem_lines) if @new_deps.any?
+
+      # resolve to see if the new deps broke anything
+      definition = builder.to_definition(lockfile_path, {})
+      definition.resolve_remotely!
+
+      # since nothing broke, we can add those gems to the gemfile
+      append_to(gemfile_path) if @new_deps.any?
+
+      # since we resolved successfully, write out the lockfile
+      definition.lock(Bundler.default_lockfile)
+
+      # return an array of the deps that we added
+      return @new_deps
+    ensure
+      Bundler.settings[:frozen] = '1' if frozen
+    end
+
+  private
+
+    def new_gem_lines
+      @new_deps.map do |d|
+        %|gem '#{d.name}', '#{d.requirement}'|
+      end.join("\n")
+    end
+
+    def append_to(gemfile_path)
+      gemfile_path.open("a") do |f|
+        f.puts
+        f.puts "# Added at #{Time.now} by #{`whoami`.chomp}:"
+        f.puts new_gem_lines
+      end
+    end
+
+
+  end
+end

data/lib/bundler/installer.rb

@@ -66,13 +66,11 @@ module Bundler
       end
 
       if Bundler.default_lockfile.exist? && !options["update"]
-        real_ui, Bundler.ui = Bundler.ui, Bundler::UI.new
         begin
           tmpdef = Definition.build(Bundler.default_gemfile, Bundler.default_lockfile, nil)
           local = true unless tmpdef.new_platform? || tmpdef.missing_specs.any?
         rescue BundlerError
         end
-        Bundler.ui = real_ui
       end
 
       # Since we are installing, we can resolve the definition
@@ -177,16 +175,12 @@ module Bundler
 
         spec.require_paths.each do |path|
           full_path = File.join(spec.full_gem_path, path)
-          gem_path = Pathname.new(full_path).relative_path_from(Bundler.root.join(bundler_path))
-          paths << gem_path.to_s.sub("#{SystemRubyVersion.new.engine}/#{RbConfig::CONFIG['ruby_version']}", '#{ruby_engine}/#{ruby_version}')
+          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 "# ruby 1.8.7 doesn't define RUBY_ENGINE"
-        file.puts "ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'"
-        file.puts "ruby_version = RbConfig::CONFIG[\"ruby_version\"]"
         file.puts "path = File.expand_path('..', __FILE__)"
         paths.each do |path|
           file.puts %{$:.unshift File.expand_path("\#{path}/#{path}")}

data/lib/bundler/lazy_specification.rb

@@ -26,8 +26,7 @@ module Bundler
     end
 
     def ==(other)
-      [name, version, dependencies, platform, source] ==
-        [other.name, other.version, other.dependencies, other.platform, other.source]
+      identifier == other.identifier
     end
 
     def satisfies?(dependency)
@@ -58,7 +57,11 @@ module Bundler
     end
 
     def to_s
-      "#{name} (#{version})"
+      @__to_s ||= "#{name} (#{version})"
+    end
+
+    def identifier
+      @__identifier ||= [name, version, source, platform, dependencies].hash
     end
 
   private

data/lib/bundler/lockfile_parser.rb

@@ -14,22 +14,31 @@ module Bundler
   class LockfileParser
     attr_reader :sources, :dependencies, :specs, :platforms
 
+    DEPENDENCIES = "DEPENDENCIES"
+    PLATFORMS    = "PLATFORMS"
+    GIT          = "GIT"
+    GEM          = "GEM"
+    PATH         = "PATH"
+    SPECS        = "  specs:"
+    OPTIONS      = /^  ([a-z]+): (.*)$/i
+
     def initialize(lockfile)
       @platforms    = []
       @sources      = []
       @dependencies = []
-      @specs        = []
       @state        = :source
+      @specs        = {}
 
-      lockfile.split(/(\r?\n)+/).each do |line|
-        if line == "DEPENDENCIES"
+      lockfile.split(/(?:\r?\n)+/).each do |line|
+        if line == DEPENDENCIES
           @state = :dependency
-        elsif line == "PLATFORMS"
+        elsif line == PLATFORMS
           @state = :platform
         else
           send("parse_#{@state}", line)
         end
       end
+      @specs        = @specs.values
     end
 
   private
@@ -42,10 +51,10 @@ module Bundler
 
     def parse_source(line)
       case line
-      when "GIT", "GEM", "PATH"
+      when GIT, GEM, PATH
         @current_source = nil
         @opts, @type = {}, line
-      when "  specs:"
+      when SPECS
         @current_source = TYPES[@type].from_lock(@opts)
 
         # Strip out duplicate GIT sections
@@ -54,7 +63,7 @@ module Bundler
         end
 
         @sources << @current_source
-      when /^  ([a-z]+): (.*)$/i
+      when OPTIONS
         value = $2
         value = true if value == "true"
         value = false if value == "false"
@@ -73,17 +82,20 @@ module Bundler
     end
 
     NAME_VERSION = '(?! )(.*?)(?: \(([^-]*)(?:-(.*))?\))?'
+    NAME_VERSION_2 = %r{^ {2}#{NAME_VERSION}(!)?$}
+    NAME_VERSION_4 = %r{^ {4}#{NAME_VERSION}$}
+    NAME_VERSION_6 = %r{^ {6}#{NAME_VERSION}$}
 
     def parse_dependency(line)
-      if line =~ %r{^ {2}#{NAME_VERSION}(!)?$}
+      if line =~ NAME_VERSION_2
         name, version, pinned = $1, $2, $4
         version = version.split(",").map { |d| d.strip } if version
 
         dep = Bundler::Dependency.new(name, version)
 
         if pinned && dep.name != 'bundler'
-          spec = @specs.find { |s| s.name == dep.name }
-          dep.source = spec.source if spec
+          spec = @specs.find {|k, v| v.name == dep.name }
+          dep.source = spec.last.source if spec
 
           # Path sources need to know what the default name / version
           # to use in the case that there are no gemspecs present. A fake
@@ -100,7 +112,7 @@ module Bundler
     end
 
     def parse_spec(line)
-      if line =~ %r{^ {4}#{NAME_VERSION}$}
+      if line =~ NAME_VERSION_4
         name, version = $1, Gem::Version.new($2)
         platform = $3 ? Gem::Platform.new($3) : Gem::Platform::RUBY
         @current_spec = LazySpecification.new(name, version, platform)
@@ -108,8 +120,8 @@ module Bundler
 
         # Avoid introducing multiple copies of the same spec (caused by
         # duplicate GIT sections)
-        @specs << @current_spec unless @specs.include?(@current_spec)
-      elsif line =~ %r{^ {6}#{NAME_VERSION}$}
+        @specs[@current_spec.identifier] ||= @current_spec
+      elsif line =~ NAME_VERSION_6
         name, version = $1, $2
         version = version.split(',').map { |d| d.strip } if version
         dep = Gem::Dependency.new(name, version)

data/lib/bundler/resolver.rb

@@ -122,7 +122,6 @@ module Bundler
     # <GemBundle>,nil:: If the list of dependencies can be resolved, a
     #   collection of gemspecs is returned. Otherwise, nil is returned.
     def self.resolve(requirements, index, source_requirements = {}, base = [])
-      Bundler.ui.info "Resolving dependencies..."
       base = SpecSet.new(base) unless base.is_a?(SpecSet)
       resolver = new(index, source_requirements, base)
       result = catch(:success) do

data/lib/bundler/rubygems_integration.rb

@@ -1,10 +1,7 @@
+require 'rubygems'
+
 module Bundler
   class RubygemsIntegration
-    def initialize
-      # Work around a RubyGems bug
-      configuration
-    end
-
     def loaded_specs(name)
       Gem.loaded_specs[name]
     end
@@ -90,6 +87,22 @@ module Bundler
       Gem::SpecFetcher.new.list(all, pre).each(&blk)
     end
 
+    def fetch_all_remote_specs
+      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 => e
+          # ignore if we can't fetch the prerelease specs
+        end
+      end
+
+      return spec_list
+    end
+
     def with_build_args(args)
       old_args = Gem::Command.build_args
       begin
@@ -101,7 +114,19 @@ module Bundler
     end
 
     def spec_from_gem(path)
+      require 'rubygems/format'
       Gem::Format.from_file_by_path(path).spec
+    rescue Gem::Package::FormatError
+      raise Bundler::GemspecError, "Could not read gem at #{path}. It may be corrupted."
+    end
+
+    def build(spec)
+      require 'rubygems/builder'
+      Gem::Builder.new(spec).build
+    end
+
+    def build_gem(gem_dir, spec)
+      Dir.chdir(gem_dir) { build(spec) }
     end
 
     def download_gem(spec, uri, path)
@@ -161,16 +186,6 @@ module Bundler
       end
     end
 
-    if defined? ::Deprecate
-      Deprecate = ::Deprecate
-    elsif defined? Gem::Deprecate
-      Deprecate = Gem::Deprecate
-    else
-      class Deprecate
-        def skip_during; yield; end
-      end
-    end
-
     def stub_source_index137(specs)
       # Rubygems versions lower than 1.7 use SourceIndex#from_gems_in
       source_index_class = (class << Gem::SourceIndex ; self ; end)
@@ -341,7 +356,7 @@ module Bundler
       end
     end
 
-    # Rubygems 1.8.5
+    # Rubygems ~> 1.8.5
     class Modern < RubygemsIntegration
       def stub_rubygems(specs)
         Gem::Specification.all = specs
@@ -374,9 +389,60 @@ module Bundler
       end
     end
 
+    # Rubygems 2.0
+    class Future < RubygemsIntegration
+      require 'rubygems/package'
+
+      def stub_rubygems(specs)
+        Gem::Specification.all = specs
+
+        Gem.post_reset {
+          Gem::Specification.all = specs
+        }
+      end
+
+      def all_specs
+        Gem::Specification.to_a
+      end
+
+      def find_name(name)
+        Gem::Specification.find_all_by_name name
+      end
+
+      def fetch_all_remote_specs
+        tuples, errors = Gem::SpecFetcher.new.available_specs(:complete)
+        # only raise if we don't get any specs back.
+        # this means we still work if prerelease_specs.4.8.gz
+        # don't exist but specs.4.8.gz do
+        if tuples.empty? && error = errors.detect {|e| e.is_a?(Gem::SourceFetchProblem) }
+          raise Gem::RemoteFetcher::FetchError.new(error.error, error.source)
+        end
+
+        hash = {}
+        tuples.each do |source,tuples|
+          hash[source.uri] = tuples.map { |tuple| tuple.to_a }
+        end
+
+        hash
+      end
+
+      def spec_from_gem(path)
+        Gem::Package.new(path).spec
+      rescue Gem::Package::FormatError
+        raise Bundler::GemspecError, "Could not read gem at #{path}. It may be corrupted."
+      end
+
+      def build(spec)
+        Gem::Package.build(spec)
+      end
+
+    end
+
   end
 
-  if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.8.5')
+  if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.99.99')
+    @rubygems = RubygemsIntegration::Future.new
+  elsif Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.8.5')
     @rubygems = RubygemsIntegration::Modern.new
   elsif Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.8.0')
     @rubygems = RubygemsIntegration::AlmostModern.new