officer_neetzsche 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 100c19f093b3f8972a0c73262ea4d1020057aea94a4835ac2a3e573d6b4d95c6
-  data.tar.gz: 7d267e9d2cd3c091223b63c65243aa9f369d3cc8356de4346772188edcfdd681
+  metadata.gz: 22890bd97c3719ada7fdb61dd55402c68b110045cdfc75e99961e85efbe6d2b6
+  data.tar.gz: 61c8a23f85804cfda9b60f5f7b86e79c5afb872d1b42ef72125ff9a364683dcb
 SHA512:
-  metadata.gz: 8cf5f9105e71d0044dbbe8267db688767ea642f73ef6a00bc4272930e2bd8cecd3e42a6529b195e5b9ba905917345021447a701164372616e8c2fa214ae78b6c
-  data.tar.gz: b4fafbac860b255990358dfc15e95a4463358b3106a72fdb54627908f5484516722c0a616299e862c28241fef26e4a438d2cd1d3026d82c3d0e6b81bdb7c285d
+  metadata.gz: 64d16df6a4336e4b0c39f7db504659e565831f581cc3dcbd135a17a034717e5ed75ff3be2c6da1ee2110c3c373c453fae707e393ab5e59b135fac9beaab759b7
+  data.tar.gz: 6dc9fcedae06886c4c967d5d74ff7091dbf12264f073b326dfb0c64932c42f0da05f5544051d7ef32b12d88005f6e2cb84e28166613a41172d209dfc2589afa0

data/CHANGELOG.md

@@ -1,6 +1,22 @@
 # Changelog
 
-## 0.2.0 (unreleased)
+## 0.4.0 (unreleased)
+
+### Added
+
+- `NEETzsche/MultilineConditionalBody`: flags an `if`, `unless`, `elsif`, `else`, `while`, or `until` whose body is more than one statement, or one statement that spans lines, and asks for the body to be a method of its own. With `NEETzsche/StatementModifier`, that leaves a conditional two shapes: a modifier, or a block whose branches are one statement each. No autocorrect, since the method needs a name.
+
+## 0.3.0 (2026-09-15)
+
+### Added
+
+- `NEETzsche/StatementModifier`: rewrites an `if`, `unless`, `while`, `until`, or `rescue` whose body is one statement on one line as a statement modifier, whatever the resulting line length. Method-level and block-level `rescue` clauses count. Bodies that are themselves conditionals or rescues, comments inside the block, heredocs, and conditions or bodies whose meaning would change when the body is parsed first are left alone. Autocorrects, adding parentheses where the value is used.
+
+### Changed
+
+- **Breaking:** the plugin now disables `Style/IfUnlessModifier` and `Style/WhileUntilModifier`, which `NEETzsche/StatementModifier` subsumes, and `Style/RescueModifier`, which forbids what it demands. Re-enable them in your own `.rubocop.yml` if you want them back; `Style/IfUnlessModifier` will then fight over modifier lines that exceed `Layout/LineLength`.
+
+## 0.2.0 (2026-09-09)
 
 ### Added
 

data/README.md

@@ -9,7 +9,9 @@ RuboCop cops that enforce NEETzsche-isms. Every cop ships enabled: register the
 | Cop | Enforces | Autocorrect |
 | --- | --- | --- |
 | `NEETzsche/GeneratedMigrationTimestamp` | Migration timestamps come from `bin/rails generate migration`, not a keyboard. | No |
+| `NEETzsche/MultilineConditionalBody` | An `if`, `unless`, `while`, or `until` body of more than one statement, or more than one line, is a method of its own. | No |
 | `NEETzsche/NoComments` | No comments. The code explains itself. | Yes |
+| `NEETzsche/StatementModifier` | An `if`, `unless`, `while`, `until`, or `rescue` around one statement is a modifier. | Yes |
 
 ## Requirements
 
@@ -107,6 +109,67 @@ Projects that set `config.active_record.timestamped_migrations = false` number t
 
 There is no autocorrect. The fix is to delete the file and run `bin/rails generate migration` again.
 
