rubocop 1.69.2 → 1.71.1

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/ternary_parentheses.rb

@@ -232,7 +232,7 @@ module RuboCop
         end
 
         def node_with_args?(node)
-          node.call_type? || node.defined_type?
+          node.type?(:call, :defined?)
         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/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/util.rb

@@ -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)

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

@@ -72,7 +72,7 @@ module RuboCop
           parent = parent.parent if parent&.begin_type?
           return false if parent.nil?
 
-          (parent.if_type? || parent.while_type? || parent.until_type?) && parent.modifier_form?
+          parent.type?(:if, :while, :until) && parent.modifier_form?
         end
 
         def capture_with_block!

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

@@ -100,7 +100,7 @@ module RuboCop
 
             # Only block scope allows referencing outer scope variables.
             node = scope.node
-            return nil unless node.block_type? || node.numblock_type?
+            return nil unless node.any_block_type?
           end
 
           nil
@@ -113,14 +113,14 @@ module RuboCop
         def accessible_variables
           scope_stack.reverse_each.with_object([]) do |scope, variables|
             variables.concat(scope.variables.values)
-            break variables unless scope.node.block_type? || scope.node.numblock_type?
+            break variables unless scope.node.any_block_type?
           end
         end
 
         private
 
         def mark_variable_as_captured_by_block_if_so(variable)
-          return unless current_scope.node.block_type? || current_scope.node.numblock_type?
+          return unless current_scope.node.any_block_type?
           return if variable.scope == current_scope
 
           variable.capture_with_block!

data/lib/rubocop/cops_documentation_generator.rb

@@ -18,7 +18,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     description:           ->(data) { "#{data.description}\n" },
     safety:                ->(data) { safety_object(data.safety_objects, data.cop) },
     examples:              ->(data) { examples(data.example_objects, data.cop) },
-    configuration:         ->(data) { configurations(data.cop.department, data.config, data.cop) },
+    configuration:         ->(data) { configurations(data.cop.department, data.cop, data.config) },
     references:            ->(data) { references(data.cop, data.see_objects) }
   }.freeze
 
@@ -180,17 +180,17 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     content
   end
 
-  def configurations(department, pars, cop)
-    return '' if pars.empty?
-
+  def configurations(department, cop, cop_config)
     header = ['Name', 'Default value', 'Configurable values']
-    configs = pars
+    configs = cop_config
               .each_key
               .reject { |key| key.start_with?('Supported') }
               .reject { |key| key.start_with?('AllowMultipleStyles') }
+    return '' if configs.empty?
+
     content = configs.map do |name|
-      configurable = configurable_values(pars, name)
-      default = format_table_value(pars[name])
+      configurable = configurable_values(cop_config, name)
+      default = format_table_value(cop_config[name])
 
       [configuration_name(department, name), default, configurable]
     end
@@ -206,17 +206,17 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   end
 
   # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
-  def configurable_values(pars, name)
+  def configurable_values(cop_config, name)
     case name
     when /^Enforced/
       supported_style_name = RuboCop::Cop::Util.to_supported_styles(name)
-      format_table_value(pars[supported_style_name])
+      format_table_value(cop_config[supported_style_name])
     when 'IndentationWidth'
       'Integer'
     when 'Database'
-      format_table_value(pars['SupportedDatabases'])
+      format_table_value(cop_config['SupportedDatabases'])
     else
-      case pars[name]
+      case cop_config[name]
       when String
         'String'
       when Integer
@@ -319,7 +319,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
       AutoCorrect Description Enabled StyleGuide Reference Safe SafeAutoCorrect VersionAdded
       VersionChanged
     ]
-    pars = cop_config.reject { |k| non_display_keys.include? k }
+    parameters = cop_config.reject { |k| non_display_keys.include? k }
     description = 'No documentation'
     example_objects = safety_objects = see_objects = []
     cop_code(cop) do |code_object|
