rubocop 1.84.2 → 1.86.0

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

@@ -5,15 +5,26 @@ module RuboCop
     module Style
       # Enforces consistent style for empty class definitions.
       #
-      # This cop can enforce either a two-line class definition or `Class.new`
+      # This cop can enforce either a standard class definition or `Class.new`
       # for classes with no body.
       #
       # The supported styles are:
       #
-      # * class_definition (default) - prefer two-line class definition over `Class.new`
+      # * class_keyword (default) - prefer standard class definition over `Class.new`
       # * class_new - prefer `Class.new` over class definition
       #
-      # @example EnforcedStyle: class_definition (default)
+      # One difference between the two styles is that the `Class.new` form does not make
+      # the subclass name available to the base class's `inherited` callback.
+      # For this reason, `EnforcedStyle: class_keyword` is set as the default style.
+      # Class definitions without a superclass, which are not involved in inheritance,
+      # are not detected. This ensures safe detection regardless of the applied style.
+      # This avoids overlapping responsibilities with the `Lint/EmptyClass` cop.
+      #
+      # Use `AllowedParentClasses` to permit both styles for specific parent classes.
+      # For example, adding `StandardError` allows both `Error = Class.new(StandardError)`
+      # and `class Error < StandardError; end` regardless of the enforced style.
+      #
+      # @example EnforcedStyle: class_keyword (default)
       #   # bad
       #   FooError = Class.new(StandardError)
       #
@@ -35,33 +46,43 @@ module RuboCop
       #   # good
       #   FooError = Class.new(StandardError)
       #
+      # @example AllowedParentClasses: ['StandardError']
+      #   # good - allowed regardless of EnforcedStyle
+      #   FooError = Class.new(StandardError)
+      #
+      #   # good - allowed regardless of EnforcedStyle
+      #   class FooError < StandardError
+      #   end
+      #
       class EmptyClassDefinition < Base
         include ConfigurableEnforcedStyle
-        include RangeHelp
         extend AutoCorrector
 
-        MSG_CLASS_DEFINITION =
-          'Prefer a two-line class definition over `Class.new` for classes with no body.'
-        MSG_CLASS_NEW = 'Prefer `Class.new` over class definition for classes with no body.'
+        MSG_CLASS_KEYWORD =
+          'Use the `class` keyword instead of `Class.new` to define an empty class.'
+        MSG_CLASS_NEW = 'Use `Class.new` instead of the `class` keyword to define an empty class.'
 
         # @!method class_new_assignment(node)
         def_node_matcher :class_new_assignment, <<~PATTERN
-          (casgn _ _ $(send (const _ :Class) :new ...))
+          (casgn _ _ $(send (const _ :Class) :new _))
         PATTERN
 
         def on_casgn(node)
-          return unless style == :class_definition
+          return unless %i[class_keyword class_definition].include?(style)
           return unless (class_new_node = class_new_assignment(node))
           return if (arg = class_new_node.first_argument) && !arg.const_type?
+          return if allowed_parent_class?(class_new_node.first_argument.source)
 
-          add_offense(node, message: MSG_CLASS_DEFINITION) do |corrector|
+          add_offense(node, message: MSG_CLASS_KEYWORD) do |corrector|
             autocorrect_class_new(corrector, node, class_new_node)
           end
         end
 
         def on_class(node)
           return unless style == :class_new
+          return unless node.parent_class
           return if (body = node.body) && !body.children.empty?
+          return if allowed_parent_class?(node.parent_class.source)
 
           add_offense(node, message: MSG_CLASS_NEW) do |corrector|
             autocorrect_class_definition(corrector, node)
@@ -70,25 +91,27 @@ module RuboCop
 
         private
 
+        def allowed_parent_class?(parent_class_name)
+          allowed_parent_classes.include?(parent_class_name)
+        end
+
+        def allowed_parent_classes
+          cop_config.fetch('AllowedParentClasses', [])
+        end
+
         def autocorrect_class_new(corrector, node, class_new_node)
           indent = ' ' * node.loc.column
           class_name = node.name
