thor 0.19.1 → 0.19.2

data/lib/thor/actions/inject_into_file.rb

@@ -22,11 +22,8 @@ class Thor
     #   end
     #
     def insert_into_file(destination, *args, &block)
-      if block_given?
-        data, config = block, args.shift
-      else
-        data, config = args.shift, args.shift
-      end
+      data = block_given? ? block : args.shift
+      config = args.shift
       action InjectIntoFile.new(self, destination, data, config)
     end
     alias_method :inject_into_file, :insert_into_file
@@ -39,9 +36,9 @@ class Thor
 
         @behavior, @flag = if @config.key?(:after)
           [:after, @config.delete(:after)]
-                           else
-                             [:before, @config.delete(:before)]
-                           end
+        else
+          [:before, @config.delete(:before)]
+        end
 
         @replacement = data.is_a?(Proc) ? data.call : data
         @flag = Regexp.escape(@flag) unless @flag.is_a?(Regexp)
@@ -94,12 +91,11 @@ class Thor
       # Adds the content to the file.
       #
       def replace!(regexp, string, force)
-        unless base.options[:pretend]
-          content = File.binread(destination)
-          if force || !content.include?(replacement)
-            content.gsub!(regexp, string)
-            File.open(destination, "wb") { |file| file.write(content) }
-          end
+        return if base.options[:pretend]
+        content = File.binread(destination)
+        if force || !content.include?(replacement)
+          content.gsub!(regexp, string)
+          File.open(destination, "wb") { |file| file.write(content) }
         end
       end
     end

data/lib/thor/base.rb

@@ -14,11 +14,11 @@ class Thor
   autoload :Group,      "thor/group"
 
   # Shortcuts for help.
-  HELP_MAPPINGS       = %w[-h -? --help -D]
+  HELP_MAPPINGS       = %w(-h -? --help -D)
 
   # Thor methods that should not be overwritten by the user.
-  THOR_RESERVED_WORDS = %w[invoke shell options behavior root destination_root relative_root
-                           action add_file create_file in_root inside run run_ruby_script]
+  THOR_RESERVED_WORDS = %w(invoke shell options behavior root destination_root relative_root
+                           action add_file create_file in_root inside run run_ruby_script)
 
   TEMPLATE_EXTNAME = ".tt"
 
@@ -41,8 +41,8 @@ class Thor
     #
     # config<Hash>:: Configuration for this Thor class.
     #
-    def initialize(args = [], local_options = {}, config = {}) # rubocop:disable MethodLength
-      parse_options = self.class.class_options
+    def initialize(args = [], local_options = {}, config = {})
+      parse_options = config[:current_command] && config[:current_command].disable_class_options ? {} : self.class.class_options
 
       # The start method splits inbound arguments at the first argument
       # that looks like an option (starts with - or --). It then calls
@@ -52,11 +52,13 @@ class Thor
       command_options = config.delete(:command_options) # hook for start
       parse_options = parse_options.merge(command_options) if command_options
       if local_options.is_a?(Array)
-        array_options, hash_options = local_options, {}
+        array_options = local_options
+        hash_options = {}
       else
         # Handle the case where the class was explicitly instantiated
         # with pre-parsed options.
-        array_options, hash_options = [], local_options
+        array_options = []
+        hash_options = local_options
       end
 
       # Let Thor::Options parse the options first, so it can remove
@@ -205,8 +207,8 @@ class Thor
       # ==== Errors
       # ArgumentError:: Raised if you supply a required argument after a non required one.
       #
-      def argument(name, options = {}) # rubocop:disable MethodLength
-        is_thor_reserved_word?(name, :argument)
+      def argument(name, options = {})
+        thor_reserved_word?(name, :argument)
         no_commands { attr_accessor name }
 
         required = if options.key?(:optional)
@@ -219,11 +221,13 @@ class Thor
 
         remove_argument name
 
