rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # `Dir[...]` and `Dir.glob(...)` do not make any guarantees about
+      # the order in which files are returned. The final order is
+      # determined by the operating system and file system.
+      # This means that using them in cases where the order matters,
+      # such as requiring files, can lead to intermittent failures
+      # that are hard to debug. To ensure this doesn't happen,
+      # always sort the list.
+      #
+      # `Dir.glob` and `Dir[]` sort globbed results by default in Ruby 3.0.
+      # So all bad cases are acceptable when Ruby 3.0 or higher are used.
+      #
+      # NOTE: This cop will be deprecated and removed when supporting only Ruby 3.0 and higher.
+      #
+      # @safety
+      #   This cop is unsafe in the case where sorting files changes existing
+      #   expected behavior.
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir["./lib/**/*.rb"].each do |file|
+      #     require file
+      #   end
+      #
+      #   # good
+      #   Dir["./lib/**/*.rb"].sort.each do |file|
+      #     require file
+      #   end
+      #
+      #   # bad
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')) do |file|
+      #     require file
+      #   end
+      #
+      #   # good
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')).sort.each do |file|
+      #     require file
+      #   end
+      #
+      #   # bad
+      #   Dir['./lib/**/*.rb'].each(&method(:require))
+      #
+      #   # good
+      #   Dir['./lib/**/*.rb'].sort.each(&method(:require))
+      #
+      #   # bad
+      #   Dir.glob(Rails.root.join('test', '*.rb'), &method(:require))
+      #
+      #   # good
+      #   Dir.glob(Rails.root.join('test', '*.rb')).sort.each(&method(:require))
+      #
+      #   # good - Respect intent if `sort` keyword option is specified in Ruby 3.0 or higher.
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb'), sort: false).each(&method(:require))
+      #
+      class NonDeterministicRequireOrder < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Sort files before requiring them.'
+
+        maximum_target_ruby_version 2.7
+
+        def on_block(node)
+          return unless node.body
+          return unless unsorted_dir_loop?(node.send_node)
+
+          loop_variable(node.arguments) do |var_name|
+            return unless var_is_required?(node.body, var_name)
+
+            add_offense(node.send_node) { |corrector| correct_block(corrector, node.send_node) }
+          end
+        end
+
+        def on_numblock(node)
+          return unless node.body
+          return unless unsorted_dir_loop?(node.send_node)
+
+          node.argument_list
+              .filter { |argument| var_is_required?(node.body, argument.name) }
+              .each do
+                add_offense(node.send_node) { |corrector| correct_block(corrector, node.send_node) }
+              end
+        end
+
+        def on_block_pass(node)
+          return unless method_require?(node)
+          return unless unsorted_dir_pass?(node.parent)
+
+          parent_node = node.parent
+
+          add_offense(parent_node) do |corrector|
+            if parent_node.last_argument&.block_pass_type?
+              correct_block_pass(corrector, parent_node)
+            else
+              correct_block(corrector, parent_node)
+            end
+          end
+        end
+
+        private
+
+        def correct_block(corrector, node)
+          if unsorted_dir_block?(node)
+            corrector.replace(node, "#{node.source}.sort.each")
+          else
+            source = node.receiver.source
+
+            corrector.replace(node, "#{source}.sort.each")
+          end
+        end
+
+        def correct_block_pass(corrector, node)
+          if unsorted_dir_glob_pass?(node)
+            block_arg = node.last_argument
+
+            corrector.remove(last_arg_range(node))
+            corrector.insert_after(node, ".sort.each(#{block_arg.source})")
+          else
+            corrector.replace(node.loc.selector, 'sort.each')
+          end
+        end
+
+        # Returns range of last argument including comma and whitespace.
+        #
+        # @return [Parser::Source::Range]
+        #
+        def last_arg_range(node)
+          node.last_argument.source_range.join(node.arguments[-2].source_range.end)
+        end
+
+        def unsorted_dir_loop?(node)
+          unsorted_dir_block?(node) || unsorted_dir_each?(node)
+        end
+
+        def unsorted_dir_pass?(node)
+          unsorted_dir_glob_pass?(node) || unsorted_dir_each_pass?(node)
+        end
+
+        # @!method unsorted_dir_block?(node)
+        def_node_matcher :unsorted_dir_block?, <<~PATTERN
+          (send (const {nil? cbase} :Dir) :glob ...)
+        PATTERN
+
+        # @!method unsorted_dir_each?(node)
+        def_node_matcher :unsorted_dir_each?, <<~PATTERN
+          (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each)
+        PATTERN
+
+        # @!method method_require?(node)
+        def_node_matcher :method_require?, <<~PATTERN
+          (block-pass (send nil? :method (sym {:require :require_relative})))
+        PATTERN
+
+        # @!method unsorted_dir_glob_pass?(node)
+        def_node_matcher :unsorted_dir_glob_pass?, <<~PATTERN
+          (send (const {nil? cbase} :Dir) :glob ...
+            (block-pass (send nil? :method (sym {:require :require_relative}))))
+        PATTERN
+
+        # @!method unsorted_dir_each_pass?(node)
+        def_node_matcher :unsorted_dir_each_pass?, <<~PATTERN
+          (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each
+            (block-pass (send nil? :method (sym {:require :require_relative}))))
+        PATTERN
+
+        # @!method loop_variable(node)
+        def_node_matcher :loop_variable, <<~PATTERN
+          (args (arg $_))
+        PATTERN
+
+        # @!method var_is_required?(node, name)
+        def_node_search :var_is_required?, <<~PATTERN
+          (send nil? {:require :require_relative} (lvar %1))
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for non-local exits from iterators without a return
+      # value. It registers an offense under these conditions:
+      #
+      # * No value is returned,
+      # * the block is preceded by a method chain,
+      # * the block has arguments,
+      # * the method which receives the block is not `define_method`
+      # or `define_singleton_method`,
+      # * the return is not contained in an inner scope, e.g. a lambda or a
+      # method definition.
+      #
+      # @example
+      #
+      #   class ItemApi
+      #     rescue_from ValidationError do |e| # non-iteration block with arg
+      #       return { message: 'validation error' } unless e.errors # allowed
+      #       error_array = e.errors.map do |error| # block with method chain
+      #         return if error.suppress? # warned
+      #         return "#{error.param}: invalid" unless error.message # allowed
+      #         "#{error.param}: #{error.message}"
+      #       end
+      #       { message: 'validation error', errors: error_array }
+      #     end
+      #
+      #     def update_items
+      #       transaction do # block without arguments
+      #         return unless update_necessary? # allowed
+      #         find_each do |item| # block without method chain
+      #           return if item.stock == 0 # false-negative...
+      #           item.update!(foobar: true)
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      class NonLocalExitFromIterator < Base
+        MSG = 'Non-local exit from iterator, without return value. ' \
+              '`next`, `break`, `Array#find`, `Array#any?`, etc. ' \
+              'is preferred.'
+
+        def on_return(return_node)
+          return if return_value?(return_node)
+
+          return_node.each_ancestor(:any_block, :any_def) do |node|
+            break if scoped_node?(node)
+
+            # if a proc is passed to `Module#define_method` or
+            # `Object#define_singleton_method`, `return` will not cause a
+            # non-local exit error
+            break if define_method?(node.send_node)
+
+            next if node.argument_list.empty?
+
+            if chained_send?(node.send_node)
+              add_offense(return_node.loc.keyword)
+              break
+            end
+          end
+        end
+
+        private
+
+        def scoped_node?(node)
+          node.any_def_type? || node.lambda?
+        end
+
+        def return_value?(return_node)
+          !return_node.children.empty?
+        end
+
+        # @!method chained_send?(node)
+        def_node_matcher :chained_send?, '(send !nil? ...)'
+
+        # @!method define_method?(node)
+        def_node_matcher :define_method?, <<~PATTERN
+          (send _ {:define_method :define_singleton_method} _)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Warns the usage of unsafe number conversions. Unsafe
+      # number conversion can cause unexpected error if auto type conversion
+      # fails. Cop prefer parsing with number class instead.
+      #
+      # Conversion with `Integer`, `Float`, etc. will raise an `ArgumentError`
+      # if given input that is not numeric (eg. an empty string), whereas
+      # `to_i`, etc. will try to convert regardless of input (``''.to_i => 0``).
+      # As such, this cop is disabled by default because it's not necessarily
+      # always correct to raise if a value is not numeric.
+      #
+      # NOTE: Some values cannot be converted properly using one of the `Kernel`
+      # method (for instance, `Time` and `DateTime` values are allowed by this
+      # cop by default). Similarly, Rails' duration methods do not work well
+      # with `Integer()` and can be allowed with `AllowedMethods`. By default,
+      # there are no methods to allowed.
+      #
+      # @safety
+      #   Autocorrection is unsafe because it is not guaranteed that the
+      #   replacement `Kernel` methods are able to properly handle the
+      #   input if it is not a standard class.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   '10'.to_i
+      #   '10.2'.to_f
+      #   '10'.to_c
+      #   '1/3'.to_r
+      #   ['1', '2', '3'].map(&:to_i)
+      #   foo.try(:to_f)
+      #   bar.send(:to_c)
+      #
+      #   # good
+      #
+      #   Integer('10', 10)
+      #   Float('10.2')
+      #   Complex('10')
+      #   Rational('1/3')
+      #   ['1', '2', '3'].map { |i| Integer(i, 10) }
+      #   foo.try { |i| Float(i) }
+      #   bar.send { |i| Complex(i) }
+      #
+      # @example AllowedMethods: [] (default)
+      #
+      #   # bad
+      #   10.minutes.to_i
+      #
+      # @example AllowedMethods: [minutes]
+      #
+      #   # good
+      #   10.minutes.to_i
+      #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   10.minutes.to_i
+      #
+      # @example AllowedPatterns: ['min*']
+      #
+      #   # good
+      #   10.minutes.to_i
+      #
+      # @example IgnoredClasses: [Time, DateTime] (default)
+      #
+      #   # good
+      #   Time.now.to_datetime.to_i
+      class NumberConversion < Base
+        extend AutoCorrector
+        include AllowedMethods
+        include AllowedPattern
+
+        CONVERSION_METHOD_CLASS_MAPPING = {
+          to_i: "#{Integer.name}(%<number_object>s, 10)",
+          to_f: "#{Float.name}(%<number_object>s)",
+          to_c: "#{Complex.name}(%<number_object>s)",
+          to_r: "#{Rational.name}(%<number_object>s)"
+        }.freeze
+        MSG = 'Replace unsafe number conversion with number ' \
+              'class parsing, instead of using ' \
+              '`%<current>s`, use stricter ' \
+              '`%<corrected_method>s`.'
+        CONVERSION_METHODS = %i[Integer Float Complex Rational to_i to_f to_c to_r].freeze
+        METHODS = CONVERSION_METHOD_CLASS_MAPPING.keys.map(&:inspect).join(' ')
+
+        # @!method to_method(node)
+        def_node_matcher :to_method, <<~PATTERN
+          (call $_ ${#{METHODS}})
+        PATTERN
+
+        # @!method to_method_symbol(node)
+        def_node_matcher :to_method_symbol, <<~PATTERN
+          (call _ $_ ${
+            {
+              (sym ${#{METHODS}})
+              (block_pass (sym ${#{METHODS}}))
+            }
+          } ...)
+        PATTERN
+
+        def on_send(node)
+          handle_conversion_method(node)
+          handle_as_symbol(node)
+        end
+        alias on_csend on_send
+
+        private
+
+        def handle_conversion_method(node)
+          to_method(node) do |receiver, to_method|
+            next if receiver.nil? || allow_receiver?(receiver)
+
+            message = format(
+              MSG,
+              current: "#{receiver.source}.#{to_method}",
+              corrected_method: correct_method(node, receiver)
+            )
+            add_offense(node, message: message) do |corrector|
+              next if part_of_ignored_node?(node)
+
+              corrector.replace(node, correct_method(node, node.receiver))
+
+              ignore_node(node)
+            end
+          end
+        end
+
+        def handle_as_symbol(node)
+          to_method_symbol(node) do |receiver, sym_node, to_method|
+            next if receiver.nil? || !node.arguments.one?
+
+            message = format(
+              MSG,
+              current: sym_node.source,
+              corrected_method: correct_sym_method(to_method)
+            )
+            add_offense(node, message: message) do |corrector|
+              remove_parentheses(corrector, node) if node.parenthesized?
+
+              corrector.replace(sym_node, correct_sym_method(to_method))
+            end
+          end
+        end
+
+        def correct_method(node, receiver)
+          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name], number_object: receiver.source)
+        end
+
+        def correct_sym_method(to_method)
+          body = format(CONVERSION_METHOD_CLASS_MAPPING[to_method], number_object: 'i')
+          "{ |i| #{body} }"
+        end
+
+        def remove_parentheses(corrector, node)
+          corrector.replace(node.loc.begin, ' ')
+          corrector.remove(node.loc.end)
+        end
+
+        def allow_receiver?(receiver)
+          if receiver.numeric_type? || (receiver.send_type? &&
+            (conversion_method?(receiver.method_name) ||
+            allowed_method_name?(receiver.method_name)))
+            true
+          elsif (receiver = top_receiver(receiver))
+            receiver.const_type? && ignored_class?(receiver.const_name)
+          else
+            false
+          end
+        end
+
+        def allowed_method_name?(name)
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
+        def top_receiver(node)
+          receiver = node
+          receiver = receiver.receiver until receiver.receiver.nil?
+          receiver
+        end
+
+        def conversion_method?(method_name)
+          CONVERSION_METHODS.include?(method_name)
+        end
+
+        def ignored_classes
+          cop_config.fetch('IgnoredClasses', [])
+        end
+
+        def ignored_class?(name)
+          ignored_classes.include?(name.to_s)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for uses of numbered parameter assignment.
+      # It emulates the following warning in Ruby 2.7:
+      #
+      #   $ ruby -ve '_1 = :value'
+      #   ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-darwin19]
+      #   -e:1: warning: `_1' is reserved for numbered parameter; consider another name
+      #
+      # Assigning to a numbered parameter (from `_1` to `_9`) causes an error in Ruby 3.0.
+      #
+      #   $ ruby -ve '_1 = :value'
+      #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
+      #   -e:1: _1 is reserved for numbered parameter
+      #
+      # NOTE: The parametered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10`
+      # as well to prevent confusion.
+      #
+      # @example
+      #
+      #   # bad
+      #   _1 = :value
+      #
+      #   # good
+      #   non_numbered_parameter_name = :value
+      #
+      class NumberedParameterAssignment < Base
+        NUM_PARAM_MSG = '`_%<number>s` is reserved for numbered parameter; consider another name.'
+        LVAR_MSG = '`_%<number>s` is similar to numbered parameter; consider another name.'
+        NUMBERED_PARAMETER_RANGE = (1..9).freeze
+
+        def on_lvasgn(node)
+          return unless /\A_(\d+)\z/ =~ node.name
+
+          number = Regexp.last_match(1).to_i
+          template = NUMBERED_PARAMETER_RANGE.include?(number) ? NUM_PARAM_MSG : LVAR_MSG
+
+          add_offense(node, message: format(template, number: number))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Certain numeric operations have a constant result, usually 0 or 1.
+      # Multiplying a number by 0 will always return 0.
+      # Dividing a number by itself or raising it to the power of 0 will always return 1.
+      # As such, they can be replaced with that result.
+      # These are probably leftover from debugging, or are mistakes.
+      # Other numeric operations that are similarly leftover from debugging or mistakes
+      # are handled by `Lint/UselessNumericOperation`.
+      #
+      # NOTE: This cop doesn't detect offenses for the `-` and `%` operator because it
+      # can't determine the type of `x`. If `x` is an `Array` or `String`, it doesn't perform
+      # a numeric operation.
+      #
+      # @example
+      #
+      #   # bad
+      #   x * 0
+      #
+      #   # good
+      #   0
+      #
+      #   # bad
+      #   x *= 0
+      #
+      #   # good
+      #   x = 0
+      #
+      #   # bad
+      #   x / x
+      #   x ** 0
+      #
+      #   # good
+      #   1
+      #
+      #   # bad
+      #   x /= x
+      #   x **= 0
+      #
+      #   # good
+      #   x = 1
+      #
+      class NumericOperationWithConstantResult < Base
+        extend AutoCorrector
+        MSG = 'Numeric operation with a constant result detected.'
+        RESTRICT_ON_SEND = %i[* / **].freeze
+
+        # @!method operation_with_constant_result?(node)
+        def_node_matcher :operation_with_constant_result?,
+                         '(call (call nil? $_lhs) $_operation ({int | call nil?} $_rhs))'
+
+        # @!method abbreviated_assignment_with_constant_result?(node)
+        def_node_matcher :abbreviated_assignment_with_constant_result?,
+                         '(op-asgn (lvasgn $_lhs) $_operation ({int lvar} $_rhs))'
+
+        def on_send(node)
+          return unless (lhs, operation, rhs = operation_with_constant_result?(node))
+          return unless (result = constant_result?(lhs, operation, rhs))
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, result.to_s)
+          end
+        end
+        alias on_csend on_send
+
+        def on_op_asgn(node)
+          return unless (lhs, operation, rhs = abbreviated_assignment_with_constant_result?(node))
+          return unless (result = constant_result?(lhs, operation, rhs))
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, "#{lhs} = #{result}")
+          end
+        end
+
+        private
+
+        def constant_result?(lhs, operation, rhs)
+          if rhs.to_s == '0'
+            return 0 if operation == :*
+            return 1 if operation == :**
+          elsif rhs == lhs
+            return 1 if operation == :/
+          end
+          # If we weren't able to find any matches, return false so we can bail out.
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for unintended or-assignment to a constant.
+      #
+      # Constants should always be assigned in the same location. And its value
+      # should always be the same. If constants are assigned in multiple
+      # locations, the result may vary depending on the order of `require`.
+      #
+      # @safety
+      #   This cop is unsafe because code that is already conditionally
+      #   assigning a constant may have its behavior changed by autocorrection.
+      #
+      # @example
+      #
+      #   # bad
+      #   CONST ||= 1
+      #
+      #   # good
+      #   CONST = 1
+      #
+      class OrAssignmentToConstant < Base
+        extend AutoCorrector
+
+        MSG = 'Avoid using or-assignment with constants.'
+
+        def on_or_asgn(node)
+          return unless node.lhs&.casgn_type?
+
+          add_offense(node.loc.operator) do |corrector|
+            next if node.each_ancestor(:any_def).any?
+
+            corrector.replace(node.loc.operator, '=')
+          end
+        end
+      end
+    end
+  end
+end