-          if (parent_class = class_new_node.first_argument)
-            parent_class_name = " < #{parent_class.source}"
-          end
+          parent_class_name = class_new_node.first_argument.source
 
-          corrector.replace(node, "class #{class_name}#{parent_class_name}\n#{indent}end")
+          corrector.replace(node, "class #{class_name} < #{parent_class_name}\n#{indent}end")
         end
 
         def autocorrect_class_definition(corrector, node)
-          indent = ' ' * node.loc.column
           class_name = node.identifier.source
-          if (parent_class = node.parent_class)
-            parent_class_name = "(#{parent_class.source})"
-          end
-          range = range_by_whole_lines(node.source_range, include_final_newline: true)
+          parent_class_name = node.parent_class.source
 
-          corrector.replace(range, "#{indent}#{class_name} = Class.new#{parent_class_name}\n")
+          corrector.replace(node, "#{class_name} = Class.new(#{parent_class_name})")
         end
       end
     end

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

@@ -23,7 +23,7 @@ module RuboCop
 
         MSG = 'Omit parentheses for the empty lambda parameters.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           send_node = node.send_node
           return unless send_node.send_type?
 

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

@@ -3,12 +3,18 @@
 module RuboCop
   module Cop
     module Style
-      # Checks ensures source files have no utf-8 encoding comments.
+      # Checks that source files have no utf-8 encoding comments.
+      # Since Ruby 2.0, UTF-8 is the default source encoding, so
+      # these comments are no longer necessary and just add noise.
+      #
       # @example
       #   # bad
       #   # encoding: UTF-8
       #   # coding: UTF-8
       #   # -*- coding: UTF-8 -*-
+      #
+      #   # good
+      #   # No encoding comment needed
       class Encoding < Base
         include RangeHelp
         extend AutoCorrector

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for END blocks.
+      # Checks for `END` blocks. `END` blocks are Perl-style constructs
+      # and `Kernel#at_exit` is the idiomatic Ruby alternative, as it's
+      # explicit and can be used anywhere.
       #
       # @example
       #   # bad

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

@@ -157,6 +157,7 @@ module RuboCop
             handle_require_always_style(node)
           end
         end
+        alias on_defs on_def
 
         private
 
@@ -170,7 +171,7 @@ module RuboCop
         end
 
         def handle_require_single_line_style(node)
-          if node.endless? && !node.single_line?
+          if node.endless? && node.multiline?
             add_offense(node, message: MSG_MULTI_LINE) do |corrector|
               correct_to_multiline(corrector, node)
             end
@@ -207,7 +208,7 @@ module RuboCop
 
         def correct_to_multiline(corrector, node)
           replacement = <<~RUBY.strip
-            def #{node.method_name}#{arguments(node)}
+            def #{receiver(node)}#{node.method_name}#{arguments(node)}
               #{node.body.source}
             end
           RUBY
@@ -217,10 +218,14 @@ module RuboCop
 
         def endless_replacement(node)
           <<~RUBY.strip
-            def #{node.method_name}#{arguments(node)} = #{node.body.source}
+            def #{receiver(node)}#{node.method_name}#{arguments(node)} = #{node.body.source}
           RUBY
         end
 
+        def receiver(node)
+          node.receiver ? "#{node.receiver.source}#{node.loc.operator.source}" : ''
+        end
+
         def arguments(node, missing = '')
           node.arguments.any? ? node.arguments.source : missing
         end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `File.open` without a block, which can leak file descriptors.
