rubocop 1.52.1 → 1.53.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/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/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/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/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

data/lib/rubocop/lsp/routes.rb

@@ -0,0 +1,223 @@
+# 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
+    # Routes for Language Server Protocol of RuboCop.
+    # @api private
+    class Routes
+      def self.handle(name, &block)
+        define_method("handle_#{name}", &block)
+      end
+
+      private_class_method :handle
+
+      def initialize(server)
+        @server = server
+
+        @text_cache = {}
+      end
+
+      def for(name)
+        name = "handle_#{name}"
+        return unless respond_to?(name)
+
+        method(name)
+      end
+
+      handle 'initialize' do |request|
+        @server.write(
+          id: request[:id],
+          result: LanguageServer::Protocol::Interface::InitializeResult.new(
+            capabilities: LanguageServer::Protocol::Interface::ServerCapabilities.new(
+              document_formatting_provider: true,
+              diagnostic_provider: true,
+              text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
+                change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL,
+                open_close: true
+              )
+            )
+          )
+        )
+      end
+
+      handle 'initialized' do |_request|
+        version = RuboCop::Version::STRING
+
+        Logger.log("RuboCop #{version} language server initialized, PID #{Process.pid}")
+      end
+
+      handle 'shutdown' do |request|
+        Logger.log('Client asked to shutdown RuboCop language server.')
+        @server.stop do
+          @server.write(id: request[:id], result: nil)
+          Logger.log('Exiting...')
+        end
+      end
+
+      handle 'textDocument/diagnostic' do |request|
+        doc = request[:params][:textDocument]
+        result = diagnostic(doc[:uri], doc[:text])
+        @server.write(result)
+      end
+
+      handle 'textDocument/didChange' do |request|
+        params = request[:params]
+        result = diagnostic(params[:textDocument][:uri], params[:contentChanges][0][:text])
+        @server.write(result)
+      end
+
+      handle 'textDocument/didOpen' do |request|
+        doc = request[:params][:textDocument]
+        result = diagnostic(doc[:uri], doc[:text])
+        @server.write(result)
+      end
+
+      handle 'textDocument/didClose' do |request|
+        @text_cache.delete(request.dig(:params, :textDocument, :uri))
+      end
+
+      handle 'textDocument/formatting' do |request|
+        uri = request[:params][:textDocument][:uri]
+        @server.write(id: request[:id], result: format_file(uri))
+      end
+
+      handle 'workspace/didChangeConfiguration' do |_request|
+        Logger.log('Ignoring workspace/didChangeConfiguration')
+      end
+
+      handle 'workspace/didChangeWatchedFiles' do |request|
+        changed = request[:params][:changes].any? do |change|
+          change[:uri].end_with?(RuboCop::ConfigFinder::DOTFILE)
+        end
+
+        if changed
+          Logger.log('Configuration file changed; restart required')
+          @server.stop
+        end
+      end
+
+      handle 'workspace/executeCommand' do |request|
+        if request[:params][:command] == 'rubocop.formatAutocorrects'
+          uri = request[:params][:arguments][0][:uri]
+          @server.write(
+            id: request[:id],
+            method: 'workspace/applyEdit',
+            params: {
+              label: 'Format with RuboCop autocorrects',
+              edit: {
+                changes: {
+                  uri => format_file(uri)
+                }
+              }
+            }
+          )
+        else
+          handle_unsupported_method(request, request[:params][:command])
+        end
+      end
+
+      handle 'textDocument/willSave' do |_request|
+        # Nothing to do
+      end
+
+      handle 'textDocument/didSave' do |_request|
+        # Nothing to do
+      end
+
+      handle '$/cancelRequest' do |_request|
+        # Can't cancel anything because single-threaded
+      end
+
+      handle '$/setTrace' do |_request|
+        # No-op, we log everything
+      end
+
+      def handle_unsupported_method(request, method = request[:method])
+        @server.write(
+          id: request[:id],
+          error: LanguageServer::Protocol::Interface::ResponseError.new(
+            code: LanguageServer::Protocol::Constant::ErrorCodes::METHOD_NOT_FOUND,
+            message: "Unsupported Method: #{method}"
+          )
+        )
+        Logger.log("Unsupported Method: #{method}")
+      end
+
+      def handle_method_missing(request)
+        return unless request.key?(:id)
+
+        @server.write(id: request[:id], result: nil)
+      end
+
+      private
+
+      def format_file(file_uri)
+        unless (text = @text_cache[file_uri])
+          Logger.log("Format request arrived before text synchronized; skipping: `#{file_uri}'")
+
+          return []
+        end
+
+        new_text = @server.format(remove_file_protocol_from(file_uri), text)
+
+        return [] if new_text == text
+
+        [
+          newText: new_text,
+          range: {
+            start: { line: 0, character: 0 },
+            end: { line: text.count("\n") + 1, character: 0 }
+          }
+        ]
+      end
+
+      def diagnostic(file_uri, text)
+        @text_cache[file_uri] = text
+        offenses = @server.offenses(remove_file_protocol_from(file_uri), text)
+        diagnostics = offenses.map { |offense| to_diagnostic(offense) }
+
+        {
+          method: 'textDocument/publishDiagnostics',
+          params: {
+            uri: file_uri,
+            diagnostics: diagnostics
+          }
+        }
+      end
+
+      def remove_file_protocol_from(uri)
+        uri.delete_prefix('file://')
+      end
+
+      def to_diagnostic(offense)
+        code = offense[:cop_name]
+        message = offense[:message]
+        loc = offense[:location]
+        rubocop_severity = offense[:severity]
+        severity = Severity.find_by(rubocop_severity)
+
+        {
+          code: code, message: message, range: to_range(loc), severity: severity, source: 'rubocop'
+        }
+      end
+
+      def to_range(location)
+        {
+          start: { character: location[:start_column] - 1, line: location[:start_line] - 1 },
+          end: { character: location[:last_column] - 1, line: location[:last_line] - 1 }
+        }
+      end
+    end
+  end
+end

