bundler 1.3.6 → 1.4.0.pre.1

data/lib/bundler/vendor/thor/{task.rb → command.rb}

@@ -1,5 +1,5 @@
 class Thor
-  class Task < Struct.new(:name, :description, :long_description, :usage, :options)
+  class Command < Struct.new(:name, :description, :long_description, :usage, :options)
     FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/
 
     def initialize(name, description, long_description, usage, options=nil)
@@ -15,27 +15,27 @@ class Thor
       false
     end
 
-    # By default, a task invokes a method in the thor class. You can change this
-    # implementation to create custom tasks.
+    # By default, a command invokes a method in the thor class. You can change this
+    # implementation to create custom commands.
     def run(instance, args=[])
       arity = nil
 
       if private_method?(instance)
-        instance.class.handle_no_task_error(name)
+        instance.class.handle_no_command_error(name)
       elsif public_method?(instance)
         arity = instance.method(name).arity
         instance.__send__(name, *args)
       elsif local_method?(instance, :method_missing)
         instance.__send__(:method_missing, name.to_sym, *args)
       else
-        instance.class.handle_no_task_error(name)
+        instance.class.handle_no_command_error(name)
       end
     rescue ArgumentError => e
       handle_argument_error?(instance, e, caller) ?
-        instance.class.handle_argument_error(self, e, arity) : (raise e)
+        instance.class.handle_argument_error(self, e, args, arity) : (raise e)
     rescue NoMethodError => e
       handle_no_method_error?(instance, e, caller) ?
-        instance.class.handle_no_task_error(name) : (raise e)
+        instance.class.handle_no_command_error(name) : (raise e)
     end
 
     # Returns the formatted usage by injecting given required arguments
@@ -107,26 +107,30 @@ class Thor
         error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
     end
   end
+  Task = Command
 
-  # A task that is hidden in help messages but still invocable.
-  class HiddenTask < Task
+  # A command that is hidden in help messages but still invocable.
+  class HiddenCommand < Command
     def hidden?
       true
     end
   end
+  HiddenTask = HiddenCommand
 
-  # A dynamic task that handles method missing scenarios.
-  class DynamicTask < Task
+  # A dynamic command that handles method missing scenarios.
+  class DynamicCommand < Command
     def initialize(name, options=nil)
-      super(name.to_s, "A dynamically-generated task", name.to_s, name.to_s, options)
+      super(name.to_s, "A dynamically-generated command", name.to_s, name.to_s, options)
     end
 
     def run(instance, args=[])
       if (instance.methods & [name.to_s, name.to_sym]).empty?
         super
       else
-        instance.class.handle_no_task_error(name)
+        instance.class.handle_no_command_error(name)
       end
     end
   end
+  DynamicTask = DynamicCommand
+
 end

data/lib/bundler/vendor/thor/core_ext/io_binary_read.rb

@@ -0,0 +1,12 @@
+class IO #:nodoc:
+  class << self
+
+    def binread(file, *args)
+      raise ArgumentError, "wrong number of arguments (#{1 + args.size} for 1..3)" unless args.size < 3
+      File.open(file, 'rb') do |f|
+        f.read(*args)
+      end
+    end unless method_defined? :binread
+
+  end
+end

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

@@ -5,17 +5,19 @@ class Thor
   # Errors that are caused by the developer, like declaring a method which
   # overwrites a thor keyword, it SHOULD NOT raise a Thor::Error. This way, we
   # ensure that developer errors are shown with full backtrace.
-  #
   class Error < StandardError
   end
 
-  # Raised when a task was not found.
-  #
-  class UndefinedTaskError < Error
+  # Raised when a command was not found.
+  class UndefinedCommandError < Error
   end
+  UndefinedTaskError = UndefinedCommandError
 
-  # Raised when a task was found, but not invoked properly.
-  #
+  class AmbiguousCommandError < Error
+  end
+  AmbiguousTaskError = AmbiguousCommandError
+
+  # Raised when a command was found, but not invoked properly.
   class InvocationError < Error
   end
 
@@ -27,9 +29,4 @@ class Thor
 
   class MalformattedArgumentError < InvocationError
   end