+      #
+      # When `File.open` is called without a block, the caller is responsible
+      # for closing the file descriptor. If it is not explicitly closed, it
+      # will only be closed when the garbage collector runs, which may lead
+      # to resource exhaustion. Using the block form ensures the file is
+      # automatically closed when the block exits.
+      #
+      # This cop only registers an offense when the result of `File.open` is
+      # assigned to a variable or has a method chained on it, as those are the
+      # clearest indicators that the block form should be used instead. When
+      # `File.open` is used as a return value or passed as an argument, the
+      # caller is likely managing the file descriptor intentionally.
+      #
+      # @safety
+      #   This cop is unsafe because it relies on syntax heuristics and cannot
+      #   verify whether the file descriptor is safely managed. For example, it
+      #   still flags intentional one-shot reads (`File.open("f").read`) where
+      #   the file descriptor is closed by the garbage collector.
+      #
+      # @example
+      #   # bad
+      #   f = File.open('file')
+      #
+      #   # bad
+      #   File.open('file').read
+      #
+      #   # good
+      #   File.open('file') do |f|
+      #     f.read
+      #   end
+      #
+      #   # good
+      #   File.open('file', &:read)
+      #
+      #   # good - pass an open file object to an API that manages its lifecycle
+      #   process(io: File.open('file'))
+      #
+      #   # good - return an open file object for the caller to manage
+      #   def json_key_io
+      #     File.open('file')
+      #   end
+      #
+      #   # good - use File.read for one-shot reads
+      #   File.read('file')
+      #
+      class FileOpen < Base
+        MSG = '`File.open` without a block may leak a file descriptor; use the block form.'
+        RESTRICT_ON_SEND = %i[open].freeze
+
+        # @!method file_open?(node)
+        def_node_matcher :file_open?, <<~PATTERN
+          (send (const {nil? cbase} :File) :open ...)
+        PATTERN
+
+        def on_send(node)
+          return unless file_open?(node)
+          return if node.block_argument?
+          return unless offensive_usage?(node)
+
+          add_offense(node)
+        end
+        alias on_csend on_send
+
+        private
+
+        def offensive_usage?(node)
+          return true unless node.value_used?
+
+          node.parent.lvasgn_type? || receiver_of_chained_call?(node)
+        end
+
+        def receiver_of_chained_call?(node)
+          node.parent.receiver == node
+        end
+      end
+    end
+  end
+end

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

@@ -8,6 +8,9 @@ module RuboCop
       # parameter. An `each` call with a block on a single line is always
       # allowed.
       #
+      # NOTE: `each` is preferred in idiomatic Ruby because `for` leaks
+      # its loop variable into the surrounding scope.
+      #
       # @example EnforcedStyle: each (default)
       #   # bad
       #   def foo

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

@@ -18,6 +18,11 @@ module RuboCop
       # of `EnforcedStyle`) are only considered if used in the format string argument to the
       # methods `printf`, `sprintf`, `format` and `%`.
       #
+      # NOTE: In `aggressive` mode, offenses are registered for all strings containing tokens,
+      # but autocorrection is only applied when the string appears in a known formatting context
+      # (`format`, `sprintf`, `printf`, or `%`). This is done in order to prevent false
+      # autocorrections for strings that are not actually format strings.
+      #
       # NOTE: Tokens in the `unannotated` style (eg. `%s`) are always treated as if
       # configured with `Conservative: true`. This is done in order to prevent false positives,
       # because this format is very similar to encoded URLs or Date/Time formatting strings.
@@ -90,9 +95,25 @@ module RuboCop
       #   # good
       #   redirect('foo/%{bar_id}')
       #
+      # @example Mode: aggressive (default), EnforcedStyle: annotated
+      #
+      #   # bad
+      #   "%{greeting}"
+      #   foo("%{greeting}")
+      #
+      #   # bad
+      #   format("%{greeting}", greeting: 'Hello')
+      #   printf("%{greeting}", greeting: 'Hello')
+      #   sprintf("%{greeting}", greeting: 'Hello')
+      #   "%{greeting}" % { greeting: 'Hello' }
+      #
+      #   # good
+      #   format("%<greeting>s", greeting: 'Hello')
+      #   printf("%<greeting>s", greeting: 'Hello')
+      #   sprintf("%<greeting>s", greeting: 'Hello')
+      #   "%<greeting>s" % { greeting: 'Hello' }
+      #
       # @example Mode: conservative, EnforcedStyle: annotated
-      #   # In `conservative` mode, offenses are only registered for strings
-      #   # given to a known formatting method.
       #
       #   # good
       #   "%{greeting}"
@@ -104,6 +125,12 @@ module RuboCop
       #   sprintf("%{greeting}", greeting: 'Hello')
       #   "%{greeting}" % { greeting: 'Hello' }
       #
