rubocop 1.66.0 → 1.72.1

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

@@ -78,38 +78,67 @@ module RuboCop
           return unless node.arguments.one?
 
           range_node = node.first_argument
-          selector = node.loc.selector
-          unless (message, removal_range = offense_message_with_removal_range(range_node, selector))
-            return
-          end
+          offense_range = find_offense_range(node)
+          return unless (message, removal_range =
+                           offense_message_with_removal_range(node, range_node, offense_range))
+
+          # Changing the range to beginningless or endless when unparenthesized
+          # changes the semantics of the code, and thus will not be considered
+          # an offense.
+          return if removal_range != offense_range && unparenthesized_call?(node)
 
-          add_offense(selector, message: message) do |corrector|
+          add_offense(offense_range, message: message) do |corrector|
             corrector.remove(removal_range)
           end
         end
+        alias on_csend on_send
 
         private
 
-        def offense_message_with_removal_range(range_node, selector)
+        def unparenthesized_call?(node)
+          node.loc.dot && !node.parenthesized?
+        end
+
+        def find_offense_range(node)
+          if node.loc.dot
+            node.loc.dot.join(node.source_range.end)
+          else
+            node.loc.selector
+          end
+        end
+
+        def offense_message_with_removal_range(node, range_node, offense_range)
           if range_from_zero_till_minus_one?(range_node)
-            [format(MSG_USELESS_RANGE, prefer: selector.source), selector]
+            [format(MSG_USELESS_RANGE, prefer: offense_range.source), offense_range]
           elsif range_till_minus_one?(range_node)
             [
-              format(MSG, prefer: endless(range_node), current: selector.source), range_node.end
+              offense_message_for_partial_range(node, endless(range_node), offense_range),
+              range_node.end
             ]
           elsif range_from_zero?(range_node) && target_ruby_version >= 2.7
             [
-              format(MSG, prefer: beginless(range_node), current: selector.source), range_node.begin
+              offense_message_for_partial_range(node, beginless(range_node), offense_range),
+              range_node.begin
             ]
           end
         end
 
+        def offense_message_for_partial_range(node, prefer, offense_range)
+          current = node.loc.dot ? arguments_source(node) : offense_range.source
+          prefer = "[#{prefer}]" unless node.loc.dot
+          format(MSG, prefer: prefer, current: current)
+        end
+
         def endless(range_node)
-          "[#{range_node.begin.source}#{range_node.loc.operator.source}]"
+          "#{range_node.begin.source}#{range_node.loc.operator.source}"
         end
 
         def beginless(range_node)
-          "[#{range_node.loc.operator.source}#{range_node.end.source}]"
+          "#{range_node.loc.operator.source}#{range_node.end.source}"
+        end
+
+        def arguments_source(node)
+          node.first_argument.source_range.join(node.last_argument.source_range.end).source
         end
       end
     end

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

@@ -156,7 +156,7 @@ module RuboCop
           # Handle `send` and `block` nodes that need to be wrapped in parens
           # FIXME: autocorrection prevents syntax errors by wrapping the entire node in parens,
           #        but wrapping the argument list would be a more ergonomic correction.
-          node_to_check = condition&.block_type? ? condition.send_node : condition
+          node_to_check = condition&.any_block_type? ? condition.send_node : condition
           return unless wrap_condition?(node_to_check)
 
           if condition.call_type?
@@ -214,7 +214,7 @@ module RuboCop
         end
 
         def insert_bang_for_and(corrector, node)
-          lhs, rhs = *node
+          lhs, rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring
 
           if lhs.and_type?
             insert_bang_for_and(corrector, lhs)
@@ -237,14 +237,13 @@ module RuboCop
         end
 
         def wrap_condition?(node)
-          node.and_type? || node.or_type? ||
-            (node.call_type? && node.arguments.any? && !node.parenthesized?)
+          node.operator_keyword? || (node.call_type? && node.arguments.any? && !node.parenthesized?)
         end
 
         def replace_condition(condition)
           return condition.source unless wrap_condition?(condition)
 
-          if condition.call_type?
+          if condition.call_type? && !condition.comparison_method?
             parenthesized_method_arguments(condition)
           else
             "(#{condition.source})"

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

@@ -149,7 +149,7 @@ module RuboCop
         end
 
         def on_gvar(node)
-          global_var, = *node
+          global_var = node.name
 
           return unless (preferred = preferred_names(global_var))
 

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

