rubocop-avoid_unless 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cd4984b811f306fa9d68491d5db64f41e611dea914b38ab7d2540a54ecb2f241
+  data.tar.gz: 24c0639d10125868c066613d0265d2f737f800b1143e3bafe5fbe33a35bb2bf1
+SHA512:
+  metadata.gz: ec8b3927b1b4f0f754252930dcefcf32c69eaa80e735c5c5f6ff01ff596cd544ecb763abe81d209fa5a6d44bcaded018d2bb6b5ecd80b5371fdd6fe0daf910c2
+  data.tar.gz: b6e42242b8de5506a2a8a0e8e943c22a1d5134be7afeb5f8d62f4dcdad6c6e9d8c1353f70c55dc28b09e04d7cfae8eae763673d2c7e1fc87d91e6067923d631c

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Endoze
+
+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/config/default.yml

@@ -0,0 +1,4 @@
+Style/AvoidUnless:
+  Description: "Disallows the use of `unless`. Use `if` with an inverse or negated condition instead."
+  Enabled: true
+  VersionAdded: "0.1.0"

data/lib/rubocop/avoid_unless/plugin.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "lint_roller"
+
+module RuboCop
+  module AvoidUnless
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: "rubocop-avoid_unless",
+          version: VERSION,
+          homepage: "https://github.com/endoze/rubocop-avoid_unless"
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(context)
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: File.join(__dir__, "..", "..", "..", "config", "default.yml")
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/avoid_unless/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AvoidUnless
+    VERSION = "0.1.3"
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Disallows the use of `unless` in all forms.
+      # Use `if` with an inverse or negated condition instead.
+      #
+      # @example
+      #   # bad
+      #   do_something unless items.any?
+      #   return unless value.present?
+      #   return unless condition
+      #
+      #   # good
+      #   do_something if items.none?
+      #   return if value.blank?
+      #   return if !condition
+      class AvoidUnless < Base
+        extend AutoCorrector
+
+        MSG = "Avoid `unless`. Use `if` with an inverse or negated condition instead."
+
+        INVERSE_METHODS = {
+          any?: :none?,
+          none?: :any?,
+          present?: :blank?,
+          blank?: :present?,
+          empty?: :present?,
+          even?: :odd?,
+          odd?: :even?,
+          zero?: :nonzero?,
+          nonzero?: :zero?,
+          true?: :false?,
+          false?: :true?
+        }.freeze
+
+        INVERSE_METHODS_WITH_ARGS = {
+          include?: :exclude?,
+          exclude?: :include?
+        }.freeze
+
+        INVERSE_OPERATORS = {
+          :== => :!=,
+          :!= => :==,
+          :> => :<=,
+          :< => :>=,
+          :>= => :<,
+          :<= => :>,
+          :=~ => :!~,
+          :!~ => :=~
+        }.freeze
+
+        def on_if(node)
+          return if !node.unless?
+
+          add_offense(node) do |corrector|
+            condition = node.condition
+            replacement = inverted_condition(condition)
+            corrector.replace(node.loc.keyword, "if")
+            corrector.replace(condition, replacement)
+          end
+        end
+
+        private
+
+        def inverted_condition(node)
+          case node.type
+          when :send
+            invert_send(node)
+          when :begin
+            # Parenthesized expression: (expr)
+            inner = node.children.first
+            "(#{inverted_condition(inner)})"
+          when :or
+            # De Morgan: !(a || b) => !a && !b
+            lhs, rhs = *node
+            "#{inverted_condition(lhs)} && #{inverted_condition(rhs)}"
+          when :and
+            # De Morgan: !(a && b) => !a || !b
+            lhs, rhs = *node
+            "#{inverted_condition(lhs)} || #{inverted_condition(rhs)}"
+          else
+            negate(node)
+          end
+        end
+
+        def invert_send(node)
+          receiver, method_name, *args = *node
+
+          if method_name == :!
+            # unless !x => if x
+            return receiver.source
+          end
+
+          if (inverse = INVERSE_OPERATORS[method_name]) && args.size == 1
+            return "#{receiver.source} #{inverse} #{args.first.source}"
+          end
+
+          if (inverse = INVERSE_METHODS[method_name]) && args.empty?
+            receiver_source = receiver ? "#{receiver.source}." : ""
+            return "#{receiver_source}#{inverse}"
+          end
+
+          if (inverse = INVERSE_METHODS_WITH_ARGS[method_name]) && args.any?
+            receiver_source = receiver ? "#{receiver.source}." : ""
+            args_source = args.map(&:source).join(", ")
+
+            return "#{receiver_source}#{inverse}(#{args_source})"
+          end
+
+          negate(node)
+        end
+
+        def negate(node)
+          if requires_parens_for_negation?(node)
+            "!(#{node.source})"
+          else
+            "!#{node.source}"
+          end
+        end
+
+        def requires_parens_for_negation?(node)
+          node.or_type? || node.and_type?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop-avoid_unless.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require_relative "rubocop/avoid_unless/version"
+require_relative "rubocop/avoid_unless/plugin"
+require_relative "rubocop/cop/style/avoid_unless"

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-avoid_unless
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Endoze
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.72'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.72'
+- !ruby/object:Gem::Dependency
+  name: lint_roller
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: A RuboCop extension that provides a Style/AvoidUnless cop. It flags all
+  uses of `unless` and auto-corrects them to `if` with an inverse or negated condition.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- config/default.yml
+- lib/rubocop-avoid_unless.rb
+- lib/rubocop/avoid_unless/plugin.rb
+- lib/rubocop/avoid_unless/version.rb
+- lib/rubocop/cop/style/avoid_unless.rb
+homepage: https://github.com/endoze/rubocop-avoid_unless
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: RuboCop cop that disallows `unless` in favor of `if` with inverted conditions
+test_files: []