rubocop 0.49.1 → 0.52.0

data/lib/rubocop/cop/generator.rb

@@ -35,15 +35,15 @@ module RuboCop
                 # See. https://github.com/bbatsov/rubocop/blob/master/lib/rubocop/node_pattern.rb
                 #
                 # For example
-                MSG = 'Message of %<cop_name>s'.freeze
+                MSG = 'Use `#good_method` instead of `#bad_method`.'.freeze
 
                 def_node_matcher :bad_method?, <<-PATTERN
-                  (send nil :bad_method ...)
+                  (send nil? :bad_method ...)
                 PATTERN
 
                 def on_send(node)
                   return unless bad_method?(node)
-                  add_offense(node, :expression)
+                  add_offense(node)
                 end
               end
             end
@@ -51,29 +51,31 @@ module RuboCop
         end
       RUBY
 
-      SPEC_TEMPLATE = <<-RUBY.strip_indent
+      SPEC_TEMPLATE = <<-SPEC.strip_indent
         # frozen_string_literal: true
 
         describe RuboCop::Cop::%<department>s::%<cop_name>s do
-          let(:config) { RuboCop::Config.new }
           subject(:cop) { described_class.new(config) }
 
+          let(:config) { RuboCop::Config.new }
+
           # TODO: Write test code
           #
           # For example
-          it 'registers an offense for offending code' do
-            inspect_source(cop, 'bad_method')
-            expect(cop.offenses.size).to eq(1)
-            expect(cop.messages)
-              .to eq(['Message of %<cop_name>s'])
+          it 'registers an offense when using `#bad_method`' do
+            expect_offense(<<-RUBY.strip_indent)
+              bad_method
+              ^^^^^^^^^^ Use `#good_method` instead of `#bad_method`.
+            RUBY
           end
 
-          it 'accepts' do
-            inspect_source(cop, 'good_method')
-            expect(cop.offenses).to be_empty
+          it 'does not register an offense when using `#good_method`' do
+            expect_no_offenses(<<-RUBY.strip_indent)
+              good_method
+            RUBY
           end
         end
-      RUBY
+      SPEC
 
       def initialize(name)
         @badge = Badge.parse(name)
@@ -91,18 +93,41 @@ module RuboCop
         write_unless_file_exists(spec_path, generated_spec)
       end
 
+      def inject_require
+        RequireFileInjector.new(require_path).inject
+      end
+
+      def inject_config(path = 'config/enabled.yml')
+        config = File.readlines(path)
+        content = <<-YAML.strip_indent
+          #{badge}:
+            Description: 'TODO: Write a description of the cop.'
+            Enabled: true
+
+        YAML
+        target_line = config.find.with_index(1) do |line, index|
+          next if line =~ /^[\s#]/
+          break index - 1 if badge.to_s < line
+        end
+        config.insert(target_line, content)
+        File.write(path, config.join)
+      end
+
       def todo
         <<-TODO.strip_indent
-          created
-          - #{source_path}
-          - #{spec_path}
-
-          Do 4 steps
-          - Add an entry to `New feature` section in CHANGELOG.md
-            - e.g. Add new `#{badge.cop_name}` cop. ([@your_id][])
-          - Add `require '#{require_path}'` into lib/rubocop.rb
-          - Add an entry into config/enabled.yml or config/disabled.yml
-          - Implement a new cop to the generated file!
+          Files created:
+            - #{source_path}
+            - #{spec_path}
+          File modified:
+            - `require_relative '#{require_path}'` added into lib/rubocop.rb
+            - A configuration for the cop is added into config/enabled.yml
+              - If you want to disable the cop by default, move the added config to config/disabled.yml
+
+          Do 3 steps:
+            1. Add an entry to the "New features" section in CHANGELOG.md,
+               e.g. "Add new `#{badge}` cop. ([@your_id][])"
+            2. Modify the description of #{badge} in config/enabled.yml
+            3. Implement your new cop in the generated file!
         TODO
       end
 
@@ -111,7 +136,13 @@ module RuboCop
       attr_reader :badge
 
       def write_unless_file_exists(path, contents)
-        raise "#{path} already exists!" if File.exist?(path)
+        if File.exist?(path)
+          warn "rake new_cop: #{path} already exists!"
+          exit!
+        end
+
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir) unless File.exist?(dir)
 
         File.write(path, contents)
       end
@@ -158,6 +189,72 @@ module RuboCop
           .gsub(/([A-Z])([A-Z][^A-Z\d]+)/, '\1_\2')
           .downcase
       end
