bundler 1.0.0.rc.2 → 1.0.0.rc.3

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+## 1.0.0.rc.2 (August 3, 2010)
+
+Features:
+
+  - Deprecate --production flag for --deployment, since the former
+    was causing confusion with the :production group
+  - Add --gemfile option to `bundle check`
+  - Reduce memory usage of `bundle install` by 2-4x
+  - Improve message from `bundle check` under various conditions
+  - Better error when a changed Gemfile conflicts with Gemfile.lock
+
+Bugfixes:
+
+  - Create bin/ directory if it is missing, then install binstubs
+  - Error nicely on the edge case of a pinned gem with no spec
+  - Do not require gems for other platforms
+  - Update git sources along with the gems they contain
+
 ## 1.0.0.rc.2 (July 29, 2010)
 
   - `bundle install path` was causing confusion, so we now print

data/README.md

@@ -135,11 +135,13 @@ If you are still having problems, please report bugs to the github issue tracker
 
 The best possible scenario is a ticket with a fix for the bug and a test for the fix. If that's not possible, instructions to reproduce the issue are vitally important. If you're not sure exactly how to reproduce the issue that you are seeing, create a gist of the following information and include it in your ticket:
 
-  - Whether you have locked or not
   - What version of bundler you are using
   - What version of Ruby you are using
   - Whether you are using RVM, and if so what version
   - Your Gemfile
+  - Your Gemfile.lock
+  - If you are on 0.9, whether you have locked or not
+  - If you are on 1.0, the result of `bundle config`
   - The command you ran to generate exception(s)
   - The exception backtrace(s)
 

data/lib/bundler.rb

@@ -60,6 +60,7 @@ module Bundler
 
   class << self
     attr_writer :ui, :bundle_path
+    attr_accessor :deployment
 
     def configure
       @configured ||= begin
@@ -68,14 +69,6 @@ module Bundler
       end
     end
 
-    def production?
-      @production
-    end
-
-    def production=(value)
-      @production = value
-    end
-
     def ui
       @ui ||= UI.new
     end
@@ -127,8 +120,7 @@ module Bundler
       @definition ||= begin
         configure
         upgrade_lockfile
-        lockfile = root.join("Gemfile.lock")
-        Definition.build(default_gemfile, lockfile, unlock)
+        Definition.build(default_gemfile, default_lockfile, unlock)
       end
     end
 
@@ -184,6 +176,10 @@ module Bundler
       SharedHelpers.default_gemfile
     end
 
+    def default_lockfile
+      SharedHelpers.default_lockfile
+    end
+
     WINDOWS = Config::CONFIG["host_os"] =~ %r!(msdos|mswin|djgpp|mingw)!
     NULL    = WINDOWS ? "NUL" : "/dev/null"
 
@@ -223,7 +219,7 @@ module Bundler
     end
 
     def upgrade_lockfile
-      lockfile = root.join("Gemfile.lock")
+      lockfile = default_lockfile
       if lockfile.exist? && lockfile.read(3) == "---"
         Bundler.ui.warn "Detected Gemfile.lock generated by 0.9, deleting..."
         lockfile.rmtree

data/lib/bundler/cli.rb

@@ -58,8 +58,17 @@ module Bundler
       all gems are found, Bundler prints a success message and exits with a status of 0.
       If not, the first missing gem is listed and Bundler exits status 1.
     D
+    method_option "gemfile", :type => :string, :banner =>
+      "Use the specified gemfile instead of Gemfile"
     def check
-      not_installed = Bundler.definition.missing_specs
+      ENV['BUNDLE_GEMFILE'] = File.expand_path(options[:gemfile]) if options[:gemfile]
+      begin
+        not_installed = Bundler.definition.missing_specs
+      rescue GemNotFound, VersionConflict
+        Bundler.ui.error "Your Gemfile's dependencies could not be satisfied"
+        Bundler.ui.warn  "Install missing gems with `bundle install`"
+        exit 1
+      end
 
       if not_installed.any?
         Bundler.ui.error "The following gems are missing"
