rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant uses of `self`.
+      #
+      # The usage of `self` is only needed when:
+      #
+      # * Sending a message to same object with zero arguments in
+      #   presence of a method name clash with an argument or a local
+      #   variable.
+      #
+      # * Calling an attribute writer to prevent a local variable assignment.
+      #
+      # Note, with using explicit self you can only send messages with public or
+      # protected scope, you cannot send private messages this way.
+      #
+      # Note we allow uses of `self` with operators because it would be awkward
+      # otherwise. Also allows the use of `self.it` without arguments in blocks,
+      # as in `0.times { self.it }`, following `Lint/ItWithoutArgumentsInBlock` cop.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo(bar)
+      #     self.baz
+      #   end
+      #
+      #   # good
+      #   def foo(bar)
+      #     self.bar  # Resolves name clash with the argument.
+      #   end
+      #
+      #   def foo
+      #     bar = 1
+      #     self.bar  # Resolves name clash with the local variable.
+      #   end
+      #
+      #   def foo
+      #     %w[x y z].select do |bar|
+      #       self.bar == bar  # Resolves name clash with argument of the block.
+      #     end
+      #   end
+      class RedundantSelf < Base
+        extend AutoCorrector
+
+        MSG = 'Redundant `self` detected.'
+        KERNEL_METHODS = Kernel.methods(false)
+        KEYWORDS = %i[alias and begin break case class def defined? do
+                      else elsif end ensure false for if in module
+                      next nil not or redo rescue retry return self
+                      super then true undef unless until when while
+                      yield __FILE__ __LINE__ __ENCODING__].freeze
+
+        def self.autocorrect_incompatible_with
+          [ColonMethodCall, Layout::DotPosition]
+        end
+
+        def initialize(config = nil, options = nil)
+          super
+          @allowed_send_nodes = []
+          @local_variables_scopes = Hash.new { |hash, key| hash[key] = [] }.compare_by_identity
+        end
+
+        # Assignment of self.x
+
+        def on_or_asgn(node)
+          allow_self(node.lhs)
+        end
+        alias on_and_asgn on_or_asgn
+
+        def on_op_asgn(node)
+          allow_self(node.lhs)
+        end
+
+        # Using self.x to distinguish from local variable x
+
+        def on_def(node)
+          add_scope(node)
+        end
+        alias on_defs on_def
+
+        def on_args(node)
+          node.children.each { |arg| on_argument(arg) }
+        end
+
+        def on_blockarg(node)
+          on_argument(node)
+        end
+
+        def on_masgn(node)
+          add_masgn_lhs_variables(node.rhs, node.lhs)
+        end
+
+        def on_lvasgn(node)
+          add_lhs_to_local_variables_scopes(node.rhs, node.lhs)
+        end
+
+        def on_in_pattern(node)
+          add_match_var_scopes(node)
+        end
+
+        def on_send(node)
+          return unless node.self_receiver? && regular_method_call?(node)
+          return if node.parent&.mlhs_type?
+          return if allowed_send_node?(node)
+          return if it_method_in_block?(node)
+
+          add_offense(node.receiver) do |corrector|
+            corrector.remove(node.receiver)
+            corrector.remove(node.loc.dot)
+          end
+        end
+
+        def on_block(node)
+          add_scope(node, @local_variables_scopes[node])
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_if(node)
+          # Allow conditional nodes to use `self` in the condition if that variable
+          # name is used in an `lvasgn` or `masgn` within the `if`.
+          node.child_nodes.each do |child_node|
+            if child_node.lvasgn_type?
+              add_lhs_to_local_variables_scopes(node.condition, child_node.lhs)
+            elsif child_node.masgn_type?
+              add_masgn_lhs_variables(node.condition, child_node.lhs)
+            end
+          end
+        end
+        alias on_while on_if
+        alias on_until on_if
+
+        private
+
+        def add_scope(node, local_variables = [])
+          node.each_descendant do |child_node|
+            @local_variables_scopes[child_node] = local_variables
+          end
+        end
+
+        def allowed_send_node?(node)
+          @allowed_send_nodes.include?(node) ||
+            @local_variables_scopes[node].include?(node.method_name) ||
+            node.each_ancestor.any? do |ancestor|
+              @local_variables_scopes[ancestor].include?(node.method_name)
+            end ||
+            KERNEL_METHODS.include?(node.method_name)
+        end
+
+        # Respects `Lint/ItWithoutArgumentsInBlock` cop and the following Ruby 3.3's warning:
+        #
+        # $ ruby -e '0.times { begin; it; end }'
+        # -e:1: warning: `it` calls without arguments will refer to the first block param in
+        # Ruby 3.4; use it() or self.it
+        #
+        def it_method_in_block?(node)
+          return false unless node.method?(:it)
+          return false unless (block_node = node.each_ancestor(:block).first)
+          return false unless block_node.arguments.empty_and_without_delimiters?
+
+          node.arguments.empty? && !node.block_literal?
+        end
+
+        def regular_method_call?(node)
+          !(node.operator_method? ||
+            KEYWORDS.include?(node.method_name) ||
+            node.camel_case_method? ||
+            node.setter_method? ||
+            node.implicit_call?)
+        end
+
+        def on_argument(node)
+          if node.mlhs_type?
+            on_args(node)
+          elsif node.respond_to?(:name)
+            @local_variables_scopes[node] << node.name
+          end
+        end
+
+        def allow_self(node)
+          return unless node.send_type? && node.self_receiver?
+
+          @allowed_send_nodes << node
+        end
+
+        def add_lhs_to_local_variables_scopes(rhs, lhs)
+          if rhs&.send_type? && !rhs.arguments.empty?
+            rhs.arguments.each { |argument| @local_variables_scopes[argument] << lhs }
+          else
+            @local_variables_scopes[rhs] << lhs
+          end
+        end
+
+        def add_masgn_lhs_variables(rhs, lhs)
+          lhs.children.each do |child|
+            add_lhs_to_local_variables_scopes(rhs, child.to_a.first)
+          end
+        end
+
+        def add_match_var_scopes(in_pattern_node)
+          in_pattern_node.each_descendant(:match_var) do |match_var_node|
+            @local_variables_scopes[in_pattern_node] << match_var_node.children.first
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for places where redundant assignments are made for in place
+      # modification methods.
+      #
+      # @safety
+      #   This cop is unsafe, because it can produce false positives for
+      #   user defined methods having one of the expected names, but not modifying
+      #   its receiver in place.
+      #
+      # @example
+      #   # bad
+      #   args = args.concat(ary)
+      #   hash = hash.merge!(other)
+      #
+      #   # good
+      #   args.concat(foo)
+      #   args += foo
+      #   hash.merge!(other)
+      #
+      #   # good
+      #   foo.concat(ary)
+      #
+      class RedundantSelfAssignment < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Redundant self assignment detected. ' \
+              'Method `%<method_name>s` modifies its receiver in place.'
+
+        METHODS_RETURNING_SELF = %i[
+          append clear collect! compare_by_identity concat delete_if
+          fill initialize_copy insert keep_if map! merge! prepend push
+          rehash replace reverse! rotate! shuffle! sort! sort_by!
+          transform_keys! transform_values! unshift update
+        ].to_set.freeze
+
+        ASSIGNMENT_TYPE_TO_RECEIVER_TYPE = {
+          lvasgn: :lvar,
+          ivasgn: :ivar,
+          cvasgn: :cvar,
+          gvasgn: :gvar
+        }.freeze
+
+        # @!method redundant_self_assignment?
+        def_node_matcher :redundant_self_assignment?, <<~PATTERN
+          (call
+            %1 _
+            (call
+              (call
+                %1 %2) #method_returning_self?
+              ...))
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize
+        def on_lvasgn(node)
+          return unless (rhs = node.rhs)
+          return unless rhs.type?(:any_block, :call) && method_returning_self?(rhs.method_name)
+          return unless (receiver = rhs.receiver)
+
+          receiver_type = ASSIGNMENT_TYPE_TO_RECEIVER_TYPE[node.type]
+          return unless receiver.type == receiver_type && receiver.children.first == node.lhs
+
+          message = format(MSG, method_name: rhs.method_name)
+          add_offense(node.loc.operator, message: message) do |corrector|
+            corrector.replace(node, rhs.source)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+        alias on_ivasgn on_lvasgn
+        alias on_cvasgn on_lvasgn
+        alias on_gvasgn on_lvasgn
+
+        def on_send(node)
+          return unless node.assignment_method?
+          return unless redundant_assignment?(node)
+
+          message = format(MSG, method_name: node.first_argument.method_name)
+          add_offense(node.loc.operator, message: message) do |corrector|
+            corrector.remove(correction_range(node))
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def method_returning_self?(method_name)
+          METHODS_RETURNING_SELF.include?(method_name)
+        end
+
+        def redundant_assignment?(node)
+          receiver_name = node.method_name.to_s.delete_suffix('=').to_sym
+
+          redundant_self_assignment?(node, node.receiver, receiver_name)
+        end
+
+        def correction_range(node)
+          range_between(node.source_range.begin_pos, node.first_argument.source_range.begin_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for places where conditional branch makes redundant self-assignment.
+      #
+      # It only detects local variable because it may replace state of instance variable,
+      # class variable, and global variable that have state across methods with `nil`.
+      #
+      # @example
+      #
+      #   # bad
+      #   foo = condition ? bar : foo
+      #
+      #   # good
+      #   foo = bar if condition
+      #
+      #   # bad
+      #   foo = condition ? foo : bar
+      #
+      #   # good
+      #   foo = bar unless condition
+      #
+      class RedundantSelfAssignmentBranch < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the self-assignment branch.'
+
+        # @!method bad_method?(node)
+        def_node_matcher :bad_method?, <<~PATTERN
+          (send nil? :bad_method ...)
+        PATTERN
+
+        def on_lvasgn(node)
+          expression = node.expression
+
+          return unless use_if_and_else_branch?(expression)
+
+          if_branch = expression.if_branch
+          else_branch = expression.else_branch
+          return if inconvertible_to_modifier?(if_branch, else_branch)
+
+          if self_assign?(node.name, if_branch)
+            register_offense(expression, if_branch, else_branch, 'unless')
+          elsif self_assign?(node.name, else_branch)
+            register_offense(expression, else_branch, if_branch, 'if')
+          end
+        end
+
+        private
+
+        def use_if_and_else_branch?(expression)
+          return false unless expression&.if_type?
+
+          !expression.ternary? || !expression.else?
+        end
+
+        def inconvertible_to_modifier?(if_branch, else_branch)
+          multiple_statements?(if_branch) || multiple_statements?(else_branch) ||
+            (else_branch.respond_to?(:elsif?) && else_branch.elsif?)
+        end
+
+        def multiple_statements?(branch)
+          return false unless branch&.begin_type?
+
+          !branch.children.empty?
+        end
+
+        def self_assign?(variable, branch)
+          variable.to_s == branch&.source
+        end
+
+        def register_offense(if_node, offense_branch, opposite_branch, keyword)
+          add_offense(offense_branch) do |corrector|
+            assignment_value = opposite_branch ? opposite_branch.source : 'nil'
+            replacement = "#{assignment_value} #{keyword} #{if_node.condition.source}"
+            if opposite_branch.respond_to?(:heredoc?) && opposite_branch.heredoc?
+              replacement += opposite_branch.loc.heredoc_end.with(
+                begin_pos: opposite_branch.source_range.end_pos
+              ).source
+            end
+
+            corrector.replace(if_node, replacement)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies instances of sorting and then
+      # taking only the first or last element. The same behavior can
+      # be accomplished without a relatively expensive sort by using
+      # `Enumerable#min` instead of sorting and taking the first
+      # element and `Enumerable#max` instead of sorting and taking the
+      # last element. Similarly, `Enumerable#min_by` and
+      # `Enumerable#max_by` can replace `Enumerable#sort_by` calls
+      # after which only the first or last element is used.
+      #
+      # @safety
+      #   This cop is unsafe, because `sort...last` and `max` may not return the
+      #   same element in all cases.
+      #
+      #   In an enumerable where there are multiple elements where ``a <=> b == 0``,
+      #   or where the transformation done by the `sort_by` block has the
+      #   same result, `sort.last` and `max` (or `sort_by.last` and `max_by`)
+      #   will return different elements. `sort.last` will return the last
+      #   element but `max` will return the first element.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #     class MyString < String; end
+      #     strings = [MyString.new('test'), 'test']
+      #     strings.sort.last.class   #=> String
+      #     strings.max.class         #=> MyString
+      #   ----
+      #
+      #   [source,ruby]
+      #   ----
+      #     words = %w(dog horse mouse)
+      #     words.sort_by { |word| word.length }.last   #=> 'mouse'
+      #     words.max_by { |word| word.length }         #=> 'horse'
+      #   ----
+      #
+      # @example
+      #   # bad
+      #   [2, 1, 3].sort.first
+      #   [2, 1, 3].sort[0]
+      #   [2, 1, 3].sort.at(0)
+      #   [2, 1, 3].sort.slice(0)
+      #
+      #   # good
+      #   [2, 1, 3].min
+      #
+      #   # bad
+      #   [2, 1, 3].sort.last
+      #   [2, 1, 3].sort[-1]
+      #   [2, 1, 3].sort.at(-1)
+      #   [2, 1, 3].sort.slice(-1)
+      #
+      #   # good
+      #   [2, 1, 3].max
+      #
+      #   # bad
+      #   arr.sort_by(&:foo).first
+      #   arr.sort_by(&:foo)[0]
+      #   arr.sort_by(&:foo).at(0)
+      #   arr.sort_by(&:foo).slice(0)
+      #
+      #   # good
+      #   arr.min_by(&:foo)
+      #
+      #   # bad
+      #   arr.sort_by(&:foo).last
+      #   arr.sort_by(&:foo)[-1]
+      #   arr.sort_by(&:foo).at(-1)
+      #   arr.sort_by(&:foo).slice(-1)
+      #
+      #   # good
+      #   arr.max_by(&:foo)
+      #
+      class RedundantSort < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<suggestion>s` instead of `%<sorter>s...%<accessor_source>s`.'
+
+        RESTRICT_ON_SEND = %i[sort sort_by].freeze
+
+        # @!method redundant_sort?(node)
+        def_node_matcher :redundant_sort?, <<~MATCHER
+          {
+            (call $(call _ $:sort) ${:last :first})
+            (call $(call _ $:sort) ${:[] :at :slice} {(int 0) (int -1)})
+
+            (call $(call _ $:sort_by _) ${:last :first})
+            (send $(send _ $:sort_by _) ${:[] :at :slice} {(int 0) (int -1)})
+
+            (call (any_block $(call _ ${:sort_by :sort}) ...) ${:last :first})
+            (call
+              (any_block $(call _ ${:sort_by :sort}) ...)
+              ${:[] :at :slice} {(int 0) (int -1)}
+            )
+          }
+        MATCHER
+
+        def on_send(node)
+          ancestor, sort_node, sorter, accessor =
+            find_redundant_sort(node.parent, node.parent&.parent)
+          return unless ancestor
+
+          register_offense(ancestor, sort_node, sorter, accessor)
+        end
+        alias on_csend on_send
+
+        private
+
+        def find_redundant_sort(*nodes)
+          nodes.each do |node|
+            if (sort_node, sorter, accessor = redundant_sort?(node))
+              return [node, sort_node, sorter, accessor]
+            end
+          end
+
+          nil
+        end
+
+        def register_offense(node, sort_node, sorter, accessor)
+          message = message(node, sorter, accessor)
+          add_offense(offense_range(sort_node, node), message: message) do |corrector|
+            autocorrect(corrector, node, sort_node, sorter, accessor)
+          end
+        end
+
+        def offense_range(sort_node, node)
+          range_between(sort_node.loc.selector.begin_pos, node.source_range.end_pos)
+        end
+
+        def message(node, sorter, accessor)
+          accessor_source = range_between(
+            node.loc.selector.begin_pos,
+            node.source_range.end_pos
+          ).source
+
+          format(MSG,
+                 suggestion: suggestion(sorter, accessor, arg_value(node)),
+                 sorter: sorter,
+                 accessor_source: accessor_source)
+        end
+
+        def autocorrect(corrector, node, sort_node, sorter, accessor)
+          # Remove accessor, e.g. `first` or `[-1]`.
+          corrector.remove(range_between(accessor_start(node), node.source_range.end_pos))
+          # Replace "sort" or "sort_by" with the appropriate min/max method.
+          corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
+          # Replace to avoid syntax errors when followed by a logical operator.
+          replace_with_logical_operator(corrector, node) if with_logical_operator?(node)
+        end
+
+        def replace_with_logical_operator(corrector, node)
+          corrector.insert_after(node.child_nodes.first, " #{node.parent.loc.operator.source}")
+          corrector.remove(node.parent.loc.operator)
+        end
+
+        def suggestion(sorter, accessor, arg)
+          base(accessor, arg) + suffix(sorter)
+        end
+
+        def base(accessor, arg)
+          if accessor == :first || arg&.zero?
+            'min'
+          elsif accessor == :last || arg == -1
+            'max'
+          end
+        end
+
+        def suffix(sorter)
+          case sorter
+          when :sort
+            ''
+          when :sort_by
+            '_by'
+          end
+        end
+
+        def arg_node(node)
+          node.first_argument
+        end
+
+        def arg_value(node)
+          arg_node(node)&.node_parts&.first
+        end
+
+        # This gets the start of the accessor whether it has a dot
+        # (e.g. `.first`) or doesn't (e.g. `[0]`)
+        def accessor_start(node)
+          if node.loc.dot
+            node.loc.dot.begin_pos
+          else
+            node.loc.selector.begin_pos
+          end
+        end
+
+        def with_logical_operator?(node)
+          return false unless (parent = node.parent)
+
+          parent.operator_keyword?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies places where `sort_by { ... }` can be replaced by
+      # `sort`.
+      #
+      # @example
+      #   # bad
+      #   array.sort_by { |x| x }
+      #   array.sort_by do |var|
+      #     var
+      #   end
+      #
+      #   # good
+      #   array.sort
+      class RedundantSortBy < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_BLOCK = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'
+        MSG_NUMBLOCK = 'Use `sort` instead of `sort_by { _1 }`.'
+        MSG_ITBLOCK = 'Use `sort` instead of `sort_by { it }`.'
+
+        def on_block(node)
+          redundant_sort_by_block(node) do |send, var_name|
+            range = sort_by_range(send, node)
+
+            add_offense(range, message: format(MSG_BLOCK, var: var_name)) do |corrector|
+              corrector.replace(range, 'sort')
+            end
+          end
+        end
+
+        def on_numblock(node)
+          redundant_sort_by_numblock(node) do |send|
+            range = sort_by_range(send, node)
+
+            add_offense(range, message: MSG_NUMBLOCK) do |corrector|
+              corrector.replace(range, 'sort')
+            end
+          end
+        end
+
+        def on_itblock(node)
+          redundant_sort_by_itblock(node) do |send|
+            range = sort_by_range(send, node)
+
+            add_offense(range, message: MSG_ITBLOCK) do |corrector|
+              corrector.replace(range, 'sort')
+            end
+          end
+        end
+
+        private
+
+        # @!method redundant_sort_by_block(node)
+        def_node_matcher :redundant_sort_by_block, <<~PATTERN
+          (block $(call _ :sort_by) (args (arg $_x)) (lvar _x))
+        PATTERN
+
+        # @!method redundant_sort_by_numblock(node)
+        def_node_matcher :redundant_sort_by_numblock, <<~PATTERN
+          (numblock $(call _ :sort_by) 1 (lvar :_1))
+        PATTERN
+
+        # @!method redundant_sort_by_itblock(node)
+        def_node_matcher :redundant_sort_by_itblock, <<~PATTERN
+          (itblock $(call _ :sort_by) _ (lvar :it))
+        PATTERN
+
+        def sort_by_range(send, node)
+          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
+        end
+      end
+    end
+  end
+end