bundler 0.9.6 → 0.9.7

data/README.markdown

@@ -54,6 +54,12 @@ Bundler::Dsl.
     #
     gem "rack", "1.0.0"
 
+    # Add a git repository as a source, and add a dependency on a gem
+    # from it
+    git "git://github.com/indirect/rails3-generators.git"
+    gem "rails3-generators"
+    
+
 ### Groups
 
 Applications may have dependencies that are specific to certain environments,

data/lib/bundler.rb

@@ -4,7 +4,7 @@ require 'yaml'
 require 'bundler/rubygems-ext'
 
 module Bundler
-  VERSION = "0.9.6"
+  VERSION = "0.9.7"
 
   autoload :Definition,          'bundler/definition'
   autoload :Dependency,          'bundler/dependency'

data/lib/bundler/cli.rb

@@ -126,6 +126,12 @@ module Bundler
       Kernel.exec *ARGV
     end
 
+    desc "version", "Prints the bundler's version information"
+    def version
+      Bundler.ui.info "Bundler version #{Bundler::VERSION}"
+    end
+    map %w(-v --version) => :version
+
   private
 
     def locked?

data/lib/bundler/installer.rb

@@ -16,15 +16,15 @@ module Bundler
       FileUtils.mkdir_p(Bundler.bundle_path)
 
       specs.sort_by { |s| s.name }.each do |spec|
-        # unless spec.source.is_a?(Source::SystemGems)
-          Bundler.ui.info "Installing #{spec.name} (#{spec.version}) from #{spec.source} "
-        # end
-
         if (spec.groups & options[:without]).any?
           Bundler.ui.debug "  * Not in requested group; skipping."
           next
         end
 
+        # unless spec.source.is_a?(Source::SystemGems)
+          Bundler.ui.info "Installing #{spec.name} (#{spec.version}) from #{spec.source} "
+        # end
+
         spec.source.install(spec)
 
         Bundler.ui.info ""

data/lib/bundler/resolver.rb

@@ -1,6 +1,6 @@
 require 'set'
 # This is the latest iteration of the gem dependency resolving algorithm. As of now,
-# it can resolve (as a success of failure) any set of gem dependencies we throw at it
+# it can resolve (as a success or failure) any set of gem dependencies we throw at it
 # in a reasonable amount of time. The most iterations I've seen it take is about 150.
 # The actual implementation of the algorithm is not as good as it could be yet, but that
 # can come later.

data/lib/bundler/runtime.rb

@@ -172,13 +172,10 @@ module Bundler
     end
 
     def specs_for_lock_file
-      specs.map do |spec|
-        dep  = @definition.dependencies.find { |d| d.name == spec.name }
+      specs.map do |s|
         hash = {}
-        hash[:name]       = spec.name
-        hash[:version]    = spec.version.to_s
-        hash[:groups]     = spec.groups
-        hash[:load_paths] = spec.load_paths
+        hash[:loaded_from] = s.loaded_from.to_s
+        hash[:load_paths]  = s.load_paths
         hash
       end
     end
@@ -213,70 +210,5 @@ module Bundler
         groups.inject({}) { |h,g| h[g] = autorequires[g]; h }
       end
     end
