rubocop-sane 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 46577dac32dde6106d874ce5fa85e7a54a94d589e075b54d281d7b68d9649e19
+  data.tar.gz: 8e1280ecc3bee57ed3cb65924ee86ce9b02c6032e74ee58864989fdf9b4cdac9
+SHA512:
+  metadata.gz: 70e429be341dc7b52167483547162dcf4f52a99f278c98782eec989d0a8a061b72f40cd8dfd5d8b9d56cdfd79b9eb3c1934c353e1de29b435f46790b9c1586eb
+  data.tar.gz: 58dc631f79eb2cb9a022359fe0ba690ae55607b927b840113f469f648909f205619d5ef15fd427d88a24ed1ddac43fd7156b0aa7c1576385585951b5228706ea

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,110 @@
+plugins:
+  - rubocop-rake
+  - rubocop-rspec
+  - rubocop-performance
+
+AllCops:
+  DisplayCopNames: true
+  DisplayStyleGuide: true
+  NewCops: enable
+  TargetRubyVersion: 3.2
+  Exclude:
+    - sorbet/**/*.rbi
+
+# Standard naming for RuboCop extension gems
+Naming/FileName:
+  Exclude:
+    - lib/rubocop-sane.rb
+
+Layout/FirstArrayElementIndentation:
+  EnforcedStyle: consistent
+
+Layout/FirstHashElementIndentation:
+  EnforcedStyle: consistent
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
+Layout/SpaceInsideArrayLiteralBrackets:
+  EnforcedStyle: no_space
+
+Lint/EmptyFile:
+  Enabled: true
+
+Metrics/AbcSize:
+  Max: 20
+  Exclude:
+    - lib/rubocop/cop/sane/empty_lines_around_multiline_block.rb
+
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*_spec.rb
+
+Metrics/ClassLength:
+  Max: 150
+  Exclude:
+    - lib/rubocop/cop/sane/empty_lines_around_multiline_block.rb
+
+Metrics/CyclomaticComplexity:
+  Max: 10
+  Exclude:
+    - lib/rubocop/cop/sane/empty_lines_around_multiline_block.rb
+
+Metrics/MethodLength:
+  Max: 20
+
+Metrics/PerceivedComplexity:
+  Max: 10
+  Exclude:
+    - lib/rubocop/cop/sane/empty_lines_around_multiline_block.rb
+
+Naming/PredicatePrefix:
+  Enabled: false
+
+RSpec/ExampleLength:
+  Max: 20
+
+RSpec/MultipleDescribes:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Max: 15
+
+RSpec/MultipleMemoizedHelpers:
+  Max: 10
+
+RSpec/NestedGroups:
+  Max: 5
+
+Style/ClassVars:
+  Enabled: false
+
+Style/ConditionalAssignment:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/SymbolArray:
+  EnforcedStyle: brackets
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: diff_comma
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/WordArray:
+  EnforcedStyle: brackets
+
+Style/NumericPredicate:
+  Enabled: false

data/.vscode/cspell.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://raw.githubusercontent.com/streetsidesoftware/cspell/main/cspell.schema.json",
+  "version": "0.2",
+  "dictionaryDefinitions": [
+    {
+      "name": "project-words",
+      "path": "./project-words.txt",
+      "addWords": true
+    }
+  ],
+  "dictionaries": [
+    "project-words"
+  ],
+  "ignorePaths": [
+    ".idea",
+    ".ruby-lsp",
+    "log",
+    "storage",
+    "tmp",
+    "vendor",
+    "*.svg",
+    "*.dump",
+    "*.enc",
+    "Gemfile.lock",
+    "/.vscode/project-words.txt",
+    "spec/fixtures/**/*"
+  ]
+}

data/.vscode/project-words.txt

@@ -0,0 +1,6 @@
+bindir
+Kodkod
+numblock
+popen
+readlines
+RuboCop

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-12-19
+
+- Initial release

data/CLAUDE.md

