rubocop 1.22.1 → 1.24.0

data/lib/rubocop/cop/gemspec/required_ruby_version.rb

@@ -3,10 +3,11 @@
 module RuboCop
   module Cop
     module Gemspec
-      # Checks that `required_ruby_version` of gemspec is specified and
-      # equal to `TargetRubyVersion` of .rubocop.yml.
-      # Thereby, RuboCop to perform static analysis working on the version
-      # required by gemspec.
+      # Checks that `required_ruby_version` in a gemspec file is set to a valid
+      # value (non-blank) and matches `TargetRubyVersion` as set in RuboCop's
+      # configuration for the gem.
+      #
+      # This ensures that RuboCop is using the same Ruby version as the gem.
       #
       # @example
       #   # When `TargetRubyVersion` of .rubocop.yml is `2.5`.
@@ -26,6 +27,11 @@ module RuboCop
       #     spec.required_ruby_version = '>= 2.6.0'
       #   end
       #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     spec.required_ruby_version = ''
+      #   end
+      #
       #   # good
       #   Gem::Specification.new do |spec|
       #     spec.required_ruby_version = '>= 2.5.0'
@@ -49,15 +55,15 @@ module RuboCop
       class RequiredRubyVersion < Base
         include RangeHelp
 
-        NOT_EQUAL_MSG = '`required_ruby_version` (%<required_ruby_version>s, ' \
-                        'declared in %<gemspec_filename>s) and `TargetRubyVersion` ' \
+        RESTRICT_ON_SEND = %i[required_ruby_version=].freeze
+        NOT_EQUAL_MSG = '`required_ruby_version` and `TargetRubyVersion` ' \
                         '(%<target_ruby_version>s, which may be specified in ' \
                         '.rubocop.yml) should be equal.'
         MISSING_MSG = '`required_ruby_version` should be specified.'
 
-        # @!method required_ruby_version(node)
-        def_node_search :required_ruby_version, <<~PATTERN
-          (send _ :required_ruby_version= $_)
+        # @!method required_ruby_version?(node)
+        def_node_search :required_ruby_version?, <<~PATTERN
+          (send _ :required_ruby_version= _)
         PATTERN
 
         # @!method defined_ruby_version(node)
@@ -66,27 +72,28 @@ module RuboCop
             (send (const (const nil? :Gem) :Requirement) :new $(str _))}
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
         def on_new_investigation
-          version_def = required_ruby_version(processed_source.ast).first
+          add_global_offense(MISSING_MSG) unless required_ruby_version?(processed_source.ast)
+        end
 
-          if version_def
-            ruby_version = extract_ruby_version(defined_ruby_version(version_def))
-            return if !ruby_version || ruby_version == target_ruby_version.to_s
+        def on_send(node)
+          version_def = node.first_argument
+          return if dynamic_version?(version_def)
 
-            add_offense(
-              version_def.loc.expression,
-              message: not_equal_message(ruby_version, target_ruby_version)
-            )
-          else
-            range = source_range(processed_source.buffer, 1, 0)
-            add_offense(range, message: MISSING_MSG)
-          end
+          ruby_version = extract_ruby_version(defined_ruby_version(version_def))
+          return if ruby_version == target_ruby_version.to_s
+
+          add_offense(version_def, message: not_equal_message(ruby_version, target_ruby_version))
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
+        def dynamic_version?(node)
+          (node.send_type? && !node.receiver) ||
+            node.variable? ||
+            node.each_descendant(:send, *RuboCop::AST::Node::VARIABLES).any?
+        end
+
         def extract_ruby_version(required_ruby_version)
           return unless required_ruby_version
 

data/lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb

@@ -26,20 +26,13 @@ module RuboCop
       #   end
       #
       class RubyVersionGlobalsUsage < Base
+        include GemspecHelp
+
         MSG = 'Do not use `RUBY_VERSION` in gemspec file.'
 
         # @!method ruby_version?(node)
         def_node_matcher :ruby_version?, '(const {cbase nil?} :RUBY_VERSION)'
 
-        # @!method gem_specification?(node)
-        def_node_search :gem_specification?, <<~PATTERN
-          (block
-            (send
-              (const
-                (const {cbase nil?} :Gem) :Specification) :new)
-            ...)
-        PATTERN
-
         def on_const(node)
           return unless gem_spec_with_ruby_version?(node)
 