@@ -103,20 +112,28 @@ module Bundler
       "Specify a different path than the system default ($BUNDLE_PATH or $GEM_HOME). Bundler will remember this value for future installs on this machine"
     method_option "system", :type => :boolean, :banner =>
       "Install to the system location ($BUNDLE_PATH or $GEM_HOME) even if the bundle was previously installed somewhere else for this application"
-    method_option "production", :type => :boolean, :banner =>
+    method_option "deployment", :type => :boolean, :banner =>
       "Install using defaults tuned for deployment environments"
+    method_option "production", :type => :boolean, :banner =>
+      "Deprecated, please use --deployment instead"
     def install(path = nil)
       opts = options.dup
       opts[:without] ||= []
       opts[:without].map! { |g| g.to_sym }
 
-      if (path || options[:path] || options[:production]) && options[:system]
+      if opts[:production]
+        opts[:deployment] = true
+        Bundler.ui.warn "The --production option is deprecated, and will be removed in " \
+                        "the final release of Bundler 1.0. Please use --deployment instead."
+      end
+
+      if (path || opts[:path] || opts[:deployment]) && opts[:system]
         Bundler.ui.error "You have specified both a path to install your gems to, \n" \
                          "as well as --system. Please choose."
         exit 1
       end
 
-      if path && options[:path]
+      if path && opts[:path]
         Bundler.ui.error "You have specified a path via `bundle install #{path}` as well as\n" \
                          "by `bundle install --path #{options[:path]}`. These options are\n" \
                          "equivalent, so please use one or the other."
@@ -132,26 +149,26 @@ module Bundler
         exit 1
       end
 
-      if opts[:production]
-        Bundler.production = true
+      if opts[:deployment]
+        Bundler.deployment = true
 
-        unless Bundler.root.join("Gemfile.lock").exist?
-          raise ProductionError, "The --production flag requires a Gemfile.lock. Please\n" \
-                                 "make sure you have checked your Gemfile.lock into version\n" \
-                                 "control before deploying."
+        unless Bundler.default_lockfile.exist?
+          raise ProductionError, "The --deployment flag requires a Gemfile.lock. Please make " \
+                                 "sure you have checked your Gemfile.lock into version control " \
+                                 "before deploying."
         end
 
         if Bundler.root.join("vendor/cache").exist?
-          opts["local"] = true
+          opts[:local] = true
         end
       end
 
       # Can't use Bundler.settings for this because settings needs gemfile.dirname
-      ENV['BUNDLE_GEMFILE'] = opts[:gemfile] if opts[:gemfile]
-      Bundler.settings[:path] = nil if options[:system]
-      Bundler.settings[:path] = "vendor/bundle" if options[:production]
+      ENV['BUNDLE_GEMFILE'] = File.expand_path(opts[:gemfile]) if opts[:gemfile]
+      Bundler.settings[:path] = nil if opts[:system]
+      Bundler.settings[:path] = "vendor/bundle" if opts[:deployment]
       Bundler.settings[:path] = path if path
-      Bundler.settings[:path] = options[:path] if options[:path]
+      Bundler.settings[:path] = opts[:path] if opts[:path]
       Bundler.settings[:bin] = opts["binstubs"] if opts[:binstubs]
       Bundler.settings[:disable_shared_gems] = '1' if Bundler.settings[:path]
       Bundler.settings.without = opts[:without]

data/lib/bundler/definition.rb

@@ -65,11 +65,10 @@ module Bundler
       @unlock[:sources] ||= []
 
       current_platform = Gem.platforms.map { |p| generic(p) }.compact.last
+      @new_platform = !@platforms.include?(current_platform)
       @platforms |= [current_platform]
 
-      if Bundler.production?
-        ensure_equivalent_gemfile_and_lockfile
-      end
+      ensure_equivalent_gemfile_and_lockfile if Bundler.deployment
 
       converge_sources
       converge_dependencies
@@ -101,6 +100,10 @@ module Bundler
       end
     end
 
