thor 0.14.6 → 0.19.4

data/lib/thor/group.rb

@@ -1,9 +1,9 @@
-require 'thor/base'
+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
@@ -13,12 +13,11 @@ class Thor::Group
     # ==== Parameters
     # description<String>:: The description for this Thor::Group.
     #
-    def desc(description=nil)
-      case description
-        when nil
-          @desc ||= from_superclass(:desc, nil)
-        else
-          @desc = description
+    def desc(description = nil)
+      if description
+        @desc = description
+      else
+        @desc ||= from_superclass(:desc, nil)
       end
     end
 
@@ -32,7 +31,7 @@ class Thor::Group
       shell.say "  #{banner}\n"
       shell.say
       class_options_help(shell)
-      shell.say self.desc if self.desc
+      shell.say desc if desc
     end
 
     # Stores invocations for this class merging with superclass values.
@@ -48,7 +47,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 +63,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,11 +99,11 @@ 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
     #
-    # You can also supply a block to customize how the option is giong to be
+    # You can also supply a block to customize how the option is going to be
     # invoked. The block receives two parameters, an instance of the current
     # class and the klass to be invoked.
     #
@@ -114,8 +113,8 @@ class Thor::Group
 
       names.each do |name|
         unless class_options.key?(name)
-          raise ArgumentError, "You have to define the option #{name.inspect} " <<
-                               "before setting invoke_from_option."
+          raise ArgumentError, "You have to define the option #{name.inspect} " \
+                              "before setting invoke_from_option."
         end
 
         invocations[name] = true
@@ -127,12 +126,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 +148,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)
@@ -159,7 +158,7 @@ class Thor::Group
     # Overwrite class options help to allow invoked generators options to be
     # shown recursively when invoking a generator.
     #
-    def class_options_help(shell, groups={}) #:nodoc:
+    def class_options_help(shell, groups = {}) #:nodoc:
       get_options_from_invocations(groups, class_options) do |klass|
         klass.send(:get_options_from_invocations, groups, class_options)
       end
@@ -170,7 +169,7 @@ class Thor::Group
     # options are added to group_options hash. Options that already exists
     # in base_options are not added twice.
     #
-    def get_options_from_invocations(group_options, base_options) #:nodoc:
+    def get_options_from_invocations(group_options, base_options) #:nodoc: # rubocop:disable MethodLength
       invocations.each do |name, from_option|
         value = if from_option
           option = class_options[name]
@@ -180,93 +179,102 @@ class Thor::Group
         end
         next unless value
 
-        klass, task = prepare_for_invocation(name, value)
+        klass, _ = prepare_for_invocation(name, value)
         next unless klass && klass.respond_to?(:class_options)
 
         value = value.to_s
         human_name = value.respond_to?(:classify) ? value.classify : value
 
         group_options[human_name] ||= []
-        group_options[human_name] += klass.class_options.values.select do |option|
-          base_options[option.name.to_sym].nil? && option.group.nil? &&
-          !group_options.values.flatten.any? { |i| i.name == option.name }
+        group_options[human_name] += klass.class_options.values.select do |class_option|
+          base_options[class_option.name.to_sym].nil? && class_option.group.nil? &&
+            !group_options.values.flatten.any? { |i| i.name == class_option.name }
         end
 
         yield klass if block_given?
       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 << (desc ? "# #{desc.gsub(/\s+/m, ' ')}" : "")
       [item]
     end
+    alias_method :printable_tasks, :printable_commands
 
-    def handle_argument_error(task, error) #:nodoc:
-      raise error, "#{task.name.inspect} was called incorrectly. Are you sure it has arity equals to 0?"
+    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
+  protected
 
-      # The method responsible for dispatching given the args.
-      def dispatch(task, given_args, given_opts, config) #:nodoc:
-        if Thor::HELP_MAPPINGS.include?(given_args.first)
-          help(config[:shell])
-          return
-        end
+    # The method responsible for dispatching given the args.
+    def dispatch(command, given_args, given_opts, config) #:nodoc:
+      if Thor::HELP_MAPPINGS.include?(given_args.first)
+        help(config[:shell])
+        return
+      end
 