-
-    def cripple_rubygems(specs)
-      reverse_rubygems_kernel_mixin
-
-      executables = specs.map { |s| s.executables }.flatten
-
-      # TODO: This is duplicated a bit too much in environment.erb.
-      #       Let's figure out how to improve that.
-      ::Kernel.send(:define_method, :gem) do |dep, *reqs|
-        if executables.include? File.basename(caller.first.split(':').first)
-          return
-        end
-        opts = reqs.last.is_a?(Hash) ? reqs.pop : {}
-
-        unless dep.respond_to?(:name) && dep.respond_to?(:version_requirements)
-          dep = Gem::Dependency.new(dep, reqs)
-        end
-
-        spec = specs.find  { |s| s.name == dep.name }
-
-        if spec.nil?
-          e = Gem::LoadError.new "#{dep} is not part of the bundle. Add it to Gemfile."
-          e.name = dep.name
-          e.version_requirement = dep.version_requirements
-          raise e
-        elsif dep !~ spec
-          e = Gem::LoadError.new "can't activate #{dep}, already activated #{spec.full_name}. " \
-                                 "Make sure all dependencies are added to Gemfile."
-          e.name = dep.name
-          e.version_requirement = dep.version_requirements
-          raise e
-        end
-
-        true
-      end
-
-      # === Following hacks are to improve on the generated bin wrappers ===
-
-      # Yeah, talk about a hack
-      source_index_class = (class << Gem::SourceIndex ; self ; end)
-      source_index_class.send(:define_method, :from_gems_in) do |*args|
-        source_index = Gem::SourceIndex.new
-        source_index.spec_dirs = *args
-        source_index.add_specs(*specs)
-        source_index
-      end
-
-      # OMG more hacks
-      gem_class = (class << Gem ; self ; end)
-      gem_class.send(:define_method, :bin_path) do |name, *args|
-        exec_name, *reqs = args
-
-        spec = nil
-
-        if exec_name
-          spec = specs.find { |s| s.executables.include?(exec_name) }
-          spec or raise Gem::Exception, "can't find executable #{exec_name}"
-        else
-          spec = specs.find  { |s| s.name == name }
-          exec_name = spec.default_executable or raise Gem::Exception, "no default executable for #{spec.full_name}"
-        end
-
-        File.join(spec.full_gem_path, spec.bindir, exec_name)
-      end
-    end
   end
 end

data/lib/bundler/shared_helpers.rb

@@ -1,18 +1,6 @@
 module Bundler
   module SharedHelpers
 
-    def reverse_rubygems_kernel_mixin
-      # Disable rubygems' gem activation system
-      ::Kernel.class_eval do
-        if private_method_defined?(:gem_original_require)
-          alias rubygems_require require
-          alias require gem_original_require
-        end
-
-        undef gem
-      end
-    end
-
     def default_gemfile
       gemfile = find_gemfile
       gemfile or raise GemfileNotFound, "The default Gemfile was not found"
@@ -51,6 +39,87 @@ module Bundler
       end
     end
 
+    def reverse_rubygems_kernel_mixin
+      # Disable rubygems' gem activation system
+      ::Kernel.class_eval do
+        if private_method_defined?(:gem_original_require)
+          alias rubygems_require require
+          alias require gem_original_require
+        end
+
+        undef gem
+      end
+    end
+
+    def cripple_rubygems(specs)
+      reverse_rubygems_kernel_mixin
+
+      executables = specs.map { |s| s.executables }.flatten
+
+     :: Kernel.class_eval do
+        private
+        def gem(*) ; end
+      end
+      Gem.source_index # ensure RubyGems is fully loaded
+
+      ::Kernel.send(:define_method, :gem) do |dep, *reqs|
+        if executables.include? File.basename(caller.first.split(':').first)
+          return
+        end
+        opts = reqs.last.is_a?(Hash) ? reqs.pop : {}
+
+        unless dep.respond_to?(:name) && dep.respond_to?(:version_requirements)
+          dep = Gem::Dependency.new(dep, reqs)
+        end
+
+        spec = specs.find  { |s| s.name == dep.name }
+
+        if spec.nil?
+          e = Gem::LoadError.new "#{dep.name} is not part of the bundle. Add it to Gemfile."
+          e.name = dep.name
+          e.version_requirement = dep.version_requirements
+          raise e
+        elsif dep !~ spec
+          e = Gem::LoadError.new "can't activate #{dep}, already activated #{spec.full_name}. " \
+                                 "Make sure all dependencies are added to Gemfile."
+          e.name = dep.name
+          e.version_requirement = dep.version_requirements
+          raise e
+        end
+
+        true
+      end
+
+      # === Following hacks are to improve on the generated bin wrappers ===
+
+      # Yeah, talk about a hack
+      source_index_class = (class << Gem::SourceIndex ; self ; end)
+      source_index_class.send(:define_method, :from_gems_in) do |*args|
+        source_index = Gem::SourceIndex.new
+        source_index.spec_dirs = *args
+        source_index.add_specs(*specs)
+        source_index
+      end
+
+      # OMG more hacks
+      gem_class = (class << Gem ; self ; end)
+      gem_class.send(:define_method, :bin_path) do |name, *args|
+        exec_name, *reqs = args
+
+        spec = nil
+
+        if exec_name
+          spec = specs.find { |s| s.executables.include?(exec_name) }
+          spec or raise Gem::Exception, "can't find executable #{exec_name}"
+        else
+          spec = specs.find  { |s| s.name == name }
+          exec_name = spec.default_executable or raise Gem::Exception, "no default executable for #{spec.full_name}"
+        end
+
+        File.join(spec.full_gem_path, spec.bindir, exec_name)
+      end
+    end
+
     extend self
   end
 end