-        arguments.each do |argument|
-          next if argument.required?
-          fail ArgumentError, "You cannot have #{name.to_s.inspect} as required argument after " <<
-                               "the non-required argument #{argument.human_name.inspect}."
-        end if required
+        if required
+          arguments.each do |argument|
+            next if argument.required?
+            raise ArgumentError, "You cannot have #{name.to_s.inspect} as required argument after " \
+                                "the non-required argument #{argument.human_name.inspect}."
+          end
+        end
 
         options[:required] = required
 
@@ -343,7 +347,7 @@ class Thor
       #
       def all_commands
         @all_commands ||= from_superclass(:all_commands, Thor::CoreExt::OrderedHash.new)
-        @all_commands.merge(commands)
+        @all_commands.merge!(commands)
       end
       alias_method :all_tasks, :all_commands
 
@@ -467,11 +471,8 @@ class Thor
       alias_method :public_task, :public_command
 
       def handle_no_command_error(command, has_namespace = $thor_runner) #:nodoc:
-        if has_namespace
-          fail UndefinedCommandError, "Could not find command #{command.inspect} in #{namespace.inspect} namespace."
-        else
-          fail UndefinedCommandError, "Could not find command #{command.inspect}."
-        end
+        raise UndefinedCommandError, "Could not find command #{command.inspect} in #{namespace.inspect} namespace." if has_namespace
+        raise UndefinedCommandError, "Could not find command #{command.inspect}."
       end
       alias_method :handle_no_task_error, :handle_no_command_error
 
@@ -480,7 +481,7 @@ class Thor
         msg << "no arguments"               if     args.empty?
         msg << "arguments " << args.inspect unless args.empty?
         msg << "\nUsage: #{banner(command).inspect}"
-        fail InvocationError, msg
+        raise InvocationError, msg
       end
 
     protected
@@ -513,14 +514,13 @@ class Thor
         padding = options.map { |o| o.aliases.size }.max.to_i * 4
 
         options.each do |option|
-          unless option.hide
-            item = [option.usage(padding)]
-            item.push(option.description ? "# #{option.description}" : "")
+          next if option.hide
+          item = [option.usage(padding)]
+          item.push(option.description ? "# #{option.description}" : "")
 
-            list << item
-            list << ["", "# Default: #{option.default}"] if option.show_default?
-            list << ["", "# Possible values: #{option.enum.join(', ')}"] if option.enum
-          end
+          list << item
+          list << ["", "# Default: #{option.default}"] if option.show_default?
+          list << ["", "# Possible values: #{option.enum.join(', ')}"] if option.enum
         end
 
         shell.say(group_name ? "#{group_name} options:" : "Options:")
@@ -529,9 +529,9 @@ class Thor
       end
 
       # Raises an error if the word given is a Thor reserved word.
-      def is_thor_reserved_word?(word, type) #:nodoc:
+      def thor_reserved_word?(word, type) #:nodoc:
         return false unless THOR_RESERVED_WORDS.include?(word.to_s)
-        fail "#{word.inspect} is a Thor reserved word and cannot be defined as #{type}"
+        raise "#{word.inspect} is a Thor reserved word and cannot be defined as #{type}"
       end
 
       # Build an option and adds it to the given scope.
@@ -566,7 +566,7 @@ class Thor
         elsif command = all_commands[name.to_s] # rubocop:disable AssignmentInCondition
           commands[name.to_s] = command.clone
         else
-          fail ArgumentError, "You supplied :for => #{name.inspect}, but the command #{name.inspect} could not be found."
+          raise ArgumentError, "You supplied :for => #{name.inspect}, but the command #{name.inspect} could not be found."
         end
       end
       alias_method :find_and_refresh_task, :find_and_refresh_command
@@ -594,7 +594,7 @@ class Thor
         @no_commands ||= false
         return if @no_commands || !create_command(meth)
 
-        is_thor_reserved_word?(meth, :command)
+        thor_reserved_word?(meth, :command)
         Thor::Base.register_klass_file(self)
       end
 
@@ -649,7 +649,7 @@ class Thor
 
       # SIGNATURE: The hook invoked by start.
       def dispatch(command, given_args, given_opts, config) #:nodoc:
