rubocop-style-compact_nesting 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9522330e63c14fdd73354334b2d9dfefd06d49df980caf688fe2bd4275334670
+  data.tar.gz: f6b7dec706d52314d6da24f9dc511e3d212e7ec1a3577d2c8ae4714798ad5105
+SHA512:
+  metadata.gz: a69a975b93152147a509dabe4b55762126a018e9d08bd06e6b4710da937aaabe4ba81b76bb439ae1f70c07dbf7d785078e2b6262061bdbfe518a03705c5778d7
+  data.tar.gz: 1d07834409a49eae53ff01740770b7b6f16d742eb03adaf2fc94593529aa5abbe2c85762b171d7501b663b8e177a48861428be8ce2c7a975c69803a1be39e19a

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## [0.1.0] - 2026-06-01
+
+### Added
+- Initial release.
+- `Style/CompactModuleNesting` cop with safe autocorrect:
+  - Collapses outer module wrappers around an innermost class into a single
+    compact `module A::B` with the class nested separately.
+  - Splits `class A::B::C` into `module A::B; class C; end; end`.
+  - Collapses pure module-only chains into a single compact
+    `module A::B::C` wrapping the body directly.
+  - Flags files with more than one top-level module/class.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ramon GR
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,114 @@
+# rubocop-style-compact_nesting
+
+A RuboCop plugin that enforces a hybrid module/class nesting style:
+
+- All namespace segments are **collapsed onto a single `module` line** using
+  `::`.
+- When the innermost definition in a wrapper chain is a `class`, that class
+  is **nested separately** inside the compact `module` wrapper.
+- When the chain is entirely modules, every segment is collapsed into a
+  single compact `module A::B::C` wrapping the body directly.
+
+## Canonical form
+
+```ruby
+module A::B::C
+  class D
+    # ...
+  end
+end
+```
+
+## Examples
+
+```ruby
+# bad
+module A
+  module B
+    class C
+      # ...
+    end
+  end
+end
+
+# good
+module A::B
+  class C
+    # ...
+  end
+end
+```
+
+```ruby
+# bad
+class A::B::C
+  # ...
+end
+
+# good
+module A::B
+  class C
+    # ...
+  end
+end
+```
+
+```ruby
+# good (no namespace)
+class Foo
+  # ...
+end
+```
+
+```ruby
+# bad
+module A
+  module B
+    module C
+    end
+  end
+end
+
+# good (module-only chain collapses to one compact module)
+module A::B::C
+end
+```
+
+## Installation
+
+```ruby
+# Gemfile
+gem 'rubocop-style-compact_nesting', require: false
+```
+
+```yaml
+# .rubocop.yml
+plugins:
+  - rubocop-style-compact_nesting
+
+# This cop conflicts with the built-in Style/ClassAndModuleChildren.
+Style/ClassAndModuleChildren:
+  Enabled: false
+```
+
+Requires RuboCop `>= 1.72` and Ruby `>= 3.1`.
+
+## Rules
+
+### `Style/CompactModuleNesting`
+
+- Detects chains of wrapper modules whose body is a single nested
+  module/class ending in a `class`, and rewrites them to one compact outer
+  `module A::B::C` with a separately nested innermost `class D`.
+- Rewrites `class A::B::C` to `module A::B; class C; end; end`.
+- Collapses pure module-only chains into a single compact
+  `module A::B::C` wrapping the body directly.
+- Flags (without autocorrect) files that define more than one top-level
+  module/class.
+- Ignores bare top-level classes/modules with no namespace.
+- Ignores wrapper modules whose body contains anything besides a single
+  nested definition (e.g. constants, methods, or sibling classes).
+
+## License
+
+MIT

data/config/default.yml

@@ -0,0 +1,9 @@
+Style/CompactModuleNesting:
+  Description: >-
+    Enforce a compact outer module namespace with a separately nested
+    innermost class or module.
+  Enabled: true
+  Severity: convention
+  VersionAdded: '0.1'
+  SafeAutoCorrect: true
+  StyleGuide: ~