data/lib/bundler/templates/environment.erb

@@ -8,20 +8,20 @@ require "rubygems"
 module Bundler
   LOCKED_BY    = '<%= Bundler::VERSION %>'
   FINGERPRINT  = <%= gemfile_fingerprint.inspect %>
+  AUTOREQUIRES = <%= autorequires_for_groups.inspect %>
   SPECS        = [
     <% specs_for_lock_file.each do |spec| -%>
     <%= spec.inspect %>,
     <% end -%>
-  ]
-  AUTOREQUIRES = <%= autorequires_for_groups.inspect %>
+  ].map do |hash|
+    spec = eval(File.read(hash[:loaded_from]), binding, hash[:loaded_from])
+    spec.loaded_from = hash[:loaded_from]
+    spec.require_paths = hash[:load_paths]
+    spec
+  end
 
   extend SharedHelpers
 
-  def self.cripple_ruby_gems
-    reverse_rubygems_kernel_mixin
-    patch_rubygems
-  end
-
   def self.match_fingerprint
     print = Digest::SHA1.hexdigest(File.read(File.expand_path('../../Gemfile', __FILE__)))
     unless print == FINGERPRINT
@@ -32,8 +32,10 @@ module Bundler
   def self.setup(*groups)
     match_fingerprint
     clean_load_path
+    cripple_rubygems(SPECS)
     SPECS.each do |spec|
-      spec[:load_paths].each { |path| $LOAD_PATH.unshift path }
+      Gem.loaded_specs[spec.name] = spec
+      $LOAD_PATH.unshift(*spec.require_paths)
     end
   end
 
@@ -53,30 +55,6 @@ module Bundler
     end
   end
 
-  def self.patch_rubygems
-    Kernel.class_eval do
-      private
-      def gem(*) ; end
-    end
-    Gem.source_index # ensure RubyGems is fully loaded
-    specs = SPECS
-
-    ::Kernel.send(:define_method, :gem) do |dep, *reqs|
-      opts = reqs.last.is_a?(Hash) ? reqs.pop : {}
-
-      dep  = dep.name if dep.respond_to?(:name)
-      unless specs.any?  { |s| s[:name] == dep }
-        e = Gem::LoadError.new "#{dep} is not part of the bundle. Add it to Gemfile."
-        e.name = dep
-        e.version_requirement = reqs
-        raise e
-      end
-
-      true
-    end
-  end
-
   # Setup bundle when it's required.
-  cripple_ruby_gems
   setup
 end

data/lib/bundler/vendor/thor.rb

@@ -120,8 +120,8 @@ class Thor
     #   script = MyScript.new(args, options, config)
     #   script.invoke(:task, first_arg, second_arg, third_arg)
     #
-    def start(given_args=ARGV, config={})
-      super do
+    def start(original_args=ARGV, config={})
+      super do |given_args|
         meth = normalize_task_name(given_args.shift)
         task = all_tasks[meth]
 
@@ -145,8 +145,9 @@ class Thor
     # task_name<String>
     #
     def task_help(shell, task_name)
-      task = all_tasks[task_name]
-      raise UndefinedTaskError, "task '#{task_name}' could not be found in namespace '#{self.namespace}'" unless task
+      meth = normalize_task_name(task_name)
+      task = all_tasks[meth]
+      handle_no_task_error(meth) unless task
 
       shell.say "Usage:"
       shell.say "  #{banner(task)}"
@@ -183,6 +184,10 @@ class Thor
       end
     end
 
+    def handle_argument_error(task, error) #:nodoc:
+      raise InvocationError, "#{task.name.inspect} was called incorrectly. Call as #{task.formatted_usage(self, banner_base == "thor").inspect}."
+    end
+
     protected
 
       # The banner for this class. You can customize it if you are invoking the