+    def new_platform?
+      @new_platform
+    end
+
     def missing_specs
       missing = []
       resolve.materialize(requested_dependencies, missing)
@@ -128,18 +131,14 @@ module Bundler
     def resolve
       @resolve ||= begin
         converge_locked_specs
-        if @last_resolve.valid_for?(expanded_dependencies)
-          @last_resolve
-        else
-          source_requirements = {}
-          dependencies.each do |dep|
-            next unless dep.source
-            source_requirements[dep.name] = dep.source.specs
-          end
-
-          # Run a resolve against the locally available gems
-          @last_resolve.merge Resolver.resolve(expanded_dependencies, index, source_requirements, @last_resolve)
+        source_requirements = {}
+        dependencies.each do |dep|
+          next unless dep.source
+          source_requirements[dep.name] = dep.source.specs
         end
+
+        # Run a resolve against the locally available gems
+        @last_resolve.merge Resolver.resolve(expanded_dependencies, index, source_requirements, @last_resolve)
       end
     end
 
@@ -305,6 +304,11 @@ module Bundler
         if in_locked_deps?(dep, locked_dep) || satisfies_locked_spec?(dep)
           deps << dep
         elsif dep.source.is_a?(Source::Path) && (!locked_dep || dep.source != locked_dep.source)
+          @last_resolve.each do |s|
+            @unlock[:gems] << s.name if s.source == dep.source
+          end
+
+          dep.source.unlock! if dep.source.respond_to?(:unlock!)
           dep.source.specs.each { |s| @unlock[:gems] << s.name }
         end
       end
@@ -335,6 +339,17 @@ module Bundler
 
       resolve = SpecSet.new(converged)
       resolve = resolve.for(expand_dependencies(deps, true), @unlock[:gems])
+      diff    = @last_resolve.to_a - resolve.to_a
+
+      # Now, we unlock any sources that do not have anymore gems pinned to it
+      @sources.each do |source|
+        next unless source.respond_to?(:unlock!)
+
+        unless resolve.any? { |s| s.source == source }
+          source.unlock! if diff.any? { |s| s.source == source }
+        end
+      end
+
       @last_resolve = resolve
     end
 

data/lib/bundler/dependency.rb

@@ -1,5 +1,6 @@
 require 'rubygems/dependency'
 require 'bundler/shared_helpers'
+require 'bundler/rubygems_ext'
 
 module Bundler
   class Dependency < Gem::Dependency
@@ -16,7 +17,7 @@ module Bundler
       :mri_19  => Gem::Platform::RUBY,
       :jruby   => Gem::Platform::JAVA,
       :mswin   => Gem::Platform::MSWIN
-    }
+    }.freeze
 
     def initialize(name, version, options = {}, &blk)
       super(name, version)

data/lib/bundler/dsl.rb

@@ -1,3 +1,5 @@
+require 'bundler/dependency'
+
 module Bundler
   class Dsl
     def self.evaluate(gemfile)
@@ -6,7 +8,7 @@ module Bundler
       builder.to_definition
     end
 
-    VALID_PLATFORMS = [:ruby, :ruby_18, :ruby_19, :mri, :mri_18, :mri_19, :jruby, :mswin]
+    VALID_PLATFORMS = Bundler::Dependency::PLATFORM_MAP.keys.freeze
 
     def initialize
       @rubygems_source = Source::Rubygems.new

data/lib/bundler/environment.rb

@@ -36,7 +36,7 @@ module Bundler
     end
 
     def lock
-      @definition.lock(root.join('Gemfile.lock'))
+      @definition.lock(Bundler.default_lockfile)
     end
 
     def update(*gems)

data/lib/bundler/installer.rb

@@ -15,10 +15,10 @@ module Bundler
         return
       end
 
-      if Bundler.root.join("Gemfile.lock").exist? && !options["update"]
+      if Bundler.default_lockfile.exist? && !options["update"]
         begin
