rubocop-elegant 0.0.20 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68c6e6f486a9804d01f7be2db7087ed14501cec590250e50b89d32511c3cce97
-  data.tar.gz: f654452715b5e92d85fe3d3e410aca24858a9f28ce25ece59103d66bd3f27582
+  metadata.gz: d8341c1ab1fa0a7363197452f41a6146ecff051b7f6f094386612cf3f27b5427
+  data.tar.gz: 229010b24b1fbafe803804f3b6615f9295727fe1f8e87bf79902dc9c2a0675d7
 SHA512:
-  metadata.gz: af01d8551f274a0c56e69f3caed9097d7db6ffe55d7be9519ba7ea8fc169c6a484eba3e5d5af64e0788eb690d5bd4d155034d60d1d473de6a86bfa4baba480d9
-  data.tar.gz: f58fb9bbbb83617de532b7ac4712d3089fc61548d43040235cef7bbf46e533a6a5b9d0477b6c2c2124bde2a6b1adcb02eac99f8cec5edcbf0e3831c632e3a620
+  metadata.gz: f20ed17a83b4263d2c1336a9d5b1e1d44299c13014fba2a32220df5dd326794cbeda32e15fa1b68474661545b94744d58ed6e8400d894405329a51ad6ca0b965
+  data.tar.gz: 79975886caca7e40ac61a08a5a2737b9654c4dd4f43d6633a8a2a0a6047d01c1517094906b2d3920ebccd0e386d5a8afadaa784fc7cf5a5c87d5952f54ab9193

data/README.md