@@ -51,7 +51,6 @@ module RuboCop
       #   Pathname.new('/') + 'test'
       #
       class StringConcatenation < Base
-        include Util
         include RangeHelp
         extend AutoCorrector
 
@@ -133,7 +132,7 @@ module RuboCop
         end
 
         def heredoc?(node)
-          return false unless node.str_type? || node.dstr_type?
+          return false unless node.type?(:str, :dstr)
 
           node.heredoc?
         end
@@ -143,22 +142,24 @@ module RuboCop
         end
 
         def replacement(parts)
-          interpolated_parts =
-            parts.map do |part|
-              case part.type
-              when :str
-                value = part.value
-                single_quoted?(part) ? value.gsub(/(\\|")/, '\\\\\&') : value.inspect[1..-2]
-              when :dstr
-                contents_range(part).source
-              else
-                "\#{#{part.source}}"
-              end
+          interpolated_parts = parts.map do |part|
+            case part.type
+            when :str
+              adjust_str(part)
+            when :dstr
+              part.children.all?(&:str_type?) ? adjust_str(part) : contents_range(part).source
+            else
+              "\#{#{part.source}}"
             end
+          end
 
           "\"#{handle_quotes(interpolated_parts).join}\""
         end
 
+        def adjust_str(node)
+          single_quoted?(node) ? node.value.gsub(/(\\|")/, '\\\\\&') : node.value.inspect[1..-2]
+        end
+
         def handle_quotes(parts)
           parts.map do |part|
             part == '"' ? '\"' : part

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

@@ -69,7 +69,7 @@ module RuboCop
         end
 
         def all_string_literals?(nodes)
-          nodes.all? { |n| n.str_type? || n.dstr_type? }
+          nodes.all? { |n| n.type?(:str, :dstr) }
         end
 
         def detect_quote_styles(node)

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Enforces the use of consistent method names
-      # from the String class.
+      # from the `String` class.
       #
       # @example
       #   # bad

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

@@ -33,7 +33,7 @@ module RuboCop
         def on_class(node)
           return unless struct_constructor?(node.parent_class)
 
-          add_offense(node.parent_class.source_range) do |corrector|
+          add_offense(node.parent_class) do |corrector|
             corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
             corrector.replace(node.loc.operator, '=')
 

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

@@ -23,6 +23,10 @@ module RuboCop
       # `define_method`, therefore, `super` used within these blocks will be allowed.
       # This approach might result in false negatives, yet ensuring safe detection takes precedence.
       #
+      # NOTE: When forwarding the same arguments but replacing the block argument with a new inline
+      # block, it is not necessary to explicitly list the non-block arguments. As such, an offense
+      # will be registered in this case.
+      #
       # @example
       #   # bad
       #   def method(*args, **kwargs)
@@ -44,6 +48,16 @@ module RuboCop
       #     super()
       #   end
       #
+      #   # bad - forwarding with overridden block
+      #   def method(*args, **kwargs, &block)
+      #     super(*args, **kwargs) { do_something }
+      #   end
+      #
+      #   # good - implicitly passing all non-block arguments
+      #   def method(*args, **kwargs, &block)
+      #     super { do_something }
+      #   end
+      #
       #   # good - assigning to the block variable before calling super
       #   def method(&block)
       #     # Assigning to the block variable would pass the old value to super,
@@ -58,46 +72,77 @@ module RuboCop
         ASSIGN_TYPES = %i[or_asgn lvasgn].freeze
 
         MSG = 'Call `super` without arguments and parentheses when the signature is identical.'
+        MSG_INLINE_BLOCK = 'Call `super` without arguments and parentheses when all positional ' \
+                           'and keyword arguments are forwarded.'
 
         def on_super(super_node)
-          def_node = super_node.ancestors.find do |node|
+          return unless (def_node = find_def_node(super_node))
+
+          def_node_args = def_node.arguments.argument_list
+          super_args = preprocess_super_args(super_node.arguments)
+
+          return unless arguments_identical?(def_node, super_node, def_node_args, super_args)
+
+          # If the number of arguments to the def node and super node are different here,
+          # it's because the block argument is not forwarded.
+          message = def_node_args.size == super_args.size ? MSG : MSG_INLINE_BLOCK
+          add_offense(super_node, message: message) do |corrector|
+            corrector.replace(super_node, 'super')
+          end
+        end
+
+        private
+
+        def find_def_node(super_node)
+          super_node.ancestors.find do |node|
             # When defining dynamic methods, implicitly calling `super` is not possible.
             # Since there is a possibility of delegation to `define_method`,
             # `super` used within the block is always allowed.
-            break if node.block_type?
+            break if node.any_block_type? && !block_sends_to_super?(super_node, node)
 
             break node if DEF_TYPES.include?(node.type)
           end
-          return unless def_node
-          return unless arguments_identical?(def_node, def_node.arguments.argument_list,
-                                             super_node.arguments)
-
-          add_offense(super_node) { |corrector| corrector.replace(super_node, 'super') }
         end
 
-        private
-
         # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def arguments_identical?(def_node, def_args, super_args)
-          super_args = preprocess_super_args(super_args)
-          return false if def_args.size != super_args.size
+        def arguments_identical?(def_node, super_node, def_args, super_args)
+          return false if argument_list_size_differs?(def_args, super_args, super_node)
 
           def_args.zip(super_args).each do |def_arg, super_arg|
             next if positional_arg_same?(def_arg, super_arg)
             next if positional_rest_arg_same(def_arg, super_arg)
             next if keyword_arg_same?(def_arg, super_arg)
             next if keyword_rest_arg_same?(def_arg, super_arg)
-            next if block_arg_same?(def_node, def_arg, super_arg)
+            next if block_arg_same?(def_node, super_node, def_arg, super_arg)
             next if forward_arg_same?(def_arg, super_arg)
 
             return false
           end
+
           true
         end
         # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
+        def argument_list_size_differs?(def_args, super_args, super_node)
+          # If the def node has a block argument and the super node has an explicit block,
+          # the number of arguments is the same, so ignore the def node block arg.
+          def_args_size = def_args.size
+          def_args_size -= 1 if def_args.any?(&:blockarg_type?) && block_sends_to_super?(super_node)
+
+          def_args_size != super_args.size
+        end
+
+        def block_sends_to_super?(super_node, parent_node = super_node.parent)
+          # Checks if the send node of a block is the given super node,
+          # or a method chain containing it.
+          return false unless parent_node
+          return false unless parent_node.any_block_type?
+
+          parent_node.send_node.each_node(:super).any?(super_node)
+        end
+
         def positional_arg_same?(def_arg, super_arg)
-          return false unless def_arg.arg_type? || def_arg.optarg_type?
+          return false unless def_arg.type?(:arg, :optarg)
           return false unless super_arg.lvar_type?
 
           def_arg.name == super_arg.children.first
@@ -114,7 +159,7 @@ module RuboCop
         end
 
         def keyword_arg_same?(def_arg, super_arg)
-          return false unless def_arg.kwarg_type? || def_arg.kwoptarg_type?
+          return false unless def_arg.type?(:kwarg, :kwoptarg)
           return false unless (pair_node = super_arg).pair_type?
           return false unless (sym_node = pair_node.key).sym_type?
           return false unless (lvar_node = pair_node.value).lvar_type?
@@ -133,8 +178,11 @@ module RuboCop
           def_arg.name == lvar_node.children.first
         end
 
-        def block_arg_same?(def_node, def_arg, super_arg)
-          return false unless def_arg.blockarg_type? && super_arg.block_pass_type?
+        def block_arg_same?(def_node, super_node, def_arg, super_arg)
+          return false unless def_arg.blockarg_type?
+          return true if block_sends_to_super?(super_node)
+          return false unless super_arg.block_pass_type?
+
           # anonymous forwarding
           return true if (block_pass_child = super_arg.children.first).nil? && def_arg.name.nil?
 

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

@@ -79,26 +79,15 @@ module RuboCop
         end
 
         def lhs(node)
-          case node.type
-          when :casgn
-            namespace, name, = *node
-            if namespace
-              "#{namespace.const_name}::#{name}"
-            else
-              name.to_s
-            end
+          if node.casgn_type?
+            "#{'::' if node.absolute?}#{node.const_name}"
           else
-            node.children[0].to_s
+            node.name.to_s
           end
         end
 
         def rhs(node)
-          case node.type
-          when :casgn
-            node.children[2].source
-          else
-            node.children[1].source
-          end
+          node.expression.source
         end
 
         def correction_range(tmp_assign, y_assign)

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

@@ -75,7 +75,7 @@ module RuboCop
 
           message = message(node)
 
-          add_offense(node.source_range, message: message) do |corrector|
+          add_offense(node, message: message) do |corrector|
             autocorrect(corrector, node)
           end
         end
@@ -171,9 +171,7 @@ module RuboCop
         end
 
         def unsafe_autocorrect?(condition)
-          condition.children.any? do |child|
-            unparenthesized_method_call?(child) || below_ternary_precedence?(child)
-          end
+          condition.children.any? { |child| below_ternary_precedence?(child) }
         end
 
         def unparenthesized_method_call?(child)
@@ -192,7 +190,7 @@ module RuboCop
         # @!method method_name(node)
         def_node_matcher :method_name, <<~PATTERN
           {($:defined? _ ...)
-           (send {_ nil?} $_ _ ...)}
+           (call {_ nil?} $_ _ ...)}
         PATTERN
 
         def correct_parenthesized(corrector, condition)
@@ -203,16 +201,39 @@ module RuboCop
           # If we remove the parentheses, we need to add a space or we'll
           # generate invalid code.
           corrector.insert_after(condition.loc.end, ' ') unless whitespace_after?(condition)
+
+          if (send_node = condition.child_nodes.last) && node_args_need_parens?(send_node)
+            parenthesize_condition_arguments(corrector, send_node)
+          end
         end
 
         def correct_unparenthesized(corrector, condition)
           corrector.wrap(condition, '(', ')')
         end
 
+        def parenthesize_condition_arguments(corrector, send_node)
+          range_start = send_node.defined_type? ? send_node.loc.keyword : send_node.loc.selector
+          opening_range = range_start.end.join(send_node.first_argument.source_range.begin)
+
+          corrector.replace(opening_range, '(')
+          corrector.insert_after(send_node.last_argument, ')')
+        end
+
         def whitespace_after?(node)
           last_token = processed_source.last_token_of(node)
           last_token.space_after?
         end
+
+        def node_args_need_parens?(send_node)
+          return false unless node_with_args?(send_node)
+          return false if send_node.arguments.none? || send_node.parenthesized?
+
+          send_node.dot? || send_node.safe_navigation? || unparenthesized_method_call?(send_node)
+        end
+
+        def node_with_args?(node)
+          node.type?(:call, :defined?)
+        end
       end
     end
   end

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

@@ -77,7 +77,7 @@ module RuboCop
 
         # @!method define_method_block?(node)
         def_node_matcher :define_method_block?, <<~PATTERN
-          ({block numblock} (send _ :define_method _) ...)
+          (any_block (send _ :define_method _) ...)
         PATTERN
       end
     end

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

@@ -7,12 +7,15 @@ module RuboCop
       # The supported styles are:
       #
       # * `consistent_comma`: Requires a comma after the last argument,
-      # for all parenthesized method calls with arguments.
+      # for all parenthesized multi-line method calls with arguments.
       # * `comma`: Requires a comma after the last argument, but only for
       # parenthesized method calls where each argument is on its own line.
       # * `no_comma`: Requires that there is no comma after the last
       # argument.
       #
+      # Regardless of style, trailing commas are not allowed in
+      # single-line method calls.
+      #
       # @example EnforcedStyleForMultiline: consistent_comma
       #   # bad
       #   method(1, 2,)

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

@@ -94,7 +94,7 @@ module RuboCop
         end
 
         def unneeded_ranges(node)
-          node.masgn_type? ? (mlhs_node, = *node) : mlhs_node = node
+          mlhs_node = node.masgn_type? ? node.lhs : node
           variables = *mlhs_node
 
           main_offense = main_node_offense(node)
@@ -106,15 +106,15 @@ module RuboCop
         end
 
         def main_node_offense(node)
-          node.masgn_type? ? (mlhs_node, right = *node) : mlhs_node = node
-
+          mlhs_node = node.masgn_type? ? node.lhs : node
           variables = *mlhs_node
+
           first_offense = find_first_offense(variables)
 
           return unless first_offense
 
           if unused_variables_only?(first_offense, variables)
-            return unused_range(node.type, mlhs_node, right)
+            return unused_range(node.type, mlhs_node, node.rhs)
           end
 
           return range_for_parentheses(first_offense, mlhs_node) if Util.parentheses?(mlhs_node)

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

@@ -179,7 +179,7 @@ module RuboCop
         end
 
         def looks_like_trivial_reader?(node)
-          !node.arguments? && node.body && node.body.ivar_type?
+          !node.arguments? && node.body&.ivar_type?
         end
 
         def trivial_writer?(node)

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

@@ -19,8 +19,7 @@ module RuboCop
         include Interpolation
         extend AutoCorrector
 
-        MSG = 'Replace interpolated variable `%<variable>s` ' \
-              'with expression `#{%<variable>s}`.' # rubocop:disable Lint/InterpolationCheck
+        MSG = 'Replace interpolated variable `%<variable>s` with expression `#{%<variable>s}`.'
 
         def on_node_with_interpolations(node)
           var_nodes(node.children).each do |var_node|

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

@@ -24,7 +24,6 @@ module RuboCop
       #   # good
       #   x += 1 until x > 10
       #
-      # @example
       #   # bad
       #   x += 100 while x < 500 # a long comment that makes code too long if it were a single line
       #

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

@@ -85,6 +85,12 @@ module RuboCop
         NONCOMMUTATIVE_OPERATORS = %i[===].freeze
         PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
         RESTRICT_ON_SEND = RuboCop::AST::Node::COMPARISON_OPERATORS
+        ENFORCE_YODA_STYLES = %i[
+          require_for_all_comparison_operators require_for_equality_operators_only
+        ].freeze
+        EQUALITY_ONLY_STYLES = %i[
+          forbid_for_equality_operators_only require_for_equality_operators_only
+        ].freeze
 
         # @!method file_constant_equal_program_name?(node)
         def_node_matcher :file_constant_equal_program_name?, <<~PATTERN
@@ -105,13 +111,11 @@ module RuboCop
         private
 
         def enforce_yoda?
-          style == :require_for_all_comparison_operators ||
-            style == :require_for_equality_operators_only
+          ENFORCE_YODA_STYLES.include?(style)
         end
 
         def equality_only?
-          style == :forbid_for_equality_operators_only ||
-            style == :require_for_equality_operators_only
+          EQUALITY_ONLY_STYLES.include?(style)
         end
 
         def yoda_compatible_condition?(node)

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

@@ -50,6 +50,7 @@ module RuboCop
 
         def on_send(node)
           return unless supported_operators.include?(node.method_name.to_s)
+          return unless node.arguments?
 
           lhs = node.receiver
           rhs = node.first_argument
@@ -71,7 +72,7 @@ module RuboCop
         end
 
         def constant_portion?(node)
-          node.numeric_type? || node.const_type?
+          node.type?(:numeric, :const)
         end
 
         def supported_operators

data/lib/rubocop/cop/team.rb

@@ -9,11 +9,17 @@ module RuboCop
     # For performance reasons, Team will first dispatch cops & forces in two groups,
     # first the ones needed for autocorrection (if any), then the rest
     # (unless autocorrections happened).
+    # rubocop:disable Metrics/ClassLength
     class Team
       # @return [Team]
       def self.new(cop_or_classes, config, options = {})
         # Support v0 api:
-        return mobilize(cop_or_classes, config, options) if cop_or_classes.first.is_a?(Class)
+        if cop_or_classes.first.is_a?(Class)
+          warn Rainbow(<<~WARNING).yellow, uplevel: 1
+            `Team.new` with cop classes is deprecated. Use `Team.mobilize` instead.
+          WARNING
+          return mobilize(cop_or_classes, config, options)
+        end
 
         super
       end
@@ -279,5 +285,6 @@ module RuboCop
         end
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/rubocop/cop/util.rb

@@ -32,7 +32,7 @@ module RuboCop
       end
 
       def parentheses?(node)
-        node.loc.respond_to?(:end) && node.loc.end && node.loc.end.is?(')')
+        node.loc_is?(:end, ')')
       end
 
       # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
@@ -74,9 +74,9 @@ module RuboCop
 
       def args_begin(node)
         loc = node.loc
-        selector = if node.super_type? || node.yield_type?
+        selector = if node.type?(:super, :yield)
                      loc.keyword
-                   elsif node.def_type? || node.defs_type?
+                   elsif node.type?(:def, :defs)
                      loc.name
                    else
                      loc.selector
@@ -193,11 +193,18 @@ module RuboCop
           enforced_style.sub(/^Enforced/, 'Supported').sub('Style', 'Styles')
       end
 
+      def parse_regexp(text)
+        Regexp::Parser.parse(text)
+      rescue Regexp::Parser::Error
+        # Upon encountering an invalid regular expression,
+        # we aim to proceed and identify any remaining potential offenses.
+        nil
+      end
+
       private
 
       def compatible_external_encoding_for?(src)
-        src = src.dup if RUBY_ENGINE == 'jruby'
-        src.force_encoding(Encoding.default_external).valid_encoding?
+        src.dup.force_encoding(Encoding.default_external).valid_encoding?
       end
 
       def include_or_equal?(source, target)