rubocop-grantbirki 1.75.2

data/lib/rubocop/cop/lint/suppressed_exception.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for `rescue` blocks with no body.
+      #
+      # @example
+      #
+      #   # bad
+      #   def some_method
+      #     do_something
+      #   rescue
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue
+      #   end
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     handle_exception
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue
+      #     handle_exception
+      #   end
+      #
+      # @example AllowComments: true (default)
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      # @example AllowComments: false
+      #
+      #   # bad
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      # @example AllowNil: true (default)
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      #   # good
+      #   do_something rescue nil
+      #
+      # @example AllowNil: false
+      #
+      #   # bad
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   do_something rescue nil
+      class SuppressedException < Base
+        MSG = 'Do not suppress exceptions.'
+
+        def on_resbody(node)
+          return if node.body && !nil_body?(node)
+          return if cop_config['AllowComments'] && comment_between_rescue_and_end?(node)
+          return if cop_config['AllowNil'] && nil_body?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def comment_between_rescue_and_end?(node)
+          ancestor = node.each_ancestor(:kwbegin, :any_def, :any_block).first
+          return false unless ancestor
+
+          end_line = ancestor.loc.end&.line || ancestor.loc.last_line
+          processed_source[node.first_line...end_line].any? { |line| comment_line?(line) }
+        end
+
+        def nil_body?(node)
+          node.body&.nil_type?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/suppressed_exception_in_number_conversion.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for cases where exceptions unrelated to the numeric constructors `Integer()`,
+      # `Float()`, `BigDecimal()`, `Complex()`, and `Rational()` may be unintentionally swallowed.
+      #
+      # @safety
+      #   The cop is unsafe for autocorrection because unexpected errors occurring in the argument
+      #   passed to numeric constructor (e.g., `Integer()`) can lead to incompatible behavior.
+      #   For example, changing it to `Integer(potential_exception_method_call, exception: false)`
+      #   ensures that exceptions raised by `potential_exception_method_call` are not ignored.
+      #
+      #   [source,ruby]
+      #   ----
+      #   Integer(potential_exception_method_call) rescue nil
+      #   ----
+      #
+      # @example
+      #
+      #   # bad
+      #   Integer(arg) rescue nil
+      #
+      #   # bad
+      #   begin
+      #     Integer(arg)
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     Integer(arg)
+      #   rescue
+      #   end
+      #
+      #   # good
+      #   Integer(arg, exception: false)
+      #
+      class SuppressedExceptionInNumberConversion < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `%<prefer>s` instead.'
+        EXPECTED_EXCEPTION_CLASSES = %w[ArgumentError TypeError ::ArgumentError ::TypeError].freeze
+
+        # @!method numeric_constructor_rescue_nil(node)
+        def_node_matcher :numeric_constructor_rescue_nil, <<~PATTERN
+          (rescue
+            $#numeric_method?
+            (resbody nil? nil? (nil)) nil?)
+        PATTERN
+
+        # @!method begin_numeric_constructor_rescue_nil(node)
+        def_node_matcher :begin_numeric_constructor_rescue_nil, <<~PATTERN
+          (kwbegin
+            (rescue
+              $#numeric_method?
+              (resbody $_? nil?
+                {(nil) nil?}) nil?))
+        PATTERN
+
+        # @!method numeric_method?(node)
+        def_node_matcher :numeric_method?, <<~PATTERN
+          {
+            (call #constructor_receiver? {:Integer :BigDecimal :Complex :Rational}
+              _ _?)
+            (call #constructor_receiver? :Float
+              _)
+          }
+        PATTERN
+
+        # @!method constructor_receiver?(node)
+        def_node_matcher :constructor_receiver?, <<~PATTERN
+          {nil? (const {nil? cbase} :Kernel)}
+        PATTERN
+
+        minimum_target_ruby_version 2.6
+
+        # rubocop:disable Metrics/AbcSize
+        def on_rescue(node)
+          if (method, exception_classes = begin_numeric_constructor_rescue_nil(node.parent))
+            return unless expected_exception_classes_only?(exception_classes)
+
+            node = node.parent
+          else
+            return unless (method = numeric_constructor_rescue_nil(node))
+          end
+
+          arguments = method.arguments.map(&:source) << 'exception: false'
+          prefer = "#{method.method_name}(#{arguments.join(', ')})"
+          prefer = "#{method.receiver.source}#{method.loc.dot.source}#{prefer}" if method.receiver
+
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(node, prefer)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        def expected_exception_classes_only?(exception_classes)
+          return true unless (arguments = exception_classes.first)
+
+          (arguments.values.map(&:source) - EXPECTED_EXCEPTION_CLASSES).none?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/symbol_conversion.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for uses of literal strings converted to
+      # a symbol where a literal symbol could be used instead.
+      #
+      # There are two possible styles for this cop.
+      # `strict` (default) will register an offense for any incorrect usage.
+      # `consistent` additionally requires hashes to use the same style for
+      # every symbol key (ie. if any symbol key needs to be quoted it requires
+      # all keys to be quoted).
+      #
+      # @example
+      #   # bad
+      #   'string'.to_sym
+      #   :symbol.to_sym
+      #   'underscored_string'.to_sym
+      #   :'underscored_symbol'
+      #   'hyphenated-string'.to_sym
+      #   "string_#{interpolation}".to_sym
+      #
+      #   # good
+      #   :string
+      #   :symbol
+      #   :underscored_string
+      #   :underscored_symbol
+      #   :'hyphenated-string'
+      #   :"string_#{interpolation}"
+      #
+      # @example EnforcedStyle: strict (default)
+      #
+      #   # bad
+      #   {
+      #     'a': 1,
+      #     "b": 2,
+      #     'c-d': 3
+      #   }
+      #
+      #   # good (don't quote keys that don't require quoting)
+      #   {
+      #     a: 1,
+      #     b: 2,
+      #     'c-d': 3
+      #   }
+      #
+      # @example EnforcedStyle: consistent
+      #
+      #   # bad
+      #   {
+      #     a: 1,
+      #     'b-c': 2
+      #   }
+      #
+      #   # good (quote all keys if any need quoting)
+      #   {
+      #     'a': 1,
+      #     'b-c': 2
+      #   }
+      #
+      #   # good (no quoting required)
+      #   {
+      #     a: 1,
+      #     b: 2
+      #   }
+      #
+      class SymbolConversion < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+        include SymbolHelp
+
+        MSG = 'Unnecessary symbol conversion; use `%<correction>s` instead.'
+        MSG_CONSISTENCY = 'Symbol hash key should be quoted for consistency; ' \
+                          'use `%<correction>s` instead.'
+        RESTRICT_ON_SEND = %i[to_sym intern].freeze
+
+        def on_send(node)
+          return unless node.receiver
+
+          if node.receiver.type?(:str, :sym)
+            register_offense(node, correction: node.receiver.value.to_sym.inspect)
+          elsif node.receiver.dstr_type?
+            register_offense(node, correction: ":\"#{node.receiver.value.to_sym}\"")
+          end
+        end
+
+        def on_sym(node)
+          return if ignored_node?(node) || properly_quoted?(node.source, node.value.inspect)
+
+          # `alias` arguments are symbols but since a symbol that requires
+          # being quoted is not a valid method identifier, it can be ignored
+          return if in_alias?(node)
+
+          # The `%I[]` and `%i[]` macros are parsed as normal arrays of symbols
+          # so they need to be ignored.
+          return if in_percent_literal_array?(node)
+
+          # Symbol hash keys have a different format and need to be handled separately
+          return correct_hash_key(node) if hash_key?(node)
+
+          register_offense(node, correction: node.value.inspect)
+        end
+
+        def on_hash(node)
+          # For `EnforcedStyle: strict`, hash keys are evaluated in `on_sym`
+          return unless style == :consistent
+
+          keys = node.keys.select(&:sym_type?)
+
+          if keys.any? { |key| requires_quotes?(key) }
+            correct_inconsistent_hash_keys(keys)
+          else
+            # If there are no symbol keys requiring quoting,
+            # treat the hash like `EnforcedStyle: strict`.
+            keys.each { |key| correct_hash_key(key) }
+          end
+        end
+
+        private
+
+        def register_offense(node, correction:, message: format(MSG, correction: correction))
+          add_offense(node, message: message) { |corrector| corrector.replace(node, correction) }
+        end
+
+        def properly_quoted?(source, value)
+          return true if style == :strict && (!source.match?(/['"]/) || value.end_with?('='))
+
+          source == value ||
+            # `Symbol#inspect` uses double quotes, but allow single-quoted
+            # symbols to work as well.
+            source.gsub('"', '\"').tr("'", '"') == value
+        end
+
+        def requires_quotes?(sym_node)
+          sym_node.value.inspect.match?(/^:".*?"|=$/)
+        end
+
+        def in_alias?(node)
+          node.parent&.alias_type?
+        end
+
+        def in_percent_literal_array?(node)
+          node.parent&.array_type? && node.parent.percent_literal?
+        end
+
+        def correct_hash_key(node)
+          # Although some operators can be converted to symbols normally
+          # (ie. `:==`), these are not accepted as hash keys and will
+          # raise a syntax error (eg. `{ ==: ... }`). Therefore, if the
+          # symbol does not start with an alphanumeric or underscore, it
+          # will be ignored.
+          return unless node.value.to_s.match?(/\A[a-z0-9_]/i)
+
+          correction = node.value.inspect
+          correction = correction.delete_prefix(':') if node.parent.colon?
+          return if properly_quoted?(node.source, correction)
+
+          register_offense(
+            node,
+            correction: correction,
+            message: format(MSG, correction: node.parent.colon? ? "#{correction}:" : correction)
+          )
+        end
+
+        def correct_inconsistent_hash_keys(keys)
+          keys.each do |key|
+            ignore_node(key)
+
+            next if requires_quotes?(key)
+            next if properly_quoted?(key.source, %("#{key.value}"))
+
+            correction = %("#{key.value}")
+            register_offense(
+              key,
+              correction: correction,
+              message: format(MSG_CONSISTENCY, correction: "#{correction}:")
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/syntax.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Repacks Parser's diagnostics/errors
+      # into RuboCop's offenses.
+      class Syntax < Base
+        LEVELS = %i[error fatal].freeze
+
+        def on_other_file
+          add_offense_from_error(processed_source.parser_error) if processed_source.parser_error
+          syntax_errors = processed_source.diagnostics.select { |d| LEVELS.include?(d.level) }
+          syntax_errors.each do |diagnostic|
+            add_offense_from_diagnostic(diagnostic, processed_source.ruby_version)
+          end
+          super
+        end
+
+        private
+
+        def add_offense_from_diagnostic(diagnostic, ruby_version)
+          message = if LSP.enabled?
+                      diagnostic.message
+                    else
+                      "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
+                        'configure using `TargetRubyVersion` parameter, under `AllCops`)'
+                    end
+          add_offense(diagnostic.location, message: message, severity: diagnostic.level)
+        end
+
+        def add_offense_from_error(error)
+          message = beautify_message(error.message)
+          add_global_offense(message, severity: :fatal)
+        end
+
+        def beautify_message(message)
+          message = message.capitalize
+          message << '.' unless message.end_with?('.')
+          message
+        end
+
+        def find_severity(_range, _severity)
+          :fatal
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/to_enum_arguments.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Ensures that `to_enum`/`enum_for`, called for the current method,
+      # has correct arguments.
+      #
+      # @example
+      #   # bad
+      #   def foo(x, y = 1)
+      #     return to_enum(__callee__, x) # `y` is missing
+      #   end
+      #
+      #   # good
+      #   def foo(x, y = 1)
+      #     # Alternatives to `__callee__` are `__method__` and `:foo`.
+      #     return to_enum(__callee__, x, y)
+      #   end
+      #
+      #   # good
+      #   def foo(x, y = 1)
+      #     # It is also allowed if it is wrapped in some method like Sorbet.
+      #     return to_enum(T.must(__callee__), x, y)
+      #   end
+      #
+      class ToEnumArguments < Base
+        MSG = 'Ensure you correctly provided all the arguments.'
+
+        RESTRICT_ON_SEND = %i[to_enum enum_for].freeze
+
+        # @!method enum_conversion_call?(node)
+        def_node_matcher :enum_conversion_call?, <<~PATTERN
+          (send {nil? self} {:to_enum :enum_for} $_ $...)
+        PATTERN
+
+        # @!method method_name?(node, name)
+        def_node_matcher :method_name?, <<~PATTERN
+          {(send nil? {:__method__ :__callee__}) (sym %1)}
+        PATTERN
+
+        # @!method passing_keyword_arg?(node, name)
+        def_node_matcher :passing_keyword_arg?, <<~PATTERN
+          (pair (sym %1) (lvar %1))
+        PATTERN
+
+        def on_send(node)
+          def_node = node.each_ancestor(:any_def).first
+          return unless def_node
+
+          enum_conversion_call?(node) do |method_node, arguments|
+            next if !method_name?(method_node, def_node.method_name) ||
+                    arguments_match?(arguments, def_node)
+
+            add_offense(node)
+          end
+        end
+
+        private
+
+        def arguments_match?(arguments, def_node)
+          index = 0
+
+          def_node.arguments.reject(&:blockarg_type?).all? do |def_arg|
+            send_arg = arguments[index]
+            case def_arg.type
+            when :arg, :restarg, :optarg
+              index += 1
+            end
+
+            send_arg && argument_match?(send_arg, def_arg)
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+        def argument_match?(send_arg, def_arg)
+          def_arg_name = def_arg.children[0]
+
+          case def_arg.type
+          when :arg, :restarg
+            send_arg.source == def_arg.source
+          when :optarg
+            send_arg.source == def_arg_name.to_s
+          when :kwoptarg, :kwarg
+            send_arg.hash_type? &&
+              send_arg.pairs.any? { |pair| passing_keyword_arg?(pair, def_arg_name) }
+          when :kwrestarg
+            send_arg.each_child_node(:kwsplat, :forwarded_kwrestarg).any? do |child|
+              child.source == def_arg.source
+            end
+          when :forward_arg
+            send_arg.forwarded_args_type?
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/to_json.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks to make sure `#to_json` includes an optional argument.
+      # When overriding `#to_json`, callers may invoke JSON
+      # generation via `JSON.generate(your_obj)`.  Since `JSON#generate` allows
+      # for an optional argument, your method should too.
+      #
+      # @example
+      #   class Point
+      #     attr_reader :x, :y
+      #
+      #     # bad, incorrect arity
+      #     def to_json
+      #       JSON.generate([x, y])
+      #     end
+      #
+      #     # good, preserving args
+      #     def to_json(*args)
+      #       JSON.generate([x, y], *args)
+      #     end
+      #
+      #     # good, discarding args
+      #     def to_json(*_args)
+      #       JSON.generate([x, y])
+      #     end
+      #   end
+      #
+      class ToJSON < Base
+        extend AutoCorrector
+
+        MSG = '`#to_json` requires an optional argument to be parsable via JSON.generate(obj).'
+
+        def on_def(node)
+          return unless node.method?(:to_json) && node.arguments.empty?
+
+          add_offense(node) do |corrector|
+            # The following used `*_args` because `to_json(*args)` has
+            # an offense of `Lint/UnusedMethodArgument` cop if `*args`
+            # is not used.
+            corrector.insert_after(node.loc.name, '(*_args)')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/top_level_return_with_argument.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for top level return with arguments. If there is a
+      # top-level return statement with an argument, then the argument is
+      # always ignored. This is detected automatically since Ruby 2.7.
+      #
+      # @example
+      #   # bad
+      #   return 1
+      #
+      #   # good
+      #   return
+      class TopLevelReturnWithArgument < Base
+        extend AutoCorrector
+
+        MSG = 'Top level return with argument detected.'
+
+        def on_return(return_node)
+          return unless top_level_return_with_any_argument?(return_node)
+
+          add_offense(return_node) do |corrector|
+            remove_arguments(corrector, return_node)
+          end
+        end
+
+        private
+
+        def top_level_return_with_any_argument?(return_node)
+          top_level_return?(return_node) && return_node.arguments?
+        end
+
+        def remove_arguments(corrector, return_node)
+          corrector.replace(return_node, 'return')
+        end
+
+        # This cop works by validating the ancestors of the return node. A
+        # top-level return node's ancestors should not be of block, def, or
+        # defs type.
+        def top_level_return?(return_node)
+          return_node.each_ancestor(:block, :any_def).none?
+        end
+      end
+    end
+  end
+end