rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for mixed-case character ranges since they include likely unintended characters.
+      #
+      # Offenses are registered for regexp character classes like `/[A-z]/`
+      # as well as range objects like `('A'..'z')`.
+      #
+      # NOTE: `Range` objects cannot be autocorrected.
+      #
+      # @safety
+      #   The cop autocorrects regexp character classes
+      #   by replacing one character range with two: `A-z` becomes `A-Za-z`.
+      #   In most cases this is probably what was originally intended
+      #   but it changes the regexp to no longer match symbols it used to include.
+      #   For this reason, this cop's autocorrect is unsafe (it will
+      #   change the behavior of the code).
+      #
+      # @example
+      #
+      #   # bad
+      #   r = /[A-z]/
+      #
+      #   # good
+      #   r = /[A-Za-z]/
+      class MixedCaseRange < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Ranges from upper to lower case ASCII letters may include unintended ' \
+              'characters. Instead of `A-z` (which also includes several symbols) ' \
+              'specify each range individually: `A-Za-z` and individually specify any symbols.'
+        RANGES = [('a'..'z').freeze, ('A'..'Z').freeze].freeze
+
+        def on_irange(node)
+          return unless node.children.compact.all?(&:str_type?)
+          return if node.begin.nil? || node.end.nil?
+
+          add_offense(node) if unsafe_range?(node.begin.value, node.end.value)
+        end
+        alias on_erange on_irange
+
+        def on_regexp(node)
+          each_unsafe_regexp_range(node) do |loc|
+            next unless (replacement = regexp_range(loc.source))
+
+            add_offense(loc) do |corrector|
+              corrector.replace(loc, replacement)
+            end
+          end
+        end
+
+        def each_unsafe_regexp_range(node)
+          node.parsed_tree&.each_expression do |expr|
+            next if skip_expression?(expr)
+
+            range_pairs(expr).reject do |range_start, range_end|
+              next if skip_range?(range_start, range_end)
+
+              next unless unsafe_range?(range_start.text, range_end.text)
+
+              yield(build_source_range(range_start, range_end))
+            end
+          end
+        end
+
+        private
+
+        def build_source_range(range_start, range_end)
+          range_between(range_start.expression.begin_pos, range_end.expression.end_pos)
+        end
+
+        def range_for(char)
+          RANGES.detect do |range|
+            range.include?(char)
+          end
+        end
+
+        def range_pairs(expr)
+          expr.expressions.filter_map { |e| [e.expressions[0], e.expressions[1]] if e.type == :set }
+        end
+
+        def unsafe_range?(range_start, range_end)
+          return false if range_start.length != 1 || range_end.length != 1
+
+          range_for(range_start) != range_for(range_end)
+        end
+
+        def skip_expression?(expr)
+          !(expr.type == :set && expr.token == :character)
+        end
+
+        def skip_range?(range_start, range_end)
+          [range_start, range_end].any? do |bound|
+            bound&.type != :literal
+          end
+        end
+
+        def regexp_range(source)
+          open, close = source.split('-')
+          return unless (open_range = range_for(open))
+          return unless (close_range = range_for(close))
+
+          first = [open, open_range.end]
+          second = [close_range.begin, close]
+          "#{first.uniq.join('-')}#{second.uniq.join('-')}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Do not mix named captures and numbered captures in a `Regexp` literal
+      # because numbered capture is ignored if they're mixed.
+      # Replace numbered captures with non-capturing groupings or
+      # named captures.
+      #
+      # @example
+      #   # bad
+      #   /(?<foo>FOO)(BAR)/
+      #
+      #   # good
+      #   /(?<foo>FOO)(?<bar>BAR)/
+      #
+      #   # good
+      #   /(?<foo>FOO)(?:BAR)/
+      #
+      #   # good
+      #   /(FOO)(BAR)/
+      #
+      class MixedRegexpCaptureTypes < Base
+        MSG = 'Do not mix named captures and numbered captures in a Regexp literal.'
+
+        def on_regexp(node)
+          return if node.interpolation?
+          return if node.each_capture(named: false).none?
+          return if node.each_capture(named: true).none?
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # In math and Python, we can use `x < y < z` style comparison to compare
+      # multiple value. However, we can't use the comparison in Ruby. However,
+      # the comparison is not syntax error. This cop checks the bad usage of
+      # comparison operators.
+      #
+      # @example
+      #
+      #   # bad
+      #   x < y < z
+      #   10 <= x <= 20
+      #
+      #   # good
+      #   x < y && y < z
+      #   10 <= x && x <= 20
+      class MultipleComparison < Base
+        extend AutoCorrector
+
+        MSG = 'Use the `&&` operator to compare multiple values.'
+        COMPARISON_METHODS = %i[< > <= >=].freeze
+        SET_OPERATION_OPERATORS = %i[& | ^].freeze
+        RESTRICT_ON_SEND = COMPARISON_METHODS
+
+        # @!method multiple_compare?(node)
+        def_node_matcher :multiple_compare?, <<~PATTERN
+          (send (send _ {:< :> :<= :>=} $_) {:#{COMPARISON_METHODS.join(' :')}} _)
+        PATTERN
+
+        def on_send(node)
+          return unless (center = multiple_compare?(node))
+          # It allows multiple comparison using `&`, `|`, and `^` set operation operators.
+          # e.g. `x >= y & y < z`
+          return if center.send_type? && SET_OPERATION_OPERATORS.include?(center.method_name)
+
+          add_offense(node) do |corrector|
+            new_center = "#{center.source} && #{center.source}"
+
+            corrector.replace(center, new_center)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for nested method definitions.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # `bar` definition actually produces methods in the same scope
+      #   # as the outer `foo` method. Furthermore, the `bar` method
+      #   # will be redefined every time `foo` is invoked.
+      #   def foo
+      #     def bar
+      #     end
+      #   end
+      #
+      #   # good
+      #
+      #   def foo
+      #     bar = -> { puts 'hello' }
+      #     bar.call
+      #   end
+      #
+      #   # good
+      #
+      #   # `class_eval`, `instance_eval`, `module_eval`, `class_exec`, `instance_exec`, and
+      #   # `module_exec` blocks are allowed by default.
+      #
+      #   def foo
+      #     self.class.class_eval do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      #   def foo
+      #     self.class.module_exec do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #
+      #   def foo
+      #     class << self
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedMethods: [] (default)
+      #   # bad
+      #   def do_something
+      #     has_many :articles do
+      #       def find_or_create_by_name(name)
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedMethods: ['has_many']
+      #   # bad
+      #   def do_something
+      #     has_many :articles do
+      #       def find_or_create_by_name(name)
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedPatterns: [] (default)
+      #   # bad
+      #   def foo(obj)
+      #     obj.do_baz do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      # @example AllowedPatterns: ['baz']
+      #   # good
+      #   def foo(obj)
+      #     obj.do_baz do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      class NestedMethodDefinition < Base
+        include AllowedMethods
+        include AllowedPattern
+
+        MSG = 'Method definitions must not be nested. Use `lambda` instead.'
+
+        def on_def(node)
+          subject, = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          return if node.defs_type? && allowed_subject_type?(subject)
+
+          def_ancestor = node.each_ancestor(:any_def).first
+          return unless def_ancestor
+
+          within_scoping_def =
+            node.each_ancestor(:any_block, :sclass).any? do |ancestor|
+              scoping_method_call?(ancestor)
+            end
+
+          add_offense(node) if def_ancestor && !within_scoping_def
+        end
+        alias on_defs on_def
+
+        private
+
+        def scoping_method_call?(child)
+          child.sclass_type? || eval_call?(child) || exec_call?(child) ||
+            child.class_constructor? || allowed_method_name?(child)
+        end
+
+        def allowed_subject_type?(subject)
+          subject.variable? || subject.const_type? || subject.call_type?
+        end
+
+        def allowed_method_name?(node)
+          name = node.method_name
+
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
+        # @!method eval_call?(node)
+        def_node_matcher :eval_call?, <<~PATTERN
+          (any_block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
+        PATTERN
+
+        # @!method exec_call?(node)
+        def_node_matcher :exec_call?, <<~PATTERN
+          (any_block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for nested percent literals.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # The percent literal for nested_attributes is parsed as four tokens,
+      #   # yielding the array [:name, :content, :"%i[incorrectly", :"nested]"].
+      #   attributes = {
+      #     valid_attributes: %i[name content],
+      #     nested_attributes: %i[name content %i[incorrectly nested]]
+      #   }
+      #
+      #   # good
+      #
+      #   # Neither is incompatible with the bad case, but probably the intended code.
+      #   attributes = {
+      #     valid_attributes: %i[name content],
+      #     nested_attributes: [:name, :content, %i[incorrectly nested]]
+      #   }
+      #
+      #   attributes = {
+      #     valid_attributes: %i[name content],
+      #     nested_attributes: [:name, :content, [:incorrectly, :nested]]
+      #   }
+      #
+      class NestedPercentLiteral < Base
+        include PercentLiteral
+
+        MSG = 'Within percent literals, nested percent literals do not ' \
+              'function and may be unwanted in the result.'
+
+        # The array of regular expressions representing percent literals that,
+        # if found within a percent literal expression, will cause a
+        # NestedPercentLiteral violation to be emitted.
+        PERCENT_LITERAL_TYPES = PreferredDelimiters::PERCENT_LITERAL_TYPES
+        REGEXES = PERCENT_LITERAL_TYPES.map { |percent_literal| /\A#{percent_literal}\W/ }.freeze
+
+        def on_array(node)
+          process(node, *PERCENT_LITERAL_TYPES)
+        end
+
+        def on_percent_literal(node)
+          add_offense(node) if contains_percent_literals?(node)
+        end
+
+        private
+
+        def contains_percent_literals?(node)
+          node.each_child_node.any? do |child|
+            literal = child.children.first.to_s.scrub
+            REGEXES.any? { |regex| literal.match?(regex) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Don't omit the accumulator when calling `next` in a `reduce` block.
+      #
+      # @example
+      #
+      #   # bad
+      #   result = (1..4).reduce(0) do |acc, i|
+      #     next if i.odd?
+      #     acc + i
+      #   end
+      #
+      #   # good
+      #   result = (1..4).reduce(0) do |acc, i|
+      #     next acc if i.odd?
+      #     acc + i
+      #   end
+      class NextWithoutAccumulator < Base
+        MSG = 'Use `next` with an accumulator argument in a `reduce`.'
+
+        def on_block(node)
+          on_block_body_of_reduce(node) do |body|
+            void_next = body.each_node(:next).find do |n|
+              n.children.empty? && parent_block_node(n) == node
+            end
+
+            add_offense(void_next) if void_next
+          end
+        end
+        alias on_numblock on_block
+
+        private
+
+        # @!method on_block_body_of_reduce(node)
+        def_node_matcher :on_block_body_of_reduce, <<~PATTERN
+          {
+            (block (call _recv {:reduce :inject} !sym) _blockargs $(begin ...))
+            (numblock (call _recv {:reduce :inject} !sym) _argscount $(begin ...))
+          }
+        PATTERN
+
+        def parent_block_node(node)
+          node.each_ancestor(:any_block).first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for the presence of a `return` inside a `begin..end` block
+      # in assignment contexts.
+      # In this situation, the `return` will result in an exit from the current
+      # method, possibly leading to unexpected behavior.
+      #
+      # @example
+      #
+      #   # bad
+      #   @some_variable ||= begin
+      #     return some_value if some_condition_is_met
+      #
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   @some_variable ||= begin
+      #     if some_condition_is_met
+      #       some_value
+      #     else
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   some_variable = if some_condition_is_met
+      #                     return if another_condition_is_met
+      #
+      #                     some_value
+      #                   else
+      #                     do_something
+      #                   end
+      #
+      class NoReturnInBeginEndBlocks < Base
+        MSG = 'Do not `return` in `begin..end` blocks in assignment contexts.'
+
+        def on_lvasgn(node)
+          node.each_node(:kwbegin) do |kwbegin_node|
+            kwbegin_node.each_node(:return) do |return_node|
+              add_offense(return_node)
+            end
+          end
+        end
+        alias on_or_asgn on_lvasgn
+        alias on_op_asgn on_lvasgn
+      end
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for non-atomic file operation.
+      # And then replace it with a nearly equivalent and atomic method.
+      #
+      # These can cause problems that are difficult to reproduce,
+      # especially in cases of frequent file operations in parallel,
+      # such as test runs with parallel_rspec.
+      #
+      # For examples: creating a directory if there is none, has the following problems
+      #
+      # An exception occurs when the directory didn't exist at the time of `exist?`,
+      # but someone else created it before `mkdir` was executed.
+      #
+      # Subsequent processes are executed without the directory that should be there
+      # when the directory existed at the time of `exist?`,
+      # but someone else deleted it shortly afterwards.
+      #
+      # @safety
+      #   This cop is unsafe, because autocorrection change to atomic processing.
+      #   The atomic processing of the replacement destination is not guaranteed
+      #   to be strictly equivalent to that before the replacement.
+      #
+      # @example
+      #   # bad - race condition with another process may result in an error in `mkdir`
+      #   unless Dir.exist?(path)
+      #     FileUtils.mkdir(path)
+      #   end
+      #
+      #   # good - atomic and idempotent creation
+      #   FileUtils.mkdir_p(path)
+      #
+      #   # bad - race condition with another process may result in an error in `remove`
+      #   if File.exist?(path)
+      #     FileUtils.remove(path)
+      #   end
+      #
+      #   # good - atomic and idempotent removal
+      #   FileUtils.rm_f(path)
+      #
+      class NonAtomicFileOperation < Base
+        extend AutoCorrector
+
+        MSG_REMOVE_FILE_EXIST_CHECK = 'Remove unnecessary existence check ' \
+                                      '`%<receiver>s.%<method_name>s`.'
+        MSG_CHANGE_FORCE_METHOD = 'Use atomic file operation method `FileUtils.%<method_name>s`.'
+        MAKE_FORCE_METHODS = %i[makedirs mkdir_p mkpath].freeze
+        MAKE_METHODS = %i[mkdir].freeze
+        REMOVE_FORCE_METHODS = %i[rm_f rm_rf].freeze
+        REMOVE_METHODS = %i[remove delete unlink remove_file rm rmdir safe_unlink].freeze
+        RECURSIVE_REMOVE_METHODS = %i[remove_dir remove_entry remove_entry_secure].freeze
+        RESTRICT_ON_SEND = (
+          MAKE_METHODS + MAKE_FORCE_METHODS + REMOVE_METHODS + RECURSIVE_REMOVE_METHODS +
+          REMOVE_FORCE_METHODS
+        ).freeze
+
+        # @!method send_exist_node(node)
+        def_node_search :send_exist_node, <<~PATTERN
+          $(send (const {cbase nil?} {:FileTest :File :Dir :Shell}) {:exist? :exists?} ...)
+        PATTERN
+
+        # @!method receiver_and_method_name(node)
+        def_node_matcher :receiver_and_method_name, <<~PATTERN
+          (send (const {cbase nil?} $_) $_ ...)
+        PATTERN
+
+        # @!method force?(node)
+        def_node_search :force?, <<~PATTERN
+          (pair (sym :force) (:true))
+        PATTERN
+
+        # @!method explicit_not_force?(node)
+        def_node_search :explicit_not_force?, <<~PATTERN
+          (pair (sym :force) (:false))
+        PATTERN
+
+        def on_send(node)
+          return unless node.receiver&.const_type?
+          return unless if_node_child?(node)
+          return if explicit_not_force?(node)
+          return unless (exist_node = send_exist_node(node.parent).first)
+          return unless exist_node.first_argument == node.first_argument
+
+          register_offense(node, exist_node)
+        end
+
+        private
+
+        def if_node_child?(node)
+          return false unless (parent = node.parent)
+
+          parent.if_type? && !allowable_use_with_if?(parent)
+        end
+
+        def allowable_use_with_if?(if_node)
+          if_node.condition.operator_keyword? || if_node.else_branch
+        end
+
+        def register_offense(node, exist_node)
+          add_offense(node, message: message_change_force_method(node)) unless force_method?(node)
+
+          parent = node.parent
+          range = parent.loc.keyword.begin.join(parent.condition.source_range.end)
+
+          add_offense(range, message: message_remove_file_exist_check(exist_node)) do |corrector|
+            autocorrect(corrector, node, range) unless parent.elsif?
+          end
+        end
+
+        def message_change_force_method(node)
+          format(MSG_CHANGE_FORCE_METHOD, method_name: replacement_method(node))
+        end
+
+        def message_remove_file_exist_check(node)
+          receiver, method_name = receiver_and_method_name(node)
+
+          format(MSG_REMOVE_FILE_EXIST_CHECK, receiver: receiver, method_name: method_name)
+        end
+
+        def autocorrect(corrector, node, range)
+          corrector.remove(range)
+          autocorrect_replace_method(corrector, node)
+
+          if node.parent.modifier_form?
+            corrector.remove(node.source_range.end.join(node.parent.loc.keyword.begin))
+          else
+            corrector.remove(node.parent.loc.end)
+          end
+        end
+
+        def autocorrect_replace_method(corrector, node)
+          return if force_method?(node)
+
+          corrector.replace(node.child_nodes.first.loc.name, 'FileUtils')
+          corrector.replace(node.loc.selector, replacement_method(node))
+          corrector.insert_before(node.last_argument, 'mode: ') if require_mode_keyword?(node)
+        end
+
+        def replacement_method(node)
+          if MAKE_METHODS.include?(node.method_name)
+            'mkdir_p'
+          elsif REMOVE_METHODS.include?(node.method_name)
+            'rm_f'
+          elsif RECURSIVE_REMOVE_METHODS.include?(node.method_name)
+            'rm_rf'
+          else
+            node.method_name
+          end
+        end
+
+        def force_method?(node)
+          force_method_name?(node) || force_option?(node)
+        end
+
+        def require_mode_keyword?(node)
+          return false unless node.receiver.const_name == 'Dir'
+
+          replacement_method(node) == 'mkdir_p' && node.arguments.length == 2
+        end
+
+        def force_option?(node)
+          node.arguments.any? { |arg| force?(arg) }
+        end
+
+        def force_method_name?(node)
+          (MAKE_FORCE_METHODS + REMOVE_FORCE_METHODS).include?(node.method_name)
+        end
+      end
+    end
+  end
+end