officer_neetzsche 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 100c19f093b3f8972a0c73262ea4d1020057aea94a4835ac2a3e573d6b4d95c6
-  data.tar.gz: 7d267e9d2cd3c091223b63c65243aa9f369d3cc8356de4346772188edcfdd681
+  metadata.gz: 7a43403b5afe1dda6db1ada7ebcbed1edfcedf20b74310ae26418ad2476caaa4
+  data.tar.gz: 2852001bdaba6f54726cba1ff1381a001a78827c201ec3a0fb91da9b181da443
 SHA512:
-  metadata.gz: 8cf5f9105e71d0044dbbe8267db688767ea642f73ef6a00bc4272930e2bd8cecd3e42a6529b195e5b9ba905917345021447a701164372616e8c2fa214ae78b6c
-  data.tar.gz: b4fafbac860b255990358dfc15e95a4463358b3106a72fdb54627908f5484516722c0a616299e862c28241fef26e4a438d2cd1d3026d82c3d0e6b81bdb7c285d
+  metadata.gz: b6306713c14f1fc76bbb93341985a1de4e98a6ef49d5a168bb14ab9373cfd381ca0c0d0efab2ce866fc8f36df15090fdb95534561e9e9bbacf4fefe337b832b3
+  data.tar.gz: cedd62f5afe1fc618b2da479f3b93fc39f4d585008fd41d1bc5dda9a73601c1df160d159407b7cd85ce8fccaf6f4cbf56329e1f368b0e2177a1645d213436efb

data/CHANGELOG.md

@@ -1,6 +1,16 @@
 # Changelog
 
-## 0.2.0 (unreleased)
+## 0.3.0 (unreleased)
+
+### 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

@@ -10,6 +10,7 @@ RuboCop cops that enforce NEETzsche-isms. Every cop ships enabled: register the
 | --- | --- | --- |
 | `NEETzsche/GeneratedMigrationTimestamp` | Migration timestamps come from `bin/rails generate migration`, not a keyboard. | 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
 
@@ -132,6 +133,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
+
+# good, 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.
+- `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

@@ -14,5 +14,19 @@ NEETzsche/NoComments:
   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.3.0"
 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

@@ -2,3 +2,4 @@
 
 require_relative "neetzsche/generated_migration_timestamp"
 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.3.0
 platform: ruby
 authors:
 - TheStranjer
@@ -53,6 +53,7 @@ files:
 - lib/officer_neetzsche/version.rb
 - lib/rubocop/cop/neetzsche/generated_migration_timestamp.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: []