rubocop-sane_conditionals 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 145264fffb5808ff6c7f5dfe04ffbf1340fd91fd1e86e150f471a9c41f086a39
+  data.tar.gz: fd868cb346b3296caee3e963831a43760ad7eb3c6f6ec430b818f3740c093034
+SHA512:
+  metadata.gz: eb90cdf3cd716033916415e0ebe1fb2ea864a295828b6284cf93c17e3a418848f6f00f6fcabaf9977714edcdbc7fb9f4d9ba39f346589883938d96047fcea35e
+  data.tar.gz: 962ae39df0757a3702fdd2f413b7ac3f98a185031f84eb859a9a23cc787955e3bb582de437941a50092035ce746b70937b576356f7d701bf6bda13e2ed9b4e03

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Federico
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,196 @@
+# rubocop-sane_conditionals
+
+RuboCop cops for people who want to read code, not decode it.
+
+## The Problem
+
+Ruby is a beautiful language. It is expressive, elegant, and reads almost like
+English. This is exactly the problem.
+
+At some point, someone decided that because Ruby *can* read like English, it
+*should* read like English — and then they implemented the wrong kind of
+English. The kind where the subject comes last. The kind you have to read
+backwards. The kind that makes you go:
+
+```ruby
+send_email unless already_sent?
+```
+
+Cool. So do we send the email, or do we not? Let me just... hold that `send_email`
+in working memory while I parse `unless`... flip the boolean in my head...
+re-check the variable name... oh. OH. We send the email when `already_sent?` is
+`false`. Got it. Only took 600ms and a small cortisol spike.
+
+And then there is:
+
+```ruby
+destroy! if admin? && confirmed?
+```
+
+This one is great. Your eye lands on `destroy!`. Your adrenal gland fires.
+Your hand moves toward the keyboard. Then you read `if admin? && confirmed?`
+and you relax. But the damage is done. Your heart rate is up. You have aged
+slightly. The code has won.
+
+This gem fights back.
+
+## What It Does
+
+### `Style/NoUnless`
+
+Bans `unless` in all its forms. Replaces it with a negated `if`.
+
+`unless` is syntactic sugar. Sugar is fine in coffee. Sugar is not fine when
+you are trying to understand whether a background job is going to run or not
+at 11pm during an incident.
+
+```ruby
+# Before (your colleagues wrote this)
+unless user.banned?
+  grant_access
+end
+
+# After (the cop wrote this)
+if !user.banned?
+  grant_access
+end
+```
+
+Yes, `!condition` looks slightly more aggressive. It is slightly more
+aggressive. That is the point. You are negating something. Own it.
+
+When the condition is compound, the parens come with it:
+
+```ruby
+# Before (your colleagues wrote this)
+unless user.banned? && account.locked?
+  grant_access
+end
+
+# After (the cop wrote this)
+if !(user.banned? && account.locked?)
+  grant_access
+end
+```
+
+```ruby
+# Before (someone thought this was clever)
+render_page unless maintenance_mode?
+
+# After
+if !maintenance_mode?
+  render_page
+end
+```
+
+**"But `unless foo` is so readable!"**
+
+It is readable the first time. The fourteenth time you see it in a file, your
+brain has learned to pattern-match it and skip the inversion step — which means
+you are now *silently wrong* about what the code does until you stop and
+actually re-read it. Congratulations on training yourself to make subtle errors
+efficiently.
+
+### `Style/IfUnlessModifierMultiline`
+
+Bans modifier `if`. Expands it to a normal `if` block.
+
+Modifier `if` is a style borrowed from Perl. If you are taking style advice
+from Perl, please close this README and reconsider your choices.
+
+```ruby
+# Before (you thought you were saving lines)
+do_the_thing if condition_is_met?
+
+# After (you are saving brain cells instead)
+if condition_is_met?
+  do_the_thing
+end
+```
+
+The argument for modifier `if` is always "it's more concise." This is true.
+It is also more concise to write variable names as single letters, skip
+comments entirely, and put everything on one line. Conciseness is not the
+goal. Clarity is the goal.
+
+When you write `do_thing if bar`, a reader must:
+
+1. Parse `do_thing`
+2. Begin forming the intention "ok, we do the thing"
+3. Hit `if`
+4. Backtrack
+5. Parse `bar`
+6. Decide whether to do the thing
+7. Wonder why this person hates them
+
+When you write `if bar` on its own line, a reader:
+
+1. Parses `if bar`
+2. Decides whether to enter the block
+3. Does or does not enter the block
+4. Goes home at a reasonable hour
+
+Note: modifier `unless` (`do_thing unless bar`) is also banned, but by
+`Style/NoUnless`. It is doubly bad — it is both backwards *and* inverted — and
+it gets its own cop because it deserves special attention.
+
+## Installation
+
+Add this to your `Gemfile`:
+
+```ruby
+gem "rubocop-sane_conditionals", require: false
+```
+
+Then add this to your `.rubocop.yml`:
+
+```yaml
+require:
+  - rubocop-sane_conditionals
+
+Style/NoUnless:
+  Enabled: true
+
+Style/IfUnlessModifierMultiline:
+  Enabled: true
+```
+
+Run `bundle exec rubocop --autocorrect` and let the gem fix your codebase
+while you make tea and quietly reflect on past decisions.
+
+## FAQ
+
+**Q: Isn't `unless` idiomatic Ruby?**
+
+A: Yes. So is `BEGIN`, `$PROGRAM_NAME`, and the flip-flop operator. Idiomatic
+does not mean good. It means common. A lot of common things are bad.
+
+**Q: My team loves `unless`. They will push back.**
+
+A: Show them this gem. If they still push back, that is useful information
+about your team.
+
+**Q: What about `if !foo`? Isn't `unless foo` cleaner?**
+
+A: No. `if !foo` is a complete, unambiguous statement. `unless foo` requires
+the reader to know that `unless` means `if not`, apply that transformation,
+and then continue. This is one extra step. Over a long career, these extra
+steps add up to a measurable amount of time you could have spent doing
+something else.
+
+**Q: Why does `unless foo && bar` become `if !(foo && bar)` instead of `if !foo && !bar`?**
+
+A: Because that would be wrong. De Morgan's law says `!(A && B)` equals
+`!A || !B`, not `!A && !B`. The cop is not here to do your boolean algebra
+for you. It is here to make the negation visible. The parens make it clear
+that the whole compound condition is being negated, which is exactly what
+`unless` was hiding.
+
+**Q: You seem angry about this.**
+
+A: I am not angry. I am tired. There is a difference. One of them requires
+backtracking to determine the meaning.
+
+## License
+
+MIT. Use it. Improve it. Inflict it on your colleagues.