data/lib/rubocop/lsp/runtime.rb

@@ -0,0 +1,79 @@
+# 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
+    # Runtime for Language Server Protocol of RuboCop.
+    # @api private
+    class Runtime
+      def initialize(config_store)
+        @config_store = config_store
+        @logged_paths = []
+      end
+
+      # This abuses the `--stdin` option of rubocop and reads the formatted text
+      # from the `options[:stdin]` that rubocop mutates. This depends on
+      # `parallel: false` as well as the fact that RuboCop doesn't otherwise dup
+      # or reassign that options object. Risky business!
+      #
+      # Reassigning `options[:stdin]` is done here:
+      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cop/team.rb#L131
+      # Printing `options[:stdin]`
+      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cli/command/execute_runner.rb#L95
+      # Setting `parallel: true` would break this here:
+      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/runner.rb#L72
+      def format(path, text)
+        formatting_options = {
+          stdin: text, force_exclusion: true, autocorrect: true, safe_autocorrect: true
+        }
+
+        redirect_stdout { run_rubocop(formatting_options, path) }
+
+        formatting_options[:stdin]
+      end
+
+      def offenses(path, text)
+        diagnostic_options = {
+          stdin: text, force_exclusion: true, formatters: ['json'], format: 'json'
+        }
+
+        json = redirect_stdout { run_rubocop(diagnostic_options, path) }
+        results = JSON.parse(json, symbolize_names: true)
+
+        if results[:files].empty?
+          unless @logged_paths.include?(path)
+            Logger.log "Ignoring file, per configuration: #{path}"
+            @logged_paths << path
+          end
+          return []
+        end
+
+        results.dig(:files, 0, :offenses)
+      end
+
+      private
+
+      def redirect_stdout(&block)
+        stdout = StringIO.new
+
+        RuboCop::Server::Helper.redirect(stdout: stdout, &block)
+
+        stdout.string
+      end
+
+      def run_rubocop(options, path)
+        runner = RuboCop::Runner.new(options, @config_store)
+
+        runner.run([path])
+      end
+    end
+  end
+end

data/lib/rubocop/lsp/server.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'language_server-protocol'
+require_relative 'logger'
+require_relative 'routes'
+require_relative 'runtime'
+
+#
+# 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
+    # Language Server Protocol of RuboCop.
+    # @api private
+    class Server
+      def initialize(config_store)
+        @reader = LanguageServer::Protocol::Transport::Io::Reader.new($stdin)
+        @writer = LanguageServer::Protocol::Transport::Io::Writer.new($stdout)
+        @runtime = RuboCop::Lsp::Runtime.new(config_store)
+        @routes = Routes.new(self)
+      end
+
+      def start
+        @reader.read do |request|
+          if !request.key?(:method)
+            @routes.handle_method_missing(request)
+          elsif (route = @routes.for(request[:method]))
+            route.call(request)
+          else
+            @routes.handle_unsupported_method(request)
+          end
+        rescue StandardError => e
+          log("Error #{e.class} #{e.message[0..100]}")
+          log(e.backtrace.inspect)
+        end
+      end
+
+      def write(response)
+        @writer.write(response)
+      end
+
+      def format(path, text)
+        @runtime.format(path, text)
+      end
+
+      def offenses(path, text)
+        @runtime.offenses(path, text)
+      end
+
+      def stop(&block)
+        at_exit(&block) if block
+        exit
+      end
+    end
+  end
+end