rubocop-sane 0.3.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd899cb79b69d5e80e9712f16cff748e59565061964ee199ee948413acadb4ae
-  data.tar.gz: d5199b3b74466a2ad62c7fc0b6c15633e3c07b3e4aa67a9465b65293c51917f3
+  metadata.gz: b17fd1e8de6294cc02871537ea6ab1392304756cfca1fe3357374457df1c05aa
+  data.tar.gz: 4d7c5d93b4a375b1b14860049227be3a253e57a7c349d8b2be2510d705f5cf71
 SHA512:
-  metadata.gz: f0a243dbd2dab34f2907cf9dd18abf84226ff2cc70992ca7a84faa04a700c8be0c307b07767a7df073a5d52a05d4d21f3aa4868b9acb06c464d84c05a4723a46
-  data.tar.gz: 403df07bdb9611e535edf8aa868c84bd80c7c62c643380d7e9f1dfc0d2c4a102969c83a2f42ee0f7f7b0cf5f45ec235850de31a2e9cac3a03e91006aaa9e06c1
+  metadata.gz: efec9c94cadc379f66a8bcbc71794baf1436a42cc6904efe10646ebe396838974a967f5d48e45027c484ea2b8c6236bc894d0dd9e384e54be945e5ea990b9394
+  data.tar.gz: c07fddd9d2a78f16beaf02ab62dc0ea1d493bdc5fd2f901a6909b600b99311400c372a5a33011a7979c88681cdcf8a0d13e0aae7d4d751b3e68b47e857b0b36d

data/.rubocop.yml

@@ -62,7 +62,7 @@ Naming/PredicatePrefix:
   Enabled: false
 
 RSpec/ExampleLength:
-  Max: 20
+  Max: 30
 
 RSpec/MultipleDescribes:
   Enabled: false

data/config/default.yml

@@ -2,37 +2,97 @@ Sane:
   Enabled: true
   DocumentationBaseURL: https://github.com/akodkod/rubocop-sane
 
+Sane/ProhibitedComments:
+  Description: "Detects comments starting with configurable prohibited words"
+  Enabled: true
+  VersionAdded: "1.0.0"
+  ProhibitedWords:
+    - DELETE
+    - delete
+    - REMEMBER
+    - remember
+
 Sane/DisallowMethods:
-  Description: "Enforces method replacements and prohibitions."
+  Description: "Enforces method replacements and prohibitions"
   Enabled: true
-  VersionAdded: "0.1.0"
+  VersionAdded: "1.0.0"
   SafeAutoCorrect: false
   ReplaceMethods: {}
   ProhibitedMethods: {}
 
 Sane/ConditionalAssignmentAllowTernary:
-  Description: "Enforces assignment inside conditions, but allows ternary operators."
+  Description: "Enforces assignment inside conditions, but allows ternary operators"
   Enabled: true
-  VersionAdded: "0.1.0"
+  VersionAdded: "1.0.0"
 
 Sane/EmptyLineBeforeComment:
-  Description: "Enforces empty line before comments, except after block starts."
+  Description: "Enforces empty line before comments, except after block starts"
+  Enabled: true
+  VersionAdded: "1.0.0"
+  SafeAutoCorrect: true
+
+Sane/EmptyLinesAroundConditionBody:
+  Description: "Disallows empty lines at the beginning and end of condition bodies"
   Enabled: true
-  VersionAdded: "0.1.0"
+  VersionAdded: "1.0.0"
   SafeAutoCorrect: true
 
 Sane/EmptyLinesAroundMultilineBlock:
-  Description: "Enforces empty lines before and after multiline blocks."
+  Description: "Enforces empty lines before and after multiline blocks"
+  Enabled: true
+  VersionAdded: "1.0.0"
+  SafeAutoCorrect: true
+
+Sane/EmptyLinesAroundMultilineCall:
+  Description: "(Experimental) Enforces empty lines before and after multiline method calls"
+  Enabled: false
+  VersionAdded: "1.0.0"
+  SafeAutoCorrect: true
+  SkipMethods:
+    - belongs_to
+    - has_one
+    - has_many
+
+Sane/MultilineChainOnSeparateLines:
+  Description: "(Experimental) Enforces that each method in a multiline chain starts on its own line with a leading dot"
+  Enabled: false
+  VersionAdded: "1.0.0"
+  SafeAutoCorrect: false
+
+Sane/OmitParentheses:
+  Description: "Enforces omitting parentheses for specific methods"
   Enabled: true
-  VersionAdded: "0.1.0"
+  VersionAdded: "1.0.0"
   SafeAutoCorrect: true
