rubocop 1.41.1 → 1.57.1

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

@@ -3,7 +3,23 @@
 module RuboCop
   module Cop
     module Layout
-      # Enforces empty line after guard clause
+      # Enforces empty line after guard clause.
+      #
+      # This cop allows `# :nocov:` directive after guard clause because
+      # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
+      #
+      # [source,ruby]
+      # ----
+      # def foo
+      #   # :nocov:
+      #   return if condition
+      #   # :nocov:
+      #   bar
+      # end
+      # ----
+      #
+      # Refer to SimpleCov's documentation for more details:
+      # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
       #
       # @example
       #
@@ -42,19 +58,22 @@ module RuboCop
 
         MSG = 'Add empty line after guard clause.'
         END_OF_HEREDOC_LINE = 1
+        SIMPLE_DIRECTIVE_COMMENT_PATTERN = /\A# *:nocov:\z/.freeze
 
         def on_if(node)
           return if correct_style?(node)
           return if multiple_statements_on_line?(node)
 
           if node.modifier_form? && (heredoc_node = last_heredoc_argument(node))
-            return if next_line_empty_or_enable_directive_comment?(heredoc_line(node, heredoc_node))
+            if next_line_empty_or_allowed_directive_comment?(heredoc_line(node, heredoc_node))
+              return
+            end
 
             add_offense(heredoc_node.loc.heredoc_end) do |corrector|
               autocorrect(corrector, heredoc_node)
             end
           else
-            return if next_line_empty_or_enable_directive_comment?(node.last_line)
+            return if next_line_empty_or_allowed_directive_comment?(node.last_line)
 
             add_offense(offense_location(node)) { |corrector| autocorrect(corrector, node) }
           end
@@ -70,7 +89,7 @@ module RuboCop
                        end
 
           next_line = node_range.last_line + 1
-          if next_line_enable_directive_comment?(next_line)
+          if next_line_allowed_directive_comment?(next_line)
             node_range = processed_source.comment_at_line(next_line)
           end
 
@@ -88,21 +107,21 @@ module RuboCop
           node.if_branch&.guard_clause?
         end
 
-        def next_line_empty_or_enable_directive_comment?(line)
+        def next_line_empty_or_allowed_directive_comment?(line)
           return true if next_line_empty?(line)
 
           next_line = line + 1
-          next_line_enable_directive_comment?(next_line) && next_line_empty?(next_line)
+          next_line_allowed_directive_comment?(next_line) && next_line_empty?(next_line)
         end
 
         def next_line_empty?(line)
           processed_source[line].blank?
         end
 
-        def next_line_enable_directive_comment?(line)
+        def next_line_allowed_directive_comment?(line)
           return false unless (comment = processed_source.comment_at_line(line))
 
-          DirectiveComment.new(comment).enabled?
+          DirectiveComment.new(comment).enabled? || simplecov_directive_comment?(comment)
         end
 
         def next_line_rescue_or_ensure?(node)
@@ -137,7 +156,7 @@ module RuboCop
             return node if node
           end
 
-          return last_heredoc_argument(n.receiver) if n.respond_to?(:receiver)
+          last_heredoc_argument(n.receiver) if n.respond_to?(:receiver)
         end
 
         def last_heredoc_argument_node(node)
@@ -145,6 +164,8 @@ module RuboCop
 
           if node.if_branch.and_type?
             node.if_branch.children.first
+          elsif use_heredoc_in_condition?(node.condition)
+            node.condition
           else
             node.if_branch.children.last
           end
@@ -161,6 +182,12 @@ module RuboCop
           node.respond_to?(:heredoc?) && node.heredoc?
         end
 
+        def use_heredoc_in_condition?(condition)
+          condition.descendants.any? do |descendant|
+            descendant.respond_to?(:heredoc?) && descendant.heredoc?
+          end
+        end
+
         def offense_location(node)
           if node.loc.respond_to?(:end) && node.loc.end
             node.loc.end
@@ -175,6 +202,12 @@ module RuboCop
 
           parent.begin_type? && parent.single_line?
         end
+
+        # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
+        # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
+        def simplecov_directive_comment?(comment)
+          SIMPLE_DIRECTIVE_COMMENT_PATTERN.match?(comment.text)
+        end
       end
     end
   end

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

@@ -135,7 +135,8 @@ module RuboCop
           return if nodes.all?(&:single_line?) && cop_config['AllowAdjacentOneLineDefs']
 
           correction_node = nodes.last
