thor 0.18.1 → 0.19.0

data/lib/thor/invocation.rb

@@ -19,12 +19,17 @@ 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
 
+    # 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.
@@ -40,11 +45,11 @@ class Thor
     #   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
     #
@@ -93,17 +98,18 @@ 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
+      args.unshift(nil) if args.first.is_a?(Array) || args.first.nil?
       command, args, opts, config = args
 
       klass, command = _retrieve_class_and_command(name, command)
-      raise "Expected Thor class, got #{klass}" unless klass <= Thor::Base
+      fail "Missing Thor class for invoke #{name}" unless klass
+      fail "Expected Thor class, got #{klass}" unless klass <= Thor::Base
 
       args, opts, config = _parse_initialization_options(args, opts, config)
       klass.send(:dispatch, command, args, opts, config) do |instance|
@@ -120,7 +126,7 @@ class Thor
         command.run(self, *args)
       end
     end
-    alias invoke_task invoke_command
+    alias_method :invoke_task, :invoke_command
 
     # Invoke all commands for the current instance.
     def invoke_all #:nodoc:
@@ -132,41 +138,41 @@ 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 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:
-        case
-        when name.nil?
-          [self.class, nil]
-        when 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
+    # 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:
+      case
+      when name.nil?
+        [self.class, nil]
+      when 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
-      alias _retrieve_class_and_task _retrieve_class_and_command
+    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.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

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/parser.rb

@@ -1,4 +1,4 @@
-require 'thor/parser/argument'
-require 'thor/parser/arguments'
-require 'thor/parser/option'
-require 'thor/parser/options'
+require "thor/parser/argument"
+require "thor/parser/arguments"
+require "thor/parser/option"
+require "thor/parser/options"

data/lib/thor/parser/argument.rb

@@ -1,17 +1,17 @@
 class Thor
   class Argument #:nodoc:
-    VALID_TYPES = [ :numeric, :hash, :array, :string ]
+    VALID_TYPES = [:numeric, :hash, :array, :string]
 
     attr_reader :name, :description, :enum, :required, :type, :default, :banner
-    alias :human_name :name
+    alias_method :human_name, :name
 
-    def initialize(name, options={})
+    def initialize(name, options = {})
       class_name = self.class.name.split("::").last
 
       type = options[:type]
 
-      raise ArgumentError, "#{class_name} name can't be nil."                         if name.nil?
-      raise ArgumentError, "Type :#{type} is not valid for #{class_name.downcase}s."  if type && !valid_type?(type)
+      fail ArgumentError, "#{class_name} name can't be nil."                         if name.nil?
+      fail ArgumentError, "Type :#{type} is not valid for #{class_name.downcase}s."  if type && !valid_type?(type)
 
       @name        = name.to_s
       @description = options[:desc]
@@ -41,34 +41,33 @@ class Thor
       end
     end
 
-    protected
+  protected
 
-      def validate!
-        if required? && !default.nil?
-          raise ArgumentError, "An argument cannot be required and have default value."
-        elsif @enum && !@enum.is_a?(Array)
-          raise ArgumentError, "An argument cannot have an enum other than an array."
-        end
+    def validate!
+      if required? && !default.nil?
+        fail ArgumentError, "An argument cannot be required and have default value."
+      elsif @enum && !@enum.is_a?(Array)
+        fail ArgumentError, "An argument cannot have an enum other than an array."
       end
+    end
 
-      def valid_type?(type)
-        self.class::VALID_TYPES.include?(type.to_sym)
-      end
+    def valid_type?(type)
+      self.class::VALID_TYPES.include?(type.to_sym)
+    end
 
-      def default_banner
-        case type
-        when :boolean
-          nil
-        when :string, :default
-          human_name.upcase
-        when :numeric
-          "N"
-        when :hash
-          "key:value"
-        when :array
-          "one two three"
-        end
+    def default_banner
+      case type
+      when :boolean
+        nil
+      when :string, :default
+        human_name.upcase
+      when :numeric
+        "N"
+      when :hash
+        "key:value"
+      when :array
+        "one two three"
       end
-
+    end
   end
 end

data/lib/thor/parser/arguments.rb

@@ -1,5 +1,5 @@
 class Thor
-  class Arguments #:nodoc:
+  class Arguments #:nodoc: # rubocop:disable ClassLength
     NUMERIC = /(\d*\.\d+|\d+)/
 
     # Receives an array of args and returns two arrays, one with arguments
@@ -13,7 +13,7 @@ class Thor
         arguments << item
       end
 
-      return arguments, args[Range.new(arguments.size, -1)]
+      [arguments, args[Range.new(arguments.size, -1)]]
     end
 
     def self.parse(*args)
@@ -23,12 +23,12 @@ class Thor
 
     # Takes an array of Thor::Argument objects.
     #
-    def initialize(arguments=[])
+    def initialize(arguments = [])
       @assigns, @non_assigned_required = {}, []
       @switches = arguments
 
       arguments.each do |argument|
-        if argument.default != nil
+        if !argument.default.nil?
           @assigns[argument.human_name] = argument.default
         elsif argument.required?
           @non_assigned_required << argument
@@ -49,123 +49,127 @@ class Thor
       @assigns
     end
 
-    def remaining
+    def remaining # rubocop:disable TrivialAccessors
       @pile
     end
 
-    private
+  private
 
-      def no_or_skip?(arg)
-        arg =~ /^--(no|skip)-([-\w]+)$/
-        $2
-      end
+    def no_or_skip?(arg)
+      arg =~ /^--(no|skip)-([-\w]+)$/
+      $2
+    end
 
-      def last?
-        @pile.empty?
-      end
+    def last?
+      @pile.empty?
+    end
 