+  Methods: []
 
 Sane/NoMethodCallAfterEnd:
-  Description: "Prohibits calling methods directly after `end`."
+  Description: "Prohibits calling methods directly after `end`"
   Enabled: true
-  VersionAdded: "0.1.0"
+  VersionAdded: "1.0.0"
 
 Sane/OutdatedComments:
-  Description: "Detects TODO/NOTE/FIXME comments with dates in the past."
+  Description: "Detects TODO/NOTE/FIXME comments with dates in the past"
   Enabled: true
-  VersionAdded: "0.2.0"
+  VersionAdded: "1.0.0"
+
+Sane/RedundantSelfAssignment:
+  Description: "Detects redundant assignment within `||=` to the same target"
+  Enabled: true
+  VersionAdded: "1.0.0"
+  SafeAutoCorrect: true
+
+Sane/VariableNameLength:
+  Description: "Enforces minimum variable name length"
+  Enabled: false
+  VersionAdded: "1.0.0"
+  MinLength: 2
+  AllowedNames:
+    - i
+    - j
+    - k
+    - n
+    - e
+    - x
+    - y
+    - _

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

@@ -95,7 +95,7 @@ module RuboCop
           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 }
+          processed_source.comments.any? { |c| c.loc.line == prev_line_number && !inline_comment?(c) }
         end
 
         def preceded_by_block_start?(comment)
@@ -105,9 +105,19 @@ module RuboCop
           prev_line = processed_source.lines[prev_line_number - 1]
           return false unless prev_line
 
+          # Strip inline comments from the previous line before checking
+          prev_line = strip_inline_comment(prev_line, prev_line_number)
+
           block_start_pattern?(prev_line)
         end
 
+        def strip_inline_comment(line, line_number)
+          inline = processed_source.comments.find { |c| c.loc.line == line_number && c.loc.column > 0 }
+          return line unless inline
+
+          line[0...inline.loc.column].rstrip
+        end
+
         def block_start_pattern?(line)
           stripped = line.strip
 

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

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sane
+      # This cop checks for empty lines at the beginning and end of
+      # condition bodies (`if`, `elsif`, `else`, `unless`).
+      #
+      # @example
+      #   # bad
+      #   if condition
+      #
+      #     body
+      #
+      #   else
+      #
+      #     another_body
+      #
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     body
+      #   else
+      #     another_body
+      #   end
+      #
+      class EmptyLinesAroundConditionBody < Base
+        extend AutoCorrector
+
+        MSG_BEGINNING = "Remove empty line at the beginning of condition body"
+        MSG_END = "Remove empty line at the end of condition body"
+
+        def on_if(node)
+          return if node.ternary?
+          return if node.modifier_form?
+
+          check_if_branch(node)
+          check_else_branch(node)
+        end
+
+        private
+
+        def check_if_branch(node)
+          body = node.if_branch
+          return unless body
+
+          keyword_line = node.loc.keyword.line
+          closing_line = end_line_for_if_branch(node)
+
+          check_beginning(body, keyword_line)
+          check_end(body, closing_line, closing_range_for_if_branch(node))
+        end
+
+        def check_else_branch(node)
+          else_branch = node.else_branch
+          return unless else_branch
+          return unless node.loc.else
+
+          # elsif is handled by its own on_if call
+          return if else_branch.if_type? && else_branch.elsif?
+
+          else_line = node.loc.else.line
+          end_node = find_end_node(node)
+          end_line = end_node.loc.end.line
+
+          check_beginning(else_branch, else_line)
+          check_end(else_branch, end_line, end_node.loc.end)
+        end
+
+        def end_line_for_if_branch(node)
+          if node.else_branch
+            if node.loc.else
+              node.loc.else.line
+            else
+              node.else_branch.loc.keyword.line
+            end
+          else
+            find_end_node(node).loc.end.line
+          end
+        end
+
+        def closing_range_for_if_branch(node)
+          if node.else_branch
+            node.loc.else || node.else_branch.loc.keyword
+          else
+            find_end_node(node).loc.end
+          end
+        end
+
+        def find_end_node(node)
+          current = node
+          current = current.parent while current.parent&.if_type? && current.elsif?
+          current
+        end
+
+        def check_beginning(body, keyword_line)
+          first_line = effective_first_line(keyword_line, body.loc.first_line)
+          return unless first_line > keyword_line + 1
+          return unless blank_lines_between?(keyword_line, first_line)
+
+          range = first_body_expression(body).source_range
+          add_offense(range, message: MSG_BEGINNING) do |corrector|
+            remove_blank_lines(corrector, keyword_line, first_line)
+          end
+        end
+
+        def check_end(body, closing_line, closing_range)
+          last_line = effective_last_line(body.loc.last_line, closing_line)
+          return unless closing_line > last_line + 1
+          return unless blank_lines_between?(last_line, closing_line)
+
+          add_offense(closing_range, message: MSG_END) do |corrector|
+            remove_blank_lines(corrector, last_line, closing_line)
+          end
+        end
+
+        def first_body_expression(body)
+          body.begin_type? ? body.children.first : body
+        end
+
+        def effective_first_line(keyword_line, body_first_line)
+          comments = comments_between(keyword_line, body_first_line)
+          comment = comments.min_by { |c| c.loc.line }
+          comment ? comment.loc.line : body_first_line
+        end
+
+        def effective_last_line(body_last_line, closing_line)
+          comments = comments_between(body_last_line, closing_line)
+          comment = comments.max_by { |c| c.loc.line }
+          comment ? comment.loc.line : body_last_line
+        end
+
+        def comments_between(start_line, end_line)
+          processed_source.comments.select do |c|
+            c.loc.line > start_line && c.loc.line < end_line && standalone_comment?(c)
+          end
+        end
+
+        def standalone_comment?(comment)
+          source_line = processed_source.lines[comment.loc.line - 1]
+          source_line.strip.start_with?("#")
+        end
+
+        def blank_lines_between?(start_line, end_line)
+          ((start_line + 1)...end_line).any? { |line_num| blank_line?(line_num) }
+        end
+
+        def blank_line?(line_num)
+          processed_source.lines[line_num - 1].strip.empty?
+        end
+
+        def remove_blank_lines(corrector, start_line, end_line)
+          buffer = processed_source.buffer
+
+          ((start_line + 1)...end_line).each do |line_num|
+            next unless blank_line?(line_num)
+
+            line_begin = buffer.line_range(line_num).begin_pos
+            next_line_begin =
+              if line_num < processed_source.lines.size
+                buffer.line_range(line_num + 1).begin_pos
+              else
+                buffer.line_range(line_num).end_pos
+              end
+
+            corrector.remove(Parser::Source::Range.new(buffer, line_begin, next_line_begin))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,10 @@ module RuboCop
   module Cop
     module Sane
       # This cop enforces empty lines before and after multiline blocks
