rubocop 1.48.1 → 1.50.0

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

@@ -111,7 +111,7 @@ module RuboCop
           return if comments.none?
 
           regexp = comment_regexp(arg_node)
-          comments.any? { |comment| regexp.match?(comment) } || regexp.match?(comments.join)
+          comments.any?(regexp) || regexp.match?(comments.join)
         end
 
         def preceding_comment_blocks(node)

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

@@ -103,12 +103,12 @@ module RuboCop
         def find_def_node_from_ascendant(node)
           return unless (parent = node.parent)
           return parent if parent.def_type? || parent.defs_type?
-          return node.parent.child_nodes.first if define_mehod?(parent)
+          return node.parent.child_nodes.first if define_method?(parent)
 
           find_def_node_from_ascendant(node.parent)
         end
 
-        def define_mehod?(node)
+        def define_method?(node)
           return false unless node.block_type?
 
           child = node.child_nodes.first

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

@@ -6,9 +6,9 @@ module RuboCop
       # Prefer to use `File.empty?('path/to/file')` when checking if a file is empty.
       #
       # @safety
-      #   This cop's autocorrection is unsafe it because `File.size`, `File.read`,
-      #   and `File.binread` raise `ENOENT` exception when there is no file
-      #   corresponding to the path, while `File.empty?` does not raise an exception.
+      #   This cop is unsafe, because `File.size`, `File.read`, and `File.binread`
+      #   raise `ENOENT` exception when there is no file corresponding to the path,
+      #   while `File.empty?` does not raise an exception.
       #
       # @example
       #   # bad

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

@@ -148,7 +148,7 @@ module RuboCop
         end
 
         def frozen_string_literal_comment(processed_source)
-          processed_source.find_token do |token|
+          processed_source.tokens.find do |token|
             token.text.start_with?(FROZEN_STRING_LITERAL)
           end
         end

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

@@ -122,8 +122,8 @@ module RuboCop
         end
 
         def safe_to_register_offense?(block, except_key)
-          extracted = extract_body_if_nagated(block.body)
-          if extracted.method?('in?') || extracted.method?('include?') || \
+          extracted = extract_body_if_negated(block.body)
+          if extracted.method?('in?') || extracted.method?('include?') ||
              extracted.method?('exclude?')
             return true
           end
@@ -132,7 +132,7 @@ module RuboCop
           except_key.sym_type? || except_key.str_type?
         end
 
-        def extract_body_if_nagated(body)
+        def extract_body_if_negated(body)
           return body unless body.method?('!')
 
           body.receiver
@@ -161,7 +161,7 @@ module RuboCop
 
         def except_key(node)
           key_argument = node.argument_list.first.source
-          body = extract_body_if_nagated(node.body)
+          body = extract_body_if_negated(node.body)
           lhs, _method_name, rhs = *body
           return if [lhs, rhs].map(&:source).none?(key_argument)
 

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

@@ -88,6 +88,9 @@ module RuboCop
       #   {foo: foo, bar: bar}
       #
       #   # good
+      #   {foo: foo, bar:}
+      #
+      #   # good
       #   {foo:, bar:}
       #
       # @example EnforcedShorthandSyntax: consistent
@@ -207,7 +210,7 @@ module RuboCop
           return true if /\A[_a-z]\w*[?!]?\z/i.match?(sym_name)
 
           # For more complicated hash keys, let the parser validate the syntax.
-          ProcessedSource.new("{ #{sym_name}: :foo }", target_ruby_version).valid_syntax?
+          parse("{ #{sym_name}: :foo }").valid_syntax?
         end
 
         def check(pairs, delim, msg)

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

@@ -11,6 +11,18 @@ module RuboCop
       # cop. The tab size is configured in the `IndentationWidth` of the
       # `Layout/IndentationStyle` cop.
       #
+      # One-line pattern matching is always allowed. To ensure that there are few cases
+      # where the match variable is not used, and to prevent oversights. The variable `x`
+      # becomes undefined and raises `NameError` when the following example is changed to
+      # the modifier form:
+      #
+      # [source,ruby]
+      # ----
+      # if [42] in [x]
+      #   x # `x` is undefined when using modifier form.
+      # end
+      # ----
+      #
       # NOTE: It is allowed when `defined?` argument has an undefined value,
       # because using the modifier form causes the following incompatibility:
       #
@@ -66,14 +78,10 @@ module RuboCop
         end
 
         def on_if(node)
