rubocop 1.18.0 → 1.56.0

data/lib/rubocop/server/client_command/start.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    module ClientCommand
+      # This class is a client command to start server process.
+      # @api private
+      class Start < Base
+        def initialize(detach: true)
+          @detach = detach
+          super()
+        end
+
+        def run
+          if Server.running?
+            warn "RuboCop server (#{Cache.pid_path.read}) is already running."
+            return
+          end
+
+          Cache.acquire_lock do |locked|
+            unless locked
+              # Another process is already starting server,
+              # so wait for it to be ready.
+              Server.wait_for_running_status!(true)
+              exit 0
+            end
+
+            Cache.write_version_file(RuboCop::Version::STRING)
+
+            host = ENV.fetch('RUBOCOP_SERVER_HOST', '127.0.0.1')
+            port = ENV.fetch('RUBOCOP_SERVER_PORT', 0)
+
+            Server::Core.new.start(host, port, detach: @detach)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/server/client_command/status.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    module ClientCommand
+      # This class is a client command to show server process status.
+      # @api private
+      class Status < Base
+        def run
+          if Server.running?
+            puts "RuboCop server (#{Cache.pid_path.read}) is running."
+          else
+            puts 'RuboCop server is not running.'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/server/client_command/stop.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    module ClientCommand
+      # This class is a client command to stop server process.
+      # @api private
+      class Stop < Base
+        def run
+          return unless check_running_server
+
+          pid = fork do
+            send_request(command: 'stop')
+            Server.wait_for_running_status!(false)
+          end
+
+          Process.waitpid(pid)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/server/client_command.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  autoload :Version, 'rubocop/version'
+
+  module Server
+    # @api private
+    module ClientCommand
+      autoload :Base, 'rubocop/server/client_command/base'
+      autoload :Exec, 'rubocop/server/client_command/exec'
+      autoload :Restart, 'rubocop/server/client_command/restart'
+      autoload :Start, 'rubocop/server/client_command/start'
+      autoload :Status, 'rubocop/server/client_command/status'
+      autoload :Stop, 'rubocop/server/client_command/stop'
+    end
+  end
+end

data/lib/rubocop/server/core.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'socket'
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    # The core of server process. It starts TCP server and perform socket communication.
+    # @api private
+    class Core
+      JSON_FORMATS = %w[json j].freeze
+
+      def self.token
+        @token ||= SecureRandom.hex(4)
+      end
+
+      def token
+        self.class.token
+      end
+
+      def start(host, port, detach: true)
+        $PROGRAM_NAME = "rubocop --server #{Cache.project_dir}"
+
+        require_relative '../../rubocop'
+        start_server(host, port)
+
+        return unless server_mode?
+
+        detach ? detach_server : run_server
+      end
+
+      private
+
+      def detach_server
+        write_port_and_token_files
+
+        pid = fork do
+          Process.daemon(true)
+          $stderr.reopen(Cache.stderr_path, 'w')
+          process_input
+        end
+
+        Process.waitpid(pid)
+      end
+
+      def write_port_and_token_files
+        Cache.write_port_and_token_files(port: @server.addr[1], token: token)
+      end
+
+      def process_input
+        Cache.write_pid_file do
+          read_socket(@server.accept) until @server.closed?
+        end
+      end
+
+      def run_server
+        write_port_and_token_files
+        process_input
+      end
+
+      def server_mode?
+        true
+      end
+
+      def start_server(host, port)
+        @server = TCPServer.open(host, port)
+
+        # JSON format does not expected output message when IDE integration with server mode.
+        # See: https://github.com/rubocop/rubocop/issues/11164
+        return if use_json_format?
+
+        output_stream = ARGV.include?('--stderr') ? $stderr : $stdout
+        output_stream.puts "RuboCop server starting on #{@server.addr[3]}:#{@server.addr[1]}."
+      end
+
+      def read_socket(socket)
+        SocketReader.new(socket).read!
+      rescue InvalidTokenError
+        socket.puts 'token is not valid.'
+      rescue ServerStopRequest
+        @server.close
+      rescue UnknownServerCommandError => e
+        socket.puts e.message
+      rescue Errno::EPIPE => e
+        warn e.inspect
+      rescue StandardError => e
+        socket.puts e.full_message
+      ensure
+        socket.close
+      end
+
+      def use_json_format?
+        return true if ARGV.include?('--format=json') || ARGV.include?('--format=j')
+        return false unless (index = ARGV.index('--format') || ARGV.index('-f'))
+
+        format = ARGV[index + 1]
+
+        JSON_FORMATS.include?(format)
+      end
+    end
+  end
+end

