Add section for empty lines after module inclusion methods

[lovro-bikic]

Adds a section for keeping empty lines after module inclusion methods (extend, include and prepend). The term "module inclusion" has been borrowed from Layout/ClassStructure docs. I couldn't find a similar issue or PR (either here or for RuboCop).

Under this style, code such as:

module Foo
  include Bar
  def baz; end
end

wouldn't be acceptable; there would have to be an empty line after include line:

module Foo
  include Bar

  def baz; end
end

This style is suggested — though not made explicit — by Consistent Classes and module_function sections of the guide (Prefer public_send section's example also shows this practice).

This GH search shows examples where module inclusion methods have been followed by an empty line or the keyword end (cca 2M at the time of writing). And this search shows examples where the methods have been followed by a non-empty line (cca 844k results; note that this search includes many false positives, like grouped include lines, so there are even fewer actual examples).

Some codebases where this style is mostly followed:

• RuboCop (there are some exceptions, for example here, but these seem to be the minority)
• Mastodon
• brew
• Discourse
• rspec-core

There's also no RuboCop cop for this style, so, if accepted, a new cop would have to be implemented.

[bbatsov]

The suggestion is fair, and probably should be coupled with something about the class structure, as those are pretty much always first, so the empty line is only after them if we have to very specific about this.

[lovro-bikic]

I should probably point out that there's a bit of discrepancy between the guide and RuboCop when it comes to these "empty lines around X" rules. For example, Empty Lines around Attribute Accessor rule (which I copied as the starting point for this rule) has a matching cop, but that cop checks only for empty lines after attribute accessors.

Re empty lines before module inclusion methods, one pattern I've seen is:

require 'foo'
include Foo

and there are more examples of no empty lines between (44.5k results) than examples of an empty line between (36.4k results) these two statements, so being explicit about an empty line only after include/extend/prepend may make more sense for the rule.

[lovro-bikic]

I updated rule wording to be explicit about empty lines only after module inclusion methods.

[bbatsov]

and there are more examples of no empty lines between (44.5k results) than examples of an empty line between (36.4k results) these two statements, so being explicit about an empty line only after include/extend/prepend may make more sense for the rule.

I had forgotten about conditional requires. Probably those should be addressed in a class structure rule, instead of here, as many of the individual rules leave some room for interpretation depending on the overall class structure. For most "blank lines around" rules being at the boundaries of a class/module definition should be the exception for the leading or training blank line. But ultimately the message we're trying to relay is very simple - the class/module structure should be enhanced by the application on blank lines around its logical parts.