rubocop 1.26.1 → 1.35.1

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,79 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'securerandom'
+
+#
+# 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
+      def self.token
+        @token ||= SecureRandom.hex(4)
+      end
+
+      def token
+        self.class.token
+      end
+
+      def start(host, port)
+        $PROGRAM_NAME = "rubocop --server #{Cache.project_dir}"
+
+        require 'rubocop'
+        start_server(host, port)
+
+        demonize if server_mode?
+      end
+
+      private
+
+      def demonize
+        Cache.write_port_and_token_files(port: @server.addr[1], token: token)
+
+        pid = fork do
+          Process.daemon(true)
+          Cache.write_pid_file do
+            read_socket(@server.accept) until @server.closed?
+          end
+        end
+
+        Process.waitpid(pid)
+      end
+
+      def server_mode?
+        true
+      end
+
+      def start_server(host, port)
+        @server = TCPServer.open(host, port)
+
+        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
+    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 memthod 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,65 @@
+# 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)
+
+        Helper.redirect(
+          stdin: StringIO.new(request.body),
+          stdout: @socket,
+          stderr: @socket
+        ) do
+          create_command_instance(request).run
+        end
+      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.dir.exist? && Cache.pid_path.file? && 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

@@ -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_ruby.rb

@@ -4,11 +4,17 @@ 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, 3.2].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].freeze
+    DEFAULT_VERSION = 2.6
 
     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'
     }.freeze
     private_constant :KNOWN_RUBIES, :OBSOLETE_RUBIES
 
@@ -166,7 +172,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 +206,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
 

data/lib/rubocop/version.rb

@@ -3,13 +3,15 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.26.1'
+    STRING = '1.35.1'
 
-    MSG = '%<version>s (using Parser %<parser_version>s, '\
+    MSG = '%<version>s (using Parser %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \
           'running on %<ruby_engine>s %<ruby_version>s %<ruby_platform>s)'
 
-    CANONICAL_FEATURE_NAMES = { 'Rspec' => 'RSpec' }.freeze
+    CANONICAL_FEATURE_NAMES = { 'Rspec' => 'RSpec', 'Graphql' => 'GraphQL', 'Md' => 'Markdown',
+                                'Thread_safety' => 'ThreadSafety' }.freeze
+    EXTENSION_PATH_NAMES = { 'rubocop-md' => 'markdown' }.freeze
 
     # @api private
     def self.version(debug: false, env: nil)
@@ -43,16 +45,21 @@ module RuboCop
       features.map do |loaded_feature|
         next unless (match = loaded_feature.match(/rubocop-(?<feature>.*)/))
 
-        feature = match[:feature]
+        # Get the expected name of the folder containing the extension code.
+        # Usually it would be the same as the extension name. but sometimes authors
+        # can choose slightly different name for their gems, e.g. rubocop-md instead of
+        # rubocop-markdown.
+        feature = EXTENSION_PATH_NAMES.fetch(loaded_feature, match[:feature])
+
         begin
           require "rubocop/#{feature}/version"
         rescue LoadError
           # Not worth mentioning libs that are not installed
-        else
-          next unless (feature_version = feature_version(feature))
-
-          "  - #{loaded_feature} #{feature_version}"
         end
+
+        next unless (feature_version = feature_version(feature))
+
+        "  - #{loaded_feature} #{feature_version}"
       end.compact
     end