bundler 1.2.5 → 1.3.0.pre

data/lib/bundler/source/path/installer.rb

@@ -0,0 +1,33 @@
+module Bundler
+  module Source
+    class Path
+
+      class Installer < Bundler::GemInstaller
+        def initialize(spec, options = {})
+          @spec              = spec
+          @bin_dir           = Bundler.requires_sudo? ? "#{Bundler.tmp}/bin" : "#{Bundler.rubygems.gem_dir}/bin"
+          @gem_dir           = Bundler.rubygems.path(spec.full_gem_path)
+          @wrappers          = options[:wrappers] || true
+          @env_shebang       = options[:env_shebang] || true
+          @format_executable = options[:format_executable] || false
+        end
+
+        def generate_bin
+          return if spec.executables.nil? || spec.executables.empty?
+
+          if Bundler.requires_sudo?
+            FileUtils.mkdir_p("#{Bundler.tmp}/bin") unless File.exist?("#{Bundler.tmp}/bin")
+          end
+          super
+          if Bundler.requires_sudo?
+            Bundler.mkdir_p "#{Bundler.rubygems.gem_dir}/bin"
+            spec.executables.each do |exe|
+              Bundler.sudo "cp -R #{Bundler.tmp}/bin/#{exe} #{Bundler.rubygems.gem_dir}/bin/"
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/bundler/source/rubygems.rb

@@ -0,0 +1,261 @@
+require 'uri'
+require 'rubygems/user_interaction'
+require 'rubygems/spec_fetcher'
+
+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 :dependency_names
+
+      def initialize(options = {})
+        @options = options
+        @remotes = (options["remotes"] || []).map { |r| normalize_uri(r) }
+        @fetchers = {}
+        @allow_remote = false
+        @allow_cached = false
+
+        @caches = [ Bundler.app_cache ] +
+          Bundler.rubygems.gem_path.map{|p| File.expand_path("#{p}/cache") }
+      end
+
+      def remote!
+        @allow_remote = true
+      end
+
+      def cached!
+        @allow_cached = true
+      end
+
+      def hash
+        Rubygems.hash
+      end
+
+      def eql?(o)
+        Rubygems === o
+      end
+
+      alias == eql?
+
+      def options
+        { "remotes" => @remotes.map { |r| r.to_s } }
+      end
+
+      def self.from_lock(options)
+        s = new(options)
+        Array(options["remote"]).each { |r| s.add_remote(r) }
+        s
+      end
+
+      def to_lock
+        out = "GEM\n"
+        out << remotes.map {|r| "  remote: #{r}\n" }.join
+        out << "  specs:\n"
+      end
+
+      def to_s
+        remote_names = self.remotes.map { |r| r.to_s }.join(', ')
+        "rubygems repository #{remote_names}"
+      end
+      alias_method :name, :to_s
+
+      def specs
+        @specs ||= fetch_specs
+      end
+
+      def install(spec)
+        if installed_specs[spec].any?
+          Bundler.ui.info "Using #{spec.name} (#{spec.version}) "
+          return
+        end
+
+        Bundler.ui.info "Installing #{spec.name} (#{spec.version}) "
+        path = cached_gem(spec)
+        if Bundler.requires_sudo?
+          install_path = Bundler.tmp
+          bin_path     = install_path.join("bin")
+        else
+          install_path = Bundler.rubygems.gem_dir
+          bin_path     = Bundler.system_bindir
+        end
+
+        installed_spec = nil
+        Bundler.rubygems.preserve_paths do
+          installed_spec = Bundler::GemInstaller.new(path,
+            :install_dir         => install_path.to_s,
+            :bin_dir             => bin_path.to_s,
+            :ignore_dependencies => true,
+            :wrappers            => true,
+            :env_shebang         => true
+          ).install
+        end
+
+        if spec.post_install_message
+          Installer.post_install_messages[spec.name] = spec.post_install_message
+        end
+
+        # SUDO HAX
+        if Bundler.requires_sudo?
+          Bundler.mkdir_p "#{Bundler.rubygems.gem_dir}/gems"
+          Bundler.mkdir_p "#{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|
+            Bundler.mkdir_p Bundler.system_bindir
+            Bundler.sudo "cp -R #{Bundler.tmp}/bin/#{exe} #{Bundler.system_bindir}"
+          end
+        end
+        installed_spec.loaded_from = "#{Bundler.rubygems.gem_dir}/specifications/#{spec.full_name}.gemspec"
+        spec.loaded_from = "#{Bundler.rubygems.gem_dir}/specifications/#{spec.full_name}.gemspec"
+      end
+
+      def cache(spec)
+        cached_path = cached_gem(spec)
+        raise GemNotFound, "Missing gem file '#{spec.full_name}.gem'." unless cached_path
+        return if File.dirname(cached_path) == Bundler.app_cache.to_s
+        Bundler.ui.info "  * #{File.basename(cached_path)}"
+        FileUtils.cp(cached_path, Bundler.app_cache)
+      end
+
+      def add_remote(source)
+        @remotes << normalize_uri(source)
+      end
+
+      def replace_remotes(source)
+        return false if source.remotes == @remotes
+
+        @remotes = []
+        source.remotes.each do |r|
+          add_remote r.to_s
+        end
+
+        true
+      end
+
+    private
+
+      def cached_gem(spec)
+        possibilities = @caches.map { |p| "#{p}/#{spec.file_name}" }
+        cached_gem = possibilities.find { |p| File.exist?(p) }
+        unless cached_gem
+          raise Bundler::GemNotFound, "Could not find #{spec.file_name} for installation"
+        end
+        cached_gem
+      end
+
+      def normalize_uri(uri)
+        uri = uri.to_s
+        uri = "#{uri}/" unless uri =~ %r'/$'
+        uri = URI(uri)
+        raise ArgumentError, "The source must be an absolute URI" unless uri.absolute?
+        uri
+      end
+
+      def fetch_specs
+        # remote_specs usually generates a way larger Index than the other
+        # sources, and large_idx.use small_idx is way faster than
+        # small_idx.use large_idx.
+        if @allow_remote
+          idx = remote_specs.dup
+        else
+          idx = Index.new
+        end
+        idx.use(cached_specs, :override_dupes) if @allow_cached || @allow_remote
+        idx.use(installed_specs, :override_dupes)
+        idx
+      end
+
+      def installed_specs
+        @installed_specs ||= begin
+          idx = Index.new
+          have_bundler = false
+          Bundler.rubygems.all_specs.reverse.each do |spec|
+            next if spec.name == 'bundler' && spec.version.to_s != VERSION
+            have_bundler = true if spec.name == 'bundler'
+            spec.source = self
+            idx << spec
+          end
+
+          # Always have bundler locally
+          unless have_bundler
+           # We're running bundler directly from the source
+           # so, let's create a fake gemspec for it (it's a path)
+           # gemspec
+           bundler = Gem::Specification.new do |s|
+             s.name     = 'bundler'
+             s.version  = VERSION
+             s.platform = Gem::Platform::RUBY
+             s.source   = self
+             s.authors  = ["bundler team"]
+             s.loaded_from = File.expand_path("..", __FILE__)
+           end
+           idx << bundler
+          end
+          idx
+        end
+      end
+
+      def cached_specs
+        @cached_specs ||= begin
+          idx = installed_specs.dup
+
+          path = Bundler.app_cache
+          Dir["#{path}/*.gem"].each do |gemfile|
+            next if gemfile =~ /^bundler\-[\d\.]+?\.gem/
+            s ||= Bundler.rubygems.spec_from_gem(gemfile)
+            s.source = self
+            idx << s
+          end
+        end
+
+        idx
+      end
+
+      def remote_specs
+        @remote_specs ||= begin
+          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
+
+            idx.use specs
+          end
+
+          # 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
+            unmet_dependency_names -= ['bundler'] # bundler will always be unmet
+
+            Bundler.ui.debug "Unmet Dependencies: #{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
+    end
+
+  end
+end

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

