rubocop 0.78.0

data/lib/rubocop/cop/generator/configuration_injector.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    class Generator
+      # 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 ConfigurationInjector
+        TEMPLATE = <<~YAML
+          %<badge>s:
+            Description: 'TODO: Write a description of the cop.'
+            Enabled: true
+            VersionAdded: '%<version_added>s'
+        YAML
+
+        def initialize(configuration_file_path:, badge:, version_added:)
+          @configuration_file_path = configuration_file_path
+          @badge = badge
+          @version_added = version_added
+          @output = output
+        end
+
+        def inject
+          target_line = find_target_line
+          if target_line
+            configuration_entries.insert(target_line,
+                                         new_configuration_entry + "\n")
+          else
+            configuration_entries.push("\n" + new_configuration_entry)
+          end
+
+          File.write(configuration_file_path, configuration_entries.join)
+
+          yield if block_given?
+        end
+
+        private
+
+        attr_reader :configuration_file_path, :badge, :version_added, :output
+
+        def configuration_entries
+          @configuration_entries ||= File.readlines(configuration_file_path)
+        end
+
+        def new_configuration_entry
+          format(TEMPLATE, badge: badge, version_added: version_added)
+        end
+
+        def find_target_line
+          configuration_entries.find.with_index do |line, index|
+            next unless cop_name_line?(line)
+
+            return index if badge.to_s < line
+          end
+
+          nil
+        end
+
+        def cop_name_line?(yaml)
+          yaml !~ /^[\s#]/
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/generator/require_file_injector.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    class Generator
+      # 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 ['"](.+)['"]/.freeze
+
+        def initialize(source_path:, root_file_path:, output: $stdout)
+          @source_path = Pathname(source_path)
+          @root_file_path = Pathname(root_file_path)
+          @require_entries = File.readlines(root_file_path)
+          @output = output
+        end
+
+        def inject
+          return if require_exists? || !target_line
+
+          File.write(root_file_path, updated_directives)
+          require = injectable_require_directive.chomp
+          output.puts "[modify] #{root_file_path} - `#{require}` was injected."
+        end
+
+        private
+
+        attr_reader :require_entries, :root_file_path, :source_path, :output
+
+        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 || require_entries.size
+          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
+
+        def require_path
+          path = source_path.relative_path_from(root_file_path.dirname)
+          path.to_s.sub('.rb', '')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/ignored_node.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Handles adding and checking ignored nodes.
+    module IgnoredNode
+      def ignore_node(node)
+        ignored_nodes << node
+      end
+
+      def part_of_ignored_node?(node)
+        ignored_nodes.map(&:loc).any? do |ignored_loc|
+          if ignored_loc.expression.begin_pos > node.source_range.begin_pos
+            next false
+          end
+
+          ignored_end_pos = if ignored_loc.respond_to?(:heredoc_body)
+                              ignored_loc.heredoc_end.end_pos
+                            else
+                              ignored_loc.expression.end_pos
+                            end
+          ignored_end_pos >= node.source_range.end_pos
+        end
+      end
+
+      def ignored_node?(node)
+        # Same object found in array?
+        ignored_nodes.any? { |n| n.equal?(node) }
+      end
+
+      private
+
+      def ignored_nodes
+        @ignored_nodes ||= []
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'internal_affairs/method_name_equal'
+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/method_name_equal.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that method names are checked using `method?` method.
+      #
+      # @example
+      #   # bad
+      #   node.method_name == :do_something
+      #
+      #   # good
+      #   node.method?(:do_something)
+      #
+      class MethodNameEqual < Cop
+        include RangeHelp
+
+        MSG = 'Use `method?(%<method_name>s)` instead of ' \
+              '`method_name == %<method_name>s`.'
+
+        def_node_matcher :method_name?, <<~PATTERN
+          (send
+            $(send
+              (...) :method_name) :==
+            $...)
+        PATTERN
+
+        def on_send(node)
+          method_name?(node) do |method_name_node, method_name_arg|
+            message = format(MSG, method_name: method_name_arg.first.source)
+
+            range = range(method_name_node, node)
+
+            add_offense(node, location: range, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            method_name?(node) do |method_name_node, method_name_arg|
+              corrector.replace(
+                range(method_name_node, node),
+                "method?(#{method_name_arg.first.source})"
+              )
+            end
+          end
+        end
+
+        private
+
+        def range(method_name_node, node)
+          range_between(
+            method_name_node.loc.selector.begin_pos, node.source_range.end_pos
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that node destructuring is using the node extensions.
+      #
+      # @example Using splat expansion
+      #
+      #   # bad
+      #   _receiver, method_name, _arguments = send_node.children
+      #
+      #   # bad
+      #   _receiver, method_name, _arguments = *send_node
+      #
+      #   # good
+      #   method_name = send_node.method_name
+      class NodeDestructuring < Cop
+        MSG = 'Use the methods provided with the node extensions instead ' \
+              'of manually destructuring nodes.'
+
+        def_node_matcher :node_variable?, <<~PATTERN
+          {(lvar [#node_suffix? _]) (send nil? [#node_suffix? _])}
+        PATTERN
+
+        def_node_matcher :node_destructuring?, <<~PATTERN
+          {(masgn (mlhs ...) {(send #node_variable? :children) (array (splat #node_variable?))})}
+        PATTERN
+
+        def on_masgn(node)
+          node_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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that node types are checked using the predicate helpers.
+      #
+      # @example
+      #
+      #   # bad
+      #   node.type == :send
+      #
+      #   # good
+      #   node.send_type?
+      #
+      class NodeTypePredicate < Cop
+        MSG = 'Use `#%<type>s_type?` to check node type.'
+
+        def_node_matcher :node_type_check, <<~PATTERN
+          (send (send $_ :type) :== (sym $_))
+        PATTERN
+
+        def on_send(node)
+          node_type_check(node) do |_receiver, node_type|
+            return unless Parser::Meta::NODE_TYPES.include?(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
+    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`.'
+
+        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,48 @@
+# 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
+        include RangeHelp
+
+        MSG = 'Redundant location argument to `#add_offense`.'
+
+        def_node_matcher :redundant_location_argument, <<~PATTERN
+          (send nil? :add_offense _
+            (hash <$(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
+
+        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