data/lib/rubocop/server/errors.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    # @api private
+    class InvalidTokenError < StandardError; end
+
+    # @api private
+    class ServerStopRequest < StandardError; end
+
+    # @api private
+    class UnknownServerCommandError < StandardError; end
+  end
+end

data/lib/rubocop/server/helper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    # This module has a helper method for `RuboCop::Server::SocketReader`.
+    # @api private
+    module Helper
+      def self.redirect(stdin: $stdin, stdout: $stdout, stderr: $stderr, &_block)
+        old_stdin = $stdin.dup
+        old_stdout = $stdout.dup
+        old_stderr = $stderr.dup
+
+        $stdin = stdin
+        $stdout = stdout
+        $stderr = stderr
+
+        yield
+      ensure
+        $stdin = old_stdin
+        $stdout = old_stdout
+        $stderr = old_stderr
+      end
+    end
+  end
+end

data/lib/rubocop/server/server_command/base.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    module ServerCommand
+      # Abstract base class for server command.
+      # @api private
+      class Base
+        # Common functionality for working with subclasses of this class.
+        # @api private
+        module Runner
+          def run
+            validate_token!
+            Dir.chdir(@cwd) do
+              super
+            end
+          end
+        end
+
+        def self.inherited(child)
+          super
+          child.prepend Runner
+        end
+
+        def initialize(args, token: '', cwd: Dir.pwd)
+          @args = args
+          @token = token
+          @cwd = cwd
+        end
+
+        def run; end
+
+        private
+
+        def validate_token!
+          raise InvalidTokenError unless Cache.token_path.read == @token
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/server/server_command/exec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    module ServerCommand
+      # This class is a server command to execute `rubocop` command using `RuboCop::CLI.new#run`.
+      # @api private
+      class Exec < Base
+        def run
+          Cache.status_path.delete if Cache.status_path.file?
+          # RuboCop output is colorized by default where there is a TTY.
+          # We must pass the --color option to preserve this behavior.
+          @args.unshift('--color') unless %w[--color --no-color].any? { |f| @args.include?(f) }
+          status = RuboCop::CLI.new.run(@args)
+          # This status file is read by `rubocop --server` (`RuboCop::Server::ClientCommand::Exec`).
+          # so that they use the correct exit code.
+          # Status is 1 when there are any issues, and 0 otherwise.
+          Cache.write_status_file(status)
+        rescue SystemExit
+          Cache.write_status_file(1)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/server/server_command/stop.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    module ServerCommand
+      # This class is a server command to stop server process.
+      # @api private
+      class Stop < Base
+        def run
+          raise ServerStopRequest
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/server/server_command.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    # @api private
+    module ServerCommand
+      autoload :Base, 'rubocop/server/server_command/base'
+      autoload :Exec, 'rubocop/server/server_command/exec'
+      autoload :Stop, 'rubocop/server/server_command/stop'
+    end
+  end
+end