-          return if defined_nodes(node).any? { |n| defined_argument_is_undefined?(node, n) }
-
-          msg = if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
-                  MSG_USE_MODIFIER
-                elsif too_long_due_to_modifier?(node)
-                  MSG_USE_NORMAL
-                end
-          return unless msg
+          condition = node.condition
+          return if defined_nodes(condition).any? { |n| defined_argument_is_undefined?(node, n) } ||
+                    pattern_matching_nodes(condition).any?
+          return unless (msg = message(node))
 
           add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
             autocorrect(corrector, node)
@@ -82,11 +90,11 @@ module RuboCop
 
         private
 
-        def defined_nodes(node)
-          if node.condition.defined_type?
-            [node.condition]
+        def defined_nodes(condition)
+          if condition.defined_type?
+            [condition]
           else
-            node.condition.each_descendant.select(&:defined_type?)
+            condition.each_descendant.select(&:defined_type?)
           end
         end
 
@@ -100,6 +108,24 @@ module RuboCop
           end
         end
 
+        def pattern_matching_nodes(condition)
+          if condition.match_pattern_type? || condition.match_pattern_p_type?
+            [condition]
+          else
+            condition.each_descendant.select do |node|
+              node.match_pattern_type? || node.match_pattern_p_type?
+            end
+          end
+        end
+
+        def message(node)
+          if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
+            MSG_USE_MODIFIER
+          elsif too_long_due_to_modifier?(node)
+            MSG_USE_NORMAL
+          end
+        end
+
         def autocorrect(corrector, node)
           replacement = if node.modifier_form?
                           replacement_for_modifier_form(corrector, node)

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

@@ -39,7 +39,10 @@ module RuboCop
 
         # @!method map_to_h?(node)
         def_node_matcher :map_to_h?, <<~PATTERN
-          $(send (block $(send _ {:map :collect}) ...) :to_h)
+          {
+            $(send ({block numblock} $(send _ {:map :collect}) ...) :to_h)
+            $(send $(send _ {:map :collect} (block_pass sym)) :to_h)
+          }
         PATTERN
 
         def on_send(node)

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

@@ -32,7 +32,10 @@ module RuboCop
 
         # @!method map_to_set?(node)
         def_node_matcher :map_to_set?, <<~PATTERN
-          $(send (block $(send _ {:map :collect}) ...) :to_set)
+          {
+            $(send ({block numblock} $(send _ {:map :collect}) ...) :to_set)
+            $(send $(send _ {:map :collect} (block_pass sym)) :to_set)
+          }
         PATTERN
 
         def on_send(node)

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -50,17 +50,13 @@ module RuboCop
             return false unless (last_argument = node.last_argument)
             return false if !last_argument.hash_type? || !last_argument.pairs.last&.value_omission?
 
-            modifier_form?(node) || exist_next_line_expression?(node)
-          end
-
-          def modifier_form?(node)
-            node.parent.respond_to?(:modifier_form?) && node.parent.modifier_form?
+            node.parent&.conditional? || !last_expression?(node)
           end
 
           # Require hash value omission be enclosed in parentheses to prevent the following issue:
           # https://bugs.ruby-lang.org/issues/18396.
-          def exist_next_line_expression?(node)
-            node.parent&.assignment? ? node.parent.right_sibling : node.right_sibling
+          def last_expression?(node)
+            !(node.parent&.assignment? ? node.parent.right_sibling : node.right_sibling)
           end
 
           def syntax_like_method_call?(node)

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

@@ -7,21 +7,19 @@ module RuboCop
       # method calls containing parameters.
       #
       # In the default style (require_parentheses), macro methods are allowed.
-      # Additional methods can be added to the `AllowedMethods`
-      # or `AllowedPatterns` list. These options are
-      # valid only in the default style. Macros can be included by
-      # either setting `IgnoreMacros` to false or adding specific macros to
-      # the `IncludedMacros` list.
+      # Additional methods can be added to the `AllowedMethods` or
+      # `AllowedPatterns` list. These options are valid only in the default
+      # style. Macros can be included by either setting `IgnoreMacros` to false
+      # or adding specific macros to the `IncludedMacros` list.
       #
-      # Precedence of options is all follows:
+      # Precedence of options is as follows:
       #
       # 1. `AllowedMethods`
       # 2. `AllowedPatterns`
       # 3. `IncludedMacros`
       #
-      # eg. If a method is listed in both
-      # `IncludedMacros` and `AllowedMethods`, then the latter takes
-      # precedence (that is, the method is allowed).
+      # If a method is listed in both `IncludedMacros` and `AllowedMethods`,
+      # then the latter takes precedence (that is, the method is allowed).
       #
       # In the alternative style (omit_parentheses), there are three additional
       # options.
