rubocop 1.51.0 → 1.54.1

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks if `return` or `return nil` is used in predicate method definitions.
+      #
+      # @safety
+      #   Autocorrection is marked as unsafe because the change of the return value
+      #   from `nil` to `false` could potentially lead to incompatibility issues.
+      #
+      # @example
+      #   # bad
+      #   def foo?
+      #     return if condition
+      #
+      #     do_something?
+      #   end
+      #
+      #   # bad
+      #   def foo?
+      #     return nil if condition
+      #
+      #     do_something?
+      #   end
+      #
+      #   # good
+      #   def foo?
+      #     return false if condition
+      #
+      #     do_something?
+      #   end
+      #
+      # @example AllowedMethod: ['foo?']
+      #   # good
+      #   def foo?
+      #     return if condition
+      #
+      #     do_something?
+      #   end
+      #
+      # @example AllowedPattern: [/foo/]
+      #   # good
+      #   def foo?
+      #     return if condition
+      #
+      #     do_something?
+      #   end
+      #
+      class ReturnNilInPredicateMethodDefinition < Base
+        extend AutoCorrector
+        include AllowedMethods
+        include AllowedPattern
+
+        MSG = 'Use `return false` instead of `%<prefer>s` in the predicate method.'
+
+        # @!method return_nil?(node)
+        def_node_matcher :return_nil?, <<~PATTERN
+          {(return) (return (nil))}
+        PATTERN
+
+        def on_def(node)
+          return unless node.predicate_method?
+          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
+          return unless (body = node.body)
+
+          body.each_descendant(:return) do |return_node|
+            next unless return_nil?(return_node)
+
+            message = format(MSG, prefer: return_node.source)
+
+            add_offense(return_node, message: message) do |corrector|
+              corrector.replace(return_node, 'return false')
+            end
+          end
+        end
+        alias on_defs on_def
+      end
+    end
+  end
+end

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

@@ -84,6 +84,7 @@ module RuboCop
           }
         PATTERN
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_send(node)
           return unless (block_node = node.block_node)
           return if block_node.body&.begin_type?
@@ -91,11 +92,14 @@ module RuboCop
           return unless (regexp_method_send_node = extract_send_node(block_node))
           return if match_predicate_without_receiver?(regexp_method_send_node)
 
-          opposite = opposite?(regexp_method_send_node)
+          replacement = replacement(regexp_method_send_node, node)
+          return if target_ruby_version <= 2.2 && replacement == 'grep_v'
+
           regexp = find_regexp(regexp_method_send_node, block_node)
 
-          register_offense(node, block_node, regexp, opposite)
+          register_offense(node, block_node, regexp, replacement)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
@@ -105,9 +109,15 @@ module RuboCop
           node.hash_type? || creates_hash?(node) || env_const?(node)
         end
 
-        def register_offense(node, block_node, regexp, opposite)
-          method_name = node.method_name.to_sym
-          replacement = opposite ? OPPOSITE_REPLACEMENTS[method_name] : REPLACEMENTS[method_name]
+        def replacement(regexp_method_send_node, node)
+          opposite = opposite?(regexp_method_send_node)
+
+          method_name = node.method_name
+
+          opposite ? OPPOSITE_REPLACEMENTS[method_name] : REPLACEMENTS[method_name]
+        end
+
+        def register_offense(node, block_node, regexp, replacement)
           message = format(MSG, replacement: replacement, original_method: node.method_name)
 
           add_offense(block_node, message: message) do |corrector|

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

@@ -198,7 +198,7 @@ module RuboCop
         end
 
         def command_or_kernel_call?(name, node)
-          return unless node.method?(name)
+          return false unless node.method?(name)
 
           node.command?(name) || kernel_call?(node, name)
         end

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

@@ -135,7 +135,7 @@ module RuboCop
 
         def disallow_endless_method_style?
           endless_method_config = config.for_cop('Style/EndlessMethod')
-          return false unless endless_method_config['Enabled']
+          return true unless endless_method_config['Enabled']
 
           endless_method_config['EnforcedStyle'] == 'disallow'
         end

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

@@ -186,7 +186,9 @@ module RuboCop
           begin_pos = condition.first_argument.source_range.begin_pos
           return if end_pos > begin_pos
 
-          corrector.replace(range_between(end_pos, begin_pos), '(')
+          range = range_between(end_pos, begin_pos)
+          corrector.remove(range)
+          corrector.insert_after(range, '(')
           corrector.insert_after(condition.last_argument, ')')
         end
 

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