-
-  # Raised when a user tries to call a private method encoded in templated filename.
-  #
-  class PrivateMethodEncodedError < Error
-  end
 end

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

@@ -1,9 +1,9 @@
 require 'thor/base'
 
 # Thor has a special class called Thor::Group. The main difference to Thor class
-# is that it invokes all tasks at once. It also include some methods that allows
+# is that it invokes all commands at once. It also include some methods that allows
 # invocations to be done at the class method, which are not available to Thor
-# tasks.
+# commands.
 class Thor::Group
   class << self
     # The description for this Thor::Group. If none is provided, but a source root
@@ -14,11 +14,11 @@ class Thor::Group
     # description<String>:: The description for this Thor::Group.
     #
     def desc(description=nil)
-      case description
-        when nil
-          @desc ||= from_superclass(:desc, nil)
-        else
-          @desc = description
+      @desc = case description
+      when nil
+        @desc || from_superclass(:desc, nil)
+      else
+        description
       end
     end
 
@@ -48,7 +48,7 @@ class Thor::Group
     end
 
     # Invoke the given namespace or class given. It adds an instance
-    # method that will invoke the klass and task. You can give a block to
+    # method that will invoke the klass and command. You can give a block to
     # configure how it will be invoked.
     #
     # The namespace/class given will have its options showed on the help
@@ -64,12 +64,12 @@ class Thor::Group
 
         class_eval <<-METHOD, __FILE__, __LINE__
           def _invoke_#{name.to_s.gsub(/\W/, '_')}