data/lib/rubocop/cop/style/compact_module_nesting.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces a compact outer module namespace with a separately nested
+      # innermost class.
+      #
+      # When the innermost definition in a wrapper chain is a `class`, the
+      # outer modules are collapsed into a single compact `module A::B`
+      # wrapping the class. When the chain is entirely modules, every
+      # segment is collapsed into a single compact `module A::B::C`
+      # wrapping the body directly.
+      #
+      # The canonical form is one `module A::B::C` line wrapping a single
+      # nested innermost `class D`:
+      #
+      #   module A::B::C
+      #     class D
+      #     end
+      #   end
+      #
+      # @example
+      #   # bad
+      #   module A
+      #     module B
+      #       class C
+      #       end
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class A::B::C
+      #   end
+      #
+      #   # good
+      #   module A::B
+      #     class C
+      #     end
+      #   end
+      #
+      #   # good (no namespace)
+      #   class Foo
+      #   end
+      class CompactModuleNesting < Base
+        extend AutoCorrector
+
+        MSG_NESTING        = 'Use compact outer module nesting: `%<canonical>s`.'
+        MSG_MULTIPLE_ROOTS = 'Only one top-level module or class is allowed per file.'
+
+        def on_module(node)
+          handle(node)
+        end
+
+        def on_class(node)
+          handle(node)
+        end
+
+        def on_new_investigation
+          check_multiple_top_level_definitions
+        end
+
+        private
+
+        # Process only outermost definitions; nested wrappers are reached via the
+        # collected chain.
+        def handle(node)
+          return if nested_inside_definition?(node)
+
+          chain = collect_wrapper_chain(node)
+          return unless chain
+
+          segments  = chain[:segments]
+          innermost = chain[:innermost]
+
+          if innermost.class_type?
+            # Skip when there's no nested innermost AND no class-path to split.
+            return if node.equal?(innermost) && !requires_split?(node, segments, innermost)
+
+            return unless segments.size >= 2
+
+            outer_segments = segments[0..-2]
+            inner_segment  = segments.last
+            inner_keyword  = :class
+
+            return if canonical?(node, innermost, outer_segments, inner_segment, inner_keyword)
+
+            register_offense(node, innermost, outer_segments, inner_segment, inner_keyword)
+          else
+            # Module-only chain: collapse all segments into a single
+            # `module A::B::C` wrapping the body directly.
+            return if node.equal?(innermost)
+            return unless segments.size >= 2
+
+            register_offense(node, innermost, segments, nil, nil)
+          end
+        end
+
+        def nested_inside_definition?(node)
+          parent = node.parent
+          return false unless parent
+
+          parent.module_type? || parent.class_type?
+        end
+
+        # Walk a chain of `module`/`class` nodes whose body is a single nested
+        # definition, gathering all namespace segments. Returns nil if the
+        # outermost is not part of any namespaced structure worth checking.
+        #
+        # Returns a hash: { segments: [String, ...], innermost: Node }
+        def collect_wrapper_chain(node)
+          segments = []
+          current  = node
+
+          loop do
+            const_path = constant_path(current.identifier)
+            return nil unless const_path
+
+            segments.concat(const_path)
+
+            body = current.body
+            if body && (body.module_type? || body.class_type?) && current.module_type?
+              # Only modules may act as namespace wrappers in our style; a class
+              # cannot wrap another definition this way.
+              current = body
+              next
+            end
+
+            return { segments: segments, innermost: current }
+          end
+        end
+
+        # Splits a const node like `A::B::C` into ['A', 'B', 'C'].
+        # Returns nil for `self::Foo`, `cbase`-rooted (`::A::B` is fine), or
+        # anything else non-trivial.
+        def constant_path(const_node)
+          return nil unless const_node&.const_type?
+
+          parts = []
+          current = const_node
+
+          while current&.const_type?
+            parts.unshift(current.short_name.to_s)
+            scope = current.namespace
+            if scope.nil?
+              return parts
+            elsif scope.cbase_type?
+              # leading `::` — treat as absolute, still valid namespace path
+              return parts
+            elsif scope.const_type?
+              current = scope
+            else
+              # e.g. `self::Foo`
+              return nil
+            end
+          end
+
+          parts
+        end
+
+        def requires_split?(node, segments, innermost)
+          # `class A::B::C` (single class node with multi-segment path) needs
+          # to be split into `module A::B` + `class C`.
+          return false unless segments.size >= 2
+
+          node.equal?(innermost) && node.class_type?
+        end
+
+        def canonical?(outer, innermost, outer_segments, inner_segment, inner_keyword)
+          return false unless outer.module_type?
+          return false unless innermost.send(:"#{inner_keyword}_type?")
+
+          outer_path = constant_path(outer.identifier)
+          inner_path = constant_path(innermost.identifier)
+
+          outer_path == outer_segments &&
+            inner_path == [inner_segment] &&
+            outer.body.equal?(innermost) &&
+            outer_segments.any?
+        end
+
+        def register_offense(node, innermost, outer_segments, inner_segment, inner_keyword)
+          canonical_source = build_canonical_source(node, innermost, outer_segments, inner_segment, inner_keyword)
+          first_line = canonical_source.lines.first.strip
+
+          add_offense(node, message: format(MSG_NESTING, canonical: first_line)) do |corrector|
+            corrector.replace(node, canonical_source)
+          end
+        end
+
+        def build_canonical_source(node, innermost, outer_segments, inner_segment, inner_keyword)
+          base_indent  = ' ' * node.loc.expression.column
+          outer_const  = outer_segments.join('::')
+
+          lines = ["module #{outer_const}"]
+
+          if inner_keyword
+            inner_indent = "#{base_indent}  "
+            body_source  = inner_body_source(innermost, inner_indent)
+
+            lines << "#{inner_indent}#{inner_keyword} #{inner_segment}"
+            lines << body_source unless body_source.empty?
+            lines << "#{inner_indent}end"
+          else
+            body_source = inner_body_source(innermost, base_indent)
+            lines << body_source unless body_source.empty?
+          end
+
+          lines << "#{base_indent}end"
+
+          # First line already sits at `base_indent` in the source we're
+          # replacing; subsequent lines need explicit indentation, which we've
+          # baked in above. Just join.
+          lines.join("\n")
+        end
+
+        # Re-indents the body of the innermost definition so it sits two spaces
+        # deeper than the new inner keyword line. Returns "" if there is no
+        # body.
+        def inner_body_source(innermost, inner_indent)
+          body = innermost.body
+          return '' unless body
+
+          body_indent = "#{inner_indent}  "
+          original    = body.source
+          original_col = body.loc.expression.column
+          shift        = body_indent.length - original_col
+
+          original.lines.map.with_index do |line, idx|
+            if idx.zero?
+              "#{body_indent}#{line.chomp}"
+            elsif line.strip.empty?
+              line.chomp
+            elsif shift.positive?
+              "#{' ' * shift}#{line.chomp}"
+            elsif shift.negative?
+              line.chomp.sub(/\A {0,#{-shift}}/, '')
+            else
+              line.chomp
+            end
+          end.join("\n")
+        end
+
+        def check_multiple_top_level_definitions
+          root = processed_source.ast
+          return unless root
+
+          top_defs =
+            if root.begin_type?
+              root.children.select { |c| c.respond_to?(:type) && (c.class_type? || c.module_type?) }
+            elsif root.class_type? || root.module_type?
+              [root]
+            else
+              []
+            end
+
+          return if top_defs.size <= 1
+
+          top_defs.drop(1).each do |extra|
+            add_offense(extra, message: MSG_MULTIPLE_ROOTS)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/style/compact_nesting/cops.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative '../../cop/style/compact_module_nesting'

data/lib/rubocop/style/compact_nesting/plugin.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'lint_roller'
+
+module RuboCop
+  module Style
+    module CompactNesting
+      # A RuboCop plugin (LintRoller) that registers the
+      # `Style/CompactModuleNesting` cop and its default configuration.
+      class Plugin < LintRoller::Plugin
+        def about
+          LintRoller::About.new(
+            name: 'rubocop-style-compact_nesting',
+            version: VERSION,
+            homepage: 'https://github.com/ramongr/rubocop-style-compact_nesting',
+            description: 'Enforce compact outer module nesting with a separately ' \
+                         'nested innermost class/module.'
+          )
+        end
+
+        def supported?(context)
+          context.engine == :rubocop
+        end
+
+        def rules(_context)
+          project_root = Pathname.new(__dir__).join('..', '..', '..', '..').expand_path
+
+          LintRoller::Rules.new(
+            type: :path,
+            config_format: :rubocop,
+            value: project_root.join('config', 'default.yml')
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/style/compact_nesting/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Style
+    module CompactNesting
+      VERSION = '0.1.0'
+    end
+  end
+end

data/lib/rubocop-style-compact_nesting.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+require_relative 'rubocop/style/compact_nesting/version'
+require_relative 'rubocop/style/compact_nesting/plugin'
+require_relative 'rubocop/style/compact_nesting/cops'

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-style-compact_nesting
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ramon Rodrigues
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lint_roller
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.72'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.72'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: |
+  A RuboCop plugin providing Style/CompactModuleNesting, which enforces a
+  hybrid module/class nesting style: all namespace segments collapsed onto a
+  single `module A::B::C` line, with the innermost class or module nested
+  separately inside it.
+email:
+- cerberus.ramon@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- config/default.yml
+- lib/rubocop-style-compact_nesting.rb
+- lib/rubocop/cop/style/compact_module_nesting.rb
+- lib/rubocop/style/compact_nesting/cops.rb
+- lib/rubocop/style/compact_nesting/plugin.rb
+- lib/rubocop/style/compact_nesting/version.rb
+homepage: https://github.com/ramongr/rubocop-style-compact_nesting
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ramongr/rubocop-style-compact_nesting
+  source_code_uri: https://github.com/ramongr/rubocop-style-compact_nesting
+  changelog_uri: https://github.com/ramongr/rubocop-style-compact_nesting/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+  default_lint_roller_plugin: RuboCop::Style::CompactNesting::Plugin
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: RuboCop cop enforcing compact outer module nesting with a separately nested
+  innermost class/module.
+test_files: []