@@ -11,9 +11,12 @@ Gem::Specification.new do |gem|
   gem.description   = %q{TODO: Write a gem description}
   gem.summary       = %q{TODO: Write a gem summary}
   gem.homepage      = ""
+  gem.license       = "MIT"
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "rake"
 end

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

@@ -0,0 +1,2 @@
+--format specdoc
+--color

data/lib/bundler/templates/newgem/spec/newgem_spec.rb.tt

@@ -0,0 +1,9 @@
+describe <%= config[:constant_name] %> do
+  it 'should have a version number' do
+    <%= config[:constant_name] %>::VERSION.should_not be_nil
+  end
+
+  it 'should do something useful' do
+    false.should be_true
+  end
+end

data/lib/bundler/templates/newgem/spec/spec_helper.rb.tt

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require '<%= config[:name] %>'

data/lib/bundler/templates/newgem/test/minitest_helper.rb.tt

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require '<%= config[:name] %>'
+
+require 'minitest/autorun'

data/lib/bundler/templates/newgem/test/test_newgem.rb.tt

@@ -0,0 +1,11 @@
+require './minitest_helper'
+
+class Test<%= config[:constant_name] %> < MiniTest::Unit::TestCase
+  def test_that_it_has_a_version_number
+    refute_nil ::<%= config[:constant_name] %>::VERSION
+  end
+
+  def test_it_does_something_useful
+    assert false
+  end
+end

data/lib/bundler/ui.rb

@@ -8,6 +8,9 @@ module Bundler
     def debug(message, newline = nil)
     end
 
+    def trace(message, newline = nil)
+    end
+
     def error(message, newline = nil)
     end
 
@@ -22,13 +25,16 @@ module Bundler
     end
 
     class Shell < UI
-      attr_reader :quiet
       attr_writer :shell
 
-      def initialize(shell)
-        @shell = shell
+      def initialize(options = {})
+        if options["no-color"] || !STDOUT.tty?
+          Thor::Base.shell = Thor::Shell::Basic
+        end
+        @shell = Thor::Base.shell.new
         @quiet = false
         @debug = ENV['DEBUG']
+        @trace = ENV['TRACE']
       end
 
       def info(msg, newline = nil)