+
+      # A class that injects a require directive into the root RuboCop file.
+      # It looks for other directives that require files in the same (cop)
+      # namespace and injects the provided one in alpha
+      class RequireFileInjector
+        REQUIRE_PATH = /require_relative ['"](.+)['"]/
+
+        def initialize(require_path)
+          @require_path    = require_path
+          @require_entries = File.readlines(rubocop_root_file_path)
+        end
+
+        def inject
+          return if require_exists? || !target_line
+
+          File.write(rubocop_root_file_path, updated_directives)
+        end
+
+        private
+
+        attr_reader :require_path, :require_entries
+
+        def rubocop_root_file_path
+          File.join('lib', 'rubocop.rb')
+        end
+
+        def require_exists?
+          require_entries.any? do |entry|
+            entry == injectable_require_directive
+          end
+        end
+
+        def updated_directives
+          require_entries.insert(target_line,
+                                 injectable_require_directive).join
+        end
+
+        def target_line
+          @target_line ||= begin
+            in_the_same_department = false
+            inject_parts = require_path_fragments(injectable_require_directive)
+
+            require_entries.find.with_index do |entry, index|
+              current_entry_parts = require_path_fragments(entry)
+
+              if inject_parts[0..-2] == current_entry_parts[0..-2]
+                in_the_same_department = true
+
+                break index if inject_parts.last < current_entry_parts.last
+              elsif in_the_same_department
+                break index
+              end
+            end
+          end
+        end
+
+        def require_path_fragments(require_directove)
+          path = require_directove.match(REQUIRE_PATH)
+
+          path ? path.captures.first.split('/') : []
+        end
+
+        def injectable_require_directive
+          "require_relative '#{require_path}'\n"
+        end
+      end
     end
   end
 end

data/lib/rubocop/cop/internal_affairs.rb

@@ -1,4 +1,8 @@
 # frozen_string_literal: true
 
-require 'rubocop/cop/internal_affairs/node_type_predicate'
-require 'rubocop/cop/internal_affairs/useless_message_assertion'
+require_relative 'internal_affairs/node_destructuring'
+require_relative 'internal_affairs/node_type_predicate'
+require_relative 'internal_affairs/offense_location_keyword'
+require_relative 'internal_affairs/redundant_message_argument'
+require_relative 'internal_affairs/redundant_location_argument'
+require_relative 'internal_affairs/useless_message_assertion'

data/lib/rubocop/cop/internal_affairs/node_destructuring.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that node destructuring is done either using the node
+      # extensions or using a splat.
+      #
+      # @example Using splat expansion
+      #
+      #   # bad
+      #   receiver, method_name, arguments = send_node.children
+      #
+      #   # good
+      #   receiver, method_name, arguments = *send_node
+      #
+      # @example Using node extensions
+      #
+      #   # bad
+      #   _receiver, method_name, _arguments = send_node.children
+      #
+      #   # good
+      #   method_name = send_node.method_name
+      class NodeDestructuring < Cop
+        MSG = 'Use the methods provided with the node extensions, or ' \
+              'destructure the node using `*`.'.freeze
+
+        def_node_matcher :node_children_destructuring?, <<-PATTERN
+          (masgn (mlhs ...) (send (send nil? [#node_suffix? _]) :children))
+        PATTERN
+
+        def on_masgn(node)
+          node_children_destructuring?(node) do
+            add_offense(node)
+          end
+        end
+
+        private
+
+        def node_suffix?(method_name)
+          method_name.to_s.end_with?('node')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/node_type_predicate.rb

@@ -14,17 +14,28 @@ module RuboCop
       #   node.send_type?
       #
       class NodeTypePredicate < Cop
-        MSG = 'Use `#%s_type?` to check node type.'.freeze
+        MSG = 'Use `#%<type>s_type?` to check node type.'.freeze
 
-        def_node_search :node_type_check, <<-PATTERN
-          (send (send _ :type) :== (sym $_))
+        def_node_matcher :node_type_check, <<-PATTERN
+          (send (send $_ :type) :== (sym $_))
         PATTERN
 
         def on_send(node)
-          node_type_check(node) do |node_type|
+          node_type_check(node) do |_receiver, node_type|
             return unless Parser::Meta::NODE_TYPES.include?(node_type)
 
-            add_offense(node, :expression, format(MSG, node_type))
+            add_offense(node, message: format(MSG, type: node_type))
+          end
+        end
+
+        def autocorrect(node)
+          receiver, node_type = node_type_check(node)
+          range = Parser::Source::Range.new(node.source_range.source_buffer,
+                                            receiver.loc.expression.end_pos + 1,
+                                            node.loc.expression.end_pos)
+
+          lambda do |corrector|
+            corrector.replace(range, "#{node_type}_type?")
           end
         end
       end

data/lib/rubocop/cop/internal_affairs/offense_location_keyword.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for potential uses of the location keywords which can be used as
+      # shortcut arguments to `#add_offense`.
+      #
+      # @example
+      #
+      #   # bad
+      #   add_offense(node, location: node.loc.selector)
+      #
+      #   # good
+      #   add_offense(node, location: :selector)
+      class OffenseLocationKeyword < Cop
+        MSG = 'Use `:%<keyword>s` as the location argument to ' \
+              '`#add_offense`.'.freeze
+
+        def on_send(node)
+          node_type_check(node) do |node_arg, kwargs|
+            find_offending_argument(node_arg, kwargs) do |location, keyword|
+              add_offense(location, message: format(MSG, keyword: keyword))
+            end
+          end
+        end
+
+        def autocorrect(node)
+          (*, keyword) = offending_location_argument(node.parent)
+
+          ->(corrector) { corrector.replace(node.source_range, ":#{keyword}") }
+        end
+
+        private
+
+        def_node_matcher :node_type_check, <<-PATTERN
+          (send nil? :add_offense $_node $hash)
+        PATTERN
+
+        def_node_matcher :offending_location_argument, <<-PATTERN
+          (pair (sym :location) $(send (send $_node :loc) $_keyword))
+        PATTERN
+
+        def find_offending_argument(searched_node, kwargs)
+          kwargs.pairs.each do |pair|
+            offending_location_argument(pair) do |location, node, keyword|
+              yield(location, keyword) if searched_node == node
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/redundant_location_argument.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for redundant `location` argument to `#add_offense`. `location`
+      # argument has a default value of `:expression` and this method will
+      # automatically use it.
+      #
+      # @example
+      #
+      #   # bad
+      #   add_offense(node, location: :expression)
+      #
+      #   # good
+      #   add_offense(node)
+      #   add_offense(node, location: :selector)
+      #
+      class RedundantLocationArgument < Cop
+        MSG = 'Redundant location argument to `#add_offense`.'.freeze
+
+        def_node_matcher :add_offense_kwargs, <<-PATTERN
+          (send nil? :add_offense _ $hash)
+        PATTERN
+
+        def_node_matcher :redundant_location_argument?, <<-PATTERN
+          (pair (sym :location) (sym :expression))
+        PATTERN
+
+        def on_send(node)
+          redundant_location_argument(node) { |argument| add_offense(argument) }
+        end
+
+        def autocorrect(node)
+          range = offending_range(node)
+
+          ->(corrector) { corrector.remove(range) }
+        end
+
+        private
+
+        def redundant_location_argument(node)
+          add_offense_kwargs(node) do |kwargs|
+            result =
+              kwargs.pairs.find { |arg| redundant_location_argument?(arg) }
+
+            yield result if result
+          end
+        end
+
+        def offending_range(node)
+          with_space = range_with_surrounding_space(range: node.loc.expression)
+
+          range_with_surrounding_comma(with_space, :left)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/redundant_message_argument.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for redundant message arguments to `#add_offense`. This method
+      # will automatically use `#message` or `MSG` (in that order of priority)
+      # if they are defined.
+      #
+      # @example
+      #
+      #   # bad
+      #   add_offense(node, message: MSG)
+      #   add_offense(node, message: message)
+      #   add_offense(node, message: message(node))
+      #
+      #   # good
+      #   add_offense(node)
+      #   add_offense(node, message: CUSTOM_MSG)
+      #   add_offense(node, message: message(other_node))
+      #
+      class RedundantMessageArgument < Cop
+        MSG = 'Redundant message argument to `#add_offense`.'.freeze
+
+        def_node_matcher :node_type_check, <<-PATTERN
+          (send nil? :add_offense $_node $hash)
+        PATTERN
+
+        def_node_matcher :redundant_message_argument, <<-PATTERN
+          (pair
+            (sym :message)
+            ${(const nil? :MSG) (send nil? :message) (send nil? :message _)})
+        PATTERN
+
+        def_node_matcher :message_method_call, '(send nil? :message $_node)'
+
+        def on_send(node)
+          node_type_check(node) do |node_arg, kwargs|
+            find_offending_argument(node_arg, kwargs) do |pair|
+              add_offense(pair)
+            end
+          end
+        end
+
+        def autocorrect(node)
+          range = offending_range(node)
+
+          ->(corrector) { corrector.remove(range) }
+        end
+
+        private
+
+        def offending_range(node)
+          with_space = range_with_surrounding_space(range: node.loc.expression)
+
+          range_with_surrounding_comma(with_space, :left)
+        end
+
+        def find_offending_argument(searched_node, kwargs)
+          kwargs.pairs.each do |pair|
+            redundant_message_argument(pair) do |message_argument|
+              node = message_method_call(message_argument)
+
+              yield pair if !node || node == searched_node
+            end
+          end
+        end
+      end
+    end
+  end
+end