@@ -40,14 +38,29 @@ module RuboCop
       #     to `true` allows the presence of parentheses in such a method call
       #     even with arguments.
       #
-      # NOTE: Parentheses are still allowed in cases where omitting them
-      # results in ambiguous or syntactically incorrect code. For example,
-      # parentheses are required around a method with arguments when inside an
-      # endless method definition introduced in Ruby 3.0. Parentheses are also
-      # allowed when forwarding arguments with the triple-dot syntax introduced
-      # in Ruby 2.7 as omitting them starts an endless range.
-      # And Ruby 3.1's hash omission syntax has a case that requires parentheses
-      # because of the following issue: https://bugs.ruby-lang.org/issues/18396.
+      # NOTE: The style of `omit_parentheses` allows parentheses in cases where
+      # omitting them results in ambiguous or syntactically incorrect code.
+      #
+      # Non-exhaustive list of examples:
+      #
+      # - Parentheses are required allowed in method calls with arguments inside
+      #   literals, logical operators, setting default values in position and
+      #   keyword arguments, chaining and more.
+      # - Parentheses are allowed in method calls with arguments inside
+      #   operators to avoid ambiguity.
+      #   triple-dot syntax introduced in Ruby 2.7 as omitting them starts an
+      #   endless range.
+      # - Parentheses are allowed when forwarding arguments with the
+      #   triple-dot syntax introduced in Ruby 2.7 as omitting them starts an
+      #   endless range.
+      # - Parentheses are required in calls with arguments when inside an
+      #   endless method definition introduced in Ruby 3.0.
+      # - Ruby 3.1's hash omission syntax allows parentheses if the method call
+      #   is in conditionals and requires parentheses if the call
+      #   is not the value-returning expression. See
+      #   https://bugs.ruby-lang.org/issues/18396.
+      # - Parentheses are required in anonymous arguments, keyword arguments
+      #   and block passing in Ruby 3.2.
       #
       # @example EnforcedStyle: require_parentheses (default)
       #
@@ -80,34 +93,28 @@ module RuboCop
       #   array.delete e
       #
       #   # bad
-      #   foo.enforce(strict: true)
+      #   action.enforce(strict: true)
       #
       #   # good
-      #   foo.enforce strict: true
+      #   action.enforce strict: true
       #
       #   # good
-      #   # Allows parens for calls that won't produce valid Ruby or be ambiguous.
-      #   model.validate strict(true)
+      #   # Parentheses are allowed for code that can be ambiguous without
+      #   # them.
+      #   action.enforce(condition) || other_condition
       #
       #   # good
-      #   # Allows parens for calls that won't produce valid Ruby or be ambiguous.
+      #   # Parentheses are allowed for calls that won't produce valid Ruby
+      #   # without them.
       #   yield path, File.basename(path)
       #
       #   # good
-      #   # Operators methods calls with parens
-      #   array&.[](index)
-      #
-      #   # good
-      #   # Operators methods without parens, if you prefer
-      #   array.[] index
-      #
-      #   # good
-      #   # Operators methods calls with parens
-      #   array&.[](index)
-      #
-      #   # good
-      #   # Operators methods without parens, if you prefer
-      #   array.[] index
+      #   # Omitting the parentheses in Ruby 3.1 hash omission syntax can lead
+      #   # to ambiguous code. We allow them in conditionals and non-last
+      #   # expressions. See https://bugs.ruby-lang.org/issues/18396
+      #   if meets(criteria:, action:)
+      #     safe_action(action) || dangerous_action(action)
+      #   end
       #
       # @example IgnoreMacros: true (default)
       #

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

@@ -28,14 +28,17 @@ module RuboCop
           return unless node.arguments?
           return if opening_line(node) == closing_line(node)
           return if correction_exceeds_max_line_length?(node)
+          return unless (begin_of_arguments = node.arguments.loc.begin)
 
-          add_offense(node) { |corrector| autocorrect(corrector, node) }
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node, begin_of_arguments)
+          end
         end
         alias on_defs on_def
 
         private
 
-        def autocorrect(corrector, node)
+        def autocorrect(corrector, node, begin_of_arguments)
           arguments = node.arguments
           joined_arguments = arguments.map(&:source).join(', ')
           last_line_source_of_arguments = last_line_source_of_arguments(arguments)