-      # such as `if/else` and `case/when`.
+      # such as `if/else`, `case/when`, and `begin...rescue...end`.
+      #
+      # Sorbet `sig` blocks require a blank line before, but not after,
+      # since they should be tightly coupled to their method definitions.
       #
       # @example
       #   # bad
@@ -49,6 +52,33 @@ module RuboCop
       #     end
       #   end
       #
+      #   # good - Sorbet sig blocks don't need blank line after
+      #   something
+      #
+      #   sig do
+      #     params(x: Integer).returns(String)
+      #   end
+      #   def foo(x)
+      #     x.to_s
+      #   end
+      #
+      #   # bad - missing blank line before begin
+      #   temp_file = Tempfile.new(["import", ".csv"])
+      #   begin
+      #     temp_file.write(data)
+      #   rescue IOError
+      #     handle_error
+      #   end
+      #
+      #   # good - blank line before begin
+      #   temp_file = Tempfile.new(["import", ".csv"])
+      #
+      #   begin
+      #     temp_file.write(data)
+      #   rescue IOError
+      #     handle_error
+      #   end
+      #
       class EmptyLinesAroundMultilineBlock < Base
         extend AutoCorrector
 
@@ -97,13 +127,37 @@ module RuboCop
 
         alias on_case_match on_case
 
+        def on_kwbegin(node)
+          return unless multiline?(node)
+
+          assignment_parent = find_assignment_parent(node)
+          if assignment_parent
+            check_empty_line_before_assignment(node, assignment_parent)
+            check_empty_line_after_assignment(node, assignment_parent)
+          else
+            check_empty_line_before(node)
+            check_empty_line_after(node)
+          end
+        end
+
         def on_block(node)
           return unless multiline?(node)
-          return if chained_block?(node) # e.g., expect { ... }.to raise_error
+          return if method_chain_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)
+          return if block_in_collection?(node) # e.g., [items.map do...end] or {key: items.map do...end}
+
+          assignment_parent = find_assignment_parent(node)
+          if assignment_parent
+            # Don't require blank line before assignment
+            # But do check for blank line after the assignment
+            check_empty_line_after_assignment(node, assignment_parent)
+          elsif sig_block?(node)
+            # Sorbet sig blocks: require blank line before, but not after
+            check_empty_line_before(node)
+          else
+            check_empty_line_before(node)
+            check_empty_line_after(node)
+          end
         end
 
         alias on_numblock on_block
