bundler 1.1.pre.5 → 1.1.pre.7

data/lib/bundler/rubygems_ext.rb

@@ -141,6 +141,7 @@ module Gem
 
     alias eql? ==
   end
+
 end
 
 module Bundler

data/lib/bundler/rubygems_integration.rb

@@ -250,7 +250,17 @@ module Bundler
       Gem.clear_paths
     end
 
-    # Rubygems versions 1.3.6 through 1.6.2
+    # This backports the correct segment generation code from Rubygems 1.4+
+    # by monkeypatching it into the method in Rubygems 1.3.6 and 1.3.7.
+    def backport_segment_generation
+      Gem::Version.send(:define_method, :segments) do
+        @segments ||= @version.scan(/[0-9]+|[a-z]+/i).map do |s|
+          /^\d+$/ =~ s ? s.to_i : s
+        end
+      end
+    end
+
+    # Rubygems 1.4 through 1.6
     class Legacy < RubygemsIntegration
       def stub_rubygems(specs)
         stub_source_index137(specs)
@@ -265,6 +275,14 @@ module Bundler
       end
     end
 
+    # Rubygems versions 1.3.6 and 1.3.7
+    class Ancient < Legacy
+      def initialize
+        super
+        backport_segment_generation
+      end
+    end
+
     # Rubygems 1.7
     class Transitional < Legacy
       def stub_rubygems(specs)
@@ -313,8 +331,10 @@ module Bundler
     @rubygems = RubygemsIntegration::AlmostModern.new
   elsif Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.7.0')
     @rubygems = RubygemsIntegration::Transitional.new
-  else # Rubygems 1.3.6 through 1.6.2
+  elsif Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.4.0')
     @rubygems = RubygemsIntegration::Legacy.new
+  else # Rubygems 1.3.6 and 1.3.7
+    @rubygems = RubygemsIntegration::Ancient.new
   end
 
   class << self

data/lib/bundler/runtime.rb

@@ -142,6 +142,8 @@ module Bundler
         FileUtils.rm_rf(gem_dir)
         specification_file = "#{Gem.dir}/specifications/#{full_name}.gemspec"
         FileUtils.rm(specification_file) if File.exists?(specification_file)
+        gem_file = "#{Gem.dir}/cache/#{full_name}.gem"
+        FileUtils.rm(gem_file) if File.exists?(gem_file)
 
         parts   = full_name.split('-')
         name    = parts[0..-2].join('-')

data/lib/bundler/source.rb

@@ -10,8 +10,10 @@ module Bundler
   module Source
     # TODO: Refactor this class
     class Rubygems
+      FORCE_MODERN_INDEX_LIMIT = 100 # threshold for switching back to the modern index instead of fetching every spec
+
       attr_reader :remotes, :caches
-      attr_accessor :dependencies
+      attr_accessor :dependency_names
 
       def initialize(options = {})
         @options = options
@@ -22,8 +24,6 @@ module Bundler
 
         @caches = [ Bundler.app_cache ] +
           Bundler.rubygems.gem_path.map{|p| File.expand_path("#{p}/cache") }
-
-        @spec_fetch_map = {}
       end
 
       def remote!
@@ -70,15 +70,6 @@ module Bundler
         @specs ||= fetch_specs
       end
 
-      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) if spec.is_a?(RemoteSpecification)
-        end
-      end
-
       def install(spec)
         if installed_specs[spec].any?
           Bundler.ui.info "Using #{spec.name} (#{spec.version}) "
@@ -107,22 +98,18 @@ module Bundler
 
         # SUDO HAX
         if Bundler.requires_sudo?
-          sudo "mkdir -p #{Bundler.rubygems.gem_dir}/gems #{Bundler.rubygems.gem_dir}/specifications"
-          sudo "cp -R #{Bundler.tmp}/gems/#{spec.full_name} #{Bundler.rubygems.gem_dir}/gems/"
-          sudo "cp -R #{Bundler.tmp}/specifications/#{spec.full_name}.gemspec #{Bundler.rubygems.gem_dir}/specifications/"
+          Bundler.sudo "mkdir -p #{Bundler.rubygems.gem_dir}/gems #{Bundler.rubygems.gem_dir}/specifications"
+          Bundler.sudo "cp -R #{Bundler.tmp}/gems/#{spec.full_name} #{Bundler.rubygems.gem_dir}/gems/"
+          Bundler.sudo "cp -R #{Bundler.tmp}/specifications/#{spec.full_name}.gemspec #{Bundler.rubygems.gem_dir}/specifications/"
           spec.executables.each do |exe|