@@ -0,0 +1,77 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+rubocop-sane is a RuboCop extension gem that provides custom cops for enforcing sensible Ruby coding conventions. It uses the LintRoller plugin system for integration with RuboCop.
+
+## Common Commands
+
+```bash
+# Install dependencies
+bin/setup
+
+# Run all tests
+bundle exec rake spec
+
+# Run a single test file
+bundle exec rspec spec/rubocop/cop/sane/disallow_methods_spec.rb
+
+# Run a single test by line number
+bundle exec rspec spec/rubocop/cop/sane/disallow_methods_spec.rb:42
+
+# Run RuboCop linting
+bundle exec rubocop
+
+# Run all checks (tests + rubocop)
+bundle exec rake
+
+# Interactive console
+bin/console
+```
+
+## Architecture
+
+### Entry Point & Plugin System
+
+- `lib/rubocop-sane.rb` - Main entry point that loads all components
+- `lib/rubocop/sane/plugin.rb` - LintRoller plugin that integrates with RuboCop's plugin system
+- `config/default.yml` - Default cop configurations
+
+### Cop Structure
+
+All cops live under `lib/rubocop/cop/sane/` and follow RuboCop's cop pattern:
+- Inherit from `RuboCop::Cop::Base`
+- Use `extend AutoCorrector` for auto-fix support
+- Implement `on_*` methods (e.g., `on_send`, `on_if`) to visit AST nodes
+
+### Current Cops
+
+1. **DisallowMethods** - Configurable cop for method replacements and prohibitions with auto-correct
+2. **ConditionalAssignmentAllowTernary** - Enforces assignment inside conditions but allows ternary operators
+3. **EmptyLineBeforeComment** - Requires blank line before comments (except after block starts, class/method definitions, etc.)
+4. **EmptyLinesAroundMultilineBlock** - Enforces empty lines around multiline if/case/block statements
+
+### Testing
+
+Tests use RuboCop's `ExpectOffense` helper which provides a DSL for testing cop behavior:
+```ruby
+expect_offense(<<~RUBY)
+  foo = if bar
+  ^^^^^^^^^^^^ Move the assignment inside the `if` branch.
+    1
+  else
+    2
+  end
+RUBY
+```
+
+The `^` characters mark where the offense should be detected.
+
+## Adding a New Cop
+
+1. Create cop file in `lib/rubocop/cop/sane/your_cop.rb`
+2. Add require in `lib/rubocop/cop/sane_cops.rb`
+3. Add configuration in `config/default.yml`
+4. Create spec in `spec/rubocop/cop/sane/your_cop_spec.rb`

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"rubocop-sane" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at ["678665+akodkod@users.noreply.github.com"](mailto:"678665+akodkod@users.noreply.github.com").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Andrew Kodkod
+
+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,43 @@
+# Rubocop::Sane
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/rubocop/sane`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rubocop-sane. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/rubocop-sane/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Rubocop::Sane project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/rubocop-sane/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: [:spec, :rubocop]

data/config/default.yml

@@ -0,0 +1,33 @@
+Sane:
+  Enabled: true
+  DocumentationBaseURL: https://github.com/akodkod/rubocop-sane
+
+Sane/DisallowMethods:
+  Description: "Enforces method replacements and prohibitions."
+  Enabled: true
+  VersionAdded: "0.1.0"
+  SafeAutoCorrect: false
+  ReplaceMethods: {}
+  ProhibitedMethods: {}
+
+Sane/ConditionalAssignmentAllowTernary:
+  Description: "Enforces assignment inside conditions, but allows ternary operators."
+  Enabled: true
+  VersionAdded: "0.1.0"
+
+Sane/EmptyLineBeforeComment:
+  Description: "Enforces empty line before comments, except after block starts."
+  Enabled: true
+  VersionAdded: "0.1.0"
+  SafeAutoCorrect: true
+
+Sane/EmptyLinesAroundMultilineBlock:
+  Description: "Enforces empty lines before and after multiline blocks."
+  Enabled: true
+  VersionAdded: "0.1.0"
+  SafeAutoCorrect: true
+
+Sane/NoMethodCallAfterEnd:
+  Description: "Prohibits calling methods directly after `end`."
+  Enabled: true
+  VersionAdded: "0.1.0"

data/lib/rubocop/cop/sane/conditional_assignment_allow_ternary.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sane
+      # This cop enforces `assign_inside_condition` style like
+      # `Style/ConditionalAssignment`, but allows ternary operators.
+      #
+      # @example
+      #   # bad
+      #   foo = if condition
+      #     1
+      #   else
+      #     2
+      #   end
+      #
+      #   # bad
+      #   foo = case bar
+      #   when :a then 1
+      #   when :b then 2
+      #   end
+      #
+      #   # good - assignment inside condition
+      #   if condition
+      #     foo = 1
+      #   else
+      #     foo = 2
+      #   end
+      #
+      #   # good - ternary operators are allowed
+      #   foo = condition ? 1 : 2
+      #
+      #   # good - multiline ternary operators are allowed
+      #   foo = condition
+      #     ? 1
+      #     : 2
+      #
+      class ConditionalAssignmentAllowTernary < Base
+        MSG = "Move the assignment inside the `%<keyword>s` branch."
+
+        ASSIGNMENT_TYPES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn].freeze
+
+        def on_lvasgn(node)
+          check_assignment(node)
+        end
+
+        alias on_ivasgn on_lvasgn
+        alias on_cvasgn on_lvasgn
+        alias on_gvasgn on_lvasgn
+        alias on_casgn on_lvasgn
+
+        def on_masgn(node)
+          check_assignment(node)
+        end
+
+        def on_op_asgn(node)
+          check_assignment(node)
+        end
+
+        def on_or_asgn(node)
+          check_assignment(node)
+        end
+
+        def on_and_asgn(node)
+          check_assignment(node)
+        end
+
+        private
+
+        def check_assignment(node)
+          return unless assignment_to_conditional?(node)
+
+          rhs = extract_rhs(node)
+          return unless rhs
+
+          keyword = rhs.if_type? ? rhs.keyword : "case"
+          add_offense(node, message: format(MSG, keyword: keyword))
+        end
+
+        def assignment_to_conditional?(node)
+          rhs = extract_rhs(node)
+          return false unless rhs
+
+          if rhs.if_type?
+            # Allow ternary operators, only flag if/else blocks
+            return false if rhs.ternary?
+
+            rhs.else?
+          else
+            rhs.case_type?
+          end
+        end
+
+        def extract_rhs(node)
+          case node.type
+          when :lvasgn, :ivasgn, :cvasgn, :gvasgn, :masgn, :or_asgn, :and_asgn
+            node.children[1]
+          when :casgn, :op_asgn
+            node.children[2]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sane/disallow_methods.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sane
+      # Enforces method replacements and prohibitions.
+      #
+      # This cop checks for usage of specified methods and either suggests
+      # replacements (with auto-correction) or prohibits usage entirely.
+      #
+      # @example ReplaceMethods configuration
+      #   # .rubocop.yml
+      #   # Sane/DisallowMethods:
+      #   #   ReplaceMethods:
+      #   #     deliver_now:
+      #   #       with: deliver_later
+      #   #       reason: "`deliver_later` sends the email via background job"
+      #
+      #   # bad
+      #   UserMailer.welcome(user).deliver_now
+      #
+      #   # good
+      #   UserMailer.welcome(user).deliver_later
+      #
+      # @example ProhibitedMethods configuration
+      #   # .rubocop.yml
+      #   # Sane/DisallowMethods:
+      #   #   ProhibitedMethods:
+      #   #     dangerous_method:
+      #   #       reason: "This method is deprecated and unsafe"
+      #
+      #   # bad
+      #   obj.dangerous_method
+      #
+      class DisallowMethods < Base
+        extend AutoCorrector
+
+        REPLACEABLE_METHOD_MSG = "You should use `%<with>s` instead of `%<method_name>s` because %<reason>s"
+        PROHIBITED_METHOD_MSG = "You should not use `%<method_name>s` because %<reason>s"
+
+        def on_send(node)
+          method_name = node.method_name
+          replaceable = replace_methods[method_name]
+          prohibited = prohibited_methods[method_name]
+
+          if replaceable
+            handle_replaceable_method(node, method_name, replaceable)
+          elsif prohibited
+            handle_prohibited_method(node, method_name, prohibited)
+          end
+        end
+
+        private
+
+        def handle_replaceable_method(node, method_name, config)
+          message = format(
+            REPLACEABLE_METHOD_MSG,
+            method_name: method_name,
+            with: config["with"],
+            reason: config["reason"],
+          )
+
+          add_offense(node, severity: :error, message: message) do |corrector|
+            corrector.replace(node.loc.selector, config["with"])
+          end
+        end
+
+        def handle_prohibited_method(node, method_name, config)
+          message = format(
+            PROHIBITED_METHOD_MSG,
+            method_name: method_name,
+            reason: config["reason"],
+          )
+
+          add_offense(node, severity: :error, message: message)
+        end
+
+        def replace_methods
+          @replace_methods ||= build_method_hash(cop_config.fetch("ReplaceMethods", {}))
+        end
+
+        def prohibited_methods
+          @prohibited_methods ||= build_method_hash(cop_config.fetch("ProhibitedMethods", {}))
+        end
+
+        def build_method_hash(config)
+          return {} unless config.is_a?(Hash)
+
+          config.transform_keys(&:to_sym)
+        end
+
+        def safe_autocorrect?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sane/empty_line_before_comment.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sane
+      # Enforces an empty line before comments, except when the previous line
+      # is the start of a block, class, method, or another comment.
+      #
+      # @example
+      #   # bad
+      #   foo = 1
+      #   # This is a comment
+      #   bar = 2
+      #
+      #   # good
+      #   foo = 1
+      #
+      #   # This is a comment
+      #   bar = 2
+      #
+      #   # good - after block/class/method start
+      #   def foo
+      #     # This comment doesn't need a blank line
+      #     bar
+      #   end
+      #
+      #   # good - consecutive comments
+      #   # First comment
+      #   # Second comment
+      #
+      #   # good - after control structure start
+      #   if condition
+      #     # Comment inside if
+      #     do_something
+      #   end
+      #
+      class EmptyLineBeforeComment < Base
+        extend AutoCorrector
+
+        MSG = "Add empty line before comment."
+
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            check_comment(comment)
+          end
+        end
+
+        private
+
+        def check_comment(comment)
+          return if inline_comment?(comment)
+          return if first_line?(comment)
+          return if preceded_by_empty_line?(comment)
+          return if preceded_by_comment?(comment)
+          return if preceded_by_block_start?(comment)
+
+          add_offense(comment) do |corrector|
+            corrector.insert_before(
+              comment.source_range.with(
+                begin_pos: comment.source_range.begin_pos - comment.source_range.column,
+              ),
+              "\n",
+            )
+          end
+        end
+
+        def inline_comment?(comment)
+          # Check if there's code before the comment on the same line
+          comment_line = processed_source.lines[comment.loc.line - 1]
+          return false unless comment_line
+
+          # Get the portion of the line before the comment
+          before_comment = comment_line[0...comment.loc.column]
+          before_comment && !before_comment.strip.empty?
+        end
+
+        def first_line?(comment)
+          comment.loc.line == 1
+        end
+
+        def preceded_by_empty_line?(comment)
+          prev_line_number = comment.loc.line - 1
+          return true if prev_line_number < 1
+
+          prev_line = processed_source.lines[prev_line_number - 1]
+          prev_line.nil? || prev_line.strip.empty?
+        end
+
+        def preceded_by_comment?(comment)
+          prev_line_number = comment.loc.line - 1
+          return false if prev_line_number < 1
+
+          processed_source.comments.any? { |c| c.loc.line == prev_line_number }
+        end
+
+        def preceded_by_block_start?(comment)
+          prev_line_number = comment.loc.line - 1
+          return false if prev_line_number < 1
+
+          prev_line = processed_source.lines[prev_line_number - 1]
+          return false unless prev_line
+
+          block_start_pattern?(prev_line)
+        end
+
+        def block_start_pattern?(line)
+          stripped = line.strip
+
+          # Class, module, method definitions
+          return true if stripped.match?(/\A(class|module|def)\s/)
+
+          # Control structures
+          return true if stripped.match?(/\A(if|unless|case|while|until|for|begin)\s/)
+          return true if stripped == "begin"
+
+          # Block openers (do or {)
+          return true if stripped.end_with?(" do", " do |", "\tdo")
+          return true if stripped.match?(/do\s*\|[^|]*\|\s*\z/)
+          return true if stripped.end_with?("{")
+          return true if stripped.match?(/\{\s*\|[^|]*\|\s*\z/)
+
+          # Rescue/ensure/else/elsif/when inside blocks
+          return true if stripped.match?(/\A(rescue|ensure|else|elsif|when)\b/)
+
+          # Private/protected/public access modifiers
+          return true if stripped.match?(/\A(private|protected|public)\s*\z/)
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sane/empty_lines_around_multiline_block.rb

@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sane
+      # This cop enforces empty lines before and after multiline blocks
+      # such as `if/else` and `case/when`.
+      #
+      # @example
+      #   # bad
+      #   work_for = data.work_done_for
+      #   if data.present?
+      #     creation_date = date1
+      #   else
+      #     creation_date = date2
+      #   end
+      #   legal_start_date = date3
+      #
+      #   # good
+      #   work_for = data.work_done_for
+      #
+      #   if data.present?
+      #     creation_date = date1
+      #   else
+      #     creation_date = date2
+      #   end
+      #
+      #   legal_start_date = date3
+      #
+      #   # good - no blank line needed at beginning of method
+      #   def foo
+      #     if condition
+      #       bar
+      #     else
+      #       baz
+      #     end
+      #
+      #     qux
+      #   end
+      #
+      #   # good - no blank line needed at end of method
+      #   def foo
+      #     bar
+      #
+      #     if condition
+      #       baz
+      #     else
+      #       qux
+      #     end
+      #   end
+      #
+      class EmptyLinesAroundMultilineBlock < Base
+        extend AutoCorrector
+
+        MSG_BEFORE = "Add empty line before multiline `%<keyword>s` block."
+        MSG_AFTER = "Add empty line after multiline `%<keyword>s` block."
+
+        def on_if(node)
+          return if node.ternary?
+          return if node.modifier_form?
+          return if node.elsif? # elsif is part of parent if, not a separate block
+          return unless multiline?(node)
+          return if part_of_expression?(node)
+
+          check_empty_line_before(node)
+          check_empty_line_after(node)
+        end
+
+        def part_of_expression?(node)
+          parent = node.parent
+          return false unless parent
+
+          # Part of assignment: foo = if ... end
+          return true if assignment_node?(parent)
+
+          # Part of setter call: obj.foo = if ... end
+          return true if parent.send_type? && parent.method_name.to_s.end_with?("=")
+
+          # Part of method arguments: foo(if ... end)
+          return true if parent.send_type? && parent.arguments.include?(node)
+
+          # Part of array: [if ... end]
+          return true if parent.array_type?
+
+          # Part of hash value: { key: if ... end }
+          return true if parent.pair_type?
+
+          false
+        end
+
+        def on_case(node)
+          return unless multiline?(node)
+
+          check_empty_line_before(node)
+          check_empty_line_after(node)
+        end
+
+        alias on_case_match on_case
+
+        def on_block(node)
+          return unless multiline?(node)
+          return if chained_block?(node) # e.g., expect { ... }.to raise_error
+          return if lambda_block?(node) # e.g., -> { ... } or -> do ... end
+
+          check_empty_line_before(node)
+          check_empty_line_after(node)
+        end
+
+        alias on_numblock on_block
+
+        def lambda_block?(node)
+          node.send_node&.lambda_literal?
+        end
+
+        def chained_block?(node)
+          # Skip blocks that are part of a method chain
+          # e.g., expect { ... }.to raise_error
+          # e.g., foo.map { ... }&.join (csend is safe navigation &.)
+          parent = node.parent
+          return true if (parent&.send_type? || parent&.csend_type?) && parent.receiver == node
+
+          # Skip blocks that are part of an assignment expression
+          # e.g., self.foo = items.map do ... end
+          return true if part_of_assignment?(node)
+
+          false
+        end
+
+        def part_of_assignment?(node)
+          parent = node.parent
+          return false unless parent
+
+          # Direct assignment: foo = bar.map do...end
+          return true if assignment_node?(parent)
+
+          # Assignment via setter: self.foo = bar.map do...end
+          return true if parent.send_type? && parent.method_name.to_s.end_with?("=")
+
+          # Hash value: { key: items.map do...end }
+          return true if parent.pair_type?
+
+          # Array element: [items.map do...end]
+          return true if parent.array_type?
+
+          false
+        end
+
+        def assignment_node?(node)
+          [:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn, :masgn, :op_asgn, :or_asgn, :and_asgn].include?(node.type)
+        end
+
+        def preceded_by_paired_method?(node, prev_sibling)
+          # Skip blank line requirement for idiomatic pairings like desc + task
+          # Only applies to block nodes
+          return false unless node.block_type? || node.numblock_type?
+          return false unless prev_sibling&.send_type?
+          return false unless node.send_node
+
+          prev_method = prev_sibling.method_name
+          current_method = node.send_node.method_name
+
+          paired_methods?(prev_method, current_method)
+        end
+
+        def paired_methods?(prev_method, current_method)
+          # desc + task is idiomatic in rake files
+          prev_method == :desc && current_method == :task
+        end
+
+        def followed_by_rescue?(node)
+          # Don't require blank line before rescue clause
+          parent = node.parent
+          return false unless parent
+
+          # Check if parent is a rescue node and next sibling is a resbody
+          if parent.rescue_type?
+            siblings = parent.children
+            index = siblings.index(node)
+            return false unless index
+
+            next_sib = siblings[index + 1]
+            return next_sib&.resbody_type?
+          end
+
+          false
+        end
+
+        private
+
+        def multiline?(node)
+          node.loc.first_line != node.loc.last_line
+        end
+
+        def block_keyword(node)
+          if node.if_type?
+            node.keyword
+          elsif node.case_type? || node.case_match_type?
+            "case"
+          elsif node.block_type? || node.numblock_type?
+            "do...end"
+          else
+            "block"
+          end
+        end
+
+        def check_empty_line_before(node)
+          return if first_child_of_parent?(node)
+
+          prev_sibling = previous_sibling(node)
+          return unless prev_sibling
+          return if prev_sibling.is_a?(Symbol) # Skip non-node siblings
+          return if empty_line_between?(prev_sibling, node)
+          return if comment_line_before?(node)
+          return if preceded_by_paired_method?(node, prev_sibling)
+
+          keyword = block_keyword(node)
+
+          add_offense(node, message: format(MSG_BEFORE, keyword: keyword)) do |corrector|
+            # Insert newline after the previous line's end
+            corrector.insert_before(
+              node.source_range.with(
+                begin_pos: node.source_range.begin_pos - node.loc.column,
+              ),
+              "\n",
+            )
+          end
+        end
+
+        def check_empty_line_after(node)
+          return if last_child_of_parent?(node)
+          return if followed_by_rescue?(node)
+
+          next_sibling = next_sibling(node)
+          return unless next_sibling
+          return if next_sibling.is_a?(Symbol) # Skip non-node siblings
+          return if empty_line_between?(node, next_sibling)
+          return if comment_line_after?(node)
+
+          keyword = block_keyword(node)
+
+          add_offense(node.loc.end, message: format(MSG_AFTER, keyword: keyword)) do |corrector|
+            corrector.insert_after(node, "\n")
+          end
+        end
+
+        def first_child_of_parent?(node)
+          parent = node.parent
+          return true unless parent
+
+          # For block/def/class bodies, check within the body only
+          return true if only_child_in_body?(node, parent)
+
+          siblings = body_siblings(parent)
+          siblings.first == node
+        end
+
+        def last_child_of_parent?(node)
+          parent = node.parent
+          return true unless parent
+
+          # For block/def/class bodies, check within the body only
+          return true if only_child_in_body?(node, parent)
+
+          siblings = body_siblings(parent)
+          siblings.last == node
+        end
+
+        def only_child_in_body?(node, parent)
+          # When the node IS the body (not wrapped in begin), it's the only child
+          return true if parent.type == :block && parent.body == node
+          return true if parent.type == :def && parent.body == node
+          return true if parent.type == :defs && parent.body == node
+          return true if parent.type == :resbody && parent.body == node
+
+          # For if/unless, check if node is the only thing in the if-branch or else-branch
+          if parent.type == :if
+            return true if parent.if_branch == node
+            return true if parent.else_branch == node
+          end
+
+          # For case/when
+          return true if parent.type == :when && parent.body == node
+          return true if parent.type == :case && parent.else_branch == node
+
+          false
+        end
+
+        def body_siblings(parent)
+          # For begin nodes, all children are body siblings
+          # For other nodes, filter to valid siblings
+          parent.children.select { |c| valid_sibling?(c) }
+        end
+
+        def previous_sibling(node)
+          parent = node.parent
+          return unless parent
+
+          siblings = parent.children
+          index = siblings.index(node)
+          return unless index&.positive?
+
+          # Find previous node sibling (skip non-nodes and nodes without location)
+          (index - 1).downto(0) do |i|
+            sibling = siblings[i]
+            return sibling if valid_sibling?(sibling)
+          end
+
+          nil
+        end
+
+        def next_sibling(node)
+          parent = node.parent
+          return unless parent
+
+          siblings = parent.children
+          index = siblings.index(node)
+          return unless index
+
+          # Find next node sibling (skip non-nodes and nodes without location)
+          ((index + 1)...siblings.size).each do |i|
+            sibling = siblings[i]
+            return sibling if valid_sibling?(sibling)
+          end
+
+          nil
+        end
+
+        def valid_sibling?(sibling)
+          sibling.is_a?(RuboCop::AST::Node) &&
+            sibling.loc&.expression
+        end
+
+        def empty_line_between?(node1, node2)
+          return true unless node1.loc&.expression && node2.loc&.expression
+
+          line1 = node1.loc.last_line
+          line2 = node2.loc.first_line
+
+          # There's an empty line if there's more than 1 line between them
+          (line2 - line1) > 1
+        end
+
+        def comment_line_before?(node)
+          line_before = node.loc.first_line - 1
+          return false if line_before < 1
+
+          processed_source.comments.any? { |c| c.loc.line == line_before }
+        end
+
+        def comment_line_after?(node)
+          line_after = node.loc.last_line + 1
+          processed_source.comments.any? { |c| c.loc.line == line_after }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sane/no_method_call_after_end.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sane
+      # Prohibits calling methods directly after `end`.
+      #
+      # This cop detects method calls chained directly on blocks, conditionals,
+      # and other structures that end with `end`. Such code is harder to read
+      # and should be refactored to assign the result to a variable first.
+      #
+      # @example
+      #   # bad
+      #   if condition
+      #     value
+      #   end.foo
+      #
+      #   # bad
+      #   if condition
+      #     value
+      #   end&.foo
+      #
+      #   # bad
+      #   array.map do |item|
+      #     transform(item)
+      #   end.compact
+      #
+      #   # good
+      #   result = if condition
+      #     value
+      #   end
+      #   result.foo
+      #
+      #   # good
+      #   result = array.map do |item|
+      #     transform(item)
+      #   end
+      #   result.compact
+      #
+      class NoMethodCallAfterEnd < Base
+        MSG = "Do not call methods directly after `end`."
+
+        END_KEYWORD_NODES = [
+          :if, :case, :case_match, :while, :until, :for,
+          :kwbegin, :block, :numblock,
+          :def, :defs, :class, :module, :sclass,
+        ].freeze
+
+        BLOCK_NODES = [:block, :numblock].freeze
+
+        def on_send(node)
+          check_method_call_after_end(node)
+        end
+
+        def on_csend(node)
+          check_method_call_after_end(node)
+        end
+
+        private
+
+        def check_method_call_after_end(node)
+          receiver = node.receiver
+          return unless receiver
+          return unless ends_with_end_keyword?(receiver)
+
+          add_offense(node.loc.dot || node.loc.selector)
+        end
+
+        def ends_with_end_keyword?(node)
+          return false unless END_KEYWORD_NODES.include?(node.type)
+          return !node.braces? if BLOCK_NODES.include?(node.type)
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sane_cops.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "sane/disallow_methods"
+require_relative "sane/conditional_assignment_allow_ternary"
+require_relative "sane/empty_line_before_comment"
+require_relative "sane/empty_lines_around_multiline_block"
+require_relative "sane/no_method_call_after_end"

data/lib/rubocop/sane/plugin.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "lint_roller"
+
+module RuboCop
+  module Sane
+    # A plugin that integrates RuboCop Sane with RuboCop's plugin system.
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: "rubocop-sane",
+          version: VERSION,
+          homepage: "https://github.com/akodkod/rubocop-sane",
+          description: "Sane RuboCop cops for modern Ruby development.",
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: RuboCop::Sane::CONFIG_DEFAULT,
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/sane/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Sane
+    VERSION = "0.1.0"
+  end
+end

data/lib/rubocop/sane.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # RuboCop Sane project namespace
+  module Sane
+    class Error < StandardError; end
+
+    PROJECT_ROOT = Pathname.new(__dir__).parent.parent.expand_path.freeze
+    CONFIG_DEFAULT = PROJECT_ROOT.join("config", "default.yml").freeze
+  end
+end

data/lib/rubocop-sane.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+require_relative "rubocop/sane"
+require_relative "rubocop/sane/version"
+require_relative "rubocop/sane/plugin"
+require_relative "rubocop/cop/sane_cops"

data/sig/rubocop/sane.rbs

@@ -0,0 +1,6 @@
+module Rubocop
+  module Sane
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-sane
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Kodkod
+bindir: exe
+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.48.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.48.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: A collection of RuboCop cops that enforce sensible coding conventions
+email:
+- 678665+akodkod@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".vscode/cspell.json"
+- ".vscode/project-words.txt"
+- CHANGELOG.md
+- CLAUDE.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- config/default.yml
+- lib/rubocop-sane.rb
+- lib/rubocop/cop/sane/conditional_assignment_allow_ternary.rb
+- lib/rubocop/cop/sane/disallow_methods.rb
+- lib/rubocop/cop/sane/empty_line_before_comment.rb
+- lib/rubocop/cop/sane/empty_lines_around_multiline_block.rb
+- lib/rubocop/cop/sane/no_method_call_after_end.rb
+- lib/rubocop/cop/sane_cops.rb
+- lib/rubocop/sane.rb
+- lib/rubocop/sane/plugin.rb
+- lib/rubocop/sane/version.rb
+- sig/rubocop/sane.rbs
+homepage: https://github.com/akodkod/rubocop-sane
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/akodkod/rubocop-sane
+  source_code_uri: https://github.com/akodkod/rubocop-sane
+  changelog_uri: https://github.com/akodkod/rubocop-sane/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+  default_lint_roller_plugin: RuboCop::Sane::Plugin
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.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: Sane RuboCop cops for modern Ruby development
+test_files: []