+      #   # good
+      #   format("%<greeting>s", greeting: 'Hello')
+      #   printf("%<greeting>s", greeting: 'Hello')
+      #   sprintf("%<greeting>s", greeting: 'Hello')
+      #   "%<greeting>s" % { greeting: 'Hello' }
+      #
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
         include AllowedMethods

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

@@ -3,7 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # Looks for uses of global variables.
+      # Looks for uses of global variables. Global variables introduce
+      # shared mutable state that makes code harder to test, debug,
+      # and reason about, since any part of the program can read or modify them.
+      #
       # It does not report offenses for built-in global variables.
       # Built-in global variables are allowed by default. Additionally
       # users can allow additional variables via the AllowedVariables option.
@@ -54,7 +57,7 @@ module RuboCop
         ].map(&:to_sym)
 
         def user_vars
-          cop_config['AllowedVariables'].map(&:to_sym)
+          @user_vars ||= cop_config['AllowedVariables'].map(&:to_sym).freeze
         end
 
         def allowed_var?(global_var)

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

@@ -6,8 +6,13 @@ module RuboCop
       # Checks for presence or absence of braces around hash literal as a last
       # array item depending on configuration.
       #
-      # NOTE: This cop will ignore arrays where all items are hashes, regardless of
-      # EnforcedStyle.
+      # NOTE: This cop will ignore arrays where multiple items are all hashes,
+      # regardless of `EnforcedStyle`.
+      #
+      # [source,ruby]
+      # ----
+      # [{ one: 1 }, { two: 2 }]
+      # ----
       #
       # @example EnforcedStyle: braces (default)
       #   # bad
@@ -16,8 +21,11 @@ module RuboCop
       #   # good
       #   [1, 2, { one: 1, two: 2 }]
       #
+      #   # bad
+      #   [one: 1, two: 2]
+      #
       #   # good
-      #   [{ one: 1 }, { two: 2 }]
+      #   [{ one: 1, two: 2 }]
       #
       # @example EnforcedStyle: no_braces
       #   # bad
@@ -26,8 +34,11 @@ module RuboCop
       #   # good
       #   [1, 2, one: 1, two: 2]
       #
+      #   # bad
+      #   [{ one: 1, two: 2 }]
+      #
       #   # good
-      #   [{ one: 1 }, { two: 2 }]
+      #   [one: 1, two: 2]
       class HashAsLastArrayItem < Base
         include RangeHelp
         include ConfigurableEnforcedStyle
@@ -69,7 +80,12 @@ module RuboCop
           return if node.braces?
 
           add_offense(node, message: 'Wrap hash in `{` and `}`.') do |corrector|
-            corrector.wrap(node, '{', '}')
+            if node.single_line? || same_line?(node, node.parent)
+              corrector.wrap(node, '{', '}')
+            else
+              indent = indent(node)
+              corrector.wrap(node, "{\n#{indent}", "\n#{indent}}")
+            end
           end
         end
 

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

@@ -41,8 +41,13 @@ module RuboCop
       #   # good
       #   hash.fetch(key)
       #
+      # @example AllowedReceivers: ['Rails.cache']
+      #   # good
+      #   Rails.cache.fetch(name, options) { block }
+      #
       class HashLookupMethod < Base
         include ConfigurableEnforcedStyle
+        include AllowedReceivers
         extend AutoCorrector
 
         BRACKET_MSG = 'Use `Hash#[]` instead of `Hash#fetch`.'
@@ -51,6 +56,8 @@ module RuboCop
         RESTRICT_ON_SEND = %i[[] fetch].freeze
 
         def on_send(node)
+          return if (receiver = node.receiver) && allowed_receiver?(receiver)
+
           if offense_for_brackets?(node)
             add_offense(node.loc.selector, message: BRACKET_MSG) do |corrector|
               correct_fetch_to_brackets(corrector, node)

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

@@ -11,9 +11,11 @@ module RuboCop
       # (`transform_keys` was added in Ruby 2.5.)
       #
       # @safety