-            sudo "mkdir -p #{Bundler.rubygems.gem_bindir}"
-            sudo "cp -R #{Bundler.tmp}/bin/#{exe} #{Bundler.rubygems.gem_bindir}"
+            Bundler.sudo "mkdir -p #{Bundler.rubygems.gem_bindir}"
+            Bundler.sudo "cp -R #{Bundler.tmp}/bin/#{exe} #{Bundler.rubygems.gem_bindir}"
           end
         end
 
         spec.loaded_from = "#{Bundler.rubygems.gem_dir}/specifications/#{spec.full_name}.gemspec"
       end
 
-      def sudo(str)
-        Bundler.sudo(str)
-      end
-
       def cache(spec)
         cached_path = cached_gem(spec)
         raise GemNotFound, "Missing gem file '#{spec.full_name}.gem'." unless cached_path
@@ -226,35 +213,41 @@ module Bundler
           idx     = Index.new
           old     = Bundler.rubygems.sources
 
+          sources = {}
           remotes.each do |uri|
+            fetcher          = Bundler::Fetcher.new(uri)
+            specs            = fetcher.specs(dependency_names, self)
+            sources[fetcher] = specs.size
 
-            @fetchers[uri] = Bundler::Fetcher.new(uri)
-            gem_names = dependencies && dependencies.map{|d| d.name }
+            idx.use specs
+          end
 
-            idx.use @fetchers[uri].specs(gem_names, self, @spec_fetch_map)
+          # don't need to fetch all specifications for every gem/version on
+          # the rubygems repo if there's no api endpoints to search over
+          # or it has too many specs to fetch
+          fetchers              = sources.keys
+          api_fetchers          = fetchers.select {|fetcher| fetcher.has_api }
+          modern_index_fetchers = fetchers - api_fetchers
+          if api_fetchers.any? && modern_index_fetchers.all? {|fetcher| sources[fetcher] < FORCE_MODERN_INDEX_LIMIT }
+            # this will fetch all the specifications on the rubygems repo
+            unmet_dependency_names = idx.unmet_dependency_names
+
+            if unmet_dependency_names.any?
+              api_fetchers.each do |fetcher|
+                idx.use fetcher.specs(unmet_dependency_names, self)
+              end
+            end
+          else
+            Bundler::Fetcher.disable_endpoint = true
+            api_fetchers.each {|fetcher| idx.use fetcher.specs([], self) }
           end
+
           idx
         ensure
           Bundler.rubygems.sources = old
         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?
-          sudo "mkdir -p #{Bundler.rubygems.gem_dir}/cache"
-          sudo "mv #{Bundler.tmp}/cache/#{spec.full_name}.gem #{gem_path}"
-        end
-
-        gem_path
-      end
     end
 
     class Path
@@ -345,9 +338,9 @@ module Bundler
               s.relative_loaded_from = "#{@name}.gemspec"
               s.authors  = ["no one"]
               if expanded_path.join("bin").exist?
-                binaries = expanded_path.join("bin").children
-                binaries.reject!{|p| File.directory?(p) }
-                s.executables = binaries.map{|c| c.basename.to_s }
+                executables = expanded_path.join("bin").children
+                executables.reject!{|p| File.directory?(p) }
+                s.executables = executables.map{|c| c.basename.to_s }
               end
             end
           end
@@ -433,8 +426,11 @@ module Bundler
         gem_file = Dir.chdir(gem_dir){ Gem::Builder.new(spec).build }
 
         installer = Installer.new(spec, :env_shebang => false)
+        run_hooks(:pre_install, installer)
         installer.build_extensions
+        run_hooks(:post_build, installer)
         installer.generate_bin
+        run_hooks(:post_install, installer)
       rescue Gem::InvalidSpecificationException => e
         Bundler.ui.warn "\n#{spec.name} at #{spec.full_gem_path} did not have a valid gemspec.\n" \
                         "This prevents bundler from installing bins or native extensions, but " \
@@ -451,6 +447,18 @@ module Bundler
         Dir.chdir(gem_dir){ FileUtils.rm_rf(gem_file) if gem_file && File.exist?(gem_file) }
       end
 