-          location = correction_node.loc.keyword.join(correction_node.loc.name)
+
+          location = def_location(correction_node)
           add_offense(location, message: message(correction_node, count: count)) do |corrector|
             autocorrect(corrector, *nodes, count)
           end
@@ -159,10 +160,28 @@ module RuboCop
 
         private
 
+        def def_location(correction_node)
+          if correction_node.block_type?
+            correction_node.source_range.join(correction_node.children.first.source_range)
+          else
+            correction_node.loc.keyword.join(correction_node.loc.name)
+          end
+        end
+
         def candidate?(node)
-          return unless node
+          return false unless node
 
-          method_candidate?(node) || class_candidate?(node) || module_candidate?(node)
+          method_candidate?(node) || class_candidate?(node) || module_candidate?(node) ||
+            macro_candidate?(node)
+        end
+
+        def empty_line_between_macros
+          cop_config.fetch('DefLikeMacros', []).map(&:to_sym)
+        end
+
+        def macro_candidate?(node)
+          node.block_type? && node.children.first.macro? &&
+            empty_line_between_macros.include?(node.children.first.method_name)
         end
 
         def method_candidate?(node)
@@ -226,7 +245,11 @@ module RuboCop
         end
 
         def def_start(node)
-          node.loc.keyword.line
+          if node.block_type? && node.children.first.send_type?
+            node.source_range.line
+          else
+            node.loc.keyword.line
+          end
         end
 
         def def_end(node)
@@ -235,7 +258,7 @@ module RuboCop
 
         def end_loc(node)
           if (node.def_type? || node.defs_type?) && node.endless?
-            node.loc.expression.end
+            node.source_range.end
           else
             node.loc.end
           end

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

@@ -31,7 +31,7 @@ module RuboCop
           return unless processed_source.raw_source.include?("\n\n\n")
 
           lines = Set.new
-          processed_source.each_token { |token| lines << token.line }
+          processed_source.tokens.each { |token| lines << token.line }
 
           each_extra_empty_line(lines.sort) do |range|
             add_offense(range) do |corrector|

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

@@ -51,6 +51,8 @@ module RuboCop
         MSG_BEFORE_FOR_ONLY_BEFORE = 'Keep a blank line before `%<modifier>s`.'
         MSG_AFTER_FOR_ONLY_BEFORE = 'Remove a blank line after `%<modifier>s`.'
 
+        RESTRICT_ON_SEND = %i[public protected private module_function].freeze
+
         def initialize(config = nil, options = nil)
           super
 

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

@@ -68,6 +68,8 @@ module RuboCop
           check_body(node.body, node.loc.line)
         end
         alias on_defs on_def
+        alias on_block on_def
+        alias on_numblock on_def
 
         def on_kwbegin(node)
           body, = *node

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

@@ -82,6 +82,10 @@ module RuboCop
           check_other_alignment(node)
         end
 
+        def on_sclass(node)
+          check_other_alignment(node)
+        end
+
         def on_module(node)
           check_other_alignment(node)
         end
@@ -105,6 +109,7 @@ module RuboCop
             check_other_alignment(node)
           end
         end
+        alias on_case_match on_case
 
         private
 
@@ -165,7 +170,10 @@ module RuboCop
         end
 
         def alignment_node_for_variable_style(node)
-          return node.parent if node.case_type? && node.argument? && same_line?(node, node.parent)
+          if (node.case_type? || node.case_match_type?) && node.argument? &&
+             same_line?(node, node.parent)
+            return node.parent
+          end
 
           assignment = assignment_or_operator_method(node)
 

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

@@ -49,7 +49,7 @@ module RuboCop
 
         private
 
-        def aligned_locations(locs)
+        def aligned_locations(locs) # rubocop:disable Metrics/AbcSize
           return [] if locs.empty?
 
           aligned = Set[locs.first.line, locs.last.line]
@@ -57,6 +57,11 @@ module RuboCop
             col = loc.column
             aligned << loc.line if col == before.column || col == after.column
           end
+
+          # if locs.size > 2 and the size of variable `aligned`
+          # has not increased from its initial value, there are not aligned lines.
+          return [] if locs.size > 2 && aligned.size == 2
+
           aligned
         end
 

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

@@ -153,9 +153,10 @@ module RuboCop
         MSG = 'Indent the first argument one step more than %<base>s.'
 
         def on_send(node)
+          return unless should_check?(node)
+          return if same_line?(node, node.first_argument)
           return if style != :consistent && enforce_first_argument_with_fixed_indentation? &&
                     !enable_layout_first_method_argument_line_break?