data/lib/rubocop/server/socket_reader.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Server
+    # This class sends the request read from the socket to server.
+    # @api private
+    class SocketReader
+      Request = Struct.new(:header, :body)
+      Header = Struct.new(:token, :cwd, :command, :args)
+
+      def initialize(socket)
+        @socket = socket
+      end
+
+      def read!
+        request = parse_request(@socket.read)
+
+        stderr = StringIO.new
+        Helper.redirect(
+          stdin: StringIO.new(request.body),
+          stdout: @socket,
+          stderr: stderr
+        ) do
+          create_command_instance(request).run
+        end
+      ensure
+        Cache.stderr_path.write(stderr.string)
+        @socket.close
+      end
+
+      private
+
+      def parse_request(content)
+        raw_header, *body = content.lines
+
+        Request.new(parse_header(raw_header), body.join)
+      end
+
+      def parse_header(header)
+        token, cwd, command, *args = header.shellsplit
+        Header.new(token, cwd, command, args)
+      end
+
+      def create_command_instance(request)
+        klass = find_command_class(request.header.command)
+
+        klass.new(request.header.args, token: request.header.token, cwd: request.header.cwd)
+      end
+
+      def find_command_class(command)
+        case command
+        when 'stop' then ServerCommand::Stop
+        when 'exec' then ServerCommand::Exec
+        else
+          raise UnknownServerCommandError, "#{command.inspect} is not a valid command"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/server.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'platform'
+
+#
+# This code is based on https://github.com/fohte/rubocop-daemon.
+#
+# Copyright (c) 2018 Hayato Kawai
+#
+# The MIT License (MIT)
+#
+# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
+#
+module RuboCop
+  # The bootstrap module for server.
+  # @api private
+  module Server
+    TIMEOUT = 20
+
+    autoload :CLI, 'rubocop/server/cli'
+    autoload :Cache, 'rubocop/server/cache'
+    autoload :ClientCommand, 'rubocop/server/client_command'
+    autoload :Helper, 'rubocop/server/helper'
+    autoload :Core, 'rubocop/server/core'
+    autoload :ServerCommand, 'rubocop/server/server_command'
+    autoload :SocketReader, 'rubocop/server/socket_reader'
+
+    class << self
+      def support_server?
+        RUBY_ENGINE == 'ruby' && !RuboCop::Platform.windows?
+      end
+
+      def running?
+        return false unless support_server? # Never running.
+
+        Cache.pid_running?
+      end
+
+      def wait_for_running_status!(expected)
+        start_time = Time.now
+        while Server.running? != expected
+          sleep 0.1
+          next unless Time.now - start_time > TIMEOUT
+
+          warn "running? was not #{expected} after #{TIMEOUT} seconds!"
+          exit 1
+        end
+      end
+    end
+  end
+end
+
+require_relative 'server/errors'

data/lib/rubocop/string_interpreter.rb

@@ -32,9 +32,9 @@ module RuboCop
 
       def interpret_string_escape(escape)
         case escape[1]
-        when 'u' then interpret_unicode(escape)
-        when 'x' then interpret_hex(escape)
-        when /\d/       then interpret_octal(escape)
+        when 'u'  then interpret_unicode(escape)
+        when 'x'  then interpret_hex(escape)
+        when /\d/ then interpret_octal(escape)
         else
           escape[1] # literal escaped char, like \\
         end
@@ -42,18 +42,18 @@ module RuboCop
 
       def interpret_unicode(escape)
         if escape[2] == '{'
-          escape[3..-1].split(/\s+/).map(&:hex).pack('U*')
+          escape[3..].split(/\s+/).map(&:hex).pack('U*')
         else
-          [escape[2..-1].hex].pack('U')
+          [escape[2..].hex].pack('U')
         end
       end
 
       def interpret_hex(escape)
-        [escape[2..-1].hex].pack('C')
+        [escape[2..].hex].pack('C')
       end
 
       def interpret_octal(escape)
-        [escape[1..-1].to_i(8)].pack('C')
+        [escape[1..].to_i(8)].pack('C')
       end
     end
   end

data/lib/rubocop/target_finder.rb

@@ -88,14 +88,18 @@ module RuboCop
       patterns.map! { |dir| File.join(dir, '*') }
       # We need this special case to avoid creating the pattern
       # /**/* which searches the entire file system.
-      patterns = [File.join(dir, '**/*')] if patterns.empty?
+      patterns = [File.join(base_dir, '**/*')] if patterns.empty?
 
       Dir.glob(patterns, flags).select { |path| FileTest.file?(path) }
     end
 
     def wanted_dir_patterns(base_dir, exclude_pattern, flags)
