officer_neetzsche 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 271ee4879a7e1972dfd96edbf5ed8db9ce1edcd6c642631f52d6aa77bba9f7c6
-  data.tar.gz: 4d6ce8fb83453d12b2bdbe4824974e776247fbbdb2a3f304d8f4fcf641fb9a5a
+  metadata.gz: 7a43403b5afe1dda6db1ada7ebcbed1edfcedf20b74310ae26418ad2476caaa4
+  data.tar.gz: 2852001bdaba6f54726cba1ff1381a001a78827c201ec3a0fb91da9b181da443
 SHA512:
-  metadata.gz: f2380fae302b365699c193d7b8721ca3ed35a56e18b039b9c335ac4bb79815db3c35afaad341512e737c06332dc35ac752d9233ed518dc92c77bb1f777610314
-  data.tar.gz: 702240bef2cf52c4fab6882271c737f0b5381d48917e3b3a10bdc43d4d36433dc1139eb6dc798db07495d9f6ca74608bc21283de9d690b8a8260a3e0490c2d62
+  metadata.gz: b6306713c14f1fc76bbb93341985a1de4e98a6ef49d5a168bb14ab9373cfd381ca0c0d0efab2ce866fc8f36df15090fdb95534561e9e9bbacf4fefe337b832b3
+  data.tar.gz: cedd62f5afe1fc618b2da479f3b93fc39f4d585008fd41d1bc5dda9a73601c1df160d159407b7cd85ce8fccaf6f4cbf56329e1f368b0e2177a1645d213436efb

data/CHANGELOG.md

@@ -1,6 +1,22 @@
 # Changelog
 
-## 0.1.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
+
+- `NEETzsche/GeneratedMigrationTimestamp`: flags a migration file whose timestamp prefix is missing, impossible, in the future, or a round or patterned clock time that a hand or an LLM typed instead of `bin/rails generate migration`. Runs on `db/migrate/**/*.rb` and `db/*_migrate/**/*.rb`.
+
+## 0.1.0 (2026-09-09)
 
 - Add `NEETzsche/NoComments`, ported from hyperborea-news.
 - Disable `Style/Documentation` whenever the plugin is loaded, since it demands the comments `NEETzsche/NoComments` forbids.

data/README.md

@@ -1,12 +1,16 @@
 # OfficerNEETzsche
 