@@ -112,37 +166,76 @@ module RuboCop
           node.send_node&.lambda_literal?
         end
 
-        def chained_block?(node)
+        def sig_block?(node)
+          # Sorbet signature blocks: sig { ... } or sig do ... end
+          node.send_node&.method_name == :sig && node.send_node&.receiver.nil?
+        end
+
+        def method_chain_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
+          (parent&.send_type? || parent&.csend_type?) && parent.receiver == node
+        end
 
-          # Skip blocks that are part of an assignment expression
-          # e.g., self.foo = items.map do ... end
-          return true if part_of_assignment?(node)
+        def block_in_collection?(node)
+          # Skip blocks that are in arrays or hashes (enclosed in a structure)
+          parent = node.parent
+          return false unless parent
 
-          false
+          parent.array_type? || parent.pair_type?
         end
 
-        def part_of_assignment?(node)
+        def find_assignment_parent(node)
           parent = node.parent
-          return false unless parent
+          return nil unless parent
 
           # Direct assignment: foo = bar.map do...end
-          return true if assignment_node?(parent)
+          return parent 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?("=")
+          return parent if parent.send_type? && parent.method_name.to_s.end_with?("=")
 
-          # Hash value: { key: items.map do...end }
-          return true if parent.pair_type?
+          nil
+        end
 
-          # Array element: [items.map do...end]
-          return true if parent.array_type?
+        def check_empty_line_before_assignment(block_node, assignment_node)
+          return if first_child_of_parent?(assignment_node)
 
-          false
+          prev_sib = previous_sibling(assignment_node)
+          return unless prev_sib
+          return if prev_sib.is_a?(Symbol)
+          return if empty_line_between?(prev_sib, assignment_node)
+          return if comment_line_before?(assignment_node)
+
+          keyword = block_keyword(block_node)
+
+          add_offense(block_node, message: format(MSG_BEFORE, keyword: keyword)) do |corrector|
+            corrector.insert_before(
+              assignment_node.source_range.with(
+                begin_pos: assignment_node.source_range.begin_pos - assignment_node.loc.column,
+              ),
+              "\n",
+            )
+          end
+        end
+
+        def check_empty_line_after_assignment(block_node, assignment_node)
+          return if last_child_of_parent?(assignment_node)
+          return if followed_by_rescue?(assignment_node)
+
+          next_sib = next_sibling(assignment_node)
+          return unless next_sib
+          return if next_sib.is_a?(Symbol)
+          return if empty_line_between?(assignment_node, next_sib)
+          return if rubocop_directive_after?(block_node)
+
+          keyword = block_keyword(block_node)
+
+          add_offense(block_node.loc.end, message: format(MSG_AFTER, keyword: keyword)) do |corrector|
+            corrector.insert_after(block_node, "\n")
+          end
         end
 
         def assignment_node?(node)
@@ -196,6 +289,8 @@ module RuboCop
             node.keyword
           elsif node.case_type? || node.case_match_type?
             "case"
+          elsif node.kwbegin_type?
+            "begin"
           elsif node.block_type? || node.numblock_type?
             "do...end"
           else
@@ -234,7 +329,7 @@ module RuboCop
           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)
+          return if rubocop_directive_after?(node)
 
           keyword = block_keyword(node)
 
@@ -271,6 +366,9 @@ module RuboCop
           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
+          return true if parent.type == :class && parent.body == node
+          return true if parent.type == :module && parent.body == node
+          return true if parent.type == :sclass && parent.body == node
 
           # For if/unless, check if node is the only thing in the if-branch or else-branch
           if parent.type == :if
@@ -282,6 +380,9 @@ module RuboCop
           return true if parent.type == :when && parent.body == node
           return true if parent.type == :case && parent.else_branch == node
 
+          # For ensure: child[1] is the ensure clause body
+          return true if parent.type == :ensure && parent.children[1] == node
+
           false
         end
 
@@ -336,20 +437,30 @@ module RuboCop
           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
+          # Check that at least one line between the nodes is truly blank
+          ((line1 + 1)...line2).any? { |line_num| processed_source.lines[line_num - 1].strip.empty? }
         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 }
+          processed_source.comments.any? { |c| c.loc.line == line_before && standalone_comment?(c) }
         end
 
-        def comment_line_after?(node)
+        def rubocop_directive_after?(node)
           line_after = node.loc.last_line + 1
-          processed_source.comments.any? { |c| c.loc.line == line_after }
+          processed_source.comments.any? { |c| c.loc.line == line_after && rubocop_directive?(c) }
+        end
+
+        def rubocop_directive?(comment)
+          comment.text.start_with?("# rubocop:")
+        end
+
+        def standalone_comment?(comment)
+          # A standalone comment is one that occupies its own line (not inline after code)
+          source_line = processed_source.lines[comment.loc.line - 1]
+          source_line.strip.start_with?("#")
         end
       end
     end

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

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sane
+      # Enforces empty lines before and after multiline method calls,
+      # including calls with multiline arguments and multiline method chains.
+      #
+      class EmptyLinesAroundMultilineCall < Base # rubocop:disable Metrics/ClassLength
+        extend AutoCorrector
+
+        MSG_BEFORE = "Add empty line before multiline method call."
+        MSG_AFTER = "Add empty line after multiline method call."
+
+        ASSIGNMENT_TYPES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn, :masgn, :op_asgn, :or_asgn, :and_asgn].freeze
+        BODY_PARENT_TYPES = [:block, :numblock, :def, :defs, :resbody, :class, :module, :sclass].freeze
+        CONTROL_FLOW_TYPES = [:return, :break, :next].freeze
+
+        def on_send(node)
+          check_call(node)
+        end
+
+        alias on_csend on_send
+
+        private
+
+        def check_call(node)
+          return unless node.loc.first_line != node.loc.last_line
+          return if excluded_call?(node)
+
+          target = effective_target(node)
+          check_empty_line_before(target)
+          check_empty_line_after(node, target)
+        end
+
+        def excluded_call?(node)
+          has_block?(node) || inner_chain_call?(node) || call_as_argument?(node) ||
+            inside_collection?(node) || setter_call?(node) || inside_control_flow?(node) || skip_method?(node)
+        end
+
+        def has_block?(node)
+          parent = node.parent
+          (parent&.block_type? || parent&.numblock_type?) && node == parent.send_node
+        end
+
+        def inner_chain_call?(node)
+          parent = node.parent
+          (parent&.send_type? || parent&.csend_type?) && node == parent.receiver
+        end
+
+        def call_as_argument?(node)
+          parent = node.parent
+          return false unless parent&.send_type? || parent&.csend_type?
+
+          parent.arguments.include?(node)
+        end
+
+        def inside_collection?(node)
+          parent = node.parent
+          parent && (parent.array_type? || parent.pair_type?)
+        end
+
+        def setter_call?(node)
+          node.method_name.to_s.end_with?("=")
+        end
+
+        def inside_control_flow?(node)
+          parent = node.parent
+          parent && CONTROL_FLOW_TYPES.include?(parent.type)
+        end
+
+        def skip_method?(node)
+          cop_config.fetch("SkipMethods", []).include?(node.method_name.to_s)
+        end
+
+        def preceded_by_sig?(node)
+          prev_sib = previous_sibling(node)
+          return false unless prev_sib.is_a?(RuboCop::AST::Node)
+
+          (prev_sib.block_type? || prev_sib.numblock_type?) &&
+            prev_sib.send_node&.method_name == :sig &&
+            prev_sib.send_node&.receiver.nil?
+        end
+
+        def effective_target(node)
+          parent = node.parent
+          parent && ASSIGNMENT_TYPES.include?(parent.type) ? parent : node
+        end
+
+        def check_empty_line_before(node)
+          return if first_child_of_parent?(node)
+          return if preceded_by_sig?(node)
+
+          prev_sib = previous_sibling(node)
+          return if prev_sib.nil? || prev_sib.is_a?(Symbol)
+          return if empty_line_between?(prev_sib, node)
+          return if comment_line_before?(node)
+
+          add_offense(node, message: MSG_BEFORE) do |corrector|
+            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(call_node, target)
+          return if last_child_of_parent?(target) || followed_by_rescue?(target)
+
+          next_sib = next_sibling(target)
+          return if next_sib.nil? || next_sib.is_a?(Symbol)
+          return if empty_line_between?(target, next_sib)
+          return if rubocop_directive_after?(call_node)
+
+          add_offense(after_offense_loc(call_node), message: MSG_AFTER) do |corrector|
+            corrector.insert_after(target, "\n")
+          end
+        end
+
+        def after_offense_loc(node)
+          if node.loc.respond_to?(:end) && node.loc.end
+            node.loc.end
+          elsif node.loc.respond_to?(:selector) && node.loc.selector
+            node.loc.selector
+          else
+            node
+          end
+        end
+
+        def first_child_of_parent?(node)
+          parent = node.parent
+          return true unless parent
+          return true if only_child_in_body?(node, parent)
+
+          body_siblings(parent).first == node
+        end
+
+        def last_child_of_parent?(node)
+          parent = node.parent
+          return true unless parent
+          return true if only_child_in_body?(node, parent)
+
+          body_siblings(parent).last == node
+        end
+
+        def only_child_in_body?(node, parent)
+          return true if BODY_PARENT_TYPES.include?(parent.type) && parent.body == node
+
+          return true if (parent.type == :if) && (parent.if_branch == node || parent.else_branch == node)
+
+          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)
+          parent.children.select { |c| c.is_a?(RuboCop::AST::Node) && c.loc&.expression }
+        end
+
+        def previous_sibling(node)
+          parent = node.parent
+          return unless parent
+
+          siblings = parent.children
+          index = siblings.index(node)
+          return unless index&.positive?
+
+          (index - 1).downto(0) do |i|
+            sib = siblings[i]
+            return sib if sib.is_a?(RuboCop::AST::Node) && sib.loc&.expression
+          end
+          nil
+        end
+
+        def next_sibling(node)
+          parent = node.parent
+          return unless parent
+
+          siblings = parent.children
+          index = siblings.index(node)
+          return unless index
+
+          ((index + 1)...siblings.size).each do |i|
+            sib = siblings[i]
+            return sib if sib.is_a?(RuboCop::AST::Node) && sib.loc&.expression
+          end
+          nil
+        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
+          ((line1 + 1)...line2).any? { |ln| processed_source.lines[ln - 1].strip.empty? }
+        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 && standalone_comment?(c) }
+        end
+
+        def rubocop_directive_after?(node)
+          line_after = node.loc.last_line + 1
+          processed_source.comments.any? { |c| c.loc.line == line_after && c.text.start_with?("# rubocop:") }
+        end
+
+        def standalone_comment?(comment)
+          processed_source.lines[comment.loc.line - 1].strip.start_with?("#")
+        end
+
+        def followed_by_rescue?(node)
+          parent = node.parent
+          return false unless parent&.rescue_type?
+
+          siblings = parent.children
+          index = siblings.index(node)
+          return false unless index
+
+          siblings[index + 1]&.resbody_type?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sane
+      # Enforces that each method in a multiline chain starts on its own line
+      # with a leading dot.
+      #
+      # @example
+      #   # bad
+      #   browser.find(
+      #     "div[role='menu'] .v-list-item",
+      #     text: "Confirmation Sheet",
+      #     wait: 10,
+      #   ).click
+      #
+      #   # good
+      #   browser
+      #     .find(
+      #       "div[role='menu'] .v-list-item",
+      #       text: "Confirmation Sheet",
+      #       wait: 10,
+      #     )
+      #     .click
+      #
+      class MultilineChainOnSeparateLines < Base
+        extend AutoCorrector
+
+        MSG = "Place each method call in a multiline chain on a separate line with a leading dot."
+
+        def on_send(node)
+          check_chain(node)
+        end
+
+        alias on_csend on_send
+
+        private
+
+        def check_chain(node)
+          return unless node.loc.dot
+          return unless node.receiver
+
+          receiver = node.receiver
+          return unless chained_call?(receiver)
+
+          return unless dot_on_receiver_last_line?(node, receiver)
+          return unless multiline?(receiver) || (multiline?(node) && used_as_chain_receiver?(node))
+
+          register_offense(node)
+        end
+
+        def chained_call?(receiver)
+          receiver.send_type? || receiver.csend_type?
+        end
+
+        def multiline?(node)
+          node.loc.first_line != node.loc.last_line
+        end
+
+        def dot_on_receiver_last_line?(node, receiver)
+          node.loc.dot.line == receiver.loc.last_line
+        end
+
+        def used_as_chain_receiver?(node)
+          parent = node.parent
+          (parent&.send_type? || parent&.csend_type?) && parent.receiver == node
+        end
+
+        def register_offense(node)
+          add_offense(node.loc.dot) do |corrector|
+            indent = chain_root_column(node) + indentation_width
+            range = node.loc.dot.with(begin_pos: node.receiver.source_range.end_pos)
+            dot_text = node.loc.dot.source
+            corrector.replace(range, "\n#{' ' * indent}#{dot_text}")
+          end
+        end
+
+        def chain_root_column(node)
+          current = node
+          while (recv = current.receiver) && (recv.send_type? || recv.csend_type?)
+            current = recv
+          end
+          current.receiver ? current.receiver.loc.column : current.loc.column
+        end
+
+        def indentation_width
+          config.for_cop("Layout/IndentationWidth")["Width"] || 2
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sane
+      # Enforces omitting parentheses for specific methods.
+      #
+      # @example Methods configuration
+      #   # .rubocop.yml
+      #   # Sane/OmitParentheses:
+      #   #   Methods:
+      #   #     - render_record
+      #   #     - Log.info
+      #
+      #   # bad
+      #   render_record(record)
+      #   Log.info("message")
+      #
+      #   # good
+      #   render_record record
+      #   Log.info "message"
+      #
+      class OmitParentheses < Base
+        extend AutoCorrector
+
+        MSG = "Omit parentheses for `%<method>s`."
+
+        def on_send(node)
+          return unless node.parenthesized?
+          return if node.multiline?
+          return if modifier_condition?(node)
+
+          matched_method = find_matching_method(node)
+          return unless matched_method
+
+          message = format(MSG, method: matched_method)
+
+          add_offense(node, message: message) do |corrector|
+            if node.arguments.empty?
+              corrector.remove(node.loc.begin)
+            else
+              corrector.replace(node.loc.begin, " ")
+            end
+
+            corrector.remove(node.loc.end)
+          end
+        end
+
+        private
+
+        def find_matching_method(node)
+          methods.find { |method| matches?(node, method) }
+        end
+
+        def matches?(node, method_config)
+          if method_config.include?(".")
+            receiver_name, method_name = method_config.split(".", 2)
+
+            node.receiver&.const_type? &&
+              node.receiver.short_name.to_s == receiver_name &&
+              node.method_name.to_s == method_name
+          else
+            node.method_name.to_s == method_config
+          end
+        end
+
+        def modifier_condition?(node)
+          parent = node.parent
+          parent&.if_type? && parent.modifier_form?
+        end
+
+        def methods
+          @methods ||= Array(cop_config.fetch("Methods", []))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sane
+      # Detects comments that start with prohibited keywords.
+      # Configure ProhibitedWords to replace the case-sensitive default list.
+      # Configured words are flagged as warnings. An empty list disables matching.
+      #
+      # @example
+      #   # bad
+      #   # DELETE
+      #   # DELETE this code after migration
+      #   # DELETE: remove after v2
+      #   # REMEMBER to update the docs
+      #   # remember to notify the team
+      #
+      #   # good
+      #   # Delete users
+      #   # DELETED items are archived
+      #   # Remember what user said
+      #
+      class ProhibitedComments < Base
+        MSG = "%<word>s comment found — review and address the comment"
+
+        def on_new_investigation
+          return unless processed_source.valid_syntax?
+
+          pattern = /^#\s*(#{Regexp.union(cop_config['ProhibitedWords'])})\b/
+          processed_source.comments.each do |comment|
+            match = comment.text.match(pattern)
+            next unless match
+
+            add_offense(comment.source_range, message: format(MSG, word: match[1]), severity: :warning)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sane
+      # Detects redundant `||=` patterns where the RHS repeats the
+      # assignment to the same target.
+      #
+      # @example
+      #   # bad
+      #   self.browser ||= self.browser = Capybara::Session.new(:cuprite)
+      #
+      #   # good
+      #   self.browser ||= Capybara::Session.new(:cuprite)
+      #
+      #   # bad
+      #   @foo ||= @foo = compute_value
+      #
+      #   # good
+      #   @foo ||= compute_value
+      #
+      class RedundantSelfAssignment < Base
+        extend AutoCorrector
+
+        MSG = "Redundant assignment in `||=`. Use `%<lhs>s ||= %<value>s` instead."
+
+        VARIABLE_ASGN_TYPES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn].freeze
+
+        def on_or_asgn(node)
+          lhs, rhs = *node
+          return unless redundant_rhs?(lhs, rhs)
+
+          value_node = rhs.children.last
+          message = format(MSG, lhs: lhs.source, value: value_node.source)
+
+          add_offense(rhs, message: message) do |corrector|
+            corrector.replace(rhs, value_node.source)
+          end
+        end
+
+        private
+
+        def redundant_rhs?(lhs, rhs)
+          if VARIABLE_ASGN_TYPES.include?(lhs.type)
+            redundant_variable_assignment?(lhs, rhs)
+          elsif lhs.type == :casgn
+            redundant_const_assignment?(lhs, rhs)
+          elsif lhs.send_type?
+            redundant_method_assignment?(lhs, rhs)
+          else
+            false
+          end
+        end
+
+        def redundant_variable_assignment?(lhs, rhs)
+          rhs.type == lhs.type &&
+            rhs.children[0] == lhs.children[0]
+        end
+
+        def redundant_const_assignment?(lhs, rhs)
+          rhs.type == :casgn &&
+            rhs.children[0] == lhs.children[0] &&
+            rhs.children[1] == lhs.children[1]
+        end
+
+        def redundant_method_assignment?(lhs, rhs)
+          rhs.send_type? &&
+            rhs.receiver == lhs.receiver &&
+            rhs.method_name == :"#{lhs.method_name}="
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sane
+      # Enforces a minimum length for variable names.
+      #
+      # Short variable names can reduce code readability. This cop checks
+      # local variable assignments and method/block parameters against a
+      # configurable minimum length. Common names like loop counters can
+      # be allowed via the `AllowedNames` option.
+      #
+      # @example MinLength: 3 (default)
+      #   # bad
+      #   a = 1
+      #   ab = 2
+      #   def foo(a, ab); end
+      #
+      #   # good
+      #   age = 1
+      #   amount = 2
+      #   def foo(age, amount); end
+      #
+      # @example AllowedNames: ['i', 'j', 'k'] (default includes more)
+      #   # good (allowed by default)
+      #   items.each_with_index { |item, i| }
+      #
+      class VariableNameLength < Base
+        MSG = "Variable name '%<name>s' is too short (minimum is %<min>s characters)."
+
+        def on_lvasgn(node)
+          name = node.name
+          check_name(name, node)
+        end
+
+        alias on_arg on_lvasgn
+        alias on_optarg on_lvasgn
+        alias on_restarg on_lvasgn
+        alias on_kwarg on_lvasgn
+        alias on_kwoptarg on_lvasgn
+        alias on_kwrestarg on_lvasgn
+        alias on_blockarg on_lvasgn
+
+        private
+
+        def check_name(name, node)
+          return unless name
+
+          name_str = name.to_s
+          return if name_str.start_with?("_")
+          return if name_str.length >= min_length
+          return if allowed_names.include?(name_str)
+
+          add_offense(node, message: format(MSG, name: name_str, min: min_length))
+        end
+
+        def min_length
+          @min_length ||= cop_config.fetch("MinLength", 3)
+        end
+
+        def allowed_names
+          @allowed_names ||= cop_config.fetch("AllowedNames", []).map(&:to_s)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sane_cops.rb

