rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Identifies places where `URI.escape` can be replaced by
+      # `CGI.escape`, `URI.encode_www_form`, or `URI.encode_www_form_component`
+      # depending on your specific use case.
+      # Also this cop identifies places where `URI.unescape` can be replaced by
+      # `CGI.unescape`, `URI.decode_www_form`,
+      # or `URI.decode_www_form_component` depending on your specific use case.
+      #
+      # @example
+      #   # bad
+      #   URI.escape('http://example.com')
+      #   URI.encode('http://example.com')
+      #
+      #   # good
+      #   CGI.escape('http://example.com')
+      #   URI.encode_www_form([['example', 'param'], ['lang', 'en']])
+      #   URI.encode_www_form(page: 10, locale: 'en')
+      #   URI.encode_www_form_component('http://example.com')
+      #
+      #   # bad
+      #   URI.unescape(enc_uri)
+      #   URI.decode(enc_uri)
+      #
+      #   # good
+      #   CGI.unescape(enc_uri)
+      #   URI.decode_www_form(enc_uri)
+      #   URI.decode_www_form_component(enc_uri)
+      class UriEscapeUnescape < Base
+        ALTERNATE_METHODS_OF_URI_ESCAPE = %w[
+          CGI.escape
+          URI.encode_www_form
+          URI.encode_www_form_component
+        ].freeze
+        ALTERNATE_METHODS_OF_URI_UNESCAPE = %w[
+          CGI.unescape
+          URI.decode_www_form
+          URI.decode_www_form_component
+        ].freeze
+
+        MSG = '`%<uri_method>s` method is obsolete and should not be used. ' \
+              'Instead, use %<replacements>s depending on your specific use ' \
+              'case.'
+        METHOD_NAMES = %i[escape encode unescape decode].freeze
+        RESTRICT_ON_SEND = METHOD_NAMES
+
+        # @!method uri_escape_unescape?(node)
+        def_node_matcher :uri_escape_unescape?, <<~PATTERN
+          (send
+            (const ${nil? cbase} :URI) ${:#{METHOD_NAMES.join(' :')}}
+            ...)
+        PATTERN
+
+        def on_send(node)
+          uri_escape_unescape?(node) do |top_level, obsolete_method|
+            replacements = if %i[escape encode].include?(obsolete_method)
+                             ALTERNATE_METHODS_OF_URI_ESCAPE
+                           else
+                             ALTERNATE_METHODS_OF_URI_UNESCAPE
+                           end
+
+            double_colon = top_level ? '::' : ''
+
+            message = format(
+              MSG, uri_method: "#{double_colon}URI.#{obsolete_method}",
+                   replacements: "`#{replacements[0]}`, `#{replacements[1]}` " \
+                                 "or `#{replacements[2]}`"
+            )
+
+            add_offense(node, message: message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Identifies places where `URI.regexp` is obsolete and should not be used.
+      #
+      # For Ruby 3.3 or lower, use `URI::DEFAULT_PARSER.make_regexp`.
+      # For Ruby 3.4 or higher, use `URI::RFC2396_PARSER.make_regexp`.
+      #
+      # NOTE: If you need to support both Ruby 3.3 and lower as well as Ruby 3.4 and higher,
+      # consider manually changing the code as follows:
+      #
+      # [source,ruby]
+      # ----
+      # defined?(URI::RFC2396_PARSER) ? URI::RFC2396_PARSER : URI::DEFAULT_PARSER
+      # ----
+      #
+      # @example
+      #   # bad
+      #   URI.regexp('http://example.com')
+      #
+      #   # good - Ruby 3.3 or lower
+      #   URI::DEFAULT_PARSER.make_regexp('http://example.com')
+      #
+      #   # good - Ruby 3.4 or higher
+      #   URI::RFC2396_PARSER.make_regexp('http://example.com')
+      #
+      class UriRegexp < Base
+        extend AutoCorrector
+
+        MSG = '`%<current>s` is obsolete and should not be used. Instead, use `%<preferred>s`.'
+        RESTRICT_ON_SEND = %i[regexp].freeze
+
+        # @!method uri_constant?(node)
+        def_node_matcher :uri_constant?, <<~PATTERN
+          (const {cbase nil?} :URI)
+        PATTERN
+
+        def on_send(node)
+          return unless uri_constant?(node.receiver)
+
+          parser = target_ruby_version >= 3.4 ? 'RFC2396_PARSER' : 'DEFAULT_PARSER'
+          argument = node.first_argument ? "(#{node.first_argument.source})" : ''
+
+          preferred_method = "#{node.receiver.source}::#{parser}.make_regexp#{argument}"
+          message = format(MSG, current: node.source, preferred: preferred_method)
+
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node, preferred_method)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for redundant access modifiers, including those with no
+      # code, those which are repeated, and leading `public` modifiers in a
+      # class or module body. Conditionally-defined methods are considered as
+      # always being defined, and thus access modifiers guarding such methods
+      # are not redundant.
+      #
+      # This cop has `ContextCreatingMethods` option. The default setting value
+      # is an empty array that means no method is specified.
+      # This setting is an array of methods which, when called, are known to
+      # create its own context in the module's current access context.
+      #
+      # It also has `MethodCreatingMethods` option. The default setting value
+      # is an empty array that means no method is specified.
+      # This setting is an array of methods which, when called, are known to
+      # create other methods in the module's current access context.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #     public # this is redundant (default access is public)
+      #
+      #     def method
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class Foo
+      #     # The following is redundant (methods defined on the class'
+      #     # singleton class are not affected by the private modifier)
+      #     private
+      #
+      #     def self.method3
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class Foo
+      #     protected
+      #
+      #     define_method(:method2) do
+      #     end
+      #
+      #     protected # this is redundant (repeated from previous modifier)
+      #
+      #     [1,2,3].each do |i|
+      #       define_method("foo#{i}") do
+      #       end
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class Foo
+      #     private # this is redundant (no following methods are defined)
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     private # this is not redundant (a method is defined)
+      #
+      #     def method2
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     # The following is not redundant (conditionally defined methods are
+      #     # considered as always defining a method)
+      #     private
+      #
+      #     if condition?
+      #       def method
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     protected # this is not redundant (a method is defined)
+      #
+      #     define_method(:method2) do
+      #     end
+      #   end
+      #
+      # @example ContextCreatingMethods: concerning
+      #   # Lint/UselessAccessModifier:
+      #   #   ContextCreatingMethods:
+      #   #     - concerning
+      #
+      #   # good
+      #   require 'active_support/concern'
+      #   class Foo
+      #     concerning :Bar do
+      #       def some_public_method
+      #       end
+      #
+      #       private
+      #
+      #       def some_private_method
+      #       end
+      #     end
+      #
+      #     # this is not redundant because `concerning` created its own context
+      #     private
+      #
+      #     def some_other_private_method
+      #     end
+      #   end
+      #
+      # @example MethodCreatingMethods: delegate
+      #   # Lint/UselessAccessModifier:
+      #   #   MethodCreatingMethods:
+      #   #     - delegate
+      #
+      #   # good
+      #   require 'active_support/core_ext/module/delegation'
+      #   class Foo
+      #     # this is not redundant because `delegate` creates methods
+      #     private
+      #
+      #     delegate :method_a, to: :method_b
+      #   end
+      class UselessAccessModifier < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Useless `%<current>s` access modifier.'
+
+        def on_class(node)
+          check_node(node.body)
+        end
+        alias on_module on_class
+        alias on_sclass on_class
+
+        def on_block(node)
+          return unless eval_call?(node) || included_block?(node)
+
+          check_node(node.body)
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        private
+
+        def autocorrect(corrector, node)
+          range = range_by_whole_lines(node.source_range, include_final_newline: true)
+
+          corrector.remove(range)
+        end
+
+        # @!method static_method_definition?(node)
+        def_node_matcher :static_method_definition?, <<~PATTERN
+          {def (send nil? {:attr :attr_reader :attr_writer :attr_accessor} ...)}
+        PATTERN
+
+        # @!method dynamic_method_definition?(node)
+        def_node_matcher :dynamic_method_definition?, <<~PATTERN
+          {(send nil? :define_method ...) (any_block (send nil? :define_method ...) ...)}
+        PATTERN
+
+        # @!method class_or_instance_eval?(node)
+        def_node_matcher :class_or_instance_eval?, <<~PATTERN
+          (any_block (send _ {:class_eval :instance_eval}) ...)
+        PATTERN
+
+        def check_node(node)
+          return if node.nil?
+
+          if node.begin_type?
+            check_scope(node)
+          elsif node.send_type? && node.bare_access_modifier?
+            add_offense(node, message: format(MSG, current: node.method_name)) do |corrector|
+              autocorrect(corrector, node)
+            end
+          end
+        end
+
+        def access_modifier?(node)
+          node.bare_access_modifier? || node.method?(:private_class_method)
+        end
+
+        def check_scope(node)
+          cur_vis, unused = check_child_nodes(node, nil, :public)
+          return unless unused
+
+          add_offense(unused, message: format(MSG, current: cur_vis)) do |corrector|
+            autocorrect(corrector, unused)
+          end
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def check_child_nodes(node, unused, cur_vis)
+          node.child_nodes.each do |child|
+            if child.send_type? && access_modifier?(child)
+              cur_vis, unused = check_send_node(child, cur_vis, unused)
+            elsif child.block_type? && included_block?(child)
+              next
+            elsif method_definition?(child)
+              unused = nil
+            elsif start_of_new_scope?(child)
+              check_scope(child)
+            elsif !child.defs_type?
+              cur_vis, unused = check_child_nodes(child, unused, cur_vis)
+            end
+          end
+
+          [cur_vis, unused]
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def check_send_node(node, cur_vis, unused)
+          if node.bare_access_modifier?
+            check_new_visibility(node, unused, node.method_name, cur_vis)
+          elsif node.method?(:private_class_method) && !node.arguments?
+            add_offense(node, message: format(MSG, current: node.method_name)) do |corrector|
+              autocorrect(corrector, node)
+            end
+            [cur_vis, unused]
+          end
+        end
+
+        def check_new_visibility(node, unused, new_vis, cur_vis)
+          # does this modifier just repeat the existing visibility?
+          if new_vis == cur_vis
+            add_offense(node, message: format(MSG, current: cur_vis)) do |corrector|
+              autocorrect(corrector, node)
+            end
+          else
+            # was the previous modifier never applied to any defs?
+            if unused
+              add_offense(unused, message: format(MSG, current: cur_vis)) do |corrector|
+                autocorrect(corrector, unused)
+              end
+            end
+            # once we have already warned about a certain modifier, don't
+            # warn again even if it is never applied to any method defs
+            unused = node
+          end
+
+          [new_vis, unused]
+        end
+
+        def included_block?(block_node)
+          active_support_extensions_enabled? && block_node.method?(:included)
+        end
+
+        def method_definition?(child)
+          static_method_definition?(child) ||
+            dynamic_method_definition?(child) ||
+            any_method_definition?(child)
+        end
+
+        def any_method_definition?(child)
+          cop_config.fetch('MethodCreatingMethods', []).any? do |m|
+            matcher_name = :"#{m}_method?"
+            unless respond_to?(matcher_name)
+              self.class.def_node_matcher matcher_name, <<~PATTERN
+                {def (send nil? :#{m} ...)}
+              PATTERN
+            end
+
+            public_send(matcher_name, child)
+          end
+        end
+
+        def start_of_new_scope?(child)
+          child.type?(:module, :class, :sclass) || eval_call?(child)
+        end
+
+        def eval_call?(child)
+          class_or_instance_eval?(child) ||
+            child.class_constructor? ||
+            any_context_creating_methods?(child)
+        end
+
+        def any_context_creating_methods?(child)
+          cop_config.fetch('ContextCreatingMethods', []).any? do |m|
+            matcher_name = :"#{m}_block?"
+            unless respond_to?(matcher_name)
+              self.class.def_node_matcher matcher_name, <<~PATTERN
+                (any_block (send {nil? const} {:#{m}} ...) ...)
+              PATTERN
+            end
+
+            public_send(matcher_name, child)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for every useless assignment to local variable in every
+      # scope.
+      # The basic idea for this cop was from the warning of `ruby -cw`:
+      #
+      # [source,console]
+      # ----
+      # assigned but unused variable - foo
+      # ----
+      #
+      # Currently this cop has advanced logic that detects unreferenced
+      # reassignments and properly handles varied cases such as branch, loop,
+      # rescue, ensure, etc.
+      #
+      # This cop's autocorrection avoids cases like `a ||= 1` because removing assignment from
+      # operator assignment can cause `NameError` if this assignment has been used to declare
+      # a local variable. For example, replacing `a ||= 1` with `a || 1` may cause
+      # "undefined local variable or method `a' for main:Object (NameError)".
+      #
+      # NOTE: Given the assignment `foo = 1, bar = 2`, removing unused variables
+      # can lead to a syntax error, so this case is not autocorrected.
+      #
+      # @example
+      #
+      #   # bad
+      #   def some_method
+      #     some_var = 1
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def some_method
+      #     some_var = 1
+      #     do_something(some_var)
+      #   end
+      class UselessAssignment < Base
+        extend AutoCorrector
+
+        include RangeHelp
+
+        MSG = 'Useless assignment to variable - `%<variable>s`.'
+
+        def self.joining_forces
+          VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value { |variable| check_for_unused_assignments(variable) }
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+        def check_for_unused_assignments(variable)
+          return if variable.should_be_unused?
+
+          variable.assignments.reverse_each do |assignment|
+            assignment_node = assignment.node
+            next if assignment.used? || part_of_ignored_node?(assignment_node)
+
+            message = message_for_useless_assignment(assignment)
+            range = offense_range(assignment)
+
+            add_offense(range, message: message) do |corrector|
+              # In cases like `x = 1, y = 2`, where removing a variable would cause a syntax error,
+              # and where changing `x ||= 1` to `x = 1` would cause `NameError`,
+              # the autocorrect will be skipped, even if the variable is unused.
+              if sequential_assignment?(assignment_node) || assignment_node.parent&.or_asgn_type?
+                next
+              end
+
+              autocorrect(corrector, assignment)
+            end
+
+            ignore_node(assignment_node) if chained_assignment?(assignment_node)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+
+        def message_for_useless_assignment(assignment)
+          variable = assignment.variable
+
+          format(MSG, variable: variable.name) + message_specification(assignment, variable).to_s
+        end
+
+        def offense_range(assignment)
+          if assignment.regexp_named_capture?
+            assignment.node.children.first.source_range
+          else
+            assignment.node.loc.name
+          end
+        end
+
+        def sequential_assignment?(node)
+          if node.lvasgn_type? && node.expression&.array_type? &&
+             node.each_descendant.any?(&:assignment?)
+            return true
+          end
+          return false unless node.parent
+
+          sequential_assignment?(node.parent)
+        end
+
+        def chained_assignment?(node)
+          node.respond_to?(:expression) && node.expression&.lvasgn_type?
+        end
+
+        def message_specification(assignment, variable)
+          if assignment.multiple_assignment?
+            multiple_assignment_message(variable.name)
+          elsif assignment.operator_assignment?
+            operator_assignment_message(variable.scope, assignment)
+          else
+            similar_name_message(variable)
+          end
+        end
+
+        def multiple_assignment_message(variable_name)
+          " Use `_` or `_#{variable_name}` as a variable name to indicate " \
+            "that it won't be used."
+        end
+
+        def operator_assignment_message(scope, assignment)
+          return_value_node = return_value_node_of_scope(scope)
+          return unless assignment.meta_assignment_node.equal?(return_value_node)
+
+          " Use `#{assignment.operator.delete_suffix('=')}` instead of `#{assignment.operator}`."
+        end
+
+        def similar_name_message(variable)
+          variable_like_names = collect_variable_like_names(variable.scope)
+          similar_name = NameSimilarity.find_similar_name(variable.name, variable_like_names)
+          " Did you mean `#{similar_name}`?" if similar_name
+        end
+
+        # TODO: More precise handling (rescue, ensure, nested begin, etc.)
+        def return_value_node_of_scope(scope)
+          body_node = scope.body_node
+
+          if body_node.begin_type?
+            body_node.children.last
+          else
+            body_node
+          end
+        end
+
+        def collect_variable_like_names(scope)
+          names = scope.each_node.with_object(Set.new) do |node, set|
+            set << node.method_name if variable_like_method_invocation?(node)
+          end
+
+          variable_names = scope.variables.each_value.map(&:name)
+          names.merge(variable_names)
+        end
+
+        def variable_like_method_invocation?(node)
+          return false unless node.send_type?
+
+          node.receiver.nil? && !node.arguments?
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def autocorrect(corrector, assignment)
+          if assignment.exception_assignment?
+            remove_exception_assignment_part(corrector, assignment.node)
+          elsif assignment.multiple_assignment? || assignment.rest_assignment? ||
+                assignment.for_assignment?
+            rename_variable_with_underscore(corrector, assignment.node)
+          elsif assignment.operator_assignment?
+            remove_trailing_character_from_operator(corrector, assignment.node)
+          elsif assignment.regexp_named_capture?
+            replace_named_capture_group_with_non_capturing_group(corrector, assignment.node,
+                                                                 assignment.variable.name)
+          else
+            remove_local_variable_assignment_part(corrector, assignment.node)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def remove_exception_assignment_part(corrector, node)
+          corrector.remove(
+            range_between(
+              (node.parent.children.first&.source_range || node.parent.location.keyword).end_pos,
+              node.source_range.end_pos
+            )
+          )
+        end
+
+        def rename_variable_with_underscore(corrector, node)
+          corrector.replace(node, '_')
+        end
+
+        def remove_trailing_character_from_operator(corrector, node)
+          corrector.remove(node.parent.location.operator.end.adjust(begin_pos: -1))
+        end
+
+        def replace_named_capture_group_with_non_capturing_group(corrector, node, variable_name)
+          corrector.replace(
+            node.children.first,
+            node.children.first.source.sub(/\(\?<#{variable_name}>/, '(?:')
+          )
+        end
+
+        def remove_local_variable_assignment_part(corrector, node)
+          corrector.replace(node, node.expression.source)
+        end
+      end
+    end
+  end
+end