-      #   This cop is unsafe, as it can produce false positives if we are
-      #   transforming an enumerable of key-value-like pairs that isn't actually
-      #   a hash, e.g.: `[[k1, v1], [k2, v2], ...]`
+      #   This cop identifies the receiver as a hash by checking for literal hash
+      #   syntax and common methods that are known to return hashes (e.g. `to_h`,
+      #   `merge`, `invert`, `group_by`, etc.). However, it is unsafe because it
+      #   is possible for a custom class to define one of these methods and return
+      #   something other than a hash.
       #
       # @example
       #   # bad
@@ -21,10 +23,18 @@ module RuboCop
       #   Hash[{a: 1, b: 2}.collect { |k, v| [foo(k), v] }]
       #   {a: 1, b: 2}.map { |k, v| [k.to_s, v] }.to_h
       #   {a: 1, b: 2}.to_h { |k, v| [k.to_s, v] }
+      #   foo.to_h.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+      #   foo.merge(bar).map { |k, v| [k.to_s, v] }.to_h
       #
       #   # good
       #   {a: 1, b: 2}.transform_keys { |k| foo(k) }
       #   {a: 1, b: 2}.transform_keys { |k| k.to_s }
+      #   foo.to_h.transform_keys { |k| k.to_sym }
+      #   foo.merge(bar).transform_keys { |k| k.to_s }
+      #
+      #   # Won't register an offense - receiver is not known to be a hash
+      #   foo.bar.each_with_object({}) { |(k, v), h| h[k.to_s] = v }
+      #   baz.map { |k, v| [k.to_s, v] }.to_h
       class HashTransformKeys < Base
         include HashTransformMethod
         extend AutoCorrector
@@ -35,7 +45,7 @@ module RuboCop
         # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            (call !#array_receiver? :each_with_object (hash))
+            (call #hash_receiver? :each_with_object (hash))
             (args
               (mlhs
                 (arg $_)
@@ -50,7 +60,7 @@ module RuboCop
             (const _ :Hash)
             :[]
             (block
-              (call !#array_receiver? {:map :collect})
+              (call #hash_receiver? {:map :collect})
               (args
                 (arg $_)
                 (arg _val))
@@ -61,7 +71,7 @@ module RuboCop
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           (call
             (block
-              (call !#array_receiver? {:map :collect})
+              (call #hash_receiver? {:map :collect})
               (args
                 (arg $_)
                 (arg _val))
@@ -72,7 +82,7 @@ module RuboCop
         # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            (call !#array_receiver? :to_h)
+            (call #hash_receiver? :to_h)
             (args
               (arg $_)
               (arg _val))

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

@@ -9,9 +9,11 @@ module RuboCop
       # call to `transform_values` instead.
       #
       # @safety
-      #   This cop is unsafe, as it can produce false positives if we are
-      #   transforming an enumerable of key-value-like pairs that isn't actually
-      #   a hash, e.g.: `[[k1, v1], [k2, v2], ...]`
+      #   This cop identifies the receiver as a hash by checking for literal hash
+      #   syntax and common methods that are known to return hashes (e.g. `to_h`,
+      #   `merge`, `invert`, `group_by`, etc.). However, it is unsafe because it
+      #   is possible for a custom class to define one of these methods and return
+      #   something other than a hash.
       #
       # @example
       #   # bad
@@ -19,10 +21,18 @@ module RuboCop
       #   Hash[{a: 1, b: 2}.collect { |k, v| [k, foo(v)] }]
       #   {a: 1, b: 2}.map { |k, v| [k, v * v] }.to_h
       #   {a: 1, b: 2}.to_h { |k, v| [k, v * v] }
+      #   foo.to_h.each_with_object({}) { |(k, v), h| h[k] = foo(v) }
+      #   foo.merge(bar).map { |k, v| [k, v.to_s] }.to_h
       #
       #   # good
       #   {a: 1, b: 2}.transform_values { |v| foo(v) }
       #   {a: 1, b: 2}.transform_values { |v| v * v }
+      #   foo.to_h.transform_values { |v| foo(v) }
+      #   foo.merge(bar).transform_values { |v| v.to_s }
+      #
+      #   # Won't register an offense - receiver is not known to be a hash
+      #   foo.bar.each_with_object({}) { |(k, v), h| h[k] = v.to_s }
+      #   baz.map { |k, v| [k, v.to_s] }.to_h
       class HashTransformValues < Base
         include HashTransformMethod
         extend AutoCorrector
@@ -33,7 +43,7 @@ module RuboCop
         # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            (call !#array_receiver? :each_with_object (hash))
+            (call #hash_receiver? :each_with_object (hash))
             (args
               (mlhs
                 (arg _key)
@@ -48,7 +58,7 @@ module RuboCop
             (const _ :Hash)
             :[]
             (block
-              (call !#array_receiver? {:map :collect})
+              (call #hash_receiver? {:map :collect})
               (args
                 (arg _key)
                 (arg $_))
@@ -59,7 +69,7 @@ module RuboCop
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           (call
             (block
-              (call !#array_receiver? {:map :collect})
+              (call #hash_receiver? {:map :collect})
               (args
                 (arg _key)
                 (arg $_))
@@ -70,7 +80,7 @@ module RuboCop
         # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            (call !#array_receiver? :to_h)
+            (call #hash_receiver? :to_h)
             (args
               (arg _key)
               (arg $_))

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

@@ -89,9 +89,9 @@ module RuboCop
           [Style::SoleNestedConditional]
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_if(node)
-          return if endless_method?(node.body)
+          return if endless_method?(node.body) || node.ancestors.any?(&:dstr_type?)
 
           condition = node.condition
           return if defined_nodes(condition).any? { |n| defined_argument_is_undefined?(node, n) } ||
@@ -101,12 +101,13 @@ module RuboCop
 
           add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
             next if part_of_ignored_node?(node)
+            next if another_modifier_if_on_same_line?(node)
 
             autocorrect(corrector, node)
             ignore_node(node)
           end
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
@@ -280,6 +281,16 @@ module RuboCop
           node.parent if node&.type?(:pair)
         end
 
+        def another_modifier_if_on_same_line?(node)
+          collection = find_containing_collection(node)
+          return false unless collection
+
+          line = node.source_range.line
+          collection.each_descendant(:if).any? do |sibling|
+            sibling != node && sibling.modifier_form? && sibling.source_range.line == line
+          end
+        end
+
         def non_simple_if_unless?(node)
           node.ternary? || node.elsif? || node.else?
         end

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

@@ -17,9 +17,9 @@ module RuboCop
         include OnNormalIfUnless
         extend AutoCorrector
 
-        MSG_IF_ELSE = 'Do not use `if %<expr>s;` - use `if/else` instead.'
-        MSG_NEWLINE = 'Do not use `if %<expr>s;` - use a newline instead.'
-        MSG_TERNARY = 'Do not use `if %<expr>s;` - use a ternary operator instead.'
+        MSG_IF_ELSE = 'Do not use `%<keyword>s %<expr>s;` - use `if/else` instead.'
+        MSG_NEWLINE = 'Do not use `%<keyword>s %<expr>s;` - use a newline instead.'
+        MSG_TERNARY = 'Do not use `%<keyword>s %<expr>s;` - use a ternary operator instead.'
 
         def on_normal_if_unless(node)
           return if node.parent&.if_type?
@@ -49,7 +49,7 @@ module RuboCop
                        MSG_TERNARY
                      end
 
-          format(template, expr: node.condition.source)
+          format(template, keyword: node.keyword, expr: node.condition.source)
         end
 
         def autocorrect(corrector, node)
@@ -71,7 +71,7 @@ module RuboCop
         end
 
         def use_return_with_argument?(node)
-          node.if_branch&.return_type? && node.if_branch&.arguments&.any?
+          node.branches.compact.any? { |branch| branch.return_type? && branch.arguments.any? }
         end
 
         def replacement(node)
@@ -80,6 +80,8 @@ module RuboCop
           then_code = node.if_branch ? build_expression(node.if_branch) : 'nil'
           else_code = node.else_branch ? build_expression(node.else_branch) : 'nil'
 
+          then_code, else_code = else_code, then_code if node.unless?
+
           "#{node.condition.source} ? #{then_code} : #{else_code}"
         end