@@ -47,7 +50,7 @@ module RuboCop
           end
 
           corrector.remove(arguments_range(node))
-          corrector.insert_after(arguments.loc.begin, joined_arguments)
+          corrector.insert_after(begin_of_arguments, joined_arguments)
         end
 
         def last_line_source_of_arguments(arguments)

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

@@ -92,9 +92,8 @@ module RuboCop
 
         def contains_delimiter?(node, delimiters)
           delimiters_regexp = Regexp.union(delimiters)
-          node
-            .children.map { |n| string_source(n) }.compact
-            .any? { |s| delimiters_regexp.match?(s) }
+
+          node.children.map { |n| string_source(n) }.compact.any?(delimiters_regexp)
         end
 
         def string_source(node)

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

@@ -44,7 +44,7 @@ module RuboCop
 
           # Report offense only if changing case doesn't change semantics,
           # i.e., if the string would become dynamic or has special characters.
-          ast = ProcessedSource.new(corrected(node.source), target_ruby_version).ast
+          ast = parse(corrected(node.source)).ast
           return if node.children != ast.children
 
           add_offense(node.loc.begin) do |corrector|

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

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Check for redundant line continuation.
+      #
+      # This cop marks a line continuation as redundant if removing the backslash
+      # does not result in a syntax error.
+      # However, a backslash at the end of a comment or
+      # for string concatenation is not redundant and is not considered an offense.
+      #
+      # @example
+      #   # bad
+      #   foo. \
+      #     bar
+      #   foo \
+      #     &.bar \
+      #       .baz
+      #
+      #   # good
+      #   foo.
+      #     bar
+      #   foo
+      #     &.bar
+      #       .baz
+      #
+      #   # bad
+      #   [foo, \
+      #     bar]
+      #   {foo: \
+      #     bar}
+      #
+      #   # good
+      #   [foo,
+      #     bar]
+      #   {foo:
+      #     bar}
+      #
+      #   # bad
+      #   foo(bar, \
+      #     baz)
+      #
+      #   # good
+      #   foo(bar,
+      #     baz)
+      #
+      #   # also good - backslash in string concatenation is not redundant
+      #   foo('bar' \
+      #     'baz')
+      #
+      #   # also good - backslash at the end of a comment is not redundant
+      #   foo(bar, # \
+      #     baz)
+      #
+      #   # also good - backslash at the line following the newline begins with a + or -,
+      #   # it is not redundant
+      #   1 \
+      #     + 2 \
+      #       - 3
+      #
+      #   # also good - backslash with newline between the method name and its arguments,
+      #   # it is not redundant.
+      #   some_method \
+      #     (argument)
+      #
+      class RedundantLineContinuation < Base
+        include MatchRange
+        extend AutoCorrector
+
+        MSG = 'Redundant line continuation.'
+        ALLOWED_STRING_TOKENS = %i[tSTRING tSTRING_CONTENT].freeze
+
+        def on_new_investigation
+          return unless processed_source.ast
+
+          each_match_range(processed_source.ast.source_range, /(\\\n)/) do |range|
+            next if require_line_continuation?(range)
+            next unless redundant_line_continuation?(range)
+
+            add_offense(range) do |corrector|
+              corrector.remove_leading(range, 1)
+            end
+          end
+        end
+
+        private
+
+        def require_line_continuation?(range)
+          !ends_with_backslash_without_comment?(range.source_line) ||
+            string_concatenation?(range.source_line) ||
+            start_with_arithmetic_operator?(processed_source[range.line]) ||
+            inside_string_literal?(range)
+        end
+
+        def ends_with_backslash_without_comment?(source_line)
+          source_line.gsub(/#.+/, '').end_with?('\\')
+        end
+
+        def string_concatenation?(source_line)
+          /["']\s*\\\z/.match?(source_line)
+        end
+
+        def inside_string_literal?(range)
+          processed_source.tokens.each.any? do |token|
+            ALLOWED_STRING_TOKENS.include?(token.type) && token.pos.overlaps?(range)
+          end
+        end
+
+        def redundant_line_continuation?(range)
+          return true unless (node = find_node_for_line(range.line))
+          return false if argument_newline?(node)
+
+          source = node.parent ? node.parent.source : node.source
+          parse(source.gsub(/\\\n/, "\n")).valid_syntax?
+        end
+
+        def argument_newline?(node)
+          node = node.children.first if node.root? && node.begin_type?
+
+          if argument_is_method?(node)
+            argument_newline?(node.first_argument)
+          else
+            return false unless method_call_with_arguments?(node)
+
+            node.loc.selector.line != node.first_argument.loc.line
+          end
+        end
+
+        def find_node_for_line(line)
+          processed_source.ast.each_node do |node|
+            return node if same_line?(node, line)
+          end
+        end
+
+        def same_line?(node, line)
+          return unless (source_range = node.source_range)
+
+          if node.is_a?(AST::StrNode)
+            if node.heredoc?
+              (node.loc.heredoc_body.line..node.loc.heredoc_body.last_line).cover?(line)
+            else
+              (source_range.line..source_range.last_line).cover?(line)
+            end
+          else
+            source_range.line == line
+          end
+        end
+
+        def argument_is_method?(node)
+          return false unless node.send_type?
+          return false unless (first_argument = node.first_argument)
+
+          method_call_with_arguments?(first_argument)
+        end
+
+        def method_call_with_arguments?(node)
+          node.call_type? && !node.arguments.empty?
+        end
+
+        def start_with_arithmetic_operator?(source_line)
+          %r{\A\s*[+\-*/%]}.match?(source_line)
+        end
+      end
+    end
+  end
+end

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

@@ -98,7 +98,7 @@ module RuboCop
         end
 
         def like_method_argument_parentheses?(node)
-          node.send_type? && node.arguments.one? &&
+          node.send_type? && node.arguments.one? && !node.parenthesized? &&
             !node.arithmetic_operation? && node.first_argument.begin_type?
         end
 

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

@@ -93,7 +93,7 @@ module RuboCop
 
           return true if STRING_INTERPOLATION_REGEXP.match?(src)
 
-          src.scan(/\\./).any? { |s| ESCAPED_NON_BACKSLASH.match?(s) }
+          src.scan(/\\./).any?(ESCAPED_NON_BACKSLASH)
         end
 
         def acceptable_capital_q?(node)

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

@@ -63,7 +63,7 @@ module RuboCop
             next if expr.type != :set || expr.expressions.size != 1
             next if expr.negative?
             next if %i[set posixclass nonposixclass].include?(expr.expressions.first.type)
-            next if multiple_codepoins?(expr.expressions.first)
+            next if multiple_codepoints?(expr.expressions.first)
 
             yield expr
           end
@@ -80,7 +80,7 @@ module RuboCop
           !non_redundant
         end
 
-        def multiple_codepoins?(expression)
+        def multiple_codepoints?(expression)
           expression.respond_to?(:codepoints) && expression.codepoints.count >= 2
         end
 

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

@@ -107,7 +107,7 @@ module RuboCop
             end
           end
         # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped.
-        # It's for compatibility with regexp_arser 1.8 and will never be maintained.
+        # It's for compatibility with regexp_parser 1.8 and will never be maintained.
         else
           def each_escape(node)
             node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|

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

@@ -36,7 +36,6 @@ module RuboCop
       #   STR
       class RedundantStringEscape < Base
         include MatchRange
-        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Redundant escape of %<char>s inside string literal.'
@@ -64,10 +63,10 @@ module RuboCop
         def str_contents_range(node)
           if heredoc?(node)
             node.loc.heredoc_body
+          elsif node.str_type?
+            node.source_range
           elsif begin_loc_present?(node)
             contents_range(node)
-          else
-            node.source_range
           end
         end
 

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

@@ -167,7 +167,7 @@ module RuboCop
           corrector.insert_before(condition,
                                   "#{'!' if node.unless?}#{replace_condition(node.condition)} && ")
 
-          corrector.remove(node.condition.source_range)
+          corrector.remove(node.condition)
           corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
           corrector.replace(if_branch.loc.keyword, 'if')
         end
@@ -187,7 +187,7 @@ module RuboCop
           return if end_pos > begin_pos
 
           corrector.replace(range_between(end_pos, begin_pos), '(')
-          corrector.insert_after(condition.last_argument.source_range, ')')
+          corrector.insert_after(condition.last_argument, ')')
         end
 
         def insert_bang(corrector, node, is_modify_form)

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

@@ -55,7 +55,7 @@ module RuboCop
           elsif (class_node = parent.parent).body.nil?
             corrector.remove(range_for_empty_class_body(class_node, parent))
           else
-            corrector.insert_after(parent.source_range, ' do')
+            corrector.insert_after(parent, ' do')
           end
         end
 

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

@@ -34,6 +34,7 @@ module RuboCop
             )
           end
         end
+        alias on_sclass on_class
       end
     end
   end