@@ -191,8 +196,7 @@ class Thor
       # the namespace should be displayed as arguments.
       #
       def banner(task)
-        base = $thor_runner ? "thor" : File.basename($0.split(" ").first)
-        "#{base} #{task.formatted_usage(self, base == "thor")}"
+        "#{banner_base} #{task.formatted_usage(self, banner_base == "thor")}"
       end
 
       def baseclass #:nodoc:

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

@@ -38,9 +38,8 @@ class Thor
     # config<Hash>:: Configuration for this Thor class.
     #
     def initialize(args=[], options={}, config={})
-      Thor::Arguments.parse(self.class.arguments, args).each do |key, value|
-        send("#{key}=", value)
-      end
+      args = Thor::Arguments.parse(self.class.arguments, args)
+      args.each { |key, value| send("#{key}=", value) }
 
       parse_options = self.class.class_options
 
@@ -52,9 +51,9 @@ class Thor
         array_options, hash_options = [], options
       end
 
-      options = Thor::Options.parse(parse_options, array_options)
-      self.options = Thor::CoreExt::HashWithIndifferentAccess.new(options).merge!(hash_options)
-      self.options.freeze
+      opts = Thor::Options.new(parse_options, hash_options)
+      self.options = opts.parse(array_options)
+      opts.check_unknown! if self.class.check_unknown_options?
     end
 
     class << self
@@ -109,6 +108,16 @@ class Thor
         no_tasks { super }
       end
 
+      # If you want to raise an error for unknown options, call check_unknown_options!
+      # This is disabled by default to allow dynamic invocations.
+      def check_unknown_options!
+        @check_unknown_options = true
+      end
+
+      def check_unknown_options? #:nodoc:
+        @check_unknown_options || false
+      end
+
       # Adds an argument to the class and creates an attr_accessor for it.
       #
       # Arguments are different from options in several aspects. The first one
@@ -355,7 +364,7 @@ class Thor
       def namespace(name=nil)
         case name
           when nil
-            @namespace ||= Thor::Util.namespace_from_thor_class(self, false)
+            @namespace ||= Thor::Util.namespace_from_thor_class(self)
           else
             @namespace = name.to_s
         end
@@ -366,14 +375,18 @@ class Thor
       def start(given_args=ARGV, config={})
         self.debugging = given_args.include?("--debug")
         config[:shell] ||= Thor::Base.shell.new
-        yield
+        yield(given_args.dup)
       rescue Thor::Error => e
-        if debugging
-          raise e
+        debugging ? (raise e) : config[:shell].error(e.message)
+        exit(1) if exit_on_failure?
+      end
+
+      def handle_no_task_error(task) #:nodoc:
+        if self.banner_base == "thor"
+          raise UndefinedTaskError, "Could not find task #{task.inspect} in #{namespace.inspect} namespace."
         else
-          config[:shell].error e.message
+          raise UndefinedTaskError, "Could not find task #{task.inspect}."
         end
-        exit(1) if exit_on_failure?
       end
 
       protected
@@ -419,7 +432,6 @@ class Thor
         end
 
         # Raises an error if the word given is a Thor reserved word.
-        #
         def is_thor_reserved_word?(word, type) #:nodoc:
           return false unless THOR_RESERVED_WORDS.include?(word.to_s)
           raise "#{word.inspect} is a Thor reserved word and cannot be defined as #{type}"
@@ -430,7 +442,6 @@ class Thor
         # ==== Parameters
         # name<Symbol>:: The name of the argument.
         # options<Hash>:: Described in both class_option and method_option.
