rubocop 0.66.0 → 1.25.1

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

@@ -3,17 +3,18 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks whether method definitions are
-      # separated by one empty line.
+      # This cop checks whether class/module/method definitions are
+      # separated by one or more empty lines.
       #
       # `NumberOfEmptyLines` can be an integer (default is 1) or
       # an array (e.g. [1, 2]) to specify a minimum and maximum
       # number of empty lines permitted.
       #
       # `AllowAdjacentOneLineDefs` configures whether adjacent
-      # one-line method definitions are considered an offense.
+      # one-line definitions are considered an offense.
       #
-      # @example
+      # @example EmptyLineBetweenMethodDefs: true (default)
+      #   # checks for empty lines between method definitions.
       #
       #   # bad
       #   def a
@@ -29,10 +30,86 @@ module RuboCop
       #
       #   def b
       #   end
-      class EmptyLineBetweenDefs < Cop
+      #
+      # @example EmptyLineBetweenClassDefs: true (default)
+      #   # checks for empty lines between class definitions.
+      #
+      #   # bad
+      #   class A
+      #   end
+      #   class B
+      #   end
+      #   def b
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #   class A
+      #   end
+      #
+      #   class B
+      #   end
+      #
+      #   def b
+      #   end
+      #
+      # @example EmptyLineBetweenModuleDefs: true (default)
+      #   # checks for empty lines between module definitions.
+      #
+      #   # bad
+      #   module A
+      #   end
+      #   module B
+      #   end
+      #   def b
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #   module A
+      #   end
+      #
+      #   module B
+      #   end
+      #
+      #   def b
+      #   end
+      #
+      # @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
 
-        MSG = 'Use empty lines between method definitions.'.freeze
+        MSG = 'Expected %<expected>s between %<type>s definitions; found %<actual>d.'
 
         def self.autocorrect_incompatible_with
           [Layout::EmptyLines]
@@ -46,42 +123,73 @@ module RuboCop
         def on_begin(node)
           node.children.each_cons(2) do |prev, n|
             nodes = [prev, n]
-            check_defs(nodes) if nodes.all?(&method(:def_node?))
+            check_defs(nodes) if nodes.all? { |def_candidate| candidate?(def_candidate) }
           end
         end
 
         def check_defs(nodes)
-          return if blank_lines_between?(*nodes)
+          count = blank_lines_count_between(*nodes)
+
+          return if line_count_allowed?(count)
           return if multiple_blank_lines_groups?(*nodes)
-          return if nodes.all?(&:single_line?) &&
-                    cop_config['AllowAdjacentOneLineDefs']
+          return if nodes.all?(&:single_line?) && cop_config['AllowAdjacentOneLineDefs']
 
-          add_offense(nodes.last, location: :keyword)
+          correction_node = nodes.last
+          location = correction_node.loc.keyword.join(correction_node.loc.name)
+          add_offense(location, message: message(correction_node, count: count)) do |corrector|
+            autocorrect(corrector, *nodes, count)
+          end
         end
 
-        def autocorrect(node)
-          prev_def = prev_node(node)
-
+        def autocorrect(corrector, prev_def, node, count)
           # finds position of first newline
-          end_pos = prev_def.loc.end.end_pos
-          source_buffer = prev_def.loc.end.source_buffer
+          end_pos = end_loc(prev_def).end_pos
+          source_buffer = end_loc(prev_def).source_buffer
           newline_pos = source_buffer.source.index("\n", end_pos)
 
-          count = blank_lines_count_between(prev_def, node)
+          # Handle the case when multiple one-liners are on the same line.
+          newline_pos = end_pos + 1 if newline_pos > node.source_range.begin_pos
 
           if count > maximum_empty_lines
-            autocorrect_remove_lines(newline_pos, count)
+            autocorrect_remove_lines(corrector, newline_pos, count)
           else
-            autocorrect_insert_lines(newline_pos, count)
+            autocorrect_insert_lines(corrector, newline_pos, count)
           end
         end
 
         private
 
-        def def_node?(node)
+        def candidate?(node)
           return unless node
 
-          node.def_type? || node.defs_type?
+          method_candidate?(node) || class_candidate?(node) || module_candidate?(node)
+        end
+
+        def method_candidate?(node)
+          cop_config['EmptyLineBetweenMethodDefs'] && (node.def_type? || node.defs_type?)
+        end
+
+        def class_candidate?(node)
+          cop_config['EmptyLineBetweenClassDefs'] && node.class_type?
+        end
+
+        def module_candidate?(node)
+          cop_config['EmptyLineBetweenModuleDefs'] && node.module_type?
+        end
+
+        def message(node, count: nil)
+          type = node_type(node)
+
+          format(MSG, type: type, expected: expected_lines, actual: count)
+        end
+
+        def expected_lines
+          if allowance_range?
+            "#{minimum_empty_lines..maximum_empty_lines} empty lines"
+          else
+            lines = maximum_empty_lines == 1 ? 'line' : 'lines'
+            "#{maximum_empty_lines} empty #{lines}"
+          end
         end
 
         def multiple_blank_lines_groups?(first_def_node, second_def_node)