+## NEETzsche/MultilineConditionalBody
+
+Flags an `if`, `unless`, `elsif`, `else`, `while`, or `until` whose body is more than one statement, or one statement that spans lines. The fix is to name what the body does and move it into a method of its own, after which `NEETzsche/StatementModifier` rewrites the call site as a modifier. Between them, the two cops leave a conditional two shapes: a modifier, or a block whose branches are one statement each.
+
+```ruby
+# bad
+if condition?
+  do_this
+  do_that
+end
+
+while queue.any?
+  item = queue.pop
+  item.call
+end
+
+if condition?
+  items.each do |item|
+    item.call
+  end
+end
+
+# good
+do_stuff if condition?
+work_one_item while queue.any?
+call_items if condition?
+
+def do_stuff
+  do_this
+  do_that
+end
+
+def work_one_item
+  item = queue.pop
+  item.call
+end
+
+def call_items
+  items.each { |item| item.call }
+end
+
+# good, because each branch is one statement
+if condition?
+  do_this
+else
+  do_that
+end
+```
+
+The offense sits on the keyword of the branch: `if`, `unless`, `elsif`, `else`, `while`, or `until`. Each branch is judged on its own, so an `if` with a two-statement body and a one-statement `else` gets one offense, on the `if`. A heredoc counts as the lines it spans. A modifier whose body spans lines, such as `begin ... end if condition?`, is flagged too. A conditional nested inside another is flagged at every level whose body spans lines, and fixing the innermost usually clears the rest.
+
+Left alone:
+
+- A body of one statement on one line, which is `NEETzsche/StatementModifier`'s to rewrite.
+- Ternaries, empty bodies, and `begin ... end while` loops.
+- A condition that spans lines. Only the body is measured.
+
+There is no autocorrect. The method needs a name that says what the body does, and that is a decision for a person. Moving the body by hand also means deciding what it reads and writes: a local variable the body uses becomes a parameter, one it assigns for later use becomes the return value, and a `return`, `break`, or `next` inside it means something else once it sits in another method. Once the body is one call, `NEETzsche/StatementModifier` turns the block into a modifier under `rubocop --autocorrect`.
+
+`Style/GuardClause` and `Style/Next` may flag the same block with a different fix. Either fix satisfies this cop too, since a guard clause or a `next` leaves no block behind. Under `rubocop --autocorrect`, `Layout/LineLength` may wrap the arguments of a long modifier line and `Style/MultilineIfModifier` then restore the block form, which this cop flags. The way out is a method.
+
 ## NEETzsche/NoComments
 
 Flags every comment. On autocorrect, a comment on its own line is deleted along with the line, and a trailing comment is deleted along with the whitespace before it.
@@ -132,6 +195,62 @@ Comments that change how Ruby or RuboCop behaves are allowed:
 
 `Style/Documentation` demands the class and module comments this cop forbids, so the plugin disables it. Re-enable it in your own `.rubocop.yml` if you want the two to fight.
 