-          return if !node.arguments? || bare_operator?(node) || node.setter_method?
 
           indent = base_indentation(node) + configured_indentation_width
 
@@ -166,6 +167,10 @@ module RuboCop
 
         private
 
+        def should_check?(node)
+          node.arguments? && !bare_operator?(node) && !node.setter_method?
+        end
+
         def autocorrect(corrector, node)
           AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
         end
@@ -179,7 +184,7 @@ module RuboCop
 
           send_node = arg_node.parent
           text = base_range(send_node, arg_node).source.strip
-          base = if !/\n/.match?(text) && special_inner_call_indentation?(send_node)
+          base = if !text.include?("\n") && special_inner_call_indentation?(send_node)
                    "`#{text}`"
                  elsif comment_line?(text.lines.reverse_each.first)
                    'the start of the previous line (not counting the comment)'
@@ -255,7 +260,7 @@ module RuboCop
           @comment_lines ||=
             processed_source
             .comments
-            .select { |c| begins_its_line?(c.loc.expression) }
+            .select { |c| begins_its_line?(c.source_range) }
             .map { |c| c.loc.line }
         end
 

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

@@ -6,49 +6,40 @@ module RuboCop
       # Checks for a line break before the first element in a
       # multi-line array.
       #
-      # @example AllowMultilineFinalElement: false (default)
+      # @example
       #
-      #     # bad
-      #     [ :a,
-      #       :b]
+      #   # bad
+      #   [ :a,
+      #     :b]
       #
-      #     # bad
-      #     [ :a, {
-      #       :b => :c
-      #     }]
+      #   # good
+      #   [
+      #     :a,
+      #     :b]
       #
-      #     # good
-      #     [:a, :b]
+      #   # good
+      #   [:a, :b]
       #
-      #     # good
-      #     [
-      #       :a,
-      #       :b]
+      # @example AllowMultilineFinalElement: false (default)
       #
-      #     # good
-      #     [
-      #       :a, {
-      #       :b => :c
-      #     }]
+      #   # bad
+      #   [ :a, {
+      #     :b => :c
+      #   }]
       #
-      # @example AllowMultilineFinalElement: true
+      #   # good
+      #   [
+      #     :a, {
+      #     :b => :c
+      #   }]
       #
-      #     # bad
-      #     [ :a,
-      #       :b]
-      #
-      #     # good
-      #     [ :a, {
-      #       :b => :c
-      #     }]
+      # @example AllowMultilineFinalElement: true
       #
-      #     # good
-      #     [
-      #       :a,
-      #       :b]
+      #   # good
+      #   [:a, {
+      #     :b => :c
+      #   }]
       #
-      #     # good
-      #     [:a, :b]
       class FirstArrayElementLineBreak < Base
         include FirstElementLineBreak
         extend AutoCorrector

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

@@ -6,17 +6,12 @@ module RuboCop
       # Checks for a line break before the first element in a
       # multi-line hash.
       #
-      # @example AllowMultilineFinalElement: false (default)
+      # @example
       #
       #     # bad
       #     { a: 1,
       #       b: 2}
       #
-      #     # bad
-      #     { a: 1, b: {
-      #       c: 3
-      #     }}
-      #
       #     # good
       #     {
       #       a: 1,
@@ -28,11 +23,14 @@ module RuboCop
       #       c: 3
       #     }}
       #
-      # @example AllowMultilineFinalElement: true
+      # @example AllowMultilineFinalElement: false (default)
       #
       #     # bad
-      #     { a: 1,
-      #       b: 2}
+      #     { a: 1, b: {
+      #       c: 3
+      #     }}
+      #
+      # @example AllowMultilineFinalElement: true
       #
       #     # bad
       #     { a: 1,
@@ -45,16 +43,6 @@ module RuboCop
       #       c: 3
       #     }}
       #
-      #     # good
-      #     {
-      #       a: 1,
-      #       b: 2 }
-      #
-      #     # good
-      #     {
-      #       a: 1, b: {
-      #       c: 3
-      #     }}
       class FirstHashElementLineBreak < Base
         include FirstElementLineBreak
         extend AutoCorrector

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

@@ -6,73 +6,63 @@ module RuboCop
       # Checks for a line break before the first argument in a
       # multi-line method call.
       #
-      # @example AllowMultilineFinalElement: false (default)
-      #
-      #     # bad
-      #     method(foo, bar,
-      #       baz)
-      #
-      #     # bad
-      #     method(foo, bar, {
-      #       baz: "a",
-      #       qux: "b",
-      #     })
+      # @example
       #