@@ -49,7 +42,7 @@ module RuboCop
         private
 
         def gem_spec_with_ruby_version?(node)
-          gem_specification?(processed_source.ast) && ruby_version?(node)
+          gem_specification(processed_source.ast) && ruby_version?(node)
         end
       end
     end

data/lib/rubocop/cop/generator.rb

@@ -150,7 +150,7 @@ module RuboCop
             1. Modify the description of #{badge} in config/default.yml
             2. Implement your new cop in the generated file!
             3. Commit your new cop with a message such as
-               e.g. "Add new `#{badge}` cop."
+               e.g. "Add new `#{badge}` cop"
             4. Run `bundle exec rake changelog:new` to generate a changelog entry
                for your new cop.
         TODO

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # This cop enforces the use of `same_line?` instead of location line comparison for equality.
+      #
+      # @example
+      #   # bad
+      #   node.loc.line == node.parent.loc.line
+      #
+      #   # bad
+      #   node.loc.first_line == node.parent.loc.first_line
+      #
+      #   # good
+      #   same_line?(node, node.parent)
+      #
+      class LocationLineEqualityComparison < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<preferred>s`.'
+
+        # @!method line_send(node)
+        def_node_matcher :line_send, <<~PATTERN
+          {
+            (send (send _ {:loc :source_range}) {:line :first_line})
+            (send _ :first_line)
+          }
+        PATTERN
+
+        # @!method location_line_equality_comparison?(node)
+        def_node_matcher :location_line_equality_comparison?, <<~PATTERN
+          (send #line_send :== #line_send)
+        PATTERN
+
+        def on_send(node)
+          return unless location_line_equality_comparison?(node)
+
+          lhs, _op, rhs = *node
+
+          lhs_receiver = extract_receiver(lhs)
+          rhs_receiver = extract_receiver(rhs)
+          preferred = "same_line?(#{lhs_receiver}, #{rhs_receiver})"
+
+          add_offense(node, message: format(MSG, preferred: preferred)) do |corrector|
+            corrector.replace(node, preferred)
+          end
+        end
+
+        private
+
+        def extract_receiver(node)
+          receiver = node.receiver
+          receiver = receiver.receiver if receiver.method?(:loc) || receiver.method?(:source_range)
+          receiver.source
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for redundant `send_node` method dispatch node.
+      #
+      # @example
+      #
+      #   # bad
+      #   node.send_node.method_name
+      #
+      #   # good
+      #   node.method_name
+      #
+      #   # bad
+      #   node.send_node.receiver
+      #
+      #   # good
+      #   node.receiver
+      #
+      class RedundantMethodDispatchNode < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `send_node`.'
+        RESTRICT_ON_SEND = %i[method_name receiver].freeze
+
+        # @!method dispatch_method(node)
+        def_node_matcher :dispatch_method, <<~PATTERN
+          (send $(send _ :send_node) _)
+        PATTERN
+
+        def on_send(node)
+          return unless (dispatch_node = dispatch_method(node))
+
+          range = range_between(dispatch_node.loc.dot.begin_pos, dispatch_node.loc.selector.end_pos)
+
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -14,7 +14,9 @@ module RuboCop
 
         # @!method cop_class_def(node)
         def_node_search :cop_class_def, <<~PATTERN
-          (class _ (const _ {:Base :Cop}) ...)
+          (class _
+            (const {nil? (const nil? :Cop) (const (const {cbase nil?} :RuboCop) :Cop)}
+              {:Base :Cop}) ...)
         PATTERN
 
         # @!method cop_config_accessor?(node)

data/lib/rubocop/cop/internal_affairs.rb

@@ -3,6 +3,7 @@
 require_relative 'internal_affairs/empty_line_between_expect_offense_and_correction'
 require_relative 'internal_affairs/example_description'
 require_relative 'internal_affairs/inherit_deprecated_cop_class'
+require_relative 'internal_affairs/location_line_equality_comparison'
 require_relative 'internal_affairs/method_name_equal'
 require_relative 'internal_affairs/node_destructuring'
 require_relative 'internal_affairs/node_matcher_directive'
@@ -12,6 +13,7 @@ require_relative 'internal_affairs/redundant_described_class_as_subject'
 require_relative 'internal_affairs/redundant_let_rubocop_config_new'
 require_relative 'internal_affairs/redundant_location_argument'
 require_relative 'internal_affairs/redundant_message_argument'
+require_relative 'internal_affairs/redundant_method_dispatch_node'
 require_relative 'internal_affairs/style_detected_api_use'
 require_relative 'internal_affairs/undefined_config'
 require_relative 'internal_affairs/useless_message_assertion'

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

@@ -33,7 +33,7 @@ module RuboCop
         def check_assignment(node, rhs)
           return unless rhs
           return unless node.loc.operator
-          return if node.loc.operator.line == rhs.first_line
+          return if same_line?(node.loc.operator, rhs)
 
           base = display_column(leftmost_multiple_assignment(node).source_range)
           check_alignment([rhs], base + configured_indentation_width)

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

@@ -101,11 +101,11 @@ module RuboCop
         def block_end_align_target(node)
           lineage = [node, *node.ancestors]
 
-          target = lineage.each_cons(2) do |current, parent|
-            break current if end_align_target?(current, parent)
+          lineage.each_cons(2) do |current, parent|
+            return current if end_align_target?(current, parent)
           end
 
-          target || lineage.last
+          lineage.last
         end
 
         def end_align_target?(node, parent)

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

@@ -32,6 +32,19 @@ module RuboCop
       #     true
       #   end
       #
+      # @example AllowForAlignment: false (default)
+      #   # bad
+      #   a = 1 # A really long comment
+      #         # spanning two lines.
+      #
+      #   # good
+      #   # A really long comment spanning one line.
+      #   a = 1
+      #
+      # @example AllowForAlignment: true
+      #   # good
+      #   a = 1 # A really long comment
+      #         # spanning two lines.
       class CommentIndentation < Base
         include Alignment
         extend AutoCorrector
@@ -40,7 +53,7 @@ module RuboCop
               'instead of %<correct_comment_indentation>d).'
 
         def on_new_investigation
-          processed_source.comments.each { |comment| check(comment) }
+          processed_source.comments.each_with_index { |comment, ix| check(comment, ix) }
         end
 
         private
@@ -76,7 +89,7 @@ module RuboCop
           AlignmentCorrector.correct(corrector, processed_source, comment, @column_delta)
         end
 
-        def check(comment)
+        def check(comment, comment_index)
           return unless own_line_comment?(comment)
 
           next_line = line_after_comment(comment)
@@ -94,11 +107,27 @@ module RuboCop
             return if column == correct_comment_indentation
           end
 
+          return if correctly_aligned_with_preceding_comment?(comment_index, column)
+
           add_offense(comment, message: message(column, correct_comment_indentation)) do |corrector|
             autocorrect(corrector, comment)
           end
         end
 
+        # Returns true if:
+        # a) the cop is configured to allow extra indentation for alignment, and
+        # b) the currently inspected comment is aligned with the nearest preceding end-of-line
+        #    comment.
+        def correctly_aligned_with_preceding_comment?(comment_index, column)
+          return false unless cop_config['AllowForAlignment']
+
+          processed_source.comments[0...comment_index].reverse_each do |other_comment|
+            return other_comment.loc.column == column unless own_line_comment?(other_comment)
+          end
+
+          false
+        end
+
         def message(column, correct_comment_indentation)
           format(MSG, column: column, correct_comment_indentation: correct_comment_indentation)
         end

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

@@ -27,6 +27,10 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
+        def self.autocorrect_incompatible_with
+          [Style::RedundantSelf]
+        end
+
         def on_send(node)
           return unless node.dot? || ampersand_dot?(node)
 
@@ -68,18 +72,14 @@ module RuboCop
         end
 
         def proper_dot_position?(node)
-          selector_line = selector_range(node).line
+          selector_range = selector_range(node)
 
-          # If the receiver is a HEREDOC and the selector is on the same line
-          # then there is nothing to do
-          return true if heredoc?(node.receiver) && node.receiver.loc.first_line == selector_line
+          return true if same_line?(selector_range, end_range(node.receiver))
 
+          selector_line = selector_range.line
           receiver_line = receiver_end_line(node.receiver)
           dot_line = node.loc.dot.line
 
-          # receiver and selector are on the same line
-          return true if selector_line == receiver_line
-
           # don't register an offense if there is a line comment between the
           # dot and the selector otherwise, we might break the code while
           # "correcting" it (even if there is just an extra blank line, treat
@@ -123,7 +123,13 @@ module RuboCop
           (node.str_type? || node.dstr_type?) && node.heredoc?
         end
 
+        def end_range(node)
+          node.source_range.end
+        end
+
         def selector_range(node)
+          return node unless node.call_type?
+
           # l.(1) has no selector, so we use the opening parenthesis instead
           node.loc.selector || node.loc.begin
         end

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

@@ -96,7 +96,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           previous_token = previous_token(node)
-          range = if previous_token && node.loc.line == previous_token.line
+          range = if previous_token && same_line?(node, previous_token)
                     range_with_surrounding_space(range: node.loc.expression, newlines: false)
                   else
                     range_by_whole_lines(node.loc.expression, include_final_newline: true)

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

@@ -77,13 +77,34 @@ module RuboCop
       #   def b
       #   end
       #
-      # @example AllowAdjacentOneLineDefs: true
+      # @example AllowAdjacentOneLineDefs: true (default)
       #
       #   # good
       #   class ErrorA < BaseError; end
       #   class ErrorB < BaseError; end
       #   class ErrorC < BaseError; end
       #
+      #   # good
+      #   class ErrorA < BaseError; end
+      #
+      #   class ErrorB < BaseError; end
+      #
+      #   class ErrorC < BaseError; end
+      #
+      # @example AllowAdjacentOneLineDefs: false
+      #
+      #   # bad
+      #   class ErrorA < BaseError; end
+      #   class ErrorB < BaseError; end
+      #   class ErrorC < BaseError; end
+      #
+      #   # good
+      #   class ErrorA < BaseError; end
+      #
+      #   class ErrorB < BaseError; end
+      #
+      #   class ErrorC < BaseError; end
+      #
       class EmptyLineBetweenDefs < Base
         include RangeHelp
         extend AutoCorrector

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

@@ -65,21 +65,24 @@ module RuboCop
         MSG = 'Extra empty line detected %<location>s the `%<keyword>s`.'
 
         def on_def(node)
-          check_body(node.body)
+          check_body(node.body, node.loc.line)
         end
         alias on_defs on_def
 
         def on_kwbegin(node)
           body, = *node
-          check_body(body)
+          check_body(body, node.loc.line)
         end
 
         private
 
-        def check_body(node)
-          locations = keyword_locations(node)
+        def check_body(body, line_of_def_or_kwbegin)
+          locations = keyword_locations(body)
+
           locations.each do |loc|
             line = loc.line
+            next if line == line_of_def_or_kwbegin
+
             keyword = loc.source
             # below the keyword
             check_line(style, line, message('after', keyword), &:empty?)

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

@@ -165,8 +165,7 @@ module RuboCop
         end
 
         def alignment_node_for_variable_style(node)
-          return node.parent if node.case_type? && node.argument? &&
-                                node.loc.line == node.parent.loc.line
+          return node.parent if node.case_type? && node.argument? && same_line?(node, node.parent)
 
           assignment = assignment_or_operator_method(node)
 

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

@@ -115,7 +115,7 @@ module RuboCop
           left_bracket = array_node.loc.begin
           first_elem = array_node.values.first
           if first_elem
-            return if first_elem.source_range.line == left_bracket.line
+            return if same_line?(first_elem, left_bracket)
 
             check_first(first_elem, left_bracket, left_parenthesis, 0)
           end

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

@@ -116,7 +116,7 @@ module RuboCop
           first_pair = hash_node.pairs.first
 
           if first_pair
-            return if first_pair.first_line == left_brace.line
+            return if same_line?(first_pair, left_brace)
 
             if separator_style?(first_pair)
               check_based_on_longest_key(hash_node, left_brace, left_parenthesis)

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

@@ -74,7 +74,7 @@ module RuboCop
           left_parenthesis = def_node.arguments.loc.begin
           first_elem = def_node.arguments.first
           return unless first_elem
-          return if first_elem.source_range.line == left_parenthesis.line
+          return if same_line?(first_elem, left_parenthesis)
 
           check_first(first_elem, left_parenthesis, nil, 0)
         end

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

@@ -224,7 +224,7 @@ module RuboCop
 
           parent_loc = node.parent.loc
           selector = parent_loc.selector || parent_loc.expression
-          selector.line == node.pairs.first.loc.line
+          same_line?(selector, node.pairs.first)
         end
 
         def reset!
@@ -313,7 +313,7 @@ module RuboCop
           # just give each lambda the same reference and they would all get the
           # last value of each. A local variable fixes the problem.
 
-          if node.value
+          if node.value && node.respond_to?(:value_omission?) && !node.value_omission?
             correct_key_value(corrector, delta, node.key.source_range,
                               node.value.source_range,
                               node.loc.operator)

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

@@ -167,7 +167,7 @@ module RuboCop
 
           end_of_outer_send = outermost_send.loc.end
 
-          end_of_outer_send.line == end_of_last_arg_of_outer_send.line &&
+          same_line?(end_of_outer_send, end_of_last_arg_of_outer_send) &&
             end_of_outer_send.column == end_of_last_arg_of_outer_send.column + 1
         end
 

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

@@ -341,7 +341,7 @@ module RuboCop
           return true unless body_node
 
           # Don't check if expression is on same line as "then" keyword, etc.
-          return true if body_node.loc.line == base_loc.line
+          return true if same_line?(body_node, base_loc)
 
           return true if starts_with_access_modifier?(body_node)
 

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

@@ -137,7 +137,7 @@ module RuboCop
           range = semicolon_token.pos
           end_pos = range.end_pos
           next_range = range_between(end_pos, end_pos + 1)
-          return nil unless next_range.line == range.line
+          return nil unless same_line?(next_range, range)
 
           next_char = next_range.source
           return nil if /[\r\n]/.match?(next_char)

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

@@ -88,7 +88,7 @@ module RuboCop
         end
 
         def check_new_line_offense(node, rhs)
-          return unless node.loc.operator.line == rhs.first_line
+          return unless same_line?(node.loc.operator, rhs)
 
           add_offense(node, message: NEW_LINE_OFFENSE) do |corrector|
             corrector.insert_after(node.loc.operator, "\n")

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

@@ -63,7 +63,7 @@ module RuboCop
             add_offense_for_expression(node, node.arguments, ARG_MSG)
           end
 
-          return unless node.body && node.loc.begin.line == node.body.first_line
+          return unless node.body && same_line?(node.loc.begin, node.body)
 
           add_offense_for_expression(node, node.body, MSG)
         end
@@ -110,7 +110,7 @@ module RuboCop
 
           expr_before_body ||= node.loc.begin
 
-          return unless expr_before_body.line == node.body.first_line
+          return unless same_line?(expr_before_body, node.body)
 
           autocorrect_body(corrector, node, node.body)
         end

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

@@ -75,7 +75,7 @@ module RuboCop
         def right_hand_side(send_node)
           dot = send_node.loc.dot
           selector = send_node.loc.selector
-          if send_node.dot? && selector && dot.line == selector.line
+          if send_node.dot? && selector && same_line?(dot, selector)
             dot.join(selector)
           elsif selector
             selector

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

@@ -61,7 +61,7 @@ module RuboCop
           alignment_loc = alignment_location(alignment_node)
           kw_loc        = node.loc.keyword
 
-          return if alignment_loc.column == kw_loc.column || alignment_loc.line == kw_loc.line
+          return if alignment_loc.column == kw_loc.column || same_line?(alignment_loc, kw_loc)
 
           add_offense(
             kw_loc, message: format_message(alignment_node, alignment_loc, kw_loc)

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

@@ -19,7 +19,7 @@ module RuboCop
         MSG = 'Space missing after colon.'
 
         def on_pair(node)
-          return unless node.colon?
+          return if !node.colon? || node.value_omission?
 
           colon = node.loc.operator
 

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

@@ -20,7 +20,7 @@ module RuboCop
         def on_new_investigation
           processed_source.sorted_tokens.each_cons(2) do |token1, token2|
             next unless token2.comment?
-            next unless token1.line == token2.line
+            next unless same_line?(token1, token2)
             next unless token1.pos.end == token2.pos.begin
 
             range = token2.pos

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

@@ -28,6 +28,10 @@ module RuboCop
 
         MSG = 'Put one space between the method name and the first argument.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           return unless regular_method_call_with_arguments?(node)