@@ -93,8 +201,7 @@ module RuboCop
           blank_start > non_blank_end
         end
 
-        def blank_lines_between?(first_def_node, second_def_node)
-          count = blank_lines_count_between(first_def_node, second_def_node)
+        def line_count_allowed?(count)
           (minimum_empty_lines..maximum_empty_lines).cover?(count)
         end
 
@@ -110,16 +217,12 @@ module RuboCop
           Array(cop_config['NumberOfEmptyLines']).last
         end
 
-        def prev_node(node)
-          return nil unless node.sibling_index > 0
-
-          node.parent.children[node.sibling_index - 1]
-        end
-
         def lines_between_defs(first_def_node, second_def_node)
-          line_range = def_end(first_def_node)..(def_start(second_def_node) - 2)
+          begin_line_num = def_end(first_def_node)
+          end_line_num = def_start(second_def_node) - 2
+          return [] if end_line_num.negative?
 
-          processed_source.lines[line_range]
+          processed_source.lines[begin_line_num..end_line_num]
         end
 
         def def_start(node)
@@ -127,24 +230,43 @@ module RuboCop
         end
 
         def def_end(node)
-          node.loc.end.line
+          end_loc(node).line
+        end
+
+        def end_loc(node)
+          if (node.def_type? || node.defs_type?) && node.endless?
+            node.loc.expression.end
+          else
+            node.loc.end
+          end
         end
 
-        def autocorrect_remove_lines(newline_pos, count)
+        def autocorrect_remove_lines(corrector, newline_pos, count)
           difference = count - maximum_empty_lines
           range_to_remove = range_between(newline_pos, newline_pos + difference)
-          lambda do |corrector|
-            corrector.remove(range_to_remove)
-          end
+
+          corrector.remove(range_to_remove)
         end
 
-        def autocorrect_insert_lines(newline_pos, count)
+        def autocorrect_insert_lines(corrector, newline_pos, count)
           difference = minimum_empty_lines - count
           where_to_insert = range_between(newline_pos, newline_pos + 1)
-          lambda do |corrector|
-            corrector.insert_after(where_to_insert, "\n" * difference)
+
+          corrector.insert_after(where_to_insert, "\n" * difference)
+        end
+
+        def node_type(node)
+          case node.type
+          when :def, :defs
+            :method
+          else
+            node.type
           end
         end
+
+        def allowance_range?
+          minimum_empty_lines != maximum_empty_lines
+        end
       end
     end
   end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module RuboCop
   module Cop
     module Layout
@@ -20,29 +18,26 @@ module RuboCop
       #   # one empty line
       #   some_method
       #
-      class EmptyLines < Cop
+      class EmptyLines < Base
         include RangeHelp
+        extend AutoCorrector
 
-        MSG = 'Extra blank line detected.'.freeze
+        MSG = 'Extra blank line detected.'
         LINE_OFFSET = 2
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.tokens.empty?
 
           lines = Set.new
-          processed_source.each_token do |token|
-            lines << token.line
-          end
+          processed_source.each_token { |token| lines << token.line }
 
           each_extra_empty_line(lines.sort) do |range|
-            add_offense(range, location: range)
+            add_offense(range) do |corrector|
+              corrector.remove(range)
+            end
           end
         end
 
-        def autocorrect(range)
-          ->(corrector) { corrector.remove(range) }
-        end
-
         private
 
         def each_extra_empty_line(lines)

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

@@ -5,7 +5,7 @@ module RuboCop
     module Layout
       # Access modifiers should be surrounded by blank lines.
       #
-      # @example
+      # @example EnforcedStyle: around (default)
       #
       #   # bad
       #   class Foo
@@ -22,12 +22,34 @@ module RuboCop
       #
       #     def baz; end
       #   end
-      class EmptyLinesAroundAccessModifier < Cop
+      #
+      # @example EnforcedStyle: only_before
+      #
+      #   # bad
+      #   class Foo
+      #     def bar; end
+      #     private
+      #     def baz; end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def bar; end
+      #
+      #     private
+      #     def baz; end
+      #   end
+      #
+      class EmptyLinesAroundAccessModifier < Base
+        include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
+
+        MSG_AFTER = 'Keep a blank line after `%<modifier>s`.'
+        MSG_BEFORE_AND_AFTER = 'Keep a blank line before and after `%<modifier>s`.'
 