-            klass, task = self.class.prepare_for_invocation(nil, #{name.inspect})
+            klass, command = self.class.prepare_for_invocation(nil, #{name.inspect})
 
             if klass
               say_status :invoke, #{name.inspect}, #{verbose.inspect}
               block = self.class.invocation_blocks[#{name.inspect}]
-              _invoke_for_class_method klass, task, &block
+              _invoke_for_class_method klass, command, &block
             else
               say_status :error, %(#{name.inspect} [not found]), :red
             end
@@ -100,7 +100,7 @@ class Thor::Group
     # In some cases you want to customize how a specified hook is going to be
     # invoked. You can do that by overwriting the class method
     # prepare_for_invocation. The class method must necessarily return a klass
-    # and an optional task.
+    # and an optional command.
     #
     # ==== Custom invocations
     #
@@ -127,12 +127,12 @@ class Thor::Group
 
             value = options[#{name.inspect}]
             value = #{name.inspect} if TrueClass === value
-            klass, task = self.class.prepare_for_invocation(#{name.inspect}, value)
+            klass, command = self.class.prepare_for_invocation(#{name.inspect}, value)
 
             if klass
               say_status :invoke, value, #{verbose.inspect}
               block = self.class.invocation_blocks[#{name.inspect}]
-              _invoke_for_class_method klass, task, &block
+              _invoke_for_class_method klass, command, &block
             else
               say_status :error, %(\#{value} [not found]), :red
             end
@@ -149,7 +149,7 @@ class Thor::Group
     #
     def remove_invocation(*names)
       names.each do |name|
-        remove_task(name)
+        remove_command(name)
         remove_class_option(name)
         invocations.delete(name)
         invocation_blocks.delete(name)
@@ -196,30 +196,26 @@ class Thor::Group
       end
     end
 
-    # Returns tasks ready to be printed.
-    def printable_tasks(*)
+    # Returns commands ready to be printed.
+    def printable_commands(*)
       item = []
       item << banner
       item << (desc ? "# #{desc.gsub(/\s+/m,' ')}" : "")
       [item]
     end
+    alias printable_tasks printable_commands
 
-    def handle_argument_error(task, error, arity=nil) #:nodoc:
-      if arity > 0
-        msg = "#{basename} #{task.name} takes #{arity} argument"
-        msg << "s" if arity > 1
-        msg << ", but it should not."
-      else
-        msg = "You should not pass arguments to #{basename} #{task.name}."
-      end
-
+    def handle_argument_error(command, error, args, arity) #:nodoc:
+      msg = "#{basename} #{command.name} takes #{arity} argument"
+      msg << "s" if arity > 1
+      msg << ", but it should not."
       raise error, msg
     end
 
     protected
 
       # The method responsible for dispatching given the args.
-      def dispatch(task, given_args, given_opts, config) #:nodoc:
+      def dispatch(command, given_args, given_opts, config) #:nodoc:
         if Thor::HELP_MAPPINGS.include?(given_args.first)
           help(config[:shell])
           return
@@ -230,10 +226,9 @@ class Thor::Group
 
         instance = new(args, opts, config)
         yield instance if block_given?
-        args = instance.args
 
-        if task
-          instance.invoke_task(all_tasks[task])
+        if command
+          instance.invoke_command(all_commands[command])
         else
           instance.invoke_all
         end
@@ -242,22 +237,24 @@ class Thor::Group
       # 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.
       def banner
-        "#{basename} #{self_task.formatted_usage(self, false)}"
+        "#{basename} #{self_command.formatted_usage(self, false)}"
       end
 
-      # Represents the whole class as a task.
-      def self_task #:nodoc:
-        Thor::DynamicTask.new(self.namespace, class_options)
+      # Represents the whole class as a command.
+      def self_command #:nodoc:
+        Thor::DynamicCommand.new(self.namespace, class_options)
       end
+      alias self_task self_command
 
       def baseclass #:nodoc:
         Thor::Group
       end
 
-      def create_task(meth) #:nodoc:
-        tasks[meth.to_s] = Thor::Task.new(meth, nil, nil, nil, nil)
+      def create_command(meth) #:nodoc:
+        commands[meth.to_s] = Thor::Command.new(meth, nil, nil, nil, nil)
         true
       end
+      alias create_task create_command
   end
 
   include Thor::Base
@@ -266,19 +263,19 @@ class Thor::Group
 
   # Shortcut to invoke with padding and block handling. Use internally by
   # invoke and invoke_from_option class methods.
-  def _invoke_for_class_method(klass, task=nil, *args, &block) #:nodoc:
+  def _invoke_for_class_method(klass, command=nil, *args, &block) #:nodoc:
     with_padding do
       if block
         case block.arity
         when 3
-          block.call(self, klass, task)
+          block.call(self, klass, command)
         when 2
           block.call(self, klass)
         when 1
           instance_exec(klass, &block)
         end
       else
-        invoke klass, task, *args
+        invoke klass, command, *args
       end
     end
   end

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

@@ -6,12 +6,12 @@ class Thor
 
     module ClassMethods
       # 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
+      # class and command 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.find_class_and_task_by_namespace(name.to_s, !key)
+          Thor::Util.find_class_and_command_by_namespace(name.to_s, !key)
         else
           name
         end
@@ -25,15 +25,15 @@ class Thor
       super
     end
 
-    # Receives a name and invokes it. The name can be a string (either "task" or
-    # "namespace:task"), a Thor::Task, a Class or a Thor instance. If the task
-    # cannot be guessed by name, it can also be supplied as second argument.
+    # Receives a name and invokes it. The name can be a string (either "command" or
+    # "namespace:command"), a Thor::Command, a Class or a Thor instance. If the
+    # command cannot be guessed by name, it can also be supplied as second argument.
     #
     # You can also supply the arguments, options and configuration values for
-    # the task to be invoked, if none is given, the same values used to
+    # the command 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.
+    # When no name is given, it will invoke the default command of the current class.
     #
     # ==== Examples
     #
@@ -54,16 +54,16 @@ class Thor
     #     end
     #   end
     #
-    # You can notice that the method "foo" above invokes two tasks: "bar",
+    # You can notice that the method "foo" above invokes two commands: "bar",
     # which belongs to the same class and "hello" which belongs to the class B.
     #
-    # By using an invocation system you ensure that a task is invoked only once.
+    # By using an invocation system you ensure that a command is invoked only once.
     # In the example above, invoking "foo" will invoke "b:hello" just once, even
     # if it's invoked later by "bar" method.
     #
     # When class A invokes class B, all arguments used on A initialization are
     # supplied to B. This allows lazy parse of options. Let's suppose you have
-    # some rspec tasks:
+    # some rspec commands:
     #
     #   class Rspec < Thor::Group
     #     class_option :mock_framework, :type => :string, :default => :rr
@@ -100,30 +100,31 @@ class Thor
       end
 
       args.unshift(nil) if Array === args.first || NilClass === args.first
-      task, args, opts, config = args
+      command, args, opts, config = args
 
-      klass, task = _retrieve_class_and_task(name, task)
+      klass, command = _retrieve_class_and_command(name, command)
       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) do |instance|
+      klass.send(:dispatch, command, args, opts, config) do |instance|
         instance.parent_options = options
       end
     end
 
-    # Invoke the given task if the given args.
-    def invoke_task(task, *args) #:nodoc:
+    # Invoke the given command if the given args.
+    def invoke_command(command, *args) #:nodoc:
       current = @_invocations[self.class]
 
-      unless current.include?(task.name)
-        current << task.name
-        task.run(self, *args)
+      unless current.include?(command.name)
+        current << command.name
+        command.run(self, *args)
       end
     end
+    alias invoke_task invoke_command
 
-    # Invoke all tasks for the current instance.
+    # Invoke all commands for the current instance.
     def invoke_all #:nodoc:
-      self.class.all_tasks.map { |_, task| invoke_task(task) }
+      self.class.all_commands.map { |_, command| invoke_command(command) }
     end
 
     # Invokes using shell padding.
@@ -138,21 +139,22 @@ class Thor
         { :invocations => @_invocations }
       end
 
-      # 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,
+      # This method simply retrieves the class and command to be invoked.
+      # If the name is nil or the given name is a command 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:
+      def _retrieve_class_and_command(name, sent_command=nil) #:nodoc:
         case
         when name.nil?
           [self.class, nil]
-        when self.class.all_tasks[name.to_s]
+        when self.class.all_commands[name.to_s]
           [self.class, name.to_s]
         else
-          klass, task = self.class.prepare_for_invocation(nil, name)
-          [klass, task || sent_task]
+          klass, command = self.class.prepare_for_invocation(nil, name)
+          [klass, command || sent_command]
         end
       end
+      alias _retrieve_class_and_task _retrieve_class_and_command
 
       # Initialize klass using values stored in the @_initializer.
       def _parse_initialization_options(args, opts, config) #:nodoc:

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

@@ -11,16 +11,16 @@ class Thor
     def self.to_switches(options)
       options.map do |key, value|
         case value
-          when true
-            "--#{key}"
-          when Array
-            "--#{key} #{value.map{ |v| v.inspect }.join(' ')}"
-          when Hash
-            "--#{key} #{value.map{ |k,v| "#{k}:#{v}" }.join(' ')}"
-          when nil, false
-            ""
-          else
-            "--#{key} #{value.inspect}"
+        when true
+          "--#{key}"
+        when Array
+          "--#{key} #{value.map{ |v| v.inspect }.join(' ')}"
+        when Hash
+          "--#{key} #{value.map{ |k,v| "#{k}:#{v}" }.join(' ')}"
+        when nil, false
+          ""
+        else
+          "--#{key} #{value.inspect}"
         end
       end.join(" ")
     end
@@ -46,7 +46,8 @@ class Thor
         @switches[option.switch_name] = option
 
         option.aliases.each do |short|
-          @shorts[short.to_s] ||= option.switch_name
+          name = short.to_s.sub(/^(?!\-)/, '-')
+          @shorts[name] ||= option.switch_name
         end
       end
     end
@@ -79,20 +80,21 @@ class Thor
 
           if is_switch
             case shifted
-              when SHORT_SQ_RE
-                unshift($1.split('').map { |f| "-#{f}" })
-                next
-              when EQ_RE, SHORT_NUM
-                unshift($2)
-                switch = $1
-              when LONG_RE, SHORT_RE
-                switch = $1
+            when SHORT_SQ_RE
+              unshift($1.split('').map { |f| "-#{f}" })
+              next
+            when EQ_RE, SHORT_NUM
+              unshift($2)
+              switch = $1
+            when LONG_RE, SHORT_RE
+              switch = $1
             end
 
             switch = normalize_switch(switch)
             option = switch_option(switch)
             @assigns[option.human_name] = parse_peek(switch, option)
           elsif @stop_on_unknown
+            @parsing_options = false
             @extra << shifted
             @extra << shift while peek
             break