-        args, opts = Thor::Options.split(given_args)
-        opts = given_opts || opts
+      args, opts = Thor::Options.split(given_args)
+      opts = given_opts || opts
 
-        if task
-          new(args, opts, config).invoke_task(all_tasks[task])
-        else
-          new(args, opts, config).invoke_all
-        end
-      end
+      instance = new(args, opts, config)
+      yield instance if block_given?
 
-      # 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)}"
+      if command
+        instance.invoke_command(all_commands[command])
+      else
+        instance.invoke_all
       end
+    end
 
-      # Represents the whole class as a task.
-      def self_task #:nodoc:
-        Thor::DynamicTask.new(self.namespace, class_options)
-      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.
+    def banner
+      "#{basename} #{self_command.formatted_usage(self, false)}"
+    end
 
-      def baseclass #:nodoc:
-        Thor::Group
-      end
+    # Represents the whole class as a command.
+    def self_command #:nodoc:
+      Thor::DynamicCommand.new(namespace, class_options)
+    end
+    alias_method :self_task, :self_command
 
-      def create_task(meth) #:nodoc:
-        tasks[meth.to_s] = Thor::Task.new(meth, nil, nil, nil, nil)
-        true
-      end
+    def baseclass #:nodoc:
+      Thor::Group
+    end
+
+    def create_command(meth) #:nodoc:
+      commands[meth.to_s] = Thor::Command.new(meth, nil, nil, nil, nil)
+      true
+    end
+    alias_method :create_task, :create_command
   end
 
   include Thor::Base
 
-  protected
+protected
 
   # 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)
+          yield(self, klass, command)
         when 2
-          block.call(self, klass)
+          yield(self, klass)
         when 1
           instance_exec(klass, &block)
         end
       else
-        invoke klass, task, *args
+        invoke klass, command, *args
       end
     end
   end

data/lib/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
@@ -19,32 +19,37 @@ class Thor
     end
 
     # 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 ]
+    def initialize(args = [], options = {}, config = {}, &block) #:nodoc:
+      @_invocations = config[:invocations] || Hash.new { |h, k| h[k] = [] }
+      @_initializer = [args, options, config]
       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.
+    # Make the current command chain accessible with in a Thor-(sub)command
+    def current_command_chain
+      @_invocations.values.flatten.map(&:to_sym)
+    end
+
+    # 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
     #
     #   class A < Thor
     #     def foo
     #       invoke :bar
-    #       invoke "b:hello", ["José"]
+    #       invoke "b:hello", ["Erik"]
     #     end
     #
     #     def bar
-    #       invoke "b:hello", ["José"]
+    #       invoke "b:hello", ["Erik"]
     #     end
     #   end
     #
@@ -54,16 +59,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
@@ -85,7 +90,7 @@ class Thor
     # that it's going to use.
     #
     # If you want Rspec::RR to be initialized with its own set of options, you
-    # have to do that explicitely:
+    # have to do that explicitly:
     #
     #   invoke "rspec:rr", [], :style => :foo
     #
@@ -93,35 +98,39 @@ class Thor
     #
     #   invoke Rspec::RR, [], :style => :foo
     #
-    def invoke(name=nil, *args)
+    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
+      args.unshift(nil) if args.first.is_a?(Array) || args.first.nil?
+      command, args, opts, config = args
 
-      klass, task = _retrieve_class_and_task(name, task)
+      klass, command = _retrieve_class_and_command(name, command)
+      raise "Missing Thor class for invoke #{name}" unless klass
       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)
+      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_method :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.
@@ -129,40 +138,40 @@ class Thor
       with_padding { invoke(*args) }
     end
 
-    protected
+  protected
 