-      base_dir = base_dir.gsub('/{}/', '/\{}/')
-      dirs = Dir.glob(File.join(base_dir.gsub('/**/', '/\**/'), '*/'), flags)
+      # Escape glob characters in base_dir to avoid unwanted behavior.
+      base_dir = base_dir.gsub(/[\\\{\}\[\]\*\?]/) do |reserved_glob_character|
+        "\\#{reserved_glob_character}"
+      end
+
+      dirs = Dir.glob(File.join(base_dir, '*/'), flags)
                 .reject do |dir|
                   next true if dir.end_with?('/./', '/../')
                   next true if File.fnmatch?(exclude_pattern, dir, flags)
@@ -114,7 +118,7 @@ module RuboCop
     end
 
     def combined_exclude_glob_patterns(base_dir)
-      exclude = @config_store.for(base_dir).for_all_cops['Exclude']
+      exclude = @config_store.for(base_dir).for_all_cops['Exclude'] || []
       patterns = exclude.select { |pattern| pattern.is_a?(String) && pattern.end_with?('/**/*') }
                         .map { |pattern| pattern.sub("#{base_dir}/", '') }
       "#{base_dir}/{#{patterns.join(',')}}"

data/lib/rubocop/target_ruby.rb

@@ -4,11 +4,18 @@ module RuboCop
   # The kind of Ruby that code inspected by RuboCop is written in.
   # @api private
   class TargetRuby
-    KNOWN_RUBIES = [2.5, 2.6, 2.7, 3.0, 3.1].freeze
-    DEFAULT_VERSION = KNOWN_RUBIES.first
+    KNOWN_RUBIES = [2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 3.0, 3.1, 3.2, 3.3].freeze
+    DEFAULT_VERSION = 2.7
 
     OBSOLETE_RUBIES = {
-      1.9 => '0.41', 2.0 => '0.50', 2.1 => '0.57', 2.2 => '0.68', 2.3 => '0.81', 2.4 => '1.12'
+      1.9 => '0.41',
+      2.0 => '0.50',
+      2.1 => '0.57',
+      2.2 => '0.68',
+      2.3 => '0.81',
+      2.4 => '1.12',
+      2.5 => '1.28',
+      2.6 => '1.50'
     }.freeze
     private_constant :KNOWN_RUBIES, :OBSOLETE_RUBIES
 
@@ -78,7 +85,7 @@ module RuboCop
     # @api private
     class ToolVersionsFile < RubyVersionFile
       TOOL_VERSIONS_FILENAME = '.tool-versions'
-      TOOL_VERSIONS_PATTERN = /\Aruby (?:ruby-)?(?<version>\d+\.\d+)/.freeze
+      TOOL_VERSIONS_PATTERN = /^(?:ruby )(?<version>\d+\.\d+)/.freeze
 
       def name
         "`#{TOOL_VERSIONS_FILENAME}`"
@@ -166,7 +173,7 @@ module RuboCop
         right_hand_side = version_from_gemspec_file(file)
         return if right_hand_side.nil?
 
-        find_minimal_known_ruby(right_hand_side)
+        find_default_minimal_known_ruby(right_hand_side)
       end
 
       def gemspec_filename
@@ -200,11 +207,13 @@ module RuboCop
         array.children.map(&:value)
       end
 
-      def find_minimal_known_ruby(right_hand_side)
+      def find_default_minimal_known_ruby(right_hand_side)
         version = version_from_right_hand_side(right_hand_side)
         requirement = Gem::Requirement.new(version)
 
-        KNOWN_RUBIES.detect { |v| requirement.satisfied_by?(Gem::Version.new("#{v}.99")) }
+        KNOWN_RUBIES.detect do |v|
+          v >= DEFAULT_VERSION && requirement.satisfied_by?(Gem::Version.new("#{v}.99"))
+        end
       end
     end
 
@@ -236,7 +245,6 @@ module RuboCop
     ].freeze
 
     private_constant :SOURCES
-
     def initialize(config)
       @config = config
     end