[Fix rubocop#9064] Add three new config options for Layout/EmptyLineBetweenDefs cop

* EmptyLineBetweenMethodDefs
* EmptyLineBetweenClassDefs
* EmptyLineBetweenModuleDefs

This cop previous had ability to check for empty lines between method
definitions only. This commit allows the cop to check for empty lines between class
and module definitions as well.

All three configs are enabled by default.

Closes rubocop#9064

Author: tejasbubane

CHANGELOG.md

@@ -15,6 +15,7 @@
 ### New features
 
 * [#7737](https://github.com/rubocop-hq/rubocop/issues/7737): Add new `Style/RedundantArgument` cop. ([@tejasbubane][])
+* [#9064](https://github.com/rubocop-hq/rubocop/issues/9064): Add `EmptyLineBetweenMethodDefs`, `EmptyLineBetweenClassDefs` and `EmptyLineBetweenModuleDefs` config options for `Layout/EmptyLineBetweenDefs` cop. ([@tejasbubane][])
 
 ## 1.3.1 (2020-11-16)
 

config/default.yml

@@ -463,6 +463,10 @@ Layout/EmptyLineBetweenDefs:
   StyleGuide: '#empty-lines-between-methods'
   Enabled: true
   VersionAdded: '0.49'
+  VersionChanged: <<next>>
+  EmptyLineBetweenMethodDefs: true
+  EmptyLineBetweenClassDefs: true
+  EmptyLineBetweenModuleDefs: true
   # If `true`, this parameter means that single line method definitions don't
   # need an empty line between them.
   AllowAdjacentOneLineDefs: false

lib/rubocop/cop/layout/empty_line_between_defs.rb

@@ -13,7 +13,8 @@ module Layout
       # `AllowAdjacentOneLineDefs` configures whether adjacent
       # one-line method definitions are considered an offense.
       #
-      # @example
+      # @example EmptyLineBetweenMethodDefs: true (default)
+      #   # checks for empty lines between method definitions.
       #
       #   # bad
       #   def a
@@ -29,11 +30,57 @@ module Layout
       #
       #   def b
       #   end
+      #
+      # @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
       class EmptyLineBetweenDefs < Base
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use empty lines between method definitions.'
+        MSG = 'Use empty lines between %<type>s definitions.'
 
         def self.autocorrect_incompatible_with
           [Layout::EmptyLines]
@@ -47,7 +94,7 @@ def self.autocorrect_incompatible_with
         def on_begin(node)
           node.children.each_cons(2) do |prev, n|
             nodes = [prev, n]
-            check_defs(nodes) if nodes.all? { |def_candidate| def_node?(def_candidate) }
+            check_defs(nodes) if nodes.all? { |def_candidate| candidate?(def_candidate) }
           end
         end
 
@@ -57,8 +104,9 @@ def check_defs(nodes)
           return if nodes.all?(&:single_line?) &&
                     cop_config['AllowAdjacentOneLineDefs']
 
-          location = nodes.last.loc.keyword.join(nodes.last.loc.name)
-          add_offense(location) do |corrector|
+          correction_node = nodes.last
+          location = correction_node.loc.keyword.join(correction_node.loc.name)
+          add_offense(location, message: message(correction_node)) do |corrector|
             autocorrect(corrector, *nodes)
           end
         end
@@ -83,10 +131,32 @@ def autocorrect(corrector, prev_def, node)
 
         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)
+          type = case node.type
+                 when :def, :defs
+                   :method
+                 else
+                   node.type
+                 end
+          format(MSG, type: type)
         end
 
         def multiple_blank_lines_groups?(first_def_node, second_def_node)

lib/rubocop/options.rb

@@ -5,6 +5,7 @@
 
 module RuboCop
   class IncorrectCopNameError < StandardError; end
+
   class OptionArgumentError < StandardError; end
 
   # This class handles command line options.

spec/rubocop/cop/layout/empty_line_between_defs_spec.rb

@@ -8,13 +8,15 @@
       class K
         def m
         end
+
         class J
           def n
           end
           def o
           ^^^^^ Use empty lines between method definitions.
           end
         end
+
         # checks something
         def p
         end
@@ -411,4 +413,123 @@ def o
       RUBY
     end
   end
+
+  context 'EmptyLineBetweenClassDefs' do
+    it 'registers offense when no empty lines between class and method definitions' do
+      expect_offense(<<~RUBY)
+        class Foo
+        end
+        class Baz
+        ^^^^^^^^^ Use empty lines between class definitions.
+        end
+        def example
+        ^^^^^^^^^^^ Use empty lines between method definitions.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo
+        end
+
+        class Baz
+        end
+
+        def example
+        end
+      RUBY
+    end
+
+    context 'when disabled' do
+      let(:cop_config) { { 'EmptyLineBetweenClassDefs' => false } }
+
+      it 'does not register offense' do
+        expect_no_offenses(<<~RUBY)
+          class Foo
+          end
+          class Baz
+          end
+          def example
+          end
+        RUBY
+      end
+    end
+
+    context 'with AllowAdjacentOneLineDefs enabled' do
+      let(:cop_config) { { 'AllowAdjacentOneLineDefs' => true } }
+
+      it 'does not register offense' do
+        expect_no_offenses(<<~RUBY)
+          class Foo; end
+          class Baz; end
+        RUBY
+      end
+    end
+  end
+
+  context 'EmptyLineBetweenModuleDefs' do
+    it 'registers offense when no empty lines between module and method definitions' do
+      expect_offense(<<~RUBY)
+        module Foo
+        end
+        module Baz
+        ^^^^^^^^^^ Use empty lines between module definitions.
+        end
+        def example
+        ^^^^^^^^^^^ Use empty lines between method definitions.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        module Foo
+        end
+
+        module Baz
+        end
+
+        def example
+        end
+      RUBY
+    end
+
+    context 'when disabled' do
+      let(:cop_config) { { 'EmptyLineBetweenModuleDefs' => false } }
+
+      it 'does not register offense' do
+        expect_no_offenses(<<~RUBY)
+          module Foo
+          end
+          module Baz
+          end
+          def example
+          end
+        RUBY
+      end
+    end
+  end
+
+  context 'when empty lines between classes and modules together' do
+    it 'registers offense when no empty lines between module and method definitions' do
+      expect_offense(<<~RUBY)
+        class Foo
+        end
+        module Baz
+        ^^^^^^^^^^ Use empty lines between module definitions.
+        end
+        def example
+        ^^^^^^^^^^^ Use empty lines between method definitions.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        class Foo
+        end
+
+        module Baz
+        end
+
+        def example
+        end
+      RUBY
+    end
+  end
 end