-        #
         def build_option(name, options, scope) #:nodoc:
           scope[name] = Thor::Option.new(name, options[:desc], options[:required],
                                                options[:type], options[:default], options[:banner],
@@ -444,7 +455,6 @@ class Thor
         #
         # ==== Parameters
         # Hash[Symbol => Object]
-        #
         def build_options(options, scope) #:nodoc:
           options.each do |key, value|
             scope[key] = Thor::Option.parse(key, value)
@@ -454,7 +464,6 @@ class Thor
         # Finds a task with the given name. If the task belongs to the current
         # class, just return it, otherwise dup it and add the fresh copy to the
         # current task hash.
-        #
         def find_and_refresh_task(name) #:nodoc:
           task = if task = tasks[name.to_s]
             task
@@ -467,14 +476,12 @@ class Thor
 
         # Everytime someone inherits from a Thor class, register the klass
         # and file into baseclass.
-        #
         def inherited(klass)
           Thor::Base.register_klass_file(klass)
         end
 
         # Fire this callback whenever a method is added. Added methods are
         # tracked as tasks by invoking the create_task method.
-        #
         def method_added(meth)
           meth = meth.to_s
 
@@ -495,7 +502,6 @@ class Thor
 
         # Retrieves a value from superclass. If it reaches the baseclass,
         # returns default.
-        #
         def from_superclass(method, default=nil)
           if self == baseclass || !superclass.respond_to?(method, true)
             default
@@ -506,11 +512,15 @@ class Thor
         end
 
         # A flag that makes the process exit with status 1 if any error happens.
-        #
         def exit_on_failure?
           false
         end
 
+        # Returns the base for banner.
+        def banner_base
+          @banner_base ||= $thor_runner ? "thor" : File.basename($0.split(" ").first)
+        end
+
         # SIGNATURE: Sets the baseclass. This is where the superclass lookup
         # finishes.
         def baseclass #:nodoc:

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

@@ -19,6 +19,9 @@ class Thor
   class InvocationError < Error
   end
 
+  class UnknownArgumentError < Error
+  end
+
   class RequiredArgumentMissingError < InvocationError
   end
 

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

@@ -5,21 +5,20 @@ class Thor
     end
 
     module ClassMethods
-      # Prepare for class methods invocations. This method must return a klass to
-      # have the invoked class options showed in help messages in generators.
-      #
+      # This method is responsible for receiving a name and find the proper
+      # class and task for it. The key is an optional parameter which is
+      # 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.namespace_to_thor_class_and_task(name.to_s, false)
+            Thor::Util.find_class_and_task_by_namespace(name.to_s)
           else
             name
         end
       end
     end
 
-    # Make initializer aware of invocations and the initializer proc.
-    #
+    # Make initializer aware of invocations and the initialization args.
     def initialize(args=[], options={}, config={}, &block) #:nodoc:
       @_invocations = config[:invocations] || Hash.new { |h,k| h[k] = [] }
       @_initializer = [ args, options, config ]
@@ -34,6 +33,8 @@ class Thor
     # the task to be invoked, if none is given, the same values used to
     # initialize the invoker are used to initialize the invoked.
     #
+    # When no name is given, it will invoke the default task of the current class.
+    #
     # ==== Examples
     #
     #   class A < Thor
@@ -92,9 +93,9 @@ class Thor
     #
     #   invoke Rspec::RR, [], :style => :foo
     #
-    def invoke(name=nil, task=nil, args=nil, opts=nil, config=nil)
-      task, args, opts, config = nil, task, args, opts if task.nil? || task.is_a?(Array)
-      args, opts, config = nil, args, opts if args.is_a?(Hash)
+    def invoke(name=nil, *args)
+      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)
@@ -121,15 +122,13 @@ class Thor
     protected
 
       # Configuration values that are shared between invocations.
-      #
       def _shared_configuration #:nodoc:
         { :invocations => @_invocations }
       end
 
-      # Prepare for invocation in the instance level. In this case, we have to
-      # take into account that a just a task name from the current class was
-      # given or even a Thor::Task object.
-      #
+      # 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
@@ -147,18 +146,16 @@ class Thor
 
       # 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 <= Thor
+        task ||= klass.default_task if klass.respond_to?(:default_task)
         task = klass.all_tasks[task.to_s] || Thor::Task::Dynamic.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

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

@@ -16,8 +16,9 @@ class Thor
       return arguments, args[Range.new(arguments.size, -1)]
     end
 
-    def self.parse(base, args)
-      new(base).parse(args)
+    def self.parse(*args)
+      to_parse = args.pop
+      new(*args).parse(to_parse)
     end
 
     # Takes an array of Thor::Argument objects.
@@ -116,7 +117,7 @@ class Thor
         return shift if peek.is_a?(Numeric)
 
         unless peek =~ NUMERIC && $& == peek