-          missing_specs = Definition.build(Bundler.default_gemfile, Bundler.root.join("Gemfile.lock"), nil).missing_specs
-          local = true unless missing_specs.any?
+          tmpdef = Definition.build(Bundler.default_gemfile, Bundler.default_lockfile, nil)
+          local = true unless tmpdef.new_platform? || tmpdef.missing_specs.any?
         rescue BundlerError
         end
       end

data/lib/bundler/lockfile_parser.rb

@@ -66,7 +66,8 @@ module Bundler
         dep = Bundler::Dependency.new(name, version)
 
         if pinned && dep.name != 'bundler'
-          dep.source = @specs.find { |s| s.name == dep.name }.source
+          spec = @specs.find { |s| s.name == dep.name }
+          dep.source = spec.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

data/lib/bundler/resolver.rb

@@ -254,7 +254,13 @@ module Bundler
 
         if matching_versions.empty?
           if current.required_by.empty?
-            if current.source
+            if base = @base[current.name] and !base.empty?
+              version = base.first.version
+              message = "You have requested:\n" \
+                    "  #{current.name} #{current.requirement}\n\n" \
+                    "The bundle currently has #{current.name} locked at #{version}.\n" \
+                    "Try running `bundle update #{current.name}`"
+            elsif current.source
               name = current.name
               versions = @source_requirements[name][name].map { |s| s.version }
               message  = "Could not find gem '#{current}' in #{current.source}.\n"

data/lib/bundler/runtime.rb

@@ -51,7 +51,7 @@ module Bundler
       @definition.dependencies.each do |dep|
         # Skip the dependency if it is not in any of the requested
         # groups
-        next unless (dep.groups & groups).any?
+        next unless ((dep.groups & groups).any? && dep.current_platform?)
 
         required_file = nil
 

data/lib/bundler/shared_helpers.rb

@@ -22,6 +22,10 @@ module Bundler
       Pathname.new(gemfile)
     end
 
+    def default_lockfile
+      Pathname.new("#{default_gemfile}.lock")
+    end
+
     def in_bundle?
       find_gemfile
     end

data/lib/bundler/source.rb

@@ -71,8 +71,12 @@ module Bundler
       end
 
       def fetch(spec)
-        action = @spec_fetch_map[spec.full_name]
-        action.call if action
+        spec, uri = @spec_fetch_map[spec.full_name]
+        if spec
+          path = download_gem_from_uri(spec, uri)
+          s = Gem::Format.from_file_by_path(path).spec
+          spec.__swap__(s)
+        end
       end
 
       def install(spec)
@@ -101,7 +105,8 @@ module Bundler
           sudo "cp -R #{Bundler.tmp}/gems/#{spec.full_name} #{Gem.dir}/gems/"
           sudo "cp -R #{Bundler.tmp}/specifications/#{spec.full_name}.gemspec #{Gem.dir}/specifications/"
           spec.executables.each do |exe|
-            Bundler.sudo "cp -R #{Bundler.tmp}/bin/#{exe} #{Gem.dir}/bin/"
+            sudo "mkdir -p #{Gem.dir}/bin"
+            sudo "cp -R #{Bundler.tmp}/bin/#{exe} #{Gem.dir}/bin/"
           end
         end
 
@@ -195,7 +200,6 @@ module Bundler
       def remote_specs
         @remote_specs ||= begin
           idx     = Index.new
-          remotes = self.remotes.map { |uri| uri.to_s }
           old     = Gem.sources
 
           remotes.each do |uri|
@@ -206,12 +210,7 @@ module Bundler
                 next if name == 'bundler'
                 spec = RemoteSpecification.new(name, version, platform, uri)
                 spec.source = self
-                # Temporary hack until this can be figured out better
-                @spec_fetch_map[spec.full_name] = lambda do
-                  path = download_gem_from_uri(spec, uri)
-                  s = Gem::Format.from_file_by_path(path).spec
-                  spec.__swap__(s)
-                end
+                @spec_fetch_map[spec.full_name] = [spec, uri]
                 idx << spec
               end
             end