+[![Gem Version](https://badge.fury.io/rb/officer_neetzsche.svg)](https://rubygems.org/gems/officer_neetzsche)
+
 RuboCop cops that enforce NEETzsche-isms. Every cop ships enabled: register the plugin and the rules apply.
 
 ## Cops
 
 | Cop | Enforces | Autocorrect |
 | --- | --- | --- |
+| `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
 
@@ -23,15 +27,13 @@ group :development, :test do
 end
 ```
 
-Until the gem is published to RubyGems, point Bundler at the repository instead:
+Then run `bundle install`. Or install it directly:
 
-```ruby
-group :development, :test do
-  gem "officer_neetzsche", github: "TheStranjer/OfficerNEETzsche", require: false
-end
+```sh
+gem install officer_neetzsche
 ```
 
-Then run `bundle install`.
+The gem is published at [rubygems.org/gems/officer_neetzsche](https://rubygems.org/gems/officer_neetzsche).
 
 ## Usage
 
@@ -58,6 +60,54 @@ Autocorrect what they flag:
 bundle exec rubocop --autocorrect --only NEETzsche
 ```
 
+## NEETzsche/GeneratedMigrationTimestamp
+
+Flags a migration file whose 14-digit timestamp prefix looks typed rather than generated. `bin/rails generate migration` stamps the file with the current UTC second, and that second is almost never round. A person, or an LLM writing the file without running the generator, reaches for round numbers and patterns instead.
+
+```
+# bad
+db/migrate/20240101000000_create_users.rb
+db/migrate/20240101000001_create_posts.rb
+db/migrate/20240115120000_add_email_to_users.rb
+db/migrate/20240315143000_create_comments.rb
+db/migrate/20240601123456_add_index_to_comments.rb
+
+# good
+db/migrate/20260409074855_create_users.rb
+```
+
+The offense sits on the first line of the file and names the tell:
+
+- **No 14-digit timestamp.** `001_create_users.rb`, `20240101_create_users.rb`, `create_users.rb`.
+- **Not a real date or time.** `2023-02-29`, month `13`, hour `24`, minute or second `60`.
+- **In the future.** A date later than today in UTC.
+- **A round clock time.** Seconds `00` on a five-minute mark: `00:00:00`, `12:00:00`, `14:30:00`, `09:15:00`.
+- **A round hour plus a counter.** Up to nine seconds or nine minutes past any hour (`12:00:01`, `12:01:00`), or any whole minute or second past midnight (`00:00:23`, `00:37:00`). Incrementing the last digits of a copied timestamp produces these.
+- **One number repeated.** `11:11:11`, `12:12:12`.
+- **Consecutive numbers.** `01:02:03`, `10:11:12`.
+- **A placeholder time.** `12:34:56`, `01:23:45`, `10:20:30`, `11:22:33`, `15:30:45`, `23:59:59`.
+
+A time that only ends in `:00`, such as `14:17:00`, passes. The date is not judged beyond existing and having happened, so a migration generated on New Year's Day passes too.
+
+The cop runs on `db/migrate/**/*.rb` and on the `db/*_migrate/**/*.rb` directories that multiple-database setups use. About one generated timestamp in a hundred lands on a clock-time tell, so an established project may see a few legitimate migrations flagged. Never rename a migration that has run anywhere, since its version is recorded in `schema_migrations`. Exclude the file instead:
+
+```yaml
+NEETzsche/GeneratedMigrationTimestamp:
+  Exclude:
+    - "db/migrate/20230614140700_add_index_to_users.rb"
+```
+
+Or silence it from the first line with a directive, which `NEETzsche/NoComments` allows:
+
+```ruby
+# rubocop:disable NEETzsche/GeneratedMigrationTimestamp
+class AddIndexToUsers < ActiveRecord::Migration[8.0]
+```
+
+Projects that set `config.active_record.timestamped_migrations = false` number their migrations `001`, `002`, and so on. Every one of those trips the cop, so disable it there.
+
+There is no autocorrect. The fix is to delete the file and run `bin/rails generate migration` again.
+
 ## 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.
@@ -83,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

@@ -1,10 +1,32 @@
 NEETzsche:
   Enabled: true
 
+NEETzsche/GeneratedMigrationTimestamp:
+  Description: "Requires migration filenames to carry the timestamp `bin/rails generate migration` stamped, not a round or patterned one typed by hand."
+  Enabled: true
+  VersionAdded: "0.2.0"
+  Include:
+    - "**/db/migrate/**/*.rb"
+    - "**/db/*_migrate/**/*.rb"
+
 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.1.0"
+  VERSION = "0.3.0"
 end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "date"
+
+module RuboCop
+  module Cop
+    module NEETzsche
+      class GeneratedMigrationTimestamp < Base
+        include RangeHelp
+
+        MSG = "Migration timestamp `%<timestamp>s` looks made up; %<tell>s. " \
+              "Let `bin/rails generate migration` name the file."
+        MSG_NO_TIMESTAMP = "Migration filename `%<basename>s` does not start with a 14-digit " \
+                           "`YYYYMMDDHHMMSS_` timestamp. Let `bin/rails generate migration` name the file."
+
+        VERSION_PREFIX = /\A\d+(?=_)/.freeze
+
+        def on_new_investigation
+          basename = File.basename(processed_source.file_path)
+          digits = basename[VERSION_PREFIX]
+          message = if digits&.length == 14
+                      made_up_message(digits)
+                    else
+                      format(MSG_NO_TIMESTAMP, basename: basename)
+                    end
+
+          add_offense(first_character, message: message) if message
+        end
+
+        private
+
+        def made_up_message(digits)
+          tell = Timestamp.new(digits).tell
+          format(MSG, timestamp: digits, tell: tell) if tell
+        end
+
+        def first_character
+          source_range(processed_source.buffer, 1, 0)
+        end
+
+        class Timestamp
+          PLACEHOLDERS = %w[123456 012345 102030 112233 153045 235959].freeze
+
+          def initialize(digits)
+            @digits = digits
+            @year, @month, @day, @hour, @minute, @second = digits.unpack("a4a2a2a2a2a2").map(&:to_i)
+          end
+
+          def tell
+            return "`#{date}` is not a real date" unless Date.valid_date?(@year, @month, @day)
+            return "`#{clock}` is not a real time" unless real_time?
+            return "`#{date}` is in the future" if Date.new(@year, @month, @day) > Time.now.utc.to_date
+
+            clock_tell
+          end
+
+          private
+
+          def clock_tell
+            if round? then "`#{clock}` is a round clock time"
+            elsif counter? then "`#{clock}` is a round hour plus a counter"
+            elsif repeated? then "`#{clock}` repeats one number"
+            elsif consecutive? then "`#{clock}` is three consecutive numbers"
+            elsif placeholder? then "`#{clock}` is a placeholder time"
+            end
+          end
+
+          def date
+            "#{@digits[0, 4]}-#{@digits[4, 2]}-#{@digits[6, 2]}"
+          end
+
+          def clock
+            "#{@digits[8, 2]}:#{@digits[10, 2]}:#{@digits[12, 2]}"
+          end
+
+          def real_time?
+            @hour < 24 && @minute < 60 && @second < 60
+          end
+
+          def round?
+            @second.zero? && (@minute % 5).zero?
+          end
+
+          def counter?
+            return @minute.zero? || @second.zero? if @hour.zero?
+
+            (@minute.zero? && @second < 10) || (@second.zero? && @minute < 10)
+          end
+
+          def repeated?
+            @hour == @minute && @minute == @second
+          end
+
+          def consecutive?
+            @minute == @hour + 1 && @second == @minute + 1
+          end
+
+          def placeholder?
+            PLACEHOLDERS.include?(@digits[8, 6])
+          end
+        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,3 +1,5 @@
 # frozen_string_literal: true
 
+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.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - TheStranjer
@@ -51,7 +51,9 @@ files:
 - lib/officer_neetzsche.rb
 - lib/officer_neetzsche/plugin.rb
 - 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: []