+      def run_hooks(type, installer)
+        hooks_meth = "#{type}_hooks"
+        return unless Gem.respond_to?(hooks_meth)
+        Gem.send(hooks_meth).each do |hook|
+          result = hook.call(installer)
+          if result == false
+            location = " at #{$1}" if hook.inspect =~ /@(.*:\d+)/
+            message = "#{type} hook#{location} failed for #{installer.spec.full_name}"
+            raise Gem::InstallError, message
+          end
+        end
+      end
     end
 
     class Git < Path
@@ -568,7 +576,7 @@ module Bundler
       end
 
       def base_name
-        File.basename(uri.sub(%r{^(\w+://)?([^/:]+:)},''), ".git")
+        File.basename(uri.sub(%r{^(\w+://)?([^/:]+:)?(//\w*/)?(\w*/)*},''),".git")
       end
 
       def shortref_for_display(ref)

data/lib/bundler/spec_set.rb

@@ -1,21 +1,18 @@
 require 'tsort'
+require 'forwardable'
 
 module Bundler
   class SpecSet
+    extend Forwardable
     include TSort, Enumerable
 
+    def_delegators :@specs, :<<, :length, :add, :remove
+    def_delegators :sorted, :each
+
     def initialize(specs)
       @specs = specs.sort_by { |s| s.name }
     end
 
-    def each
-      sorted.each { |s| yield s }
-    end
-
-    def length
-      @specs.length
-    end
-
     def for(dependencies, skip = [], check = false, match_current_platform = false)
       handled, deps, specs = {}, dependencies.dup, []
       skip << 'bundler'
@@ -68,6 +65,10 @@ module Bundler
       value
     end
 
+    def sort!
+      self
+    end
+
     def to_a
       sorted.dup
     end
@@ -80,7 +81,7 @@ module Bundler
       materialized = self.for(deps, [], false, true).to_a
       materialized.map! do |s|
         next s unless s.is_a?(LazySpecification)
-        s.source.dependencies = deps if s.source.respond_to?(:dependencies=)
+        s.source.dependency_names = deps.map {|d| d.name } if s.source.respond_to?(:dependency_names=)
         spec = s.__materialize__
         if missing_specs
           missing_specs << s unless spec

data/lib/bundler/templates/newgem/Rakefile.tt

@@ -1,2 +1,2 @@
 #!/usr/bin/env rake
-require 'bundler/gem_tasks'
+require "bundler/gem_tasks"

data/lib/bundler/templates/newgem/newgem.gemspec.tt

@@ -6,12 +6,12 @@ Gem::Specification.new do |gem|
   gem.email         = [<%=config[:email].inspect%>]
   gem.description   = %q{TODO: Write a gem description}
   gem.summary       = %q{TODO: Write a gem summary}
-  gem.homepage      = ''
+  gem.homepage      = ""
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")
   gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   gem.name          = <%=config[:name].inspect%>
-  gem.require_paths = ['lib']
+  gem.require_paths = ["lib"]
   gem.version       = <%=config[:constant_name]%>::VERSION
 end

data/lib/bundler/vendor/thor.rb

@@ -18,6 +18,23 @@ class Thor
       end
     end
 
+    # Registers another Thor subclass as a command.
+    #
+    # ==== Parameters
+    # klass<Class>:: Thor subclass to register
+    # command<String>:: Subcommand name to use
+    # usage<String>:: Short usage for the subcommand
+    # description<String>:: Description for the subcommand
+    def register(klass, subcommand_name, usage, description, options={})
+      if klass <= Thor::Group
+        desc usage, description, options
+        define_method(subcommand_name) { invoke klass }
+      else
+        desc usage, description, options
+        subcommand subcommand_name, klass
+      end
+    end
+
     # Defines the usage and the description of the next task.
     #
     # ==== Parameters
@@ -252,8 +269,7 @@ class Thor
       # the namespace should be displayed as arguments.
       #
       def banner(task, namespace = nil, subcommand = false)
-        base = File.basename($0).split(" ").first
-        "#{base} #{task.formatted_usage(self, $thor_runner, subcommand)}"
+        "#{basename} #{task.formatted_usage(self, $thor_runner, subcommand)}"
       end
 
       def baseclass #:nodoc:
@@ -295,17 +311,40 @@ class Thor
       # Receives a task name (can be nil), and try to get a map from it.
       # If a map can't be found use the sent name or the default task.
       def normalize_task_name(meth) #:nodoc:
-        meth = map[meth.to_s] || meth || default_task
+        meth = map[meth.to_s] || find_subcommand_and_update_argv(meth) || meth || default_task
         meth.to_s.gsub('-','_') # treat foo-bar > foo_bar
       end
 
+      # terrible hack that overwrites ARGV
+      def find_subcommand_and_update_argv(subcmd_name) #:nodoc:
+        return unless subcmd_name
+        cmd = find_subcommand(subcmd_name)
+        ARGV[0] = cmd if cmd
+        cmd
+      end
+
+      def find_subcommand(subcmd_name)
+        possibilities = find_subcommand_possibilities subcmd_name
+        if possibilities.size > 1
+          raise "Ambiguous subcommand #{subcmd_name} matches [#{possibilities.join(', ')}]"
+        elsif possibilities.size < 1
+          return nil
+        end
+
+        possibilities.first
+      end
+
+      def find_subcommand_possibilities(subcmd_name)
+        len = subcmd_name.length
+        all_tasks.map {|t| t.first}.select { |n| subcmd_name == n[0, len] }
+      end
+
       def subcommand_help(cmd)
         desc "help [COMMAND]", "Describe subcommands or one specific subcommand"
         class_eval <<-RUBY
           def help(task = nil, subcommand = true); super; end
         RUBY
       end
-
   end
 
   include Thor::Base

data/lib/bundler/vendor/thor/actions.rb

@@ -1,10 +1,12 @@
 require 'fileutils'
 require 'uri'
 require 'thor/core_ext/file_binary_read'
-
-Dir[File.join(File.dirname(__FILE__), "actions", "*.rb")].each do |action|
-  require action
-end
+require 'thor/actions/create_file'
+require 'thor/actions/create_link'
+require 'thor/actions/directory'
+require 'thor/actions/empty_directory'
+require 'thor/actions/file_manipulation'
+require 'thor/actions/inject_into_file'
 
 class Thor
   module Actions
@@ -158,13 +160,23 @@ class Thor
     #
     def inside(dir='', config={}, &block)
       verbose = config.fetch(:verbose, false)
+      pretend = options[:pretend]
 
       say_status :inside, dir, verbose
       shell.padding += 1 if verbose
       @destination_stack.push File.expand_path(dir, destination_root)
 
-      FileUtils.mkdir_p(destination_root) unless File.exist?(destination_root)
-      FileUtils.cd(destination_root) { block.arity == 1 ? yield(destination_root) : yield }
+      # If the directory doesnt exist and we're not pretending
+      if !File.exist?(destination_root) && !pretend
+        FileUtils.mkdir_p(destination_root)
+      end
+
+      if pretend
+        # In pretend mode, just yield down to the block
+        block.arity == 1 ? yield(destination_root) : yield
+      else
+        FileUtils.cd(destination_root) { block.arity == 1 ? yield(destination_root) : yield }
+      end
 
       @destination_stack.pop
       shell.padding -= 1 if verbose
@@ -210,7 +222,7 @@ class Thor
     #
     # ==== Parameters
     # command<String>:: the command to be executed.
-    # config<Hash>:: give :verbose => false to not log the status. Specify :with
+    # config<Hash>:: give :verbose => false to not log the status, :capture => true to hide to output. Specify :with
     #                to append an executable to command executation.
     #
     # ==== Example
@@ -231,7 +243,10 @@ class Thor
       end
 
       say_status :run, desc, config.fetch(:verbose, true)
-      `#{command}` unless options[:pretend]
+
+      unless options[:pretend]
+        config[:capture] ? `#{command}` : system("#{command}")
+      end
     end
 
     # Executes a ruby script (taking into account WIN32 platform quirks).
@@ -251,8 +266,9 @@ class Thor
     # ==== Parameters
     # task<String>:: the task to be invoked
     # args<Array>:: arguments to the task
-    # config<Hash>:: give :verbose => false to not log the status. Other options
-    #                are given as parameter to Thor.
+    # config<Hash>:: give :verbose => false to not log the status, :capture => true to hide to output.
+    #                Other options are given as parameter to Thor.
+    #
     #
     # ==== Examples
     #
@@ -266,12 +282,13 @@ class Thor
       config  = args.last.is_a?(Hash) ? args.pop : {}
       verbose = config.key?(:verbose) ? config.delete(:verbose) : true
       pretend = config.key?(:pretend) ? config.delete(:pretend) : false
+      capture = config.key?(:capture) ? config.delete(:capture) : false
 
       args.unshift task
       args.push Thor::Options.to_switches(config)
       command = args.join(' ').strip
 
-      run command, :with => :thor, :verbose => verbose, :pretend => pretend
+      run command, :with => :thor, :verbose => verbose, :pretend => pretend, :capture => capture
     end
 
     protected