@@ -332,9 +331,17 @@ module Bundler
               rescue ArgumentError, SyntaxError, Gem::EndOfYAMLException, Gem::Exception
                 begin
                   eval(File.read(file.basename), TOPLEVEL_BINDING, file.expand_path.to_s)
-                rescue LoadError
-                  raise GemspecError, "There was a LoadError while evaluating #{file.basename}.\n" +
-                    "Does it try to require a relative path? That doesn't work in Ruby 1.9."
+                rescue LoadError => e
+                  original_line = e.backtrace.find { |line| line.include?(file.to_s) }
+                  msg  = "There was a LoadError while evaluating #{file.basename}:\n  #{e.message}"
+                  msg << " from\n  #{original_line}" if original_line
+                  msg << "\n"
+
+                  if RUBY_VERSION >= "1.9.0"
+                    msg << "\nDoes it try to require a relative path? That doesn't work in Ruby 1.9."
+                  end
+
+                  raise GemspecError, msg
                 end
               end
             end

data/lib/bundler/vendor/thor.rb

@@ -126,42 +126,6 @@ class Thor
       build_option(name, options, scope)
     end
 
-    # Parses the task and options from the given args, instantiate the class
-    # and invoke the task. This method is used when the arguments must be parsed
-    # from an array. If you are inside Ruby and want to use a Thor class, you
-    # can simply initialize it:
-    #
-    #   script = MyScript.new(args, options, config)
-    #   script.invoke(:task, first_arg, second_arg, third_arg)
-    #
-    def start(original_args=ARGV, config={})
-      @@original_args = original_args
-
-      super do |given_args|
-        meth = given_args.first.to_s
-
-        if !meth.empty? && (map[meth] || meth !~ /^\-/)
-          given_args.shift
-        else
-          meth = nil
-        end
-
-        meth = normalize_task_name(meth)
-        task = all_tasks[meth]
-
-        if task
-          args, opts = Thor::Options.split(given_args)
-          config.merge!(:task_options => task.options)
-        else
-          args, opts = given_args, {}
-        end
-
-        task ||= Thor::DynamicTask.new(meth)
-        trailing = args[Range.new(arguments.size, -1)]
-        new(args, opts, config).invoke(task, trailing || [])
-      end
-    end
-
     # Prints help information for the given task.
     #
     # ==== Parameters
@@ -215,25 +179,81 @@ class Thor
     end
 
     def subcommands
-      @@subcommands ||= {}
+      @subcommands ||= from_superclass(:subcommands, [])
     end
 
     def subcommand(subcommand, subcommand_class)
-      subcommand = subcommand.to_s
-      subcommands[subcommand] = subcommand_class
+      self.subcommands << subcommand.to_s
       subcommand_class.subcommand_help subcommand
-      define_method(subcommand) { |*_| subcommand_class.start(subcommand_args) }
+      define_method(subcommand) { |*args| invoke subcommand_class, args }
+    end
+
+    # Extend check unknown options to accept a hash of conditions.
+    #
+    # === Parameters
+    # options<Hash>: A hash containing :only and/or :except keys
+    def check_unknown_options!(options={})
+      @check_unknown_options ||= Hash.new
+      options.each do |key, value|
+        if value
+          @check_unknown_options[key] = Array(value)
+        else
+          @check_unknown_options.delete(key)
+        end
+      end
+      @check_unknown_options
+    end
+
+    # Overwrite check_unknown_options? to take subcommands and options into account.
+    def check_unknown_options?(config) #:nodoc:
+      options = check_unknown_options
+      return false unless options
+
+      task = config[:current_task]
+      return true unless task
+
+      name = task.name
+
+      if subcommands.include?(name)
+        false
+      elsif options[:except]
+        !options[:except].include?(name.to_sym)
+      elsif options[:only]
+        options[:only].include?(name.to_sym)
+      else
+        true
+      end
     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)]