-        fail NotImplementedError
+        raise NotImplementedError
       end
     end
   end

data/lib/thor/command.rb

@@ -1,9 +1,9 @@
 class Thor
-  class Command < Struct.new(:name, :description, :long_description, :usage, :options)
+  class Command < Struct.new(:name, :description, :long_description, :usage, :options, :disable_class_options)
     FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/
 
-    def initialize(name, description, long_description, usage, options = nil)
-      super(name.to_s, description, long_description, usage, options || {})
+    def initialize(name, description, long_description, usage, options = nil, disable_class_options = false)
+      super(name.to_s, description, long_description, usage, options || {}, disable_class_options)
     end
 
     def initialize_copy(other) #:nodoc:
@@ -33,7 +33,7 @@ class Thor
     rescue ArgumentError => e
       handle_argument_error?(instance, e, caller) ? 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_command_error(name) : (fail e)
+      handle_no_method_error?(instance, e, caller) ? instance.class.handle_no_command_error(name) : (raise e)
     end
 
     # Returns the formatted usage by injecting given required arguments
@@ -50,7 +50,7 @@ class Thor
       # Add usage with required arguments
       formatted << if klass && !klass.arguments.empty?
                      usage.to_s.gsub(/^#{name}/) do |match|
-                       match << " " << klass.arguments.map { |a| a.usage }.compact.join(" ")
+                       match << " " << klass.arguments.map(&:usage).compact.join(" ")
                      end
                    else
                      usage.to_s
@@ -88,7 +88,7 @@ class Thor
     end
 
     def sans_backtrace(backtrace, caller) #:nodoc:
-      saned = backtrace.reject { |frame| frame =~ FILE_REGEXP || (frame =~ /\.java:/ && RUBY_PLATFORM =~ /java/) || (frame =~ /^kernel\// && RUBY_ENGINE =~ /rbx/) }
+      saned = backtrace.reject { |frame| frame =~ FILE_REGEXP || (frame =~ /\.java:/ && RUBY_PLATFORM =~ /java/) || (frame =~ %r{^kernel/} && RUBY_ENGINE =~ /rbx/) }
       saned - caller
     end
 
@@ -105,7 +105,7 @@ class Thor
         error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
     end
   end
-  Task = Command # rubocop:disable ConstantName
+  Task = Command
 
   # A command that is hidden in help messages but still invocable.
   class HiddenCommand < Command
@@ -113,7 +113,7 @@ class Thor
       true
     end
   end
-  HiddenTask = HiddenCommand # rubocop:disable ConstantName
+  HiddenTask = HiddenCommand
 
   # A dynamic command that handles method missing scenarios.
   class DynamicCommand < Command
@@ -129,5 +129,5 @@ class Thor
       end
     end
   end
-  DynamicTask = DynamicCommand # rubocop:disable ConstantName
+  DynamicTask = DynamicCommand
 end

data/lib/thor/core_ext/hash_with_indifferent_access.rb

@@ -28,6 +28,14 @@ class Thor
         super(convert_key(key))
       end
 
+      def fetch(key, *args)
+        super(convert_key(key), *args)
+      end
+
+      def key?(key)
+        super(convert_key(key))
+      end
+
       def values_at(*indices)
         indices.map { |key| self[convert_key(key)] }
       end
@@ -60,7 +68,7 @@ class Thor
       #   options.shebang                 # => "/usr/lib/local/ruby"
       #   options.test_framework?(:rspec) # => options[:test_framework] == :rspec
       #
-      def method_missing(method, *args, &block)
+      def method_missing(method, *args)
         method = method.to_s
         if method =~ /^(\w+)\?$/
           if args.empty?

data/lib/thor/core_ext/io_binary_read.rb

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

data/lib/thor/core_ext/ordered_hash.rb

@@ -1,96 +1,127 @@
 class Thor
-  module CoreExt #:nodoc:
-    if RUBY_VERSION >= "1.9"
-      class OrderedHash < ::Hash
-      end
-    else
-      # This class is based on the Ruby 1.9 ordered hashes.
-      #
-      # It keeps the semantics and most of the efficiency of normal hashes
-      # while also keeping track of the order in which elements were set.
-      #
-      class OrderedHash #:nodoc:
-        include Enumerable
-
-        Node = Struct.new(:key, :value, :next, :prev)
-
-        def initialize
-          @hash = {}
+  module CoreExt
+    class OrderedHash < ::Hash
+      if RUBY_VERSION < "1.9"
+        def initialize(*args, &block)
+          super
+          @keys = []
         end
 
-        def [](key)
-          @hash[key] && @hash[key].value
+        def initialize_copy(other)
+          super
+          # make a deep copy of keys
+          @keys = other.keys
         end
 
         def []=(key, value)
-          if node = @hash[key] # rubocop:disable AssignmentInCondition
-            node.value = value
-          else
-            node = Node.new(key, value)
-
-            if !defined?(@first) || @first.nil?
-              @first = @last = node
-            else
-              node.prev = @last
-              @last.next = node
-              @last = node
-            end
-          end
-
-          @hash[key] = node
-          value
+          @keys << key unless key?(key)
+          super
         end
 
         def delete(key)
-          if node = @hash[key] # rubocop:disable AssignmentInCondition
-            prev_node = node.prev
-            next_node = node.next
+          if key? key
+            index = @keys.index(key)
+            @keys.delete_at index
+          end
+          super
+        end
 
-            next_node.prev = prev_node if next_node
-            prev_node.next = next_node if prev_node
+        def delete_if
+          super
+          sync_keys!
+          self
+        end
 
-            @first = next_node if @first == node
-            @last = prev_node  if @last  == node
+        alias_method :reject!, :delete_if
 
-            value = node.value
-          end
-
-          @hash.delete(key)
-          value
+        def reject(&block)
+          dup.reject!(&block)
         end
 
         def keys
-          map { |k, v| k }
+          @keys.dup
         end
 
         def values
-          map { |k, v| v }
+          @keys.map { |key| self[key] }
+        end
+
+        def to_hash
+          self
+        end
+
+        def to_a
+          @keys.map { |key| [key, self[key]] }
+        end
+
+        def each_key
+          return to_enum(:each_key) unless block_given?
+          @keys.each { |key| yield(key) }
+          self
+        end
+
+        def each_value
+          return to_enum(:each_value) unless block_given?
+          @keys.each { |key| yield(self[key]) }
+          self
         end
 
         def each
-          return unless defined?(@first) && @first
-          yield [@first.key, @first.value]
-          node = @first
-          yield [node.key, node.value] while node = node.next # rubocop:disable AssignmentInCondition
+          return to_enum(:each) unless block_given?
+          @keys.each { |key| yield([key, self[key]]) }
           self
         end
 
-        def merge(other)
-          hash = self.class.new
+        def each_pair
+          return to_enum(:each_pair) unless block_given?
+          @keys.each { |key| yield(key, self[key]) }
+          self
+        end
 
-          each do |key, value|
-            hash[key] = value
-          end
+        alias_method :select, :find_all
+
+        def clear
+          super
+          @keys.clear
+          self
+        end
+
+        def shift
+          k = @keys.first
+          v = delete(k)
+          [k, v]
+        end
 
-          other.each do |key, value|
-            hash[key] = value
+        def merge!(other_hash)
+          if block_given?
+            other_hash.each { |k, v| self[k] = key?(k) ? yield(k, self[k], v) : v }
+          else
+            other_hash.each { |k, v| self[k] = v }
           end
+          self
+        end
+
+        alias_method :update, :merge!
+
+        def merge(other_hash, &block)
+          dup.merge!(other_hash, &block)
+        end
 
-          hash
+        # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
+        def replace(other)
+          super
+          @keys = other.keys
+          self
         end
 
-        def empty?
-          @hash.empty?
+        def inspect
+          "#<#{self.class} #{super}>"
+        end
+
+        private
+
+        def sync_keys!
+          @keys.delete_if { |k| !key?(k) }
         end
       end
     end