data/config/default.yml

@@ -0,0 +1,16 @@
+---
+Style/NoUnless:
+  Description: >-
+    Use negated `if` instead of `unless`. Unless is cute. Unless is also
+    a brain trap. Please stop.
+  Enabled: true
+  VersionAdded: "0.1"
+  AutoCorrect: true
+
+Style/IfUnlessModifierMultiline:
+  Description: >-
+    Expand modifier `if` to multi-line form. Your code is not a tweet.
+    You have all the lines you want.
+  Enabled: true
+  VersionAdded: "0.1"
+  AutoCorrect: true

data/lib/rubocop/cop/style/if_unless_modifier_multiline.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Disallows modifier `if` (i.e. `foo if bar`) and converts it to a
+      # standard multi-line `if` block.
+      #
+      # Modifier `if` reads right-to-left: your eye hits `foo`, your brain
+      # starts processing "ok, we do foo", then hits `if bar` and has to
+      # backtrack. Congratulations, you have implemented a for-loop in a
+      # human brain. It will crash.
+      #
+      # Note: modifier `unless` is handled separately by `Style/NoUnless`.
+      # Don't worry, it's also banned.
+      #
+      # @example
+      #   # bad
+      #   do_something if condition
+      #
+      #   # good
+      #   if condition
+      #     do_something
+      #   end
+      class IfUnlessModifierMultiline < Base
+        extend AutoCorrector
+
+        MSG = 'Convert modifier `if` to multi-line form. Reading left-to-right ' \
+              'is a feature, not a suggestion.'
+
+        def on_if(node)
+          if !node.modifier_form?
+            return
+          end
+
+          if node.unless?
+            return
+          end
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          condition = node.condition.source
+          body = node.body.source
+          indentation = ' ' * node.loc.column
+
+          replacement = <<~RUBY.chomp
+            if #{condition}
+            #{indentation}  #{body}
+            #{indentation}end
+          RUBY
+
+          corrector.replace(node, replacement)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/no_unless.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Disallows `unless` in all its forms and replaces it with a negated `if`.
+      #
+      # `unless` is syntactic sugar that requires the reader to mentally invert
+      # the condition. This is fine if your reader is a compiler. Your reader is
+      # not a compiler. Your reader is a tired human at 4pm on a Friday who just
+      # wants to know whether the code runs the thing or does not run the thing.
+      #
+      # @example
+      #   # bad
+      #   unless foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   if !foo
+      #     bar
+      #   end
+      #
+      #   # bad
+      #   unless foo && bar
+      #     baz
+      #   end
+      #
+      #   # good
+      #   if !(foo && bar)
+      #     baz
+      #   end
+      #
+      #   # bad
+      #   bar unless foo
+      #
+      #   # good
+      #   if !foo
+      #     bar
+      #   end
+      class NoUnless < Base
+        extend AutoCorrector
+
+        MSG = 'Use negated `if` instead of `unless`. Your future self will thank you. ' \
+              'Your colleagues will thank you. English teachers need not apply.'
+
+        def on_if(node)
+          if !node.unless?
+            return
+          end
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          condition_node = node.condition
+          condition_source = condition_node.source
+
+          negated_condition = if requires_parens?(condition_node)
+                                "!(#{condition_source})"
+                              else
+                                "!#{condition_source}"
+                              end
+
+          if node.modifier_form?
+            autocorrect_modifier(corrector, node, negated_condition)
+          else
+            autocorrect_multiline(corrector, node, negated_condition)
+          end
+        end
+
+        def requires_parens?(condition_node)
+          condition_node.and_type? || condition_node.or_type?
+        end
+
+        def autocorrect_modifier(corrector, node, negated_condition)
+          body = node.body.source
+          indentation = ' ' * node.loc.column
+          replacement = "if #{negated_condition}\n#{indentation}  #{body}\n#{indentation}end"
+          corrector.replace(node, replacement)
+        end
+
+        def autocorrect_multiline(corrector, node, negated_condition)
+          body_source = node.body.source
+          indentation = ' ' * node.loc.column
+
+          replacement = if node.else_branch
+                          else_body = node.else_branch.source
+                          <<~RUBY.chomp
+                            if #{negated_condition}
+                            #{indentation}  #{body_source}
+                            #{indentation}else
+                            #{indentation}  #{else_body}
+                            #{indentation}end
+                          RUBY
+                        else
+                          <<~RUBY.chomp
+                            if #{negated_condition}
+                            #{indentation}  #{body_source}
+                            #{indentation}end
+                          RUBY
+                        end
+
+          corrector.replace(node, replacement)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop-sane_conditionals/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module SaneConditionals
+    VERSION = '1.0.0'
+  end
+end

data/lib/rubocop-sane_conditionals.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require_relative 'rubocop-sane_conditionals/version'
+require_relative 'rubocop/cop/style/no_unless'
+require_relative 'rubocop/cop/style/if_unless_modifier_multiline'
+
+if defined?(Rake)
+  RuboCop::RakeTask
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-sane_conditionals
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Federico
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: |
+  Enforces conditional style that does not require you to hold the entire
+  sentence in working memory while your brain tries to figure out what
+  "do_thing if !foo unless bar" means. It means you hate your colleagues.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- config/default.yml
+- lib/rubocop-sane_conditionals.rb
+- lib/rubocop-sane_conditionals/version.rb
+- lib/rubocop/cop/style/if_unless_modifier_multiline.rb
+- lib/rubocop/cop/style/no_unless.rb
+homepage: https://github.com/jmfederico/rubocop-sane_conditionals
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: RuboCop cops for humans who can read.
+test_files: []