+
+        if task
+          args, opts = Thor::Options.split(given_args)
+        else
+          args, opts = given_args, nil
+          task = Thor::DynamicTask.new(meth)
+        end
+
+        opts = given_opts || opts || []
+        config.merge!(:current_task => task, :task_options => task.options)
+
+        trailing = args[Range.new(arguments.size, -1)]
+        new(args, opts, config).invoke_task(task, trailing || [])
+      end
+
       # The banner for this class. You can customize it if you are invoking the
       # thor class by another ways which is not the Thor::Runner. It receives
       # the task that is going to be invoked and a boolean which indicates if
       # the namespace should be displayed as arguments.
       #
       def banner(task, namespace = nil, subcommand = false)
-        "#{$0} #{task.formatted_usage(self, $thor_runner, subcommand)}"
+        base = File.basename($0).split(" ").first
+        "#{base} #{task.formatted_usage(self, $thor_runner, subcommand)}"
       end
 
       def baseclass #:nodoc:
@@ -243,10 +263,10 @@ class Thor
       def create_task(meth) #:nodoc:
         if @usage && @desc
           base_class = @hide ? Thor::HiddenTask : Thor::Task
-          tasks[meth.to_s] = base_class.new(meth, @desc, @long_desc, @usage, method_options)
+          tasks[meth] = base_class.new(meth, @desc, @long_desc, @usage, method_options)
           @usage, @desc, @long_desc, @method_options, @hide = nil
           true
-        elsif self.all_tasks[meth.to_s] || meth.to_sym == :method_missing
+        elsif self.all_tasks[meth] || meth == "method_missing"
           true
         else
           puts "[WARNING] Attempted to create task #{meth.inspect} without usage or description. " <<
@@ -261,9 +281,19 @@ class Thor
         @method_options = nil
       end
 
+      # Retrieve the task name from given args.
+      def retrieve_task_name(args) #:nodoc:
+        meth = args.first.to_s unless args.empty?
+
+        if meth && (map[meth] || meth !~ /^\-/)
+          args.shift
+        else
+          nil
+        end
+      end
+
       # 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.to_s.gsub('-','_') # treat foo-bar > foo_bar
@@ -275,11 +305,6 @@ class Thor
           def help(task = nil, subcommand = true); super; end
         RUBY
       end
-
-  end
-
-  def subcommand_args
-    @@original_args[1..-1]
   end
 
   include Thor::Base

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

@@ -53,7 +53,7 @@ class Thor
 
       opts = Thor::Options.new(parse_options, hash_options)
       self.options = opts.parse(array_options)
-      opts.check_unknown! if self.class.check_unknown_options?
+      opts.check_unknown! if self.class.check_unknown_options?(config)
     end
 
     class << self
@@ -114,8 +114,12 @@ class Thor
         @check_unknown_options = true
       end
 
-      def check_unknown_options? #:nodoc:
-        @check_unknown_options || false
+      def check_unknown_options #:nodoc:
+        @check_unknown_options ||= from_superclass(:check_unknown_options, false)
+      end
+
+      def check_unknown_options?(config) #:nodoc:
+        !!check_unknown_options
       end
 
       # Adds an argument to the class and creates an attr_accessor for it.
@@ -364,19 +368,25 @@ class Thor
       #
       def namespace(name=nil)
         case name
-          when nil
-            @namespace ||= Thor::Util.namespace_from_thor_class(self)
-          else
-            @namespace = name.to_s
+        when nil
+          @namespace ||= Thor::Util.namespace_from_thor_class(self)
+        else
+          @namespace = name.to_s
         end
       end
 
-      # Default way to start generators from the command line.
+      # Parses the task and options from the given args, instantiate the class
+      # and invoke the task. This method is used when the arguments must be parsed
+      # from an array. If you are inside Ruby and want to use a Thor class, you
+      # can simply initialize it:
+      #
+      #   script = MyScript.new(args, options, config)
+      #   script.invoke(:task, first_arg, second_arg, third_arg)
       #
       def start(given_args=ARGV, config={})