@@ -329,7 +329,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
       see_objects = code_object.tags('see')
     end
     data = CopData.new(cop: cop, description: description, example_objects: example_objects,
-                       safety_objects: safety_objects, see_objects: see_objects, config: pars)
+                       safety_objects: safety_objects, see_objects: see_objects, config: parameters)
     cops_body(data)
   end
 

data/lib/rubocop/directive_comment.rb

@@ -88,10 +88,15 @@ module RuboCop
       @cop_names ||= all_cops? ? all_cop_names : parsed_cop_names
     end
 
+    # Returns an array of cops for this directive comment, without resolving departments
+    def raw_cop_names
+      @raw_cop_names ||= (cops || '').split(/,\s*/)
+    end
+
     # Returns array of specified in this directive department names
     # when all department disabled
     def department_names
-      splitted_cops_string.select { |cop| department?(cop) }
+      raw_cop_names.select { |cop| department?(cop) }
     end
 
     # Checks if directive departments include cop
@@ -101,11 +106,11 @@ module RuboCop
 
     # Checks if cop department has already used in directive comment
     def overridden_by_department?(cop)
-      in_directive_department?(cop) && splitted_cops_string.include?(cop)
+      in_directive_department?(cop) && raw_cop_names.include?(cop)
     end
 
     def directive_count
-      splitted_cops_string.count
+      raw_cop_names.count
     end
 
     # Returns line number for directive
@@ -115,12 +120,8 @@ module RuboCop
 
     private
 
-    def splitted_cops_string
-      (cops || '').split(/,\s*/)
-    end
-
     def parsed_cop_names
-      cops = splitted_cops_string.map do |name|
+      cops = raw_cop_names.map do |name|
         department?(name) ? cop_names_for_department(name) : name
       end.flatten
       cops - [LINT_SYNTAX_COP]

data/lib/rubocop/formatter/formatter_set.rb

@@ -77,7 +77,7 @@ module RuboCop
         case formatter_type
         when Class
           formatter_type
-        when /\A[A-Z]/
+        when /\A(::)?[A-Z]/
           custom_formatter_class(formatter_type)
         else
           builtin_formatter_class(formatter_type)