-      #     # good
-      #     method(
-      #       foo, bar,
-      #       baz)
+      #   # bad
+      #   method(foo, bar,
+      #     baz)
       #
-      #     # good
-      #     method(
-      #       foo, bar, {
-      #       baz: "a",
-      #       qux: "b",
-      #     })
+      #   # good
+      #   method(
+      #     foo, bar,
+      #     baz)
       #
       #     # ignored
       #     method foo, bar,
       #       baz
       #
-      # @example AllowMultilineFinalElement: true
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # bad
+      #   method(foo, bar, {
+      #     baz: "a",
+      #     qux: "b",
+      #   })
       #
-      #     # bad
-      #     method(foo, bar,
-      #       baz)
+      #   # good
+      #   method(
+      #     foo, bar, {
+      #     baz: "a",
+      #     qux: "b",
+      #   })
       #
-      #     # bad
-      #     method(foo,
-      #       bar,
-      #       {
-      #         baz: "a",
-      #         qux: "b",
-      #       }
-      #     )
+      # @example AllowMultilineFinalElement: true
       #
-      #     # good
-      #     method(foo, bar, {
+      #   # bad
+      #   method(foo,
+      #     bar,
+      #     {
       #       baz: "a",
       #       qux: "b",
-      #     })
+      #     }
+      #   )
       #
-      #     # good
-      #     method(
-      #       foo, bar,
-      #       baz)
+      #   # good
+      #   method(foo, bar, {
+      #     baz: "a",
+      #     qux: "b",
+      #   })
       #
-      #     # good
-      #     method(
-      #       foo,
-      #       bar,
-      #       {
-      #         baz: "a",
-      #         qux: "b",
-      #       }
-      #     )
+      #   # good
+      #   method(
+      #     foo,
+      #     bar,
+      #     {
+      #       baz: "a",
+      #       qux: "b",
+      #     }
+      #   )
       #
-      #     # ignored
-      #     method foo, bar,
-      #       baz
       class FirstMethodArgumentLineBreak < Base
         include FirstElementLineBreak
         extend AutoCorrector

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

@@ -6,69 +6,52 @@ module RuboCop
       # Checks for a line break before the first parameter in a
       # multi-line method parameter definition.
       #
-      # @example AllowMultilineFinalElement: false (default)
-      #
-      #     # bad
-      #     def method(foo, bar,
-      #         baz)
-      #       do_something
-      #     end
-      #
-      #     # bad
-      #     def method(foo, bar, baz = {
-      #       :a => "b",
-      #     })
-      #       do_something
-      #     end
+      # @example
       #
-      #     # good
-      #     def method(
-      #         foo, bar,
-      #         baz)
-      #       do_something
-      #     end
+      #   # bad
+      #   def method(foo, bar,
+      #       baz)
+      #     do_something
+      #   end
       #
-      #     # good
-      #     def method(
-      #       foo, bar, baz = {
-      #       :a => "b",
-      #     })
-      #       do_something
-      #     end
+      #   # good
+      #   def method(
+      #       foo, bar,
+      #       baz)
+      #     do_something
+      #   end
       #
-      #     # ignored
-      #     def method foo,
-      #         bar
-      #       do_something
-      #     end
+      #   # ignored
+      #   def method foo,
+      #       bar
+      #     do_something
+      #   end
       #
-      # @example AllowMultilineFinalElement: true
+      # @example AllowMultilineFinalElement: false (default)
       #
-      #     # bad
-      #     def method(foo, bar,
-      #         baz)
-      #       do_something
-      #     end
+      #   # bad
+      #   def method(foo, bar, baz = {
+      #     :a => "b",
+      #   })
+      #     do_something
+      #   end
       #
-      #     # good
-      #     def method(foo, bar, baz = {
-      #       :a => "b",
-      #     })
-      #       do_something
-      #     end
+      #   # good
+      #   def method(
+      #     foo, bar, baz = {
+      #     :a => "b",
+      #   })
+      #     do_something
+      #   end
       #
-      #     # good
-      #     def method(
-      #         foo, bar,
-      #         baz)
-      #       do_something
-      #     end
+      # @example AllowMultilineFinalElement: true
       #
-      #     # ignored
-      #     def method foo,
-      #         bar
-      #       do_something
-      #     end
+      #   # good
+      #   def method(foo, bar, baz = {
+      #     :a => "b",
+      #   })
+      #     do_something
+      #   end
       #
       class FirstMethodParameterLineBreak < Base
         include FirstElementLineBreak