-        self.debugging = given_args.include?("--debug")
+        self.debugging = given_args.delete("--debug")
         config[:shell] ||= Thor::Base.shell.new
-        yield(given_args.dup)
+        dispatch(nil, given_args.dup, nil, config)
       rescue Thor::Error => e
         debugging ? (raise e) : config[:shell].error(e.message)
         exit(1) if exit_on_failure?
@@ -535,6 +545,12 @@ class Thor
         # class.
         def initialize_added #:nodoc:
         end
+
+        # SIGNATURE: The hook invoked by start.
+        def dispatch(task, given_args, given_opts, config) #:nodoc:
+          raise NotImplementedError
+        end
+
     end
   end
 end

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

@@ -10,10 +10,10 @@ class Thor
       # available only in class methods invocations (i.e. in Thor::Group).
       def prepare_for_invocation(key, name) #:nodoc:
         case name
-          when Symbol, String
-            Thor::Util.find_class_and_task_by_namespace(name.to_s, !key)
-          else
-            name
+        when Symbol, String
+          Thor::Util.find_class_and_task_by_namespace(name.to_s, !key)
+        else
+          name
         end
       end
     end
@@ -94,29 +94,34 @@ class Thor
     #   invoke Rspec::RR, [], :style => :foo
     #
     def invoke(name=nil, *args)
+      if name.nil?
+        warn "[Thor] Calling invoke() without argument is deprecated. Please use invoke_all instead.\n#{caller.join("\n")}"
+        return invoke_all
+      end
+
       args.unshift(nil) if Array === args.first || NilClass === args.first
       task, args, opts, config = args
 
-      object, task    = _prepare_for_invocation(name, task)
-      klass, instance = _initialize_klass_with_initializer(object, args, opts, config)
+      klass, task = _retrieve_class_and_task(name, task)
+      raise "Expected Thor class, got #{klass}" unless klass <= Thor::Base
+
+      args, opts, config = _parse_initialization_options(args, opts, config)
+      klass.send(:dispatch, task, args, opts, config)
+    end
 
-      method_args = []
-      current = @_invocations[klass]
+    # Invoke the given task if the given args.
+    def invoke_task(task, *args) #:nodoc:
+      current = @_invocations[self.class]
 
-      iterator = proc do |_, task|
-        unless current.include?(task.name)
-          current << task.name
-          task.run(instance, method_args)
-        end
+      unless current.include?(task.name)
+        current << task.name
+        task.run(self, *args)
       end
+    end
 
-      if task
-        args ||= []
-        method_args = args[Range.new(klass.arguments.size, -1)] || []
-        iterator.call(nil, task)
-      else
-        klass.all_tasks.map(&iterator)
-      end
+    # Invoke all tasks for the current instance.
+    def invoke_all #:nodoc:
+      self.class.all_tasks.map { |_, task| invoke_task(task) }
     end
 
     # Invokes using shell padding.
@@ -131,50 +136,33 @@ class Thor
         { :invocations => @_invocations }
       end
 
-      # This method can receive several different types of arguments and it's then
-      # responsible to normalize them by returning the object where the task should
-      # be invoked and a Thor::Task object.
-      def _prepare_for_invocation(name, sent_task=nil) #:nodoc:
-        if name.is_a?(Thor::Task)
-          task = name
-        elsif task = self.class.all_tasks[name.to_s]
-          object = self
+      # This method simply retrieves the class and task to be invoked.
+      # If the name is nil or the given name is a task in the current class,
+      # use the given name and return self as class. Otherwise, call
+      # prepare_for_invocation in the current class.
+      def _retrieve_class_and_task(name, sent_task=nil) #:nodoc:
+        case
+        when name.nil?
+          [self.class, nil]
+        when self.class.all_tasks[name.to_s]
+          [self.class, name.to_s]
         else
-          object, task = self.class.prepare_for_invocation(nil, name)
-          task ||= sent_task
+          klass, task = self.class.prepare_for_invocation(nil, name)
+          [klass, task || sent_task]
         end