data/lib/rubocop/lsp/diagnostic.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative 'severity'
+
+#
+# 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
+    # Diagnostic for Language Server Protocol of RuboCop.
+    # @api private
+    class Diagnostic
+      def initialize(document_encoding, offense, uri, cop_class)
+        @document_encoding = document_encoding
+        @offense = offense
+        @uri = uri
+        @cop_class = cop_class
+      end
+
+      def to_lsp_code_actions
+        code_actions = []
+
+        code_actions << autocorrect_action if correctable?
+        code_actions << disable_line_action
+
+        code_actions
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def to_lsp_diagnostic(config)
+        highlighted = @offense.highlighted_area
+
+        LanguageServer::Protocol::Interface::Diagnostic.new(
+          message: message,
+          source: 'RuboCop',
+          code: @offense.cop_name,
+          code_description: code_description(config),
+          severity: severity,
+          range: LanguageServer::Protocol::Interface::Range.new(
+            start: LanguageServer::Protocol::Interface::Position.new(
+              line: @offense.line - 1,
+              character: highlighted.begin_pos
+            ),
+            end: LanguageServer::Protocol::Interface::Position.new(
+              line: @offense.line - 1,
+              character: highlighted.end_pos
+            )
+          ),
+          data: {
+            correctable: correctable?,
+            code_actions: to_lsp_code_actions
+          }
+        )
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      private
+
+      def message
+        message = @offense.message
+        message += "\n\nThis offense is not autocorrectable.\n" unless correctable?
+        message
+      end
+
+      def severity
+        Severity.find_by(@offense.severity.name)
+      end
+
+      def code_description(config)
+        return unless @cop_class
+        return unless (doc_url = @cop_class.documentation_url(config))
+
+        LanguageServer::Protocol::Interface::CodeDescription.new(href: doc_url)
+      end
+
+      # rubocop:disable Layout/LineLength, Metrics/MethodLength
+      def autocorrect_action
+        LanguageServer::Protocol::Interface::CodeAction.new(
+          title: "Autocorrect #{@offense.cop_name}",
+          kind: LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX,
+          edit: LanguageServer::Protocol::Interface::WorkspaceEdit.new(
+            document_changes: [
+              LanguageServer::Protocol::Interface::TextDocumentEdit.new(
+                text_document: LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier.new(
+                  uri: ensure_uri_scheme(@uri.to_s).to_s,
+                  version: nil
+                ),
+                edits: correctable? ? offense_replacements : []
+              )
+            ]
+          ),
+          is_preferred: true
+        )
+      end
+      # rubocop:enable Layout/LineLength, Metrics/MethodLength
+
+      # rubocop:disable Metrics/MethodLength
+      def offense_replacements
+        @offense.corrector.as_replacements.map do |range, replacement|
+          LanguageServer::Protocol::Interface::TextEdit.new(
+            range: LanguageServer::Protocol::Interface::Range.new(
+              start: LanguageServer::Protocol::Interface::Position.new(
+                line: range.line - 1,
+                character: range.column
+              ),
+              end: LanguageServer::Protocol::Interface::Position.new(
+                line: range.last_line - 1,
+                character: range.last_column
+              )
+            ),
+            new_text: replacement
+          )
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # rubocop:disable Layout/LineLength, Metrics/MethodLength
+      def disable_line_action
+        LanguageServer::Protocol::Interface::CodeAction.new(
+          title: "Disable #{@offense.cop_name} for this line",
+          kind: LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX,
+          edit: LanguageServer::Protocol::Interface::WorkspaceEdit.new(
+            document_changes: [
+              LanguageServer::Protocol::Interface::TextDocumentEdit.new(
+                text_document: LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier.new(
+                  uri: ensure_uri_scheme(@uri.to_s).to_s,
+                  version: nil
+                ),
+                edits: line_disable_comment
+              )
+            ]
+          )
+        )
+      end
+      # rubocop:enable Layout/LineLength, Metrics/MethodLength
+
+      def line_disable_comment
+        new_text = if @offense.source_line.include?(' # rubocop:disable ')
+                     ",#{@offense.cop_name}"
+                   else
+                     " # rubocop:disable #{@offense.cop_name}"
+                   end
+
+        eol = LanguageServer::Protocol::Interface::Position.new(
+          line: @offense.line - 1,
+          character: length_of_line(@offense.source_line)
+        )
+
+        # TODO: fails for multiline strings - may be preferable to use block
+        # comments to disable some offenses
+        inline_comment = LanguageServer::Protocol::Interface::TextEdit.new(
+          range: LanguageServer::Protocol::Interface::Range.new(start: eol, end: eol),
+          new_text: new_text
+        )
+
+        [inline_comment]
+      end
+
+      def length_of_line(line)
+        if @document_encoding == Encoding::UTF_16LE
+          line_length = 0
+          line.codepoints.each do |codepoint|
+            line_length += 1
+            line_length += 1 if codepoint > RubyLsp::Document::Scanner::SURROGATE_PAIR_START
+          end
+          line_length
+        else
+          line.length
+        end
+      end
+
+      def correctable?
+        !@offense.corrector.nil?
+      end
+
+      def ensure_uri_scheme(uri)
+        uri = URI.parse(uri)
+        uri.scheme = 'file' if uri.scheme.nil?
+        uri
+      end
+    end
+  end
+end

data/lib/rubocop/lsp/logger.rb

@@ -14,8 +14,8 @@ module RuboCop
     # Log for Language Server Protocol of RuboCop.
     # @api private
     class Logger
-      def self.log(message)
-        warn("[server] #{message}")
+      def self.log(message, prefix: '[server]')
+        warn("#{prefix} #{message}")
       end
     end
   end