@@ -1,8 +1,15 @@
 # frozen_string_literal: true
 
+require_relative "sane/prohibited_comments"
 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_condition_body"
 require_relative "sane/empty_lines_around_multiline_block"
+require_relative "sane/empty_lines_around_multiline_call"
+require_relative "sane/multiline_chain_on_separate_lines"
 require_relative "sane/no_method_call_after_end"
 require_relative "sane/outdated_comments"
+require_relative "sane/redundant_self_assignment"
+require_relative "sane/omit_parentheses"
+require_relative "sane/variable_name_length"

data/lib/rubocop/sane/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Sane
-    VERSION = "0.3.0"
+    VERSION = "1.1.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-sane
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Andrew Kodkod
@@ -13,16 +13,16 @@ dependencies:
   name: lint_roller
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -54,7 +54,6 @@ files:
 - ".rubocop.yml"
 - ".vscode/cspell.json"
 - ".vscode/project-words.txt"
-- CHANGELOG.md
 - CLAUDE.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
@@ -65,9 +64,16 @@ files:
 - 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_condition_body.rb
 - lib/rubocop/cop/sane/empty_lines_around_multiline_block.rb
+- lib/rubocop/cop/sane/empty_lines_around_multiline_call.rb
+- lib/rubocop/cop/sane/multiline_chain_on_separate_lines.rb
 - lib/rubocop/cop/sane/no_method_call_after_end.rb
+- lib/rubocop/cop/sane/omit_parentheses.rb
 - lib/rubocop/cop/sane/outdated_comments.rb
+- lib/rubocop/cop/sane/prohibited_comments.rb
+- lib/rubocop/cop/sane/redundant_self_assignment.rb
+- lib/rubocop/cop/sane/variable_name_length.rb
 - lib/rubocop/cop/sane_cops.rb
 - lib/rubocop/sane.rb
 - lib/rubocop/sane/plugin.rb
@@ -96,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Sane RuboCop cops for modern Ruby development
 test_files: []

data/CHANGELOG.md

@@ -1,14 +0,0 @@
-## [Unreleased]
-
-## [0.3.0] - 2025-12-20
-
-- Add `Sane/OutdatedComments` cop
-
-## [0.2.0] - 2025-12-20
-
-- Add `Sane/NoMethodCallAfterEnd` cop
-- Improve `Sane/EmptyLineBeforeComment` cop
-
-## [0.1.0] - 2025-12-19
-
-- Initial release