-
-        # If the object was not set, use self and use the name as task.
-        object, task = self, name unless object
-        return object, _validate_task(object, task)
-      end
-
-      # Check if the object given is a Thor class object and get a task object
-      # for it.
-      def _validate_task(object, task) #:nodoc:
-        klass = object.is_a?(Class) ? object : object.class
-        raise "Expected Thor class, got #{klass}" unless klass <= Thor::Base
-
-        task ||= klass.default_task if klass.respond_to?(:default_task)
-        task = klass.all_tasks[task.to_s] || Thor::DynamicTask.new(task) if task && !task.is_a?(Thor::Task)
-        task
       end
 
       # Initialize klass using values stored in the @_initializer.
-      def _initialize_klass_with_initializer(object, args, opts, config) #:nodoc:
-        if object.is_a?(Class)
-          klass = object
+      def _parse_initialization_options(args, opts, config) #:nodoc:
+        stored_args, stored_opts, stored_config = @_initializer
 
-          stored_args, stored_opts, stored_config = @_initializer
-          args ||= stored_args.dup
-          opts ||= stored_opts.dup
+        args ||= stored_args.dup
+        opts ||= stored_opts.dup
 
-          config ||= {}
-          config = stored_config.merge(_shared_configuration).merge!(config)
-          [ klass, klass.new(args, opts, config) ]
-        else
-          [ object.class, object ]
-        end
+        config ||= {}
+        config = stored_config.merge(_shared_configuration).merge!(config)
+
+        [ args, opts, config ]
       end
   end
 end

data/lib/bundler/vendor/thor/parser/options.rb

@@ -151,6 +151,8 @@ class Thor
           elsif option.string? && !option.required?
             # Return the default if there is one, else the human name
             return option.lazy_default || option.default || option.human_name
+          elsif option.lazy_default
+            return option.lazy_default
           else
             raise MalformattedArgumentError, "No value provided for option '#{switch}'"
           end

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

@@ -27,7 +27,7 @@ class Thor
 
     autoload :Basic, 'thor/shell/basic'
     autoload :Color, 'thor/shell/color'
-    autoload :HTML,  'thor/shell/HTML'
+    autoload :HTML,  'thor/shell/html'
 
     # Add shell to initialize config values.
     #

data/lib/bundler/vendor/thor/shell/basic.rb

@@ -35,8 +35,8 @@ class Thor
       # say("I know you knew that.")
       #
       def say(message="", color=nil, force_new_line=(message.to_s !~ /( |\t)$/))
-        message  = message.to_s
-        message  = set_color(message, color) if color
+        message = message.to_s
+        message = set_color(message, color) if color
 
         spaces = "  " * padding
 
@@ -60,7 +60,9 @@ class Thor
 
         status = status.to_s.rjust(12)
         status = set_color status, color, true if color
-        say "#{status}#{spaces}#{message}", nil, true
+
+        $stdout.puts "#{status}#{spaces}#{message}"
+        $stdout.flush
       end
 
       # Make a question the to user and returns true if the user replies "y" or

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

@@ -1,3 +1,3 @@
 class Thor
-  VERSION = "0.13.8".freeze
+  VERSION = "0.14.0".freeze
 end

data/lib/bundler/version.rb

@@ -2,5 +2,5 @@ module Bundler
   # We're doing this because we might write tests that deal
   # with other versions of bundler and we are unsure how to
   # handle this better.
-  VERSION = "1.0.0.rc.2" unless defined?(::Bundler::VERSION)
+  VERSION = "1.0.0.rc.3" unless defined?(::Bundler::VERSION)
 end

metadata

@@ -7,8 +7,8 @@ version: !ruby/object:Gem::Version
   - 0
   - 0
   - rc
-  - 2
-  version: 1.0.0.rc.2
+  - 3
+  version: 1.0.0.rc.3
 platform: ruby
 authors: 
 - Carl Lerche
@@ -18,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-29 00:00:00 -07:00
+date: 2010-08-03 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency