rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for calls to `Kernel#format` or `Kernel#sprintf` that are redundant.
+      #
+      # Calling `format` with only a single string or constant argument is redundant,
+      # as it can be replaced by the string or constant itself.
+      #
+      # Also looks for `format` calls where the arguments are literals that can be
+      # inlined into a string easily. This applies to the `%s`, `%d`, `%i`, `%u`, and
+      # `%f` format specifiers.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because string object returned by
+      #   `format` and `sprintf` are never frozen. If `format('string')` is autocorrected to
+      #   `'string'`, `FrozenError` may occur when calling a destructive method like `String#<<`.
+      #   Consider using `'string'.dup` instead of `format('string')`.
+      #   Additionally, since the necessity of `dup` cannot be determined automatically,
+      #   this autocorrection is inherently unsafe.
+      #
+      #   [source,ruby]
+      #   ----
+      #   # frozen_string_literal: true
+      #
+      #   format('template').frozen? # => false
+      #   'template'.frozen?         # => true
+      #   ----
+      #
+      # @example
+      #
+      #   # bad
+      #   format('the quick brown fox jumps over the lazy dog.')
+      #   sprintf('the quick brown fox jumps over the lazy dog.')
+      #
+      #   # good
+      #   'the quick brown fox jumps over the lazy dog.'
+      #
+      #   # bad
+      #   format(MESSAGE)
+      #   sprintf(MESSAGE)
+      #
+      #   # good
+      #   MESSAGE
+      #
+      #   # bad
+      #   format('%s %s', 'foo', 'bar')
+      #   sprintf('%s %s', 'foo', 'bar')
+      #
+      #   # good
+      #   'foo bar'
+      #
+      class RedundantFormat < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` directly instead of `%<method_name>s`.'
+
+        RESTRICT_ON_SEND = %i[format sprintf].to_set.freeze
+        ACCEPTABLE_LITERAL_TYPES = %i[str dstr sym dsym numeric boolean nil].freeze
+
+        # @!method format_without_additional_args?(node)
+        def_node_matcher :format_without_additional_args?, <<~PATTERN
+          (send {(const {nil? cbase} :Kernel) nil?} %RESTRICT_ON_SEND ${str dstr const})
+        PATTERN
+
+        # @!method rational_number?(node)
+        def_node_matcher :rational_number?, <<~PATTERN
+          {rational (send int :/ rational) (begin rational) (begin (send int :/ rational))}
+        PATTERN
+
+        # @!method complex_number?(node)
+        def_node_matcher :complex_number?, <<~PATTERN
+          {complex (send int :+ complex) (begin complex) (begin (send int :+ complex))}
+        PATTERN
+
+        # @!method find_hash_value_node(node, name)
+        def_node_search  :find_hash_value_node, <<~PATTERN
+          (pair (sym %1) $_)
+        PATTERN
+
+        # @!method splatted_arguments?(node)
+        def_node_matcher :splatted_arguments?, <<~PATTERN
+          (send _ %RESTRICT_ON_SEND <{
+            splat
+            (hash <kwsplat ...>)
+          } ...>)
+        PATTERN
+
+        def on_send(node)
+          format_without_additional_args?(node) do |value|
+            replacement = value.source
+
+            add_offense(node, message: message(node, replacement)) do |corrector|
+              corrector.replace(node, replacement)
+            end
+            return
+          end
+
+          detect_unnecessary_fields(node)
+        end
+
+        private
+
+        def message(node, prefer)
+          format(MSG, prefer: prefer, method_name: node.method_name)
+        end
+
+        def detect_unnecessary_fields(node)
+          return unless node.first_argument&.str_type?
+
+          string = node.first_argument.value
+          arguments = node.arguments[1..]
+
+          return unless string && arguments.any?
+          return if splatted_arguments?(node)
+
+          register_all_fields_literal(node, string, arguments)
+        end
+
+        def register_all_fields_literal(node, string, arguments)
+          return unless all_fields_literal?(string, arguments.dup)
+
+          formatted_string = format(string, *argument_values(arguments))
+          replacement = quote(formatted_string, node)
+
+          add_offense(node, message: message(node, replacement)) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        def all_fields_literal?(string, arguments)
+          count = 0
+          sequences = RuboCop::Cop::Utils::FormatString.new(string).format_sequences
+          return false unless sequences.any?
+
+          sequences.each do |sequence|
+            next if sequence.percent?
+
+            hash = arguments.detect(&:hash_type?)
+            next unless (argument = find_argument(sequence, arguments, hash))
+            next unless matching_argument?(sequence, argument)
+
+            count += 1
+          end
+
+          sequences.size == count
+        end
+
+        def find_argument(sequence, arguments, hash)
+          if hash && (sequence.annotated? || sequence.template?)
+            find_hash_value_node(hash, sequence.name.to_sym).first
+          elsif sequence.arg_number
+            arguments[sequence.arg_number.to_i - 1]
+          else
+            # If the specifier contains `*`, the following arguments will be used
+            # to specify the width and can be ignored.
+            (sequence.arity - 1).times { arguments.shift }
+            arguments.shift
+          end
+        end
+
+        def matching_argument?(sequence, argument)
+          # Template specifiers don't give a type, any acceptable literal type is ok.
+          return argument.type?(*ACCEPTABLE_LITERAL_TYPES) if sequence.template?
+
+          # An argument matches a specifier if it can be easily converted
+          # to that type.
+          case sequence.type
+          when 's'
+            argument.type?(*ACCEPTABLE_LITERAL_TYPES)
+          when 'd', 'i', 'u'
+            integer?(argument)
+          when 'f'
+            float?(argument)
+          else
+            false
+          end
+        end
+
+        def numeric?(argument)
+          argument.type?(:numeric, :str) ||
+            rational_number?(argument) ||
+            complex_number?(argument)
+        end
+
+        def integer?(argument)
+          numeric?(argument) && Integer(argument_value(argument), exception: false)
+        end
+
+        def float?(argument)
+          numeric?(argument) && Float(argument_value(argument), exception: false)
+        end
+
+        # Add correct quotes to the formatted string, preferring retaining the existing
+        # quotes if possible.
+        def quote(string, node)
+          str_node = node.first_argument
+          start_delimiter = str_node.loc.begin.source
+          end_delimiter = str_node.loc.end.source
+
+          # If there is any interpolation, the delimiters need to be changed potentially
+          if node.each_descendant(:dstr, :dsym).any?
+            case start_delimiter
+            when "'"
+              start_delimiter = end_delimiter = '"'
+            when /\A%q(.)/
+              start_delimiter = "%Q#{Regexp.last_match[1]}"
+            end
+          end
+
+          "#{start_delimiter}#{string}#{end_delimiter}"
+        end
+
+        def argument_values(arguments)
+          arguments.map { |argument| argument_value(argument) }
+        end
+
+        def argument_value(argument)
+          argument = argument.children.first if argument.begin_type?
+
+          if argument.dsym_type?
+            dsym_value(argument)
+          elsif argument.hash_type?
+            hash_value(argument)
+          elsif rational_number?(argument)
+            rational_value(argument)
+          elsif complex_number?(argument)
+            complex_value(argument)
+          elsif argument.respond_to?(:value)
+            argument.value
+          else
+            argument.source
+          end
+        end
+
+        def dsym_value(dsym_node)
+          dsym_node.children.first.source
+        end
+
+        def hash_value(hash_node)
+          hash_node.each_pair.with_object({}) do |pair, hash|
+            hash[pair.key.value] = argument_value(pair.value)
+          end
+        end
+
+        def rational_value(rational_node)
+          rational_node.source.to_r
+        end
+
+        def complex_value(complex_node)
+          Complex(complex_node.source)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Check for uses of `Object#freeze` on immutable objects.
+      #
+      # NOTE: `Regexp` and `Range` literals are frozen objects since Ruby 3.0.
+      #
+      # NOTE: From Ruby 3.0, this cop allows explicit freezing of interpolated
+      # string literals when `# frozen-string-literal: true` is used.
+      #
+      # @example
+      #   # bad
+      #   CONST = 1.freeze
+      #
+      #   # good
+      #   CONST = 1
+      class RedundantFreeze < Base
+        extend AutoCorrector
+        include FrozenStringLiteral
+
+        MSG = 'Do not freeze immutable objects, as freezing them has no effect.'
+        RESTRICT_ON_SEND = %i[freeze].freeze
+
+        def on_send(node)
+          return unless node.receiver &&
+                        (immutable_literal?(node.receiver) ||
+                         operation_produces_immutable_object?(node.receiver))
+
+          add_offense(node) do |corrector|
+            corrector.remove(node.loc.dot)
+            corrector.remove(node.loc.selector)
+          end
+        end
+
+        private
+
+        def immutable_literal?(node)
+          node = strip_parenthesis(node)
+
+          return true if node.immutable_literal?
+          return true if frozen_string_literal?(node)
+
+          target_ruby_version >= 3.0 && node.type?(:regexp, :range)
+        end
+
+        def strip_parenthesis(node)
+          if node.begin_type? && node.children.first
+            node.children.first
+          else
+            node
+          end
+        end
+
+        # @!method operation_produces_immutable_object?(node)
+        def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
+          {
+            (begin (send {float int} {:+ :- :* :** :/ :% :<<} _))
+            (begin (send !{(str _) array} {:+ :- :* :** :/ :%} {float int}))
+            (begin (send _ {:== :=== :!= :<= :>= :< :>} _))
+            (send _ {:count :length :size} ...)
+            (any_block (send _ {:count :length :size} ...) ...)
+          }
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant heredoc delimiter quotes.
+      #
+      # @example
+      #
+      #   # bad
+      #   do_something(<<~'EOS')
+      #     no string interpolation style text
+      #   EOS
+      #
+      #   # good
+      #   do_something(<<~EOS)
+      #     no string interpolation style text
+      #   EOS
+      #
+      #   do_something(<<~'EOS')
+      #     #{string_interpolation_style_text_not_evaluated}
+      #   EOS
+      #
+      #   do_something(<<~'EOS')
+      #     Preserve \
+      #     newlines
+      #   EOS
+      #
+      class RedundantHeredocDelimiterQuotes < Base
+        include Heredoc
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant heredoc delimiter quotes, use `%<replacement>s` instead.'
+        STRING_INTERPOLATION_OR_ESCAPED_CHARACTER_PATTERN = /#(\{|@|\$)|\\/.freeze
+
+        def on_heredoc(node)
+          return if need_heredoc_delimiter_quotes?(node)
+
+          replacement = "#{heredoc_type(node)}#{delimiter_string(node)}"
+
+          add_offense(node, message: format(MSG, replacement: replacement)) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        private
+
+        def need_heredoc_delimiter_quotes?(node)
+          heredoc_delimiter = node.source.delete(heredoc_type(node))
+          return true unless heredoc_delimiter.start_with?("'", '"')
+
+          node.loc.heredoc_end.source.strip.match?(/\W/) ||
+            node.loc.heredoc_body.source.match?(STRING_INTERPOLATION_OR_ESCAPED_CHARACTER_PATTERN)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `initialize` methods that are redundant.
+      #
+      # An initializer is redundant if it does not do anything, or if it only
+      # calls `super` with the same arguments given to it. If the initializer takes
+      # an argument that accepts multiple values (`restarg`, `kwrestarg`, etc.) it
+      # will not register an offense, because it allows the initializer to take a different
+      # number of arguments as its superclass potentially does.
+      #
+      # NOTE: If an initializer takes any arguments and has an empty body, RuboCop
+      # assumes it to *not* be redundant. This is to prevent potential `ArgumentError`.
+      #
+      # NOTE: If an initializer argument has a default value, RuboCop assumes it
+      # to *not* be redundant.
+      #
+      # NOTE: Empty initializers are registered as offenses, but it is possible
+      # to purposely create an empty `initialize` method to override a superclass's
+      # initializer.
+      #
+      # @safety
+      #   This cop is unsafe because removing an empty initializer may alter
+      #   the behavior of the code, particularly if the superclass initializer
+      #   raises an exception. In such cases, the empty initializer may act as
+      #   a safeguard to prevent unintended errors from propagating.
+      #
+      # @example
+      #   # bad
+      #   def initialize
+      #   end
+      #
+      #   # bad
+      #   def initialize
+      #     super
+      #   end
+      #
+      #   # bad
+      #   def initialize(a, b)
+      #     super
+      #   end
+      #
+      #   # bad
+      #   def initialize(a, b)
+      #     super(a, b)
+      #   end
+      #
+      #   # good
+      #   def initialize
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def initialize
+      #     do_something
+      #     super
+      #   end
+      #
+      #   # good (different number of parameters)
+      #   def initialize(a, b)
+      #     super(a)
+      #   end
+      #
+      #   # good (default value)
+      #   def initialize(a, b = 5)
+      #     super
+      #   end
+      #
+      #   # good (default value)
+      #   def initialize(a, b: 5)
+      #     super
+      #   end
+      #
+      #   # good (changes the parameter requirements)
+      #   def initialize(_)
+      #   end
+      #
+      #   # good (changes the parameter requirements)
+      #   def initialize(*)
+      #   end
+      #
+      #   # good (changes the parameter requirements)
+      #   def initialize(**)
+      #   end
+      #
+      #   # good (changes the parameter requirements)
+      #   def initialize(...)
+      #   end
+      #
+      # @example AllowComments: true (default)
+      #
+      #   # good
+      #   def initialize
+      #     # Overriding to negate superclass `initialize` method.
+      #   end
+      #
+      # @example AllowComments: false
+      #
+      #   # bad
+      #   def initialize
+      #     # Overriding to negate superclass `initialize` method.
+      #   end
+      #
+      class RedundantInitialize < Base
+        include CommentsHelp
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Remove unnecessary `initialize` method.'
+        MSG_EMPTY = 'Remove unnecessary empty `initialize` method.'
+
+        # @!method initialize_forwards?(node)
+        def_node_matcher :initialize_forwards?, <<~PATTERN
+          (def _ (args $arg*) $({super zsuper} ...))
+        PATTERN
+
+        def on_def(node)
+          return if acceptable?(node)
+
+          if node.body.nil?
+            register_offense(node, MSG_EMPTY) if node.arguments.empty?
+          else
+            return if node.body.begin_type?
+
+            if (args, super_node = initialize_forwards?(node))
+              return unless same_args?(super_node, args)
+
+              register_offense(node, MSG)
+            end
+          end
+        end
+
+        private
+
+        def register_offense(node, message)
+          add_offense(node, message: message) do |corrector|
+            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+          end
+        end
+
+        def acceptable?(node)
+          !node.method?(:initialize) || forwards?(node) || allow_comments?(node)
+        end
+
+        def forwards?(node)
+          node.arguments.each_child_node(:restarg, :kwrestarg, :forward_args, :forward_arg).any?
+        end
+
+        def allow_comments?(node)
+          return false unless cop_config['AllowComments']
+
+          contains_comments?(node) && !comments_contain_disables?(node, name)
+        end
+
+        def same_args?(super_node, args)
+          return true if super_node.zsuper_type?
+
+          args.map(&:name) == super_node.arguments.map { |a| a.children[0] }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for strings that are just an interpolated expression.
+      #
+      # @safety
+      #   Autocorrection is unsafe because when calling a destructive method to string,
+      #   the resulting string may have different behavior or raise `FrozenError`.
+      #
+      #   [source,ruby]
+      #   ----
+      #   x = 'a'
+      #   y = "#{x}"
+      #   y << 'b'   # return 'ab'
+      #   x          # return 'a'
+      #   y = x.to_s
+      #   y << 'b'   # return 'ab'
+      #   x          # return 'ab'
+      #
+      #   x = 'a'.freeze
+      #   y = "#{x}"
+      #   y << 'b'   # return 'ab'.
+      #   y = x.to_s
+      #   y << 'b'   # raise `FrozenError`.
+      #   ----
+      #
+      # @example
+      #
+      #   # bad
+      #   "#{@var}"
+      #
+      #   # good
+      #   @var.to_s
+      #
+      #   # good if @var is already a String
+      #   @var
+      class RedundantInterpolation < Base
+        include PercentLiteral
+        extend AutoCorrector
+
+        MSG = 'Prefer `to_s` over string interpolation.'
+
+        def self.autocorrect_incompatible_with
+          [Style::LineEndConcatenation]
+        end
+
+        def on_dstr(node)
+          return unless single_interpolation?(node)
+
+          add_offense(node) do |corrector|
+            embedded_node = node.children.first
+
+            if variable_interpolation?(embedded_node)
+              autocorrect_variable_interpolation(corrector, embedded_node, node)
+            elsif single_variable_interpolation?(embedded_node)
+              autocorrect_single_variable_interpolation(corrector, embedded_node, node)
+            else
+              autocorrect_other(corrector, embedded_node, node)
+            end
+          end
+        end
+
+        private
+
+        def single_interpolation?(node)
+          node.children.one? &&
+            interpolation?(node.children.first) &&
+            !implicit_concatenation?(node) &&
+            !embedded_in_percent_array?(node)
+        end
+
+        def single_variable_interpolation?(node)
+          return false unless node.children.one?
+
+          first_child = node.children.first
+
+          variable_interpolation?(first_child) ||
+            (first_child.send_type? && !first_child.operator_method?)
+        end
+
+        def interpolation?(node)
+          variable_interpolation?(node) || node.begin_type?
+        end
+
+        def variable_interpolation?(node)
+          node.variable? || node.reference?
+        end
+
+        def implicit_concatenation?(node)
+          node.parent&.dstr_type?
+        end
+
+        def embedded_in_percent_array?(node)
+          node.parent&.array_type? && percent_literal?(node.parent)
+        end
+
+        def autocorrect_variable_interpolation(corrector, embedded_node, node)
+          replacement = "#{embedded_node.source}.to_s"
+
+          corrector.replace(node, replacement)
+        end
+
+        def autocorrect_single_variable_interpolation(corrector, embedded_node, node)
+          embedded_var = embedded_node.children.first
+
+          source = if require_parentheses?(embedded_var)
+                     receiver = range_between(
+                       embedded_var.source_range.begin_pos, embedded_var.loc.selector.end_pos
+                     )
+                     arguments = embedded_var.arguments.map(&:source).join(', ')
+
+                     "#{receiver.source}(#{arguments})"
+                   else
+                     embedded_var.source
+                   end
+
+          corrector.replace(node, "#{source}.to_s")
+        end
+
+        def autocorrect_other(corrector, embedded_node, node)
+          loc = node.loc
+          embedded_loc = embedded_node.loc
+
+          corrector.replace(loc.begin, '')
+          corrector.replace(loc.end, '')
+          corrector.replace(embedded_loc.begin, '(')
+          corrector.replace(embedded_loc.end, ').to_s')
+        end
+
+        def require_parentheses?(node)
+          node.send_type? && !node.arguments.count.zero? && !node.parenthesized_call?
+        end
+      end
+    end
+  end
+end