+## NEETzsche/StatementModifier
+
+Flags an `if`, `unless`, `while`, `until`, or `rescue` whose body is one statement on one line, and rewrites it as a statement modifier. How long the modifier line ends up does not matter.
+
+```ruby
+# bad
+if condition?
+  do_thing
+end
+
+until queue.empty?
+  queue.pop.call
+end
+
+begin
+  fetch
+rescue
+  fallback
+end
+
+def call
+  fetch
+rescue StandardError
+  fallback
+end
+
+# good
+do_thing if condition?
+queue.pop.call until queue.empty?
+fetch rescue fallback
+
+def call
+  fetch rescue fallback
+end
+
+# left to NEETzsche/MultilineConditionalBody, because the body is more than one statement
+if condition?
+  do_this
+  do_that
+end
+```
+
+The offense sits on the keyword. A `rescue` counts when it is the only clause, rescues `StandardError` (bare, or named, since that is what the modifier rescues), binds no variable, and has no `else`; the `begin`/`end` around it goes away, while a `def`, a block, or an `ensure` around it stays. Parentheses are added where the value is used, so `value = if condition? then compute end` becomes `value = (compute if condition?)` and `call(begin; fetch; rescue; fallback; end)` becomes `call((fetch rescue fallback))`. An assigned `rescue` needs none: `value = fetch rescue fallback` already binds that way.
+
+Left alone, because the block form is the only correct one:
+
+- A body of more than one statement, a statement that spans lines, or a condition that spans lines. The first two are for `NEETzsche/MultilineConditionalBody`.
+- `else`, `elsif`, ternaries, and `begin ... end while` loops.
+- A body that is itself an `if`, `unless`, `while`, `until`, `case`, or `rescue`, in either form. No chained modifiers.
+- A `rescue` that names another class, lists several, binds a variable, has several clauses, an `else`, or an empty body or handler.
+- A comment on any line of the block other than the first. A comment on the keyword line moves to the end of the modifier line.
+- A heredoc anywhere inside.
+- Anything whose meaning changes when the body is parsed before the condition, which is what the modifier form does: a condition that assigns a local variable, matches a pattern, or captures a named group; a body that assigns a name the condition calls as a method, as in `if name.nil?` followed by `name = default`; and an endless method definition, which would swallow the modifier.
+
+The plugin disables `Style/IfUnlessModifier` and `Style/WhileUntilModifier`, which this cop subsumes, and `Style/RescueModifier`, which forbids what this cop demands. Re-enable them in your own `.rubocop.yml` if you want them back; `Style/IfUnlessModifier` will then fight over any modifier line longer than `Layout/LineLength` allows. `Layout/LineLength` itself is not consulted. If a modifier line is too long for it, shorten the statement or the condition, or exclude the file. Under `rubocop --autocorrect`, `Layout/LineLength` may instead wrap the arguments of a call on that line, after which `Style/MultilineIfModifier` restores the block form around the now multi-line body, and this cop leaves it there. `Style/GuardClause` and `Style/SoleNestedConditional` may flag the same block with a different fix; whichever corrects first wins, and the result satisfies both.
+
 ## Configuration
 
 Disable one cop:

data/config/default.yml

@@ -9,10 +9,29 @@ NEETzsche/GeneratedMigrationTimestamp:
     - "**/db/migrate/**/*.rb"
     - "**/db/*_migrate/**/*.rb"
 
+NEETzsche/MultilineConditionalBody:
+  Description: "Puts an `if`, `unless`, `elsif`, `else`, `while`, or `until` body that is more than one statement, or one statement over more than one line, in a method of its own."
+  Enabled: true
+  VersionAdded: "0.4.0"
+
 NEETzsche/NoComments:
   Description: "Forbids comments. Magic comments, shebangs, and rubocop directives are allowed."
   Enabled: true
   VersionAdded: "0.1.0"
 
+NEETzsche/StatementModifier:
+  Description: "Writes an `if`, `unless`, `while`, `until`, or `rescue` whose body is one statement as a modifier, whatever the line length."
+  Enabled: true
+  VersionAdded: "0.3.0"
+
 Style/Documentation:
   Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/RescueModifier:
+  Enabled: false
+
+Style/WhileUntilModifier:
+  Enabled: false