@@ -38,7 +38,7 @@ plugins:
   - rubocop-elegant # must be the last one
 ```
 
-The `rubocop-elegant` not only provides its own cops, but also configures
+The `rubocop-elegant` plugin not only provides its own cops, but also configures
   default ones the "right" way.
 
 ## How to contribute

data/config/default.yml

@@ -1,6 +1,7 @@
 # SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 ---
+# yamllint disable rule:line-length
 Elegant:
   Enabled: true
   DocumentationBaseURL: https://github.com/yegor256/rubocop-elegant
@@ -16,6 +17,28 @@ Elegant/NoEmptyLinesInBlocks:
   Description: 'Disallows empty lines inside blocks (do/end, if/end, while, case, begin, etc.)'
   Enabled: true
   VersionAdded: '0.0.19'
+Elegant/PairedBrackets:
+  Description: 'Enforces the paired brackets notation: a bracket must pair on the same line, or start/end its line'
+  Enabled: true
+  VersionAdded: '0.0.20'
+Elegant/ClassInModule:
+  Description: 'Requires every class to be defined inside a module, not globally'
+  Enabled: true
+  VersionAdded: '0.1.0'
+  Exclude:
+    - '**/*Test.rb'
+    - '**/test_*.rb'
+Elegant/NoClassInModule:
+  Description: 'Forbids declaring a class inside a module declaration; use compact namespace syntax instead'
+  Enabled: true
+  VersionAdded: '0.1.0'
+  Exclude:
+    - '**/*Test.rb'
+    - '**/test_*.rb'
+Elegant/IndentationLadder:
+  Description: 'Requires the indentation step to be exactly two spaces when a line indents to the right of the previous one'
+  Enabled: true
+  VersionAdded: '0.1.0'
 Elegant/GoodVariableName:
   Description: 'Checks that variable names match the configured pattern'
   Enabled: true
@@ -26,7 +49,7 @@ Elegant/GoodMethodName:
   Description: 'Checks that method names match the configured pattern'
   Enabled: true
   VersionAdded: '0.0.3'
-  Pattern: '^(((to|fake|the|with|without)_)?[a-z]{1,16}[!?]?|(on|test)_[a-z_]+)$'
+  Pattern: '^(?=.{1,48}$)(((to|fake|the|with|without)_)?[a-z]{1,16}[!?]?|(on|test)_[a-z_]+)$'
   AllowedNames: []
 
 Style/RedundantException:

data/lib/rubocop/cop/elegant/class_in_module.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+
+# Enforces that every class be defined inside a module. A class declared
+# at the top level, or nested only inside another class, pollutes the
+# global namespace and breaks modular design. The compact namespaced
+# form +class Foo::Bar+ is allowed because its name already resolves
+# into an enclosing namespace.
+class RuboCop::Cop::Elegant::ClassInModule < RuboCop::Cop::Base
+  MSG = 'Class %<name>s must be defined inside a module, not globally'
+  public_constant :MSG
+
+  def on_class(node)
+    return if namespaced?(node)
+    return if scoped?(node)
+    add_offense(node, message: format(MSG, name: label(node)))
+  end
+
+  private
+
+  def namespaced?(node)
+    const = node.children[0]
+    scope = const.children[0]
+    !scope.nil? && scope.type != :cbase
+  end
+
+  def scoped?(node)
+    node.each_ancestor(:module).any?
+  end
+
+  def label(node)
+    node.children[0].source
+  end
+end

data/lib/rubocop/cop/elegant/good_method_name.rb

@@ -3,41 +3,35 @@
 # SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 
-module RuboCop
-  module Cop
-    module Elegant
-      class GoodMethodName < Base
-        MSG = 'Method name "%<name>s" does not match the required pattern'
-        public_constant :MSG
-
-        def on_def(node)
-          check(node, node.method_name.to_s)
-        end
-
-        def on_defs(node)
-          check(node, node.method_name.to_s)
-        end
-
-        private
-
-        def check(node, name)
-          return if allowed?(name)
-          return if match?(name)
-          add_offense(node, message: format(MSG, name: name))
-        end
-
-        def match?(name)
-          pattern.match?(name)
-        end
-
-        def allowed?(name)
-          Array(cop_config['AllowedNames']).map(&:to_s).include?(name)
-        end
-
-        def pattern
-          @pattern ||= Regexp.new(cop_config['Pattern'] || '^[a-z]+[!?]?$')
-        end
-      end
-    end
+class RuboCop::Cop::Elegant::GoodMethodName < RuboCop::Cop::Base
+  MSG = 'Method name "%<name>s" does not match the required pattern'
+  public_constant :MSG
+
+  def on_def(node)
+    check(node, node.method_name.to_s)
+  end
+
+  def on_defs(node)
+    check(node, node.method_name.to_s)
+  end
+
+  private
+
+  def check(node, name)
+    return if allowed?(name)
+    return if match?(name)
+    add_offense(node, message: format(MSG, name: name))
+  end
+
+  def match?(name)
+    pattern.match?(name)
+  end
+
+  def allowed?(name)
+    Array(cop_config['AllowedNames']).map(&:to_s).include?(name)
+  end
+
+  def pattern
+    @pattern ||= Regexp.new(cop_config['Pattern'] || '^[a-z]+[!?]?$')
   end
 end

data/lib/rubocop/cop/elegant/good_variable_name.rb

@@ -3,49 +3,43 @@
 # SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 
-module RuboCop
-  module Cop
-    module Elegant
-      class GoodVariableName < Base
-        MSG = 'Variable name "%<name>s" does not match the required pattern'
-        public_constant :MSG
-
-        def on_lvasgn(node)
-          check(node, node.children.first.to_s)
-        end
-
-        def on_ivasgn(node)
-          check(node, node.children.first.to_s)
-        end
-
-        def on_cvasgn(node)
-          check(node, node.children.first.to_s)
-        end
-
-        def on_gvasgn(node)
-          check(node, node.children.first.to_s)
-        end
-
-        private
-
-        def check(node, name)
-          return if allowed?(name)
-          return if match?(name)
-          add_offense(node, message: format(MSG, name: name))
-        end
-
-        def match?(name)
-          pattern.match?(name)
-        end
-
-        def allowed?(name)
-          Array(cop_config['AllowedNames']).map(&:to_s).include?(name)
-        end
-
-        def pattern
-          @pattern ||= Regexp.new(cop_config['Pattern'] || '^[a-z]+$')
-        end
-      end
-    end
+class RuboCop::Cop::Elegant::GoodVariableName < RuboCop::Cop::Base
+  MSG = 'Variable name "%<name>s" does not match the required pattern'
+  public_constant :MSG
+
+  def on_lvasgn(node)
+    check(node, node.children.first.to_s)
+  end
+
+  def on_ivasgn(node)
+    check(node, node.children.first.to_s)
+  end
+
+  def on_cvasgn(node)
+    check(node, node.children.first.to_s)
+  end
+
+  def on_gvasgn(node)
+    check(node, node.children.first.to_s)
+  end
+
+  private
+
+  def check(node, name)
+    return if allowed?(name)
+    return if match?(name)
+    add_offense(node, message: format(MSG, name: name))
+  end
+
+  def match?(name)
+    pattern.match?(name)
+  end
+
+  def allowed?(name)
+    Array(cop_config['AllowedNames']).map(&:to_s).include?(name)
+  end
+
+  def pattern
+    @pattern ||= Regexp.new(cop_config['Pattern'] || '^[a-z]+$')
   end
 end

data/lib/rubocop/cop/elegant/indentation_ladder.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+
+# Enforces the "indentation ladder" rule: when a line is indented further
+# to the right than the previous non-empty line, the extra indentation
+# must be exactly two spaces. Larger jumps (or odd ones, such as a single
+# space or three spaces) break the visual rhythm of the code and make
+# nesting harder to follow. Lines that match the previous indentation, or
+# de-indent by any amount, are not affected. Lines that belong to the
+# body of a heredoc are ignored, because their whitespace is part of the
+# literal value rather than program structure.
+class RuboCop::Cop::Elegant::IndentationLadder < RuboCop::Cop::Base
+  MSG = 'Indentation step of %<step>d spaces is not allowed; use 2 spaces'
+  public_constant :MSG
+
+  def on_new_investigation
+    super
+    skip = heredocs
+    prev = nil
+    processed_source.lines.each_with_index do |line, idx|
+      num = idx + 1
+      next if skip.include?(num)
+      next if line.strip.empty?
+      indent = line[/\A */].length
+      register(num, indent - prev) if prev && indent > prev && (indent - prev) != 2
+      prev = indent
+    end
+  end
+
+  private
+
+  def heredocs
+    result = []
+    ast = processed_source.ast
+    return result if ast.nil?
+    ast.each_node(:str, :dstr, :xstr) do |node|
+      next unless node.heredoc?
+      body = node.loc.heredoc_body
+      (body.first_line..body.last_line).each { |num| result << num }
+    end
+    result
+  end
+
+  def register(num, step)
+    target = processed_source.buffer.line_range(num)
+    add_offense(target, message: format(MSG, step: step))
+  end
+end

data/lib/rubocop/cop/elegant/no_class_in_module.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+
+# Forbids declaring a class inside a module declaration. Instead, the
+# class must be declared with the compact namespace syntax, like
+# +class Foo::Bar+. An empty module +module Foo; end+, a module that
+# contains only other modules, methods, or constants, and a class
+# nested inside another class are all allowed; only a class whose
+# nearest enclosing scope is a module is rejected.
+class RuboCop::Cop::Elegant::NoClassInModule < RuboCop::Cop::Base
+  MSG = 'Class %<name>s must use compact namespace syntax, not be nested inside a module'
+  public_constant :MSG
+
+  def on_class(node)
+    owner = node.each_ancestor(:module, :class).first
+    return if owner.nil? || !owner.module_type?
+    add_offense(node, message: format(MSG, name: label(node)))
+  end
+
+  private
+
+  def label(node)
+    node.children[0].source
+  end
+end

data/lib/rubocop/cop/elegant/no_comments.rb

@@ -3,110 +3,104 @@
 # SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 
-module RuboCop
-  module Cop
-    module Elegant
-      class NoComments < Base
-        extend AutoCorrector
-
-        MSG = 'Comment is not allowed, unless it is SPDX, magic, rubocop directive, or docblock'
-        public_constant :MSG
-
-        def on_new_investigation
-          processed_source.comments.each do |comment|
-            register(comment) unless allowed?(comment)
-          end
-        end
-
-        private
-
-        def allowed?(comment)
-          spdx?(comment) || magic?(comment) || rubocop?(comment) || (gemspec? && docblock?(comment))
-        end
-
-        def spdx?(comment)
-          comment.text.match?(/^#\s*SPDX-/)
-        end
-
-        def magic?(comment)
-          comment.text.match?(/^#\s*(frozen_string_literal|encoding|coding|warn_indent):/)
-        end
-
-        def rubocop?(comment)
-          comment.text.match?(/^#\s*rubocop:(disable|enable|todo)\s/)
-        end
-
-        def gemspec?
-          return @gemspec if defined?(@gemspec)
-          path = processed_source.path
-          return @gemspec = false if path.nil?
-          @gemspec = root(File.dirname(path))
-        end
-
-        def root(dir)
-          return true if Dir.glob(File.join(dir, '*.gemspec')).any?
-          parent = File.dirname(dir)
-          return false if parent == dir
-          root(parent)
-        end
-
-        def docblock?(comment)
-          line = comment.location.line
-          successor = codeline(line)
-          return false if successor.nil?
-          definition?(successor)
-        end
-
-        def codeline(start)
-          lines = processed_source.lines
-          (start...lines.size).each do |idx|
-            content = lines[idx]
-            next if content.nil?
-            stripped = content.strip
-            next if stripped.empty? || stripped.start_with?('#')
-            return idx + 1
-          end
-          nil
-        end
-
-        def definition?(line)
-          ast = processed_source.ast
-          return false if ast.nil?
-          ast.each_node(:class, :module, :def, :defs) do |node|
-            return true if node.location.line == line
-          end
-          false
-        end
-
-        def register(comment)
-          add_offense(comment) do |corrector|
-            corrector.remove(removal(comment))
-          end
-        end
-
-        def removal(comment)
-          target = comment.source_range
-          prefix = target.source_line[0, target.column]
-          return fullrange(target) if prefix.strip.empty?
-          prefixed(target, prefix)
-        end
-
-        def fullrange(target)
-          start = target.begin_pos - target.column
-          ending = target.end_pos
-          ending += 1 if newline?(ending)
-          target.with(begin_pos: start, end_pos: ending)
-        end
-
-        def prefixed(target, prefix)
-          spaces = prefix.match(/\s*$/)[0]
-          target.with(begin_pos: target.begin_pos - spaces.length, end_pos: target.end_pos)
-        end
-
-        def newline?(pos)
-          processed_source.buffer.source[pos] == "\n"
-        end
-      end
+class RuboCop::Cop::Elegant::NoComments < RuboCop::Cop::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  MSG = 'Comment is not allowed, unless it is SPDX, magic, rubocop directive, or docblock'
+  public_constant :MSG
+
+  def on_new_investigation
+    processed_source.comments.each do |comment|
+      register(comment) unless allowed?(comment)
+    end
+  end
+
+  private
+
+  def allowed?(comment)
+    spdx?(comment) || magic?(comment) || rubocop?(comment) || (gemspec? && docblock?(comment))
+  end
+
+  def spdx?(comment)
+    comment.text.match?(/^#\s*SPDX-/)
+  end
+
+  def magic?(comment)
+    comment.text.match?(/^#\s*(frozen_string_literal|encoding|coding|warn_indent):/)
+  end
+
+  def rubocop?(comment)
+    comment.text.match?(/^#\s*rubocop:(disable|enable|todo)\s/)
+  end
+
+  def gemspec?
+    return @gemspec if defined?(@gemspec)
+    path = processed_source.path
+    return @gemspec = false if path.nil?
+    @gemspec = root(File.dirname(path))
+  end
+
+  def root(dir)
+    return true if Dir.glob(File.join(dir, '*.gemspec')).any?
+    parent = File.dirname(dir)
+    return false if parent == dir
+    root(parent)
+  end
+
+  def docblock?(comment)
+    line = comment.location.line
+    successor = codeline(line)
+    return false if successor.nil?
+    definition?(successor)
+  end
+
+  def codeline(start)
+    lines = processed_source.lines
+    (start...lines.size).each do |idx|
+      content = lines[idx]
+      next if content.nil?
+      stripped = content.strip
+      next if stripped.empty? || stripped.start_with?('#')
+      return idx + 1
+    end
+    nil
+  end
+
+  def definition?(line)
+    ast = processed_source.ast
+    return false if ast.nil?
+    ast.each_node(:class, :module, :def, :defs) do |node|
+      return true if node.location.line == line
+    end
+    false
+  end
+
+  def register(comment)
+    add_offense(comment) do |corrector|
+      corrector.remove(removal(comment))
     end
   end
+
+  def removal(comment)
+    target = comment.source_range
+    prefix = target.source_line[0, target.column]
+    return fullrange(target) if prefix.strip.empty?
+    prefixed(target, prefix)
+  end
+
+  def fullrange(target)
+    start = target.begin_pos - target.column
+    ending = target.end_pos
+    ending += 1 if newline?(ending)
+    target.with(begin_pos: start, end_pos: ending)
+  end
+
+  def prefixed(target, prefix)
+    spaces = prefix.match(/\s*$/)[0]
+    target.with(begin_pos: target.begin_pos - spaces.length, end_pos: target.end_pos)
+  end
+
+  def newline?(pos)
+    processed_source.buffer.source[pos] == "\n"
+  end
 end

data/lib/rubocop/cop/elegant/no_empty_lines_in_blocks.rb

@@ -3,113 +3,107 @@
 # SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 
-module RuboCop
-  module Cop
-    module Elegant
-      class NoEmptyLinesInBlocks < Base
-        extend AutoCorrector
-
-        MSG = 'Empty line inside block body is not allowed'
-        public_constant :MSG
-
-        def on_new_investigation
-          super
-          @reported = []
-          @gaps = scan
-        end
-
-        def on_block(node)
-          check(node)
-        end
-
-        def on_numblock(node)
-          check(node)
-        end
-
-        def on_if(node)
-          check(node)
-        end
-
-        def on_while(node)
-          check(node)
-        end
-
-        def on_until(node)
-          check(node)
-        end
-
-        def on_for(node)
-          check(node)
-        end
-
-        def on_case(node)
-          check(node)
-        end
-
-        def on_case_match(node)
-          check(node)
-        end
-
-        def on_kwbegin(node)
-          check(node)
-        end
-
-        private
-
-        def check(node)
-          lines = range(node)
-          return if lines.nil?
-          empty(lines).each { |num| register(num) }
-        end
-
-        def range(node)
-          first = node.first_line + 1
-          last = node.last_line - 1
-          return if first > last
-          (first..last)
-        end
-
-        def empty(lines)
-          result = []
-          lines.each do |num|
-            next if @gaps.include?(num)
-            line = processed_source.lines[num - 1]
-            result << num if line.strip.empty?
-          end
-          result
-        end
-
-        def scan
-          gaps = []
-          ast = processed_source.ast
-          return gaps if ast.nil?
-          ast.each_node(:def, :defs) do |node|
-            nxt = node.right_sibling
-            next unless nxt.is_a?(RuboCop::AST::Node)
-            next unless %i[def defs].include?(nxt.type)
-            first = node.last_line + 1
-            last = nxt.first_line - 1
-            next if first > last
-            (first..last).each { |n| gaps << n }
-          end
-          gaps
-        end
-
-        def register(num)
-          return if @reported.include?(num)
-          @reported << num
-          target = processed_source.buffer.line_range(num)
-          add_offense(target) do |corrector|
-            corrector.remove(fullrange(target))
-          end
-        end
-
-        def fullrange(target)
-          ending = target.end_pos
-          ending += 1 if processed_source.buffer.source[ending] == "\n"
-          target.with(end_pos: ending)
-        end
-      end
+class RuboCop::Cop::Elegant::NoEmptyLinesInBlocks < RuboCop::Cop::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  MSG = 'Empty line inside block body is not allowed'
+  public_constant :MSG
+
+  def on_new_investigation
+    super
+    @reported = []
+    @gaps = scan
+  end
+
+  def on_block(node)
+    check(node)
+  end
+
+  def on_numblock(node)
+    check(node)
+  end
+
+  def on_if(node)
+    check(node)
+  end
+
+  def on_while(node)
+    check(node)
+  end
+
+  def on_until(node)
+    check(node)
+  end
+
+  def on_for(node)
+    check(node)
+  end
+
+  def on_case(node)
+    check(node)
+  end
+
+  def on_case_match(node)
+    check(node)
+  end
+
+  def on_kwbegin(node)
+    check(node)
+  end
+
+  private
+
+  def check(node)
+    lines = range(node)
+    return if lines.nil?
+    empty(lines).each { |num| register(num) }
+  end
+
+  def range(node)
+    first = node.first_line + 1
+    last = node.last_line - 1
+    return if first > last
+    (first..last)
+  end
+
+  def empty(lines)
+    result = []
+    lines.each do |num|
+      next if @gaps.include?(num)
+      line = processed_source.lines[num - 1]
+      result << num if line.strip.empty?
     end
+    result
+  end
+
+  def scan
+    gaps = []
+    ast = processed_source.ast
+    return gaps if ast.nil?
+    ast.each_node(:def, :defs) do |node|
+      nxt = node.right_sibling
+      next unless nxt.is_a?(RuboCop::AST::Node)
+      next unless %i[def defs].include?(nxt.type)
+      first = node.last_line + 1
+      last = nxt.first_line - 1
+      next if first > last
+      (first..last).each { |n| gaps << n }
+    end
+    gaps
+  end
+
+  def register(num)
+    return if @reported.include?(num)
+    @reported << num
+    target = processed_source.buffer.line_range(num)
+    add_offense(target) do |corrector|
+      corrector.remove(fullrange(target))
+    end
+  end
+
+  def fullrange(target)
+    ending = target.end_pos
+    ending += 1 if processed_source.buffer.source[ending] == "\n"
+    target.with(end_pos: ending)
   end
 end

data/lib/rubocop/cop/elegant/no_empty_lines_in_methods.rb

@@ -3,61 +3,55 @@
 # SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 
-module RuboCop
-  module Cop
-    module Elegant
-      class NoEmptyLinesInMethods < Base
-        extend AutoCorrector
-
-        MSG = 'Empty line inside method body is not allowed'
-        public_constant :MSG
-
-        def on_def(node)
-          check(node)
-        end
-
-        def on_defs(node)
-          check(node)
-        end
-
-        private
-
-        def check(node)
-          return if node.body.nil?
-          lines = range(node)
-          return if lines.nil?
-          empty(lines).each { |num| register(num) }
-        end
-
-        def range(node)
-          first = node.body.first_line
-          last = node.body.last_line
-          return if first == last
-          (first..last)
-        end
-
-        def empty(lines)
-          result = []
-          lines.each do |num|
-            line = processed_source.lines[num - 1]
-            result << num if line.strip.empty?
-          end
-          result
-        end
-
-        def register(num)
-          target = processed_source.buffer.line_range(num)
-          add_offense(target) do |corrector|
-            corrector.remove(fullrange(target))
-          end
-        end
-
-        def fullrange(target)
-          ending = target.end_pos
-          ending += 1 if processed_source.buffer.source[ending] == "\n"
-          target.with(end_pos: ending)
-        end
-      end
+class RuboCop::Cop::Elegant::NoEmptyLinesInMethods < RuboCop::Cop::Base
+  extend RuboCop::Cop::AutoCorrector
+
+  MSG = 'Empty line inside method body is not allowed'
+  public_constant :MSG
+
+  def on_def(node)
+    check(node)
+  end
+
+  def on_defs(node)
+    check(node)
+  end
+
+  private
+
+  def check(node)
+    return if node.body.nil?
+    lines = range(node)
+    return if lines.nil?
+    empty(lines).each { |num| register(num) }
+  end
+
+  def range(node)
+    first = node.body.first_line
+    last = node.body.last_line
+    return if first == last
+    (first..last)
+  end
+
+  def empty(lines)
+    result = []
+    lines.each do |num|
+      line = processed_source.lines[num - 1]
+      result << num if line.strip.empty?
+    end
+    result
+  end
+
+  def register(num)
+    target = processed_source.buffer.line_range(num)
+    add_offense(target) do |corrector|
+      corrector.remove(fullrange(target))
     end
   end
+
+  def fullrange(target)
+    ending = target.end_pos
+    ending += 1 if processed_source.buffer.source[ending] == "\n"
+    target.with(end_pos: ending)
+  end
 end

data/lib/rubocop/cop/elegant/paired_brackets.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+
+# Enforces the "paired brackets" notation: every round, square, or curly
+# bracket must either be paired with its matching counterpart on the same
+# line, or end its own line (when opening) or start its own line (when
+# closing). Brackets stranded in the middle of a multi-line expression
+# are forbidden because they hide the structure of the code.
+#
+# See https://www.yegor256.com/2014/10/23/paired-brackets-notation.html
+class RuboCop::Cop::Elegant::PairedBrackets < RuboCop::Cop::Base
+  MSG = 'Bracket %<text>s must be paired on the same line, or start/end its line'
+  public_constant :MSG
+
+  OPENERS = %i[tLPAREN tLPAREN2 tLPAREN_ARG tLBRACK tLBRACK2 tLCURLY tLBRACE tLBRACE_ARG].freeze
+  private_constant :OPENERS
+
+  CLOSERS = %i[tRPAREN tRBRACK tRCURLY].freeze
+  private_constant :CLOSERS
+
+  def on_new_investigation
+    super
+    pair.each { |duo| check(duo) }
+  end
+
+  private
+
+  def pair
+    stack = []
+    result = []
+    processed_source.tokens.each do |tok|
+      if OPENERS.include?(tok.type)
+        stack << tok
+      elsif CLOSERS.include?(tok.type) && !stack.empty?
+        result << [stack.pop, tok]
+      end
+    end
+    result
+  end
+
+  def check(duo)
+    opener, closer = duo
+    return if opener.line == closer.line
+    register(opener) unless ends?(opener)
+    register(closer) unless starts?(closer)
+  end
+
+  def starts?(tok)
+    line = processed_source.lines[tok.line - 1]
+    line[0...tok.column].strip.empty?
+  end
+
+  def ends?(tok)
+    line = processed_source.lines[tok.line - 1]
+    after = line[(tok.column + tok.text.length)..-1].to_s.strip
+    after.empty? || after.start_with?('#')
+  end
+
+  def register(tok)
+    add_offense(tok.pos, message: format(MSG, text: tok.text))
+  end
+end

data/lib/rubocop/cop/elegant_cops.rb

@@ -1,10 +1,16 @@
 # frozen_string_literal: true
 
-require_relative 'elegant/good_method_name'
-require_relative 'elegant/good_variable_name'
 # SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 
+module RuboCop::Cop::Elegant; end
+
+require_relative 'elegant/class_in_module'
+require_relative 'elegant/good_method_name'
+require_relative 'elegant/good_variable_name'
+require_relative 'elegant/indentation_ladder'
+require_relative 'elegant/no_class_in_module'
 require_relative 'elegant/no_comments'
 require_relative 'elegant/no_empty_lines_in_blocks'
 require_relative 'elegant/no_empty_lines_in_methods'
+require_relative 'elegant/paired_brackets'

data/lib/rubocop/elegant/plugin.rb

@@ -5,29 +5,25 @@
 
 require 'lint_roller'
 
-module RuboCop
-  module Elegant
-    class Plugin < LintRoller::Plugin
-      def about
-        LintRoller::About.new(
-          name: 'rubocop-elegant',
-          version: VERSION,
-          homepage: 'https://github.com/yegor256/rubocop-elegant',
-          description: 'Set of custom RuboCop cops for elegant Ruby coding'
-        )
-      end
+class RuboCop::Elegant::Plugin < LintRoller::Plugin
+  def about
+    LintRoller::About.new(
+      name: 'rubocop-elegant',
+      version: RuboCop::Elegant::VERSION,
+      homepage: 'https://github.com/yegor256/rubocop-elegant',
+      description: 'Set of custom RuboCop cops for elegant Ruby coding'
+    )
+  end
 
-      def supported?(context)
-        context.engine == :rubocop
-      end
+  def supported?(context)
+    context.engine == :rubocop
+  end
 
-      def rules(_context)
-        LintRoller::Rules.new(
-          type: :path,
-          config_format: :rubocop,
-          value: Pathname.new(__dir__).join('../../../config/default.yml')
-        )
-      end
-    end
+  def rules(_context)
+    LintRoller::Rules.new(
+      type: :path,
+      config_format: :rubocop,
+      value: Pathname.new(__dir__).join('../../../config/default.yml')
+    )
   end
 end

data/lib/rubocop-elegant.rb

@@ -4,6 +4,9 @@
 # SPDX-License-Identifier: MIT
 
 require 'rubocop'
+
+module RuboCop::Elegant; end
+
 require_relative 'rubocop/cop/elegant_cops'
 require_relative 'rubocop/elegant/plugin'
 require_relative 'rubocop/elegant/version'

data/rubocop-elegant.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to?(:required_rubygems_version=)
   s.required_ruby_version = '>=2.2'
   s.name = 'rubocop-elegant'
-  s.version = '0.0.20'
+  s.version = '0.1.0'
   s.license = 'MIT'
   s.summary = 'Set of custom RuboCop cops for elegant Ruby coding'
   s.description =

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-elegant
 version: !ruby/object:Gem::Version
-  version: 0.0.20
+  version: 0.1.0
 platform: ruby
 authors:
 - Yegor Bugayenko
@@ -53,11 +53,15 @@ files:
 - Rakefile
 - config/default.yml
 - lib/rubocop-elegant.rb
+- lib/rubocop/cop/elegant/class_in_module.rb
 - lib/rubocop/cop/elegant/good_method_name.rb
 - lib/rubocop/cop/elegant/good_variable_name.rb
+- lib/rubocop/cop/elegant/indentation_ladder.rb
+- lib/rubocop/cop/elegant/no_class_in_module.rb
 - lib/rubocop/cop/elegant/no_comments.rb
 - lib/rubocop/cop/elegant/no_empty_lines_in_blocks.rb
 - lib/rubocop/cop/elegant/no_empty_lines_in_methods.rb
+- lib/rubocop/cop/elegant/paired_brackets.rb
 - lib/rubocop/cop/elegant_cops.rb
 - lib/rubocop/elegant/plugin.rb
 - lib/rubocop/elegant/version.rb