-          raise MalformattedArgumentError, "expected numeric value for '#{name}'; got #{peek.inspect}"
+          raise MalformattedArgumentError, "Expected numeric value for '#{name}'; got #{peek.inspect}"
         end
 
         $&.index('.') ? shift.to_f : shift.to_i
@@ -137,7 +138,7 @@ class Thor
           end.join("', '")
 
           class_name = self.class.name.split('::').last.downcase
-          raise RequiredArgumentMissingError, "no value provided for required #{class_name} '#{names}'"
+          raise RequiredArgumentMissingError, "No value provided for required #{class_name} '#{names}'"
         end
       end
 

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

@@ -55,10 +55,6 @@ class Thor
             value
           elsif required = (value == :required)
             :string
-          elsif value == :optional
-            # TODO Remove this warning in the future.
-            warn "Optional type is deprecated. Choose :boolean or :string instead. Assumed to be :boolean."
-            :boolean
           end
         when TrueClass, FalseClass
           :boolean

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

@@ -10,7 +10,6 @@ class Thor
     SHORT_NUM   = /^(-[a-z])#{NUMERIC}$/i
 
     # Receives a hash and makes it switches.
-    #
     def self.to_switches(options)
       options.map do |key, value|
         case value
@@ -28,12 +27,18 @@ class Thor
       end.join(" ")
     end
 
-    # Takes a hash of Thor::Option objects.
-    #
-    def initialize(options={})
-      options = options.values
+    # Takes a hash of Thor::Option and a hash with defaults.
+    def initialize(hash_options={}, defaults={})
+      options = hash_options.values
       super(options)
-      @shorts, @switches = {}, {}
+
+      # Add defaults
+      defaults.each do |key, value|
+        @assigns[key.to_s] = value
+        @non_assigned_required.delete(hash_options[key])
+      end
+
+      @shorts, @switches, @unknown = {}, {}, []
 
       options.each do |option|
         @switches[option.switch_name] = option
@@ -61,16 +66,24 @@ class Thor
           end
 
           switch = normalize_switch(switch)
-          next unless option = switch_option(switch)
-
+          option = switch_option(switch)
           @assigns[option.human_name] = parse_peek(switch, option)
+        elsif peek =~ /^\-/
+          @unknown << shift
         else
           shift
         end
       end
 
       check_requirement!
-      @assigns
+
+      assigns = Thor::CoreExt::HashWithIndifferentAccess.new(@assigns)
+      assigns.freeze
+      assigns
+    end
+
+    def check_unknown!
+      raise UnknownArgumentError, "Unknown switches '#{@unknown.join(', ')}'" unless @unknown.empty?
     end
 
     protected
@@ -130,7 +143,7 @@ class Thor
           elsif option.string? && !option.required?
             return option.human_name # Return the option name
           else
-            raise MalformattedArgumentError, "no value provided for option '#{switch}'"
+            raise MalformattedArgumentError, "No value provided for option '#{switch}'"
           end
         end
 

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

@@ -9,10 +9,11 @@ class Thor
       end
 
       def run(instance, args=[])
-        unless (instance.methods & [name.to_s, name.to_sym]).empty?
-          raise Error, "could not find Thor class or task '#{name}'"
+        if (instance.methods & [name.to_s, name.to_sym]).empty?
+          super
+        else
+          instance.class.handle_no_task_error(name)
         end
-        super
       end
     end
 
@@ -28,14 +29,14 @@ class Thor
     # By default, a task invokes a method in the thor class. You can change this
     # implementation to create custom tasks.
     def run(instance, args=[])
-      raise UndefinedTaskError, "the '#{name}' task of #{instance.class} is private" unless public_method?(instance)
-      instance.send(name, *args)
+      public_method?(instance) ?
+        instance.send(name, *args) : instance.class.handle_no_task_error(name)
     rescue ArgumentError => e
-      raise e if instance.class.respond_to?(:debugging) && instance.class.debugging
-      parse_argument_error(instance, e, caller)
+      handle_argument_error?(instance, e, caller) ?
+        instance.class.handle_argument_error(self, e) : (raise e)
     rescue NoMethodError => e
-      raise e if instance.class.respond_to?(:debugging) && instance.class.debugging
-      parse_no_method_error(instance, e)
+      handle_no_method_error?(instance, e, caller) ?
+        instance.class.handle_no_task_error(name) : (raise e)
     end
 
     # Returns the formatted usage by injecting given required arguments 