data/lib/officer_neetzsche/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OfficerNEETzsche
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/rubocop/cop/neetzsche/multiline_conditional_body.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module NEETzsche
+      class MultilineConditionalBody < Base
+        MSG = "Move a multi-line `%<keyword>s` body into its own method."
+
+        HEREDOC_TYPES = %i[str dstr xstr].freeze
+
+        def on_if(node)
+          return if node.ternary?
+
+          check(node.if_branch, node.loc.keyword, node.keyword)
+          check(node.else_branch, node.loc.else, "else") if node.else? && !node.elsif_conditional?
+        end
+
+        def on_while(node)
+          check(node.body, node.loc.keyword, node.keyword)
+        end
+        alias on_until on_while
+
+        private
+
+        def check(body, keyword, name)
+          return if body.nil? || one_liner?(body)
+
+          add_offense(keyword, message: format(MSG, keyword: name))
+        end
+
+        def one_liner?(body)
+          !multiple_statements?(body) && body.first_line == last_line(body)
+        end
+
+        def multiple_statements?(body)
+          (body.begin_type? || body.kwbegin_type?) && body.children.size > 1
+        end
+
+        def last_line(body)
+          heredocs = body.each_node(*HEREDOC_TYPES).select(&:heredoc?)
+          [body.last_line, *heredocs.map { |heredoc| heredoc.loc.heredoc_end.line }].max
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/neetzsche/statement_modifier.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module NEETzsche
+      class StatementModifier < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = "Write a one-statement `%<keyword>s` as a modifier."
+
+        CHAIN_TYPES = %i[if while until while_post until_post for case case_match rescue kwbegin].freeze
+        CALLS = %i[send csend super yield].freeze
+
+        def self.autocorrect_incompatible_with
+          [Style::Next, Style::SoleNestedConditional]
+        end
+
+        def on_if(node)
+          return if node.modifier_form? || node.ternary? || node.elsif? || node.else?
+
+          check_conditional(node)
+        end
+
+        def on_while(node)
+          return if node.modifier_form?
+
+          check_conditional(node)
+        end
+        alias on_until on_while
+
+        def on_rescue(node)
+          resbody = node.resbody_branches.first
+          return unless bare_rescue?(node, resbody)
+
+          target = node.parent&.kwbegin_type? ? node.parent : node
+          return unless one_liner?(target, [node.body, resbody.body])
+
+          add_offense(resbody.loc.keyword, message: format(MSG, keyword: "rescue")) do |corrector|
+            rewrite(corrector, target, rescue_statement(node, resbody), Precedence.parenthesize_rescue?(target))
+          end
+        end
+
+        private
+
+        def check_conditional(node)
+          return unless eligible_conditional?(node)
+
+          add_offense(node.loc.keyword, message: format(MSG, keyword: node.keyword)) do |corrector|
+            rewrite(corrector, node, conditional_statement(node), Precedence.parenthesize_conditional?(node))
+          end
+        end
+
+        def eligible_conditional?(node)
+          node.condition.single_line? && one_liner?(node, [node.body]) &&
+            !Precedence.endless_def?(node.body) && !ParseOrder.hazard?(node)
+        end
+
+        def conditional_statement(node)
+          "#{statement_source(node.body)} #{node.keyword} #{node.condition.source}"
+        end
+
+        def rescue_statement(node, resbody)
+          "#{statement_source(node.body)} rescue #{statement_source(resbody.body)}"
+        end
+
+        def rewrite(corrector, node, statement, parenthesize)
+          statement = "(#{statement})" if parenthesize
+          corrector.replace(node, [statement, first_line_comment(node)&.source].compact.join(" "))
+        end
+
+        def bare_rescue?(node, resbody)
+          !rescue_modifier?(resbody) && node.resbody_branches.one? && !node.else? &&
+            resbody.exception_variable.nil? && standard_error_only?(resbody.exceptions)
+        end
+
+        def rescue_modifier?(resbody)
+          processed_source.tokens.any? { |token| token.rescue_modifier? && token.pos == resbody.loc.keyword }
+        end
+
+        def standard_error_only?(exceptions)
+          return true if exceptions.empty?
+          return false unless exceptions.one? && exceptions.first.const_type?
+
+          namespace, name = *exceptions.first
+          name == :StandardError && (namespace.nil? || namespace.cbase_type?)
+        end
+
+        def one_liner?(node, statements)
+          statements.all? { |statement| single_statement?(statement) } &&
+            !modifier_body?(node) && !heredoc?(node) && comments_movable?(node)
+        end
+
+        def single_statement?(statement)
+          return false if statement.nil? || statement.begin_type? || CHAIN_TYPES.include?(statement.type)
+          return false if statement.source.end_with?(":") && !CALLS.include?(statement.type)
+
+          statement.single_line?
+        end
+
+        def modifier_body?(node)
+          parent = node.parent
+          return false unless parent && (parent.if_type? || parent.while_type? || parent.until_type?)
+
+          parent.modifier_form? && parent.body.equal?(node)
+        end
+
+        def heredoc?(node)
+          node.each_descendant(:str, :dstr, :xstr).any?(&:heredoc?)
+        end
+
+        def comments_movable?(node)
+          return false if processed_source.each_comment_in_lines((node.first_line + 1)..node.last_line).any?
+
+          first_line_comment(node).nil? || code_after(node).nil?
+        end
+
+        def first_line_comment(node)
+          processed_source.comment_at_line(node.first_line)
+        end
+
+        def code_after(node)
+          line_end = first_line_comment(node)&.source_range&.begin_pos if node.single_line?
+          line_end ||= processed_source.buffer.line_range(node.last_line).end_pos
+          code = range_between(node.source_range.end_pos, line_end).source.strip
+          code unless code.empty?
+        end
+
+        def statement_source(statement)
+          return statement.source unless statement.source.end_with?(":")
+
+          head = range_between(statement.source_range.begin_pos, statement.first_argument.source_range.begin_pos)
+          "#{head.source.rstrip}(#{statement.arguments.map(&:source).join(", ")})"
+        end
+
+        module ParseOrder
+          CAPTURING_CONDITIONS = %i[lvasgn match_with_lvasgn match_pattern match_pattern_p].freeze
+
+          module_function
+
+          def hazard?(node)
+            condition = node.condition
+            return true if condition.each_node(*CAPTURING_CONDITIONS).any?
+
+            assigned = node.body.each_node(:lvasgn).map { |assignment| assignment.children.first }
+            return false if assigned.empty?
+
+            condition.each_node(:send).any? { |call| bare_identifier?(call) && assigned.include?(call.method_name) }
+          end
+
+          def bare_identifier?(call)
+            call.receiver.nil? && call.arguments.empty? && !call.parenthesized? && call.block_node.nil?
+          end
+        end
+
+        module Precedence
+          STATEMENT_PARENTS = %i[begin kwbegin def defs block numblock itblock class module sclass
+                                 ensure rescue resbody preexe postexe].freeze
+          ASSIGNMENTS = %i[lvasgn ivasgn cvasgn gvasgn casgn masgn op_asgn or_asgn and_asgn indexasgn].freeze
+
+          module_function
+
+          def parenthesize_conditional?(node)
+            !statement_position?(node)
+          end
+
+          def parenthesize_rescue?(node)
+            !statement_position?(node) && !assignment_value?(node)
+          end
+
+          def endless_def?(body)
+            %i[def defs].include?(body.type) && body.endless?
+          end
+
+          def statement_position?(node)
+            parent = node.parent
+            return true if parent.nil? || STATEMENT_PARENTS.include?(parent.type)
+
+            case parent.type
+            when :if, :while, :until, :case, :case_match then !parent.children.first.equal?(node)
+            when :for, :when, :in_pattern then parent.body.equal?(node)
+            else false
+            end
+          end
+
+          def assignment_value?(node)
+            parent = node.parent
+            return false unless parent.children.last.equal?(node)
+
+            ASSIGNMENTS.include?(parent.type) || (parent.send_type? && parent.assignment_method?)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/neetzsche_cops.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "neetzsche/generated_migration_timestamp"
+require_relative "neetzsche/multiline_conditional_body"
 require_relative "neetzsche/no_comments"
+require_relative "neetzsche/statement_modifier"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: officer_neetzsche
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - TheStranjer
@@ -52,7 +52,9 @@ files:
 - lib/officer_neetzsche/plugin.rb
 - lib/officer_neetzsche/version.rb
 - lib/rubocop/cop/neetzsche/generated_migration_timestamp.rb
+- lib/rubocop/cop/neetzsche/multiline_conditional_body.rb
 - lib/rubocop/cop/neetzsche/no_comments.rb
+- lib/rubocop/cop/neetzsche/statement_modifier.rb
 - lib/rubocop/cop/neetzsche_cops.rb
 homepage: https://github.com/TheStranjer/OfficerNEETzsche
 licenses: []