@@ -47,8 +53,8 @@ module Bundler
         tell_me(msg, :red, newline)
       end
 
-      def quiet=(value)
-        @quiet = value
+      def be_quiet!
+        @quiet = true
       end
 
       def debug?
@@ -64,6 +70,15 @@ module Bundler
         tell_me(msg, nil, newline) if debug?
       end
 
+      def trace(e, newline = nil)
+        msg = ["#{e.class}: #{e.message}", *e.backtrace].join("\n")
+        if debug?
+          tell_me(msg, nil, newline)
+        elsif @trace
+          STDERR.puts "#{msg}#{newline}"
+        end
+      end
+
       private
       # valimism
       def tell_me(msg, color = nil, newline = nil)

data/lib/bundler/vendor/thor.rb

@@ -1,3 +1,4 @@
+require 'set'
 require 'thor/base'
 
 class Thor
@@ -210,7 +211,7 @@ class Thor
 
       define_method(subcommand) do |*args|
         args, opts = Thor::Arguments.split(args)
-        invoke subcommand_class, args, opts
+        invoke subcommand_class, args, opts, :invoked_via_subcommand => true
       end
     end
 
@@ -251,15 +252,83 @@ class Thor
       end
     end
 
+    # Stop parsing of options as soon as an unknown option or a regular
+    # argument is encountered.  All remaining arguments are passed to the task.
+    # This is useful if you have a task that can receive arbitrary additional
+    # options, and where those additional options should not be handled by
+    # Thor.
+    #
+    # ==== Example
+    #
+    # To better understand how this is useful, let's consider a task that calls
+    # an external command.  A user may want to pass arbitrary options and
+    # arguments to that command.  The task itself also accepts some options,
+    # which should be handled by Thor.
+    #
+    #   class_option "verbose",  :type => :boolean
+    #   stop_on_unknown_option! :exec
+    #   check_unknown_options!  :except => :exec
+    #
+    #   desc "exec", "Run a shell command"
+    #   def exec(*args)
+    #     puts "diagnostic output" if options[:verbose]
+    #     Kernel.exec(*args)
+    #   end
+    #
+    # Here +exec+ can be called with +--verbose+ to get diagnostic output,
+    # e.g.:
+    #
+    #   $ thor exec --verbose echo foo
+    #   diagnostic output
+    #   foo
+    #
+    # But if +--verbose+ is given after +echo+, it is passed to +echo+ instead:
+    #
+    #   $ thor exec echo --verbose foo
+    #   --verbose foo
+    #
+    # ==== Parameters
+    # Symbol ...:: A list of tasks that should be affected.
+    def stop_on_unknown_option!(*task_names)
+      @stop_on_unknown_option ||= Set.new
+      @stop_on_unknown_option.merge(task_names)
+    end
+
+    def stop_on_unknown_option?(task) #:nodoc:
+      !!@stop_on_unknown_option && @stop_on_unknown_option.include?(task.name.to_sym)
+    end
+
     protected
 
       # The method responsible for dispatching given the args.
       def dispatch(meth, given_args, given_opts, config) #:nodoc:
-        meth ||= retrieve_task_name(given_args)
-        task = all_tasks[normalize_task_name(meth)]
+        # There is an edge case when dispatching from a subcommand.
+        # A problem occurs invoking the default task. This case occurs
+        # when arguments are passed and a default task is defined, and
+        # the first given_args does not match the default task.
+        # Thor use "help" by default so we skip that case.
+        # Note the call to retrieve_task_name. It's called with
+        # given_args.dup since that method calls args.shift. Then lookup
+        # the task normally. If the first item in given_args is not
+        # a task then use the default task. The given_args will be
+        # intact later since dup was used.
+        if config[:invoked_via_subcommand] && given_args.size >= 1 && default_task != "help" && given_args.first != default_task
+          meth ||= retrieve_task_name(given_args.dup)
+          task = all_tasks[normalize_task_name(meth)]
+          task ||= all_tasks[normalize_task_name(default_task)]
+        else
+          meth ||= retrieve_task_name(given_args)
+          task = all_tasks[normalize_task_name(meth)]
+        end
 
         if task
           args, opts = Thor::Options.split(given_args)
+          if stop_on_unknown_option?(task) && !args.empty?
+            # given_args starts with a non-option, so we treat everything as
+            # ordinary arguments
+            args.concat opts
+            opts.clear
+          end
         else
           args, opts = given_args, nil
           task = Thor::DynamicTask.new(meth)
@@ -321,7 +390,7 @@ class Thor
 
       # receives a (possibly nil) task name and returns a name that is in
       # the tasks hash. In addition to normalizing aliases, this logic
-      # will determine if a shortened command is an unambiguous prefix of
+      # will determine if a shortened command is an unambiguous substring of
       # a task or alias.
       #
       # +normalize_task_name+ also converts names like +animal-prison+
@@ -344,7 +413,7 @@ class Thor
       end
 
       # this is the logic that takes the task name passed in by the user
-      # and determines whether it is an unambiguous prefix of a task or
+      # and determines whether it is an unambiguous substrings of a task or
       # alias name.
       def find_task_possibilities(meth)
         len = meth.to_s.length