@@ -3,8 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      #
-      # This cop looks for uses of Perl-style global variables.
+      # Looks for uses of Perl-style global variables.
       # Correcting to global variables in the 'English' library
       # will add a require statement to the top of the file if
       # enabled by RequireEnglish config.

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the use of `YAML.load`, `YAML.safe_load`, and `YAML.parse` with
+      # `File.read` argument.
+      #
+      # NOTE: `YAML.safe_load_file` was introduced in Ruby 3.0.
+      #
+      # @example
+      #
+      #   # bad
+      #   YAML.load(File.read(path))
+      #   YAML.parse(File.read(path))
+      #
+      #   # good
+      #   YAML.load_file(path)
+      #   YAML.parse_file(path)
+      #
+      #   # bad
+      #   YAML.safe_load(File.read(path)) # Ruby 3.0 and newer
+      #
+      #   # good
+      #   YAML.safe_load_file(path)       # Ruby 3.0 and newer
+      #
+      class YAMLFileRead < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead.'
+        RESTRICT_ON_SEND = %i[load safe_load parse].freeze
+
+        # @!method yaml_file_read?(node)
+        def_node_matcher :yaml_file_read?, <<~PATTERN
+          (send
+            (const {cbase nil?} :YAML) _
+            (send
+              (const {cbase nil?} :File) :read $_) $...)
+        PATTERN
+
+        def on_send(node)
+          return if node.method?(:safe_load) && target_ruby_version <= 2.7
+          return unless (file_path, rest_arguments = yaml_file_read?(node))
+
+          range = offense_range(node)
+          rest_arguments = if rest_arguments.empty?
+                             ''
+                           else
+                             ", #{rest_arguments.map(&:source).join(', ')}"
+                           end
+          prefer = "#{node.method_name}_file(#{file_path.source}#{rest_arguments})"
+
+          add_offense(range, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(range, prefer)
+          end
+        end
+
+        private
+
+        def offense_range(node)
+          node.loc.selector.join(node.source_range.end)
+        end
+      end
+    end
+  end
+end

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

@@ -118,16 +118,18 @@ module RuboCop
           node.comparison_method? && !noncommutative_operator?(node)
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def valid_yoda?(node)
-          lhs = node.receiver
-          rhs = node.first_argument
+          return true unless (rhs = node.first_argument)
 
+          lhs = node.receiver
           return true if (constant_portion?(lhs) && constant_portion?(rhs)) ||
                          (!constant_portion?(lhs) && !constant_portion?(rhs)) ||
                          interpolation?(lhs)
 
           enforce_yoda? ? constant_portion?(lhs) : constant_portion?(rhs)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def message(node)
           format(MSG, source: node.source)

data/lib/rubocop/cop/util.rb

@@ -142,7 +142,7 @@ module RuboCop
       end
 
       def escape_string(string)
-        string.inspect[1..-2].tap { |s| s.gsub!(/\\"/, '"') }
+        string.inspect[1..-2].tap { |s| s.gsub!('\\"', '"') }
       end
 
       def to_string_literal(string)

data/lib/rubocop/cop/utils/regexp_ranges.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Utils
+      # Helper to abstract complexity of building range pairs
+      # with octal escape reconstruction (needed for regexp_parser < 2.7).
+      class RegexpRanges
+        attr_reader :compound_token, :root
+
+        def initialize(root)
+          @root = root
+          @compound_token = []
+        end
+
+        def pairs
+          unless @pairs
+            @pairs = []
+            populate(root)
+          end
+
+          # If either bound is a compound the first one is an escape
+          # and that's all we need to work with.
+          # If there are any cops that wanted to operate on the compound
+          # expression we could wrap it with a facade class.
+          @pairs.map { |pair| pair.map(&:first) }
+        end
+
+        private
+
+        def populate(expr)
+          expressions = expr.expressions.to_a
+
+          until expressions.empty?
+            current = expressions.shift
+
+            if escaped_octal?(current)
+              compound_token << current
+              compound_token.concat(pop_octal_digits(expressions))
+              # If we have all the digits we can discard.
+            end
+
+            next unless current.type == :set
+
+            process_set(expressions, current)
+            compound_token.clear
+          end
+        end
+
+        def process_set(expressions, current)
+          case current.token
+          when :range
+            @pairs << compose_range(expressions, current)
+          when :character
+            # Child expressions may include the range we are looking for.
+            populate(current)
+          when :intersection
+            # Each child expression could have child expressions that lead to ranges.
+            current.expressions.each do |intersected|
+              populate(intersected)
+            end
+          end
+        end
+
+        def compose_range(expressions, current)
+          range_start, range_end = current.expressions
+          range_start = if compound_token.size.between?(1, 2) && octal_digit?(range_start.text)
+                          compound_token.dup << range_start
+                        else
+                          [range_start]
+                        end
+          range_end = [range_end]
+          range_end.concat(pop_octal_digits(expressions)) if escaped_octal?(range_end.first)
+          [range_start, range_end]
+        end
+
+        def escaped_octal?(expr)
+          expr.text =~ /^\\[0-7]$/
+        end
+
+        def octal_digit?(char)
+          ('0'..'7').cover?(char)
+        end
+
+        def pop_octal_digits(expressions)
+          digits = []
+
+          2.times do
+            next unless (next_child = expressions.first)
+            next unless next_child.type == :literal && next_child.text =~ /^[0-7]$/
+
+            digits << expressions.shift
+          end
+
+          digits
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -63,6 +63,18 @@ module RuboCop
           meta_assignment_node.type == MULTIPLE_ASSIGNMENT_TYPE
         end
 
+        def rest_assignment?
+          return false unless meta_assignment_node
+
+          meta_assignment_node.type == REST_ASSIGNMENT_TYPE
+        end
+
+        def for_assignment?
+          return false unless meta_assignment_node
+
+          meta_assignment_node.for_type?
+        end
+
         def operator
           assignment_node = meta_assignment_node || @node
           assignment_node.loc.operator.source
@@ -70,7 +82,10 @@ module RuboCop
 
         def meta_assignment_node
           unless instance_variable_defined?(:@meta_assignment_node)
-            @meta_assignment_node = operator_assignment_node || multiple_assignment_node
+            @meta_assignment_node = operator_assignment_node ||
+                                    multiple_assignment_node ||
+                                    rest_assignment_node ||
+                                    for_assignment_node
           end
 
           @meta_assignment_node
@@ -87,13 +102,37 @@ module RuboCop
         end
 
         def multiple_assignment_node
-          grandparent_node = node.parent&.parent
-          return nil unless grandparent_node
+          return nil unless (grandparent_node = node.parent&.parent)
+          if (node = find_multiple_assignment_node(grandparent_node))
+            return node
+          end
           return nil unless grandparent_node.type == MULTIPLE_ASSIGNMENT_TYPE
-          return nil unless node.parent.type == MULTIPLE_LEFT_HAND_SIDE_TYPE
 
           grandparent_node
         end
+
+        def rest_assignment_node
+          return nil unless node.parent
+          return nil unless node.parent.type == REST_ASSIGNMENT_TYPE
+
+          node.parent
+        end
+
+        def for_assignment_node
+          return nil unless node.parent&.for_type?
+
+          node.parent
+        end
+
+        def find_multiple_assignment_node(grandparent_node)
+          return unless grandparent_node.type == MULTIPLE_LEFT_HAND_SIDE_TYPE
+          return if grandparent_node.children.any?(&:splat_type?)
+
+          parent = grandparent_node.parent
+          return parent if parent.type == MULTIPLE_ASSIGNMENT_TYPE
+
+          find_multiple_assignment_node(parent)
+        end
       end
     end
   end

data/lib/rubocop/cop/variable_force.rb

@@ -40,6 +40,7 @@ module RuboCop
       OPERATOR_ASSIGNMENT_TYPES = (LOGICAL_OPERATOR_ASSIGNMENT_TYPES + [:op_asgn]).freeze
 
       MULTIPLE_ASSIGNMENT_TYPE = :masgn
+      REST_ASSIGNMENT_TYPE = :splat
 
       VARIABLE_REFERENCE_TYPE = :lvar
 

data/lib/rubocop/cops_documentation_generator.rb

@@ -198,7 +198,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     table = ['|===', "| #{header.join(' | ')}\n\n"].join("\n")
     marked_contents = content.map do |plain_content|
       # Escape `|` with backslash to prevent the regexp `|` is not used as a table separator.
-      plain_content.map { |c| "| #{c.gsub(/\|/, '\|')}" }.join("\n")
+      plain_content.map { |c| "| #{c.gsub('|', '\|')}" }.join("\n")
     end
     table << marked_contents.join("\n\n")
     table << "\n|===\n"

data/lib/rubocop/ext/regexp_parser.rb

@@ -68,7 +68,9 @@ module RuboCop
             return { body: expression } unless (q = quantifier)
 
             body = expression.adjust(end_pos: -q.text.length)
-            q_loc = expression.with(begin_pos: body.end_pos)
+            q.origin = origin
+            q.source = source if q.respond_to?(:source=) # for regexp_parser 1.8
+            q_loc = q.expression
             { body: body, quantifier: q_loc }
           end
         end
@@ -86,6 +88,7 @@ module RuboCop
         end
       end
       ::Regexp::Expression::Base.include Expression::Base
+      ::Regexp::Expression::Quantifier.include Expression::Base
       ::Regexp::Expression::CharacterSet.include Expression::CharacterSet
     end
   end

data/lib/rubocop/lsp/logger.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module Lsp
+    # Log for Language Server Protocol of RuboCop.
+    # @api private
+    class Logger
+      def self.log(message)
+        warn("[server] #{message}")
+      end
+    end
+  end
+end