-      # Configuration values that are shared between invocations.
-      def _shared_configuration #:nodoc:
-        { :invocations => @_invocations }
-      end
+    # Configuration values that are shared between invocations.
+    def _shared_configuration #:nodoc:
+      {: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,
-      # 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
-          klass, task = self.class.prepare_for_invocation(nil, name)
-          [klass, task || sent_task]
-        end
+    # 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_command(name, sent_command = nil) #:nodoc:
+      if name.nil?
+        [self.class, nil]
+      elsif self.class.all_commands[name.to_s]
+        [self.class, name.to_s]
+      else
+        klass, command = self.class.prepare_for_invocation(nil, name)
+        [klass, command || sent_command]
       end
+    end
+    alias_method :_retrieve_class_and_task, :_retrieve_class_and_command
 
-      # Initialize klass using values stored in the @_initializer.
-      def _parse_initialization_options(args, opts, config) #:nodoc:
-        stored_args, stored_opts, stored_config = @_initializer
+    # Initialize klass using values stored in the @_initializer.
+    def _parse_initialization_options(args, opts, config) #:nodoc:
+      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)
+      config ||= {}
+      config = stored_config.merge(_shared_configuration).merge!(config)
 
-        [ args, opts, config ]
-      end
+      [args, opts, config]
+    end
   end
 end

data/lib/thor/line_editor/basic.rb

@@ -0,0 +1,35 @@
+class Thor
+  module LineEditor
+    class Basic
+      attr_reader :prompt, :options
+
+      def self.available?
+        true
+      end
+
+      def initialize(prompt, options)
+        @prompt = prompt
+        @options = options
+      end
+
+      def readline
+        $stdout.print(prompt)
+        get_input
+      end
+
+    private
+
+      def get_input
+        if echo?
+          $stdin.gets
+        else
+          $stdin.noecho(&:gets)
+        end
+      end
+
+      def echo?
+        options.fetch(:echo, true)
+      end
+    end
+  end
+end

data/lib/thor/line_editor/readline.rb

@@ -0,0 +1,88 @@
+begin
+  require "readline"
+rescue LoadError
+end
+
+class Thor
+  module LineEditor
+    class Readline < Basic
+      def self.available?
+        Object.const_defined?(:Readline)
+      end
+
+      def readline
+        if echo?
+          ::Readline.completion_append_character = nil
+          # Ruby 1.8.7 does not allow Readline.completion_proc= to receive nil.
+          if complete = completion_proc
+            ::Readline.completion_proc = complete
+          end
+          ::Readline.readline(prompt, add_to_history?)
+        else
+          super
+        end
+      end
+
+    private
+
+      def add_to_history?
+        options.fetch(:add_to_history, true)
+      end
+
+      def completion_proc
+        if use_path_completion?
+          proc { |text| PathCompletion.new(text).matches }
+        elsif completion_options.any?
+          proc do |text|
+            completion_options.select { |option| option.start_with?(text) }
+          end
+        end
+      end
+
+      def completion_options
+        options.fetch(:limited_to, [])
+      end
+
+      def use_path_completion?
+        options.fetch(:path, false)
+      end
+
+      class PathCompletion
+        attr_reader :text
+        private :text
+
+        def initialize(text)
+          @text = text
+        end
+
+        def matches
+          relative_matches
+        end
+
+      private
+
+        def relative_matches
+          absolute_matches.map { |path| path.sub(base_path, "") }
+        end
+
+        def absolute_matches
+          Dir[glob_pattern].map do |path|
+            if File.directory?(path)
+              "#{path}/"
+            else
+              path
+            end
+          end
+        end
+
+        def glob_pattern
+          "#{base_path}#{text}*"
+        end
+
+        def base_path
+          "#{Dir.pwd}/"
+        end
+      end
+    end
+  end
+end

data/lib/thor/line_editor.rb

@@ -0,0 +1,17 @@
+require "thor/line_editor/basic"
+require "thor/line_editor/readline"
+
+class Thor
+  module LineEditor
+    def self.readline(prompt, options = {})
+      best_available.new(prompt, options).readline
+    end
+
+    def self.best_available
+      [
+        Thor::LineEditor::Readline,
+        Thor::LineEditor::Basic
+      ].detect(&:available?)
+    end
+  end
+end