-      def peek
-        @pile.first
-      end
+    def peek
+      @pile.first
+    end
 
-      def shift
-        @pile.shift
-      end
+    def shift
+      @pile.shift
+    end
 
-      def unshift(arg)
-        unless arg.kind_of?(Array)
-          @pile.unshift(arg)
-        else
-          @pile = arg + @pile
-        end
+    def unshift(arg)
+      if arg.kind_of?(Array)
+        @pile = arg + @pile
+      else
+        @pile.unshift(arg)
       end
+    end
 
-      def current_is_value?
-        peek && peek.to_s !~ /^-/
-      end
+    def current_is_value?
+      peek && peek.to_s !~ /^-/
+    end
 
-      # Runs through the argument array getting strings that contains ":" and
-      # mark it as a hash:
-      #
-      #   [ "name:string", "age:integer" ]
-      #
-      # Becomes:
-      #
-      #   { "name" => "string", "age" => "integer" }
-      #
-      def parse_hash(name)
-        return shift if peek.is_a?(Hash)
-        hash = {}
-
-        while current_is_value? && peek.include?(?:)
-          key, value = shift.split(':',2)
-          hash[key] = value
-        end
-        hash
-      end
+    # Runs through the argument array getting strings that contains ":" and
+    # mark it as a hash:
+    #
+    #   [ "name:string", "age:integer" ]
+    #
+    # Becomes:
+    #
+    #   { "name" => "string", "age" => "integer" }
+    #
+    def parse_hash(name)
+      return shift if peek.is_a?(Hash)
+      hash = {}
 
-      # Runs through the argument array getting all strings until no string is
-      # found or a switch is found.
-      #
-      #   ["a", "b", "c"]
-      #
-      # And returns it as an array:
-      #
-      #   ["a", "b", "c"]
-      #
-      def parse_array(name)
-        return shift if peek.is_a?(Array)
-        array = []
-
-        while current_is_value?
-          array << shift
-        end
-        array
+      while current_is_value? && peek.include?(":")
+        key, value = shift.split(":", 2)
+        hash[key] = value
       end
+      hash
+    end
 
-      # Check if the peek is numeric format and return a Float or Integer.
-      # Otherwise raises an error.
-      #
-      def parse_numeric(name)
-        return shift if peek.is_a?(Numeric)
+    # Runs through the argument array getting all strings until no string is
+    # found or a switch is found.
+    #
+    #   ["a", "b", "c"]
+    #
+    # And returns it as an array:
+    #
+    #   ["a", "b", "c"]
+    #
+    def parse_array(name)
+      return shift if peek.is_a?(Array)
+      array = []
+      array << shift while current_is_value?
+      array
+    end
 
-        unless peek =~ NUMERIC && $& == peek
-          raise MalformattedArgumentError, "Expected numeric value for '#{name}'; got #{peek.inspect}"
-        end
+    # Check if the peek is numeric format and return a Float or Integer.
+    # Check if the peek is included in enum if enum is provided.
+    # Otherwise raises an error.
+    #
+    def parse_numeric(name)
+      return shift if peek.is_a?(Numeric)
 
-        $&.index('.') ? shift.to_f : shift.to_i
+      unless peek =~ NUMERIC && $& == peek
+        fail MalformattedArgumentError, "Expected numeric value for '#{name}'; got #{peek.inspect}"
       end
 
-      # Parse string:
-      # for --string-arg, just return the current value in the pile
-      # for --no-string-arg, nil
-      #
-      def parse_string(name)
-        if no_or_skip?(name)
-          nil
-        else
-          value = shift
-          if @switches.is_a?(Hash) && switch = @switches[name]
-            if switch.enum && !switch.enum.include?(value)
-              raise MalformattedArgumentError, "Expected '#{name}' to be one of #{switch.enum.join(', ')}; got #{value}"
-            end
-          end
-          value
+      value = $&.index(".") ? shift.to_f : shift.to_i
+      if @switches.is_a?(Hash) && switch = @switches[name]
+        if switch.enum && !switch.enum.include?(value)
+          fail MalformattedArgumentError, "Expected '#{name}' to be one of #{switch.enum.join(', ')}; got #{value}"
         end
       end
+      value
+    end
 
-      # Raises an error if @non_assigned_required array is not empty.
-      #
-      def check_requirement!
-        unless @non_assigned_required.empty?
-          names = @non_assigned_required.map do |o|
-            o.respond_to?(:switch_name) ? o.switch_name : o.human_name
-          end.join("', '")
-
-          class_name = self.class.name.split('::').last.downcase
-          raise RequiredArgumentMissingError, "No value provided for required #{class_name} '#{names}'"
+    # Parse string:
+    # for --string-arg, just return the current value in the pile
+    # for --no-string-arg, nil
+    # Check if the peek is included in enum if enum is provided. Otherwise raises an error.
+    #
+    def parse_string(name)
+      if no_or_skip?(name)
+        nil
+      else
+        value = shift
+        if @switches.is_a?(Hash) && switch = @switches[name] # rubocop:disable AssignmentInCondition
+          if switch.enum && !switch.enum.include?(value)
+            fail MalformattedArgumentError, "Expected '#{name}' to be one of #{switch.enum.join(', ')}; got #{value}"
+          end
         end
+        value
       end
+    end
 
+    # Raises an error if @non_assigned_required array is not empty.
+    #
+    def check_requirement!
+      unless @non_assigned_required.empty?
+        names = @non_assigned_required.map do |o|
+          o.respond_to?(:switch_name) ? o.switch_name : o.human_name
+        end.join("', '")
+
+        class_name = self.class.name.split("::").last.downcase
+        fail RequiredArgumentMissingError, "No value provided for required #{class_name} '#{names}'"
+      end
+    end
   end
 end