@@ -68,6 +69,10 @@ class Thor
 
     protected
 
+      def not_debugging?(instance)
+        !(instance.class.respond_to?(:debugging) && instance.class.debugging)
+      end
+
       def required_options
         @required_options ||= options.map{ |_, o| o.usage if o.required? }.compact.sort.join(" ")
       end
@@ -83,28 +88,14 @@ class Thor
         saned -= caller
       end
 
-      def parse_argument_error(instance, e, caller) #:nodoc:
-        backtrace = sans_backtrace(e.backtrace, caller)
-
-        if backtrace.empty? && e.message =~ /wrong number of arguments/
-          if instance.is_a?(Thor::Group)
-            raise e, "'#{name}' was called incorrectly. Are you sure it has arity equals to 0?"
-          else
-            raise InvocationError, "'#{name}' was called incorrectly. Call as " <<
-                                   "'#{formatted_usage(instance.class)}'"
-          end
-        else
-          raise e
-        end
+      def handle_argument_error?(instance, error, caller)
+        not_debugging?(instance) && error.message =~ /wrong number of arguments/ &&
+          sans_backtrace(error.backtrace, caller).empty?
       end
 
-      def parse_no_method_error(instance, e) #:nodoc:
-        if e.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
-          raise UndefinedTaskError, "The #{instance.class.namespace} namespace " <<
-                                    "doesn't have a '#{name}' task"
-        else
-          raise e
-        end
+      def handle_no_method_error?(instance, error, caller)
+        not_debugging?(instance) &&
+          error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
       end
 
   end

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

@@ -23,10 +23,7 @@ class Thor
     #
     def self.find_by_namespace(namespace)
       namespace = "default#{namespace}" if namespace.empty? || namespace =~ /^:/
-
-      Thor::Base.subclasses.find do |klass|
-        klass.namespace == namespace
-      end
+      Thor::Base.subclasses.find { |klass| klass.namespace == namespace }
     end
 
     # Receives a constant and converts it to a Thor namespace. Since Thor tasks
@@ -43,10 +40,9 @@ class Thor
     # ==== Returns
     # String:: If we receive Foo::Bar::Baz it returns "foo:bar:baz"
     #
-    def self.namespace_from_thor_class(constant, remove_default=true)
+    def self.namespace_from_thor_class(constant)
       constant = constant.to_s.gsub(/^Thor::Sandbox::/, "")
       constant = snake_case(constant).squeeze(":")
-      constant.gsub!(/^default/, '') if remove_default
       constant
     end
 
@@ -132,13 +128,7 @@ class Thor
     # ==== Parameters
     # namespace<String>
     #
-    # ==== Errors
-    # Thor::Error:: raised if the namespace cannot be found.
-    #
-    # Thor::Error:: raised if the namespace evals to a class which does not
-    #               inherit from Thor or Thor::Group.
-    #
-    def self.namespace_to_thor_class_and_task(namespace, raise_if_nil=true)
+    def self.find_class_and_task_by_namespace(namespace)
       if namespace.include?(?:)
         pieces = namespace.split(":")
         task   = pieces.pop
@@ -149,7 +139,14 @@ class Thor
         klass, task = Thor::Util.find_by_namespace(namespace), nil
       end
 
-      raise Error, "could not find Thor class or task '#{namespace}'" if raise_if_nil && klass.nil?
+      return klass, task
+    end
+
+    # The same as namespace_to_thor_class_and_task!, but raises an error if a klass
+    # could not be found.
+    def self.find_class_and_task_by_namespace!(namespace)
+      klass, task = find_class_and_task_by_namespace(namespace)
+      raise Error, "Could not find namespace or task #{namespace.inspect}." unless klass
       return klass, task
     end
 

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

@@ -1,3 +1,3 @@
 class Thor
-  VERSION = "0.12.4".freeze
+  VERSION = "0.13.3".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bundler
 version: !ruby/object:Gem::Version 
-  version: 0.9.6
+  version: 0.9.7
 platform: ruby
 authors: 
 - Carl Lerche
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-16 00:00:00 -08:00
+date: 2010-02-17 00:00:00 -08:00
 default_executable: 
 dependencies: []