-        MSG_AFTER = 'Keep a blank line after `%<modifier>s`.'.freeze
-        MSG_BEFORE_AND_AFTER = 'Keep a blank line before and after ' \
-                               '`%<modifier>s`.'.freeze
+        MSG_BEFORE_FOR_ONLY_BEFORE = 'Keep a blank line before `%<modifier>s`.'
+        MSG_AFTER_FOR_ONLY_BEFORE = 'Remove a blank line after `%<modifier>s`.'
 
         def initialize(config = nil, options = nil)
           super
@@ -36,10 +58,8 @@ module RuboCop
         end
 
         def on_class(node)
-          _name, superclass, _body = *node
-
-          @class_or_module_def_first_line = if superclass
-                                              superclass.first_line
+          @class_or_module_def_first_line = if node.parent_class
+                                              node.parent_class.first_line
                                             else
                                               node.source_range.first_line
                                             end
@@ -52,10 +72,8 @@ module RuboCop
         end
 
         def on_sclass(node)
-          self_node, _body = *node
-
-          @class_or_module_def_first_line = self_node.source_range.first_line
-          @class_or_module_def_last_line = self_node.source_range.last_line
+          @class_or_module_def_first_line = node.identifier.source_range.first_line
+          @class_or_module_def_last_line = node.source_range.last_line
         end
 
         def on_block(node)
@@ -63,42 +81,63 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless node.bare_access_modifier?
+          return unless node.bare_access_modifier? && !node.parent&.block_type?
+          return if expected_empty_lines?(node)
+
+          message = message(node)
+          add_offense(node, message: message) do |corrector|
+            line = range_by_whole_lines(node.source_range)
+
+            corrector.insert_before(line, "\n") unless previous_line_empty?(node.first_line)
 
-          return if empty_lines_around?(node)
+            correct_next_line_if_denied_style(corrector, node, line)
+          end
+        end
+
+        private
+
+        def expected_empty_lines?(node)
+          case style
+          when :around
+            return true if empty_lines_around?(node)
+          when :only_before
+            return true if allowed_only_before_style?(node)
+          end
 
-          add_offense(node)
+          false
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            line = range_by_whole_lines(node.source_range)
+        def allowed_only_before_style?(node)
+          if node.special_modifier?
+            return true if processed_source[node.last_line] == 'end'
+            return false if next_line_empty?(node.last_line)
+          end
 
-            unless previous_line_empty?(node.first_line)
-              corrector.insert_before(line, "\n")
-            end
+          previous_line_empty?(node.first_line)
+        end
+
+        def correct_next_line_if_denied_style(corrector, node, line)
+          case style
+          when :around
+            corrector.insert_after(line, "\n") unless next_line_empty?(node.last_line)
+          when :only_before
+            if next_line_empty?(node.last_line)
+              range = next_empty_line_range(node)
 
-            unless next_line_empty?(node.last_line)
-              corrector.insert_after(line, "\n")
+              corrector.remove(range)
             end
           end
         end
 
-        private
-
         def previous_line_ignoring_comments(processed_source, send_line)
-          processed_source[0..send_line - 2].reverse.find do |line|
-            !comment_line?(line)
-          end
+          processed_source[0..send_line - 2].reverse.find { |line| !comment_line?(line) }
         end
 
         def previous_line_empty?(send_line)
-          previous_line = previous_line_ignoring_comments(processed_source,
-                                                          send_line)
+          previous_line = previous_line_ignoring_comments(processed_source, send_line)
+          return true unless previous_line
 
-          block_start?(send_line) ||
-            class_def?(send_line) ||
-            previous_line.blank?
+          block_start?(send_line) || class_def?(send_line) || previous_line.blank?
         end
 
         def next_line_empty?(last_send_line)
@@ -108,8 +147,7 @@ module RuboCop
         end
 
         def empty_lines_around?(node)
-          previous_line_empty?(node.first_line) &&
-            next_line_empty?(node.last_line)
+          previous_line_empty?(node.first_line) && next_line_empty?(node.last_line)
         end
 
         def class_def?(line)
@@ -130,16 +168,38 @@ module RuboCop
           line == @class_or_module_def_last_line - 1
         end
 
+        def next_empty_line_range(node)
+          source_range(processed_source.buffer, node.last_line + 1, 0)
+        end
+
         def message(node)
+          case style
+          when :around
+            message_for_around_style(node)
+          when :only_before
+            message_for_only_before_style(node)
+          end
+        end
+
+        def message_for_around_style(node)
           send_line = node.first_line
 
