rubocop 0.87.1

data/lib/rubocop/cop/ignored_node.rb

@@ -0,0 +1,36 @@
+# 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|
+          next false if ignored_loc.expression.begin_pos > node.source_range.begin_pos
+
+          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,41 @@
+# 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 < Base
+        extend AutoCorrector
+
+        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)
+
+            message = format(MSG, type: node_type)
+            add_offense(node, message: message) do |corrector|
+              range = node.loc.expression.with(
+                begin_pos: receiver.loc.expression.end_pos + 1
+              )
+              corrector.replace(range, "#{node_type}_type?")
+            end
+          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, ":#{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

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

@@ -0,0 +1,73 @@
+# 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
+        include RangeHelp
+
+        MSG = 'Redundant message argument to `#add_offense`.'
+
+        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

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that cops are not tested using `described_class::MSG`.
+      #
+      # @example
+      #
+      #     # bad
+      #     expect(cop.messages).to eq([described_class::MSG])
+      #
+      #     # good
+      #     expect(cop.messages).to eq(['Do not write bad code like that.'])
+      #
+      class UselessMessageAssertion < Cop
+        MSG = 'Do not specify cop behavior using `described_class::MSG`.'
+
+        def_node_search :described_class_msg, <<~PATTERN
+          (const (send nil? :described_class) :MSG)
+        PATTERN
+
+        def_node_matcher :rspec_expectation_on_msg?, <<~PATTERN
+          (send (send nil? :expect #contains_described_class_msg?) :to ...)
+        PATTERN
+
+        def investigate(_processed_source)
+          assertions_using_described_class_msg.each do |node|
+            add_offense(node)
+          end
+        end
+
+        private
+
+        def contains_described_class_msg?(node)
+          described_class_msg(node).any?
+        end
+
+        def assertions_using_described_class_msg
+          described_class_msg(processed_source.ast).reject do |node|
+            node.ancestors.any?(&method(:rspec_expectation_on_msg?))
+          end
+        end
+
+        # Only process spec files
+        def relevant_file?(file)
+          file.end_with?('_spec.rb')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/access_modifier_indentation.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Bare access modifiers (those not applying to specific methods) should be
+      # indented as deep as method definitions, or as deep as the class/module
+      # keyword, depending on configuration.
+      #
+      # @example EnforcedStyle: indent (default)
+      #   # bad
+      #   class Plumbus
+      #   private
+      #     def smooth; end
+      #   end
+      #
+      #   # good
+      #   class Plumbus
+      #     private
+      #     def smooth; end
+      #   end
+      #
+      # @example EnforcedStyle: outdent
+      #   # bad
+      #   class Plumbus
+      #     private
+      #     def smooth; end
+      #   end
+      #
+      #   # good
+      #   class Plumbus
+      #   private
+      #     def smooth; end
+      #   end
+      class AccessModifierIndentation < Cop
+        include Alignment
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG = '%<style>s access modifiers like `%<node>s`.'
+
+        def on_class(node)
+          return unless node.body&.begin_type?
+
+          check_body(node.body, node)
+        end
+        alias on_sclass on_class
+        alias on_module on_class
+        alias on_block  on_class
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
+        end
+
+        private
+
+        def check_body(body, node)
+          modifiers = body.each_child_node(:send)
+                          .select(&:bare_access_modifier?)
+          end_range = node.loc.end
+
+          modifiers.each { |modifier| check_modifier(modifier, end_range) }
+        end
+
+        def check_modifier(send_node, end_range)
+          offset = column_offset_between(send_node.source_range, end_range)
+
+          @column_delta = expected_indent_offset - offset
+          if @column_delta.zero?
+            correct_style_detected
+          else
+            add_offense(send_node) do
+              if offset == unexpected_indent_offset
+                opposite_style_detected
+              else
+                unrecognized_style_detected
+              end
+            end
+          end
+        end
+
+        def message(node)
+          format(MSG, style: style.capitalize, node: node.loc.selector.source)
+        end
+
+        def expected_indent_offset
+          style == :outdent ? 0 : configured_indentation_width
+        end
+
+        # An offset that is not expected, but correct if the configuration is
+        # changed.
+        def unexpected_indent_offset
+          configured_indentation_width - expected_indent_offset
+        end
+      end
+    end
+  end
+end