-          if block_start?(send_line) ||
-             class_def?(send_line)
+          if block_start?(send_line) || class_def?(send_line)
             format(MSG_AFTER, modifier: node.loc.selector.source)
           else
             format(MSG_BEFORE_AND_AFTER, modifier: node.loc.selector.source)
           end
         end
+
+        def message_for_only_before_style(node)
+          modifier = node.loc.selector.source
+
+          if next_line_empty?(node.last_line)
+            format(MSG_AFTER_FOR_ONLY_BEFORE, modifier: modifier)
+          else
+            format(MSG_BEFORE_FOR_ONLY_BEFORE, modifier: modifier)
+          end
+        end
       end
     end
   end

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

@@ -38,26 +38,30 @@ module RuboCop
       #     x: y
       #   )
       #
-      class EmptyLinesAroundArguments < Cop
+      class EmptyLinesAroundArguments < Base
         include RangeHelp
+        extend AutoCorrector
 
-        MSG = 'Empty line detected around arguments.'.freeze
+        MSG = 'Empty line detected around arguments.'
 
         def on_send(node)
-          return if node.single_line? || node.arguments.empty?
+          return if node.single_line? || node.arguments.empty? ||
+                    receiver_and_method_call_on_different_lines?(node)
 
-          extra_lines(node) { |range| add_offense(node, location: range) }
-        end
-        alias on_csend on_send
-
-        def autocorrect(node)
-          lambda do |corrector|
-            extra_lines(node) { |range| corrector.remove(range) }
+          extra_lines(node) do |range|
+            add_offense(range) do |corrector|
+              corrector.remove(range)
+            end
           end
         end
+        alias on_csend on_send
 
         private
 
+        def receiver_and_method_call_on_different_lines?(node)
+          node.receiver && node.receiver.loc.last_line != node.loc.selector&.line
+        end
+
         def empty_lines(node)
           lines = processed_lines(node)
           lines.select! { |code, _| code.empty? }

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for a newline after an attribute accessor or a group of them.
+      # `alias` syntax and `alias_method`, `public`, `protected`, and `private` methods are allowed
+      # by default. These are customizable with `AllowAliasSyntax` and `AllowedMethods` options.
+      #
+      # @example
+      #   # bad
+      #   attr_accessor :foo
+      #   def do_something
+      #   end
+      #
+      #   # good
+      #   attr_accessor :foo
+      #
+      #   def do_something
+      #   end
+      #
+      #   # good
+      #   attr_accessor :foo
+      #   attr_reader :bar
+      #   attr_writer :baz
+      #   attr :qux
+      #
+      #   def do_something
+      #   end
+      #
+      # @example AllowAliasSyntax: true (default)
+      #   # good
+      #   attr_accessor :foo
+      #   alias :foo? :foo
+      #
+      #   def do_something
+      #   end
+      #
+      # @example AllowAliasSyntax: false
+      #   # bad
+      #   attr_accessor :foo
+      #   alias :foo? :foo
+      #
+      #   def do_something
+      #   end
+      #
+      #   # good
+      #   attr_accessor :foo
+      #
+      #   alias :foo? :foo
+      #
+      #   def do_something
+      #   end
+      #
+      # @example AllowedMethods: ['private']
+      #   # good
+      #   attr_accessor :foo
+      #   private :foo
+      #
+      #   def do_something
+      #   end
+      #
+      class EmptyLinesAroundAttributeAccessor < Base
+        include RangeHelp
+        include AllowedMethods
+        extend AutoCorrector
+
+        MSG = 'Add an empty line after attribute accessor.'
+
+        def on_send(node)
+          return unless node.attribute_accessor?
+          return if next_line_empty?(node.last_line)
+
+          next_line_node = next_line_node(node)
+          return unless require_empty_line?(next_line_node)
+
+          add_offense(node) do |corrector|
+            range = range_by_whole_lines(node.source_range)
+
+            corrector.insert_after(range, "\n")
+          end
+        end
+
+        private
+
+        def next_line_empty?(line)
+          processed_source[line].nil? || processed_source[line].blank?
+        end
+
+        def require_empty_line?(node)
+          return false unless node.respond_to?(:type)
+
+          !allow_alias?(node) && !attribute_or_allowed_method?(node)
+        end
+
+        def next_line_node(node)
+          return if node.parent.if_type?
+
+          node.right_sibling
+        end
+
+        def allow_alias?(node)
+          allow_alias_syntax? && node.alias_type?
+        end
+
+        def attribute_or_allowed_method?(node)
+          return false unless node.send_type?
+
+          node.attribute_accessor? || allowed_method?(node.method_name)
+        end
+
+        def allow_alias_syntax?
+          cop_config.fetch('AllowAliasSyntax', true)
+        end
+      end
+    end
+  end
+end