rubocop 1.30.0 → 1.31.1

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'colorizable'
-require_relative 'text_util'
 
 module RuboCop
   module Formatter
@@ -63,7 +62,7 @@ module RuboCop
                             rainbow,
                             # :safe_autocorrect is a derived option based on several command-line
                             # arguments - see Rubocop::Options#add_autocorrection_options
-                            safe_auto_correct: @options[:safe_autocorrect])
+                            safe_autocorrect: @options[:safe_autocorrect])
 
         output.puts
         output.puts report.summary
@@ -110,22 +109,22 @@ module RuboCop
         # rubocop:disable Metrics/ParameterLists
         def initialize(
           file_count, offense_count, correction_count, correctable_count, rainbow,
-          safe_auto_correct: false
+          safe_autocorrect: false
         )
           @file_count = file_count
           @offense_count = offense_count
           @correction_count = correction_count
           @correctable_count = correctable_count
           @rainbow = rainbow
-          @safe_auto_correct = safe_auto_correct
+          @safe_autocorrect = safe_autocorrect
         end
         # rubocop:enable Metrics/ParameterLists
 
         def summary
           if @correction_count.positive?
             if @correctable_count.positive?
-              "#{files} inspected, #{offenses} detected, #{corrections} corrected,"\
-                " #{correctable}"
+              "#{files} inspected, #{offenses} detected, #{corrections} corrected, " \
+                "#{correctable}"
             else
               "#{files} inspected, #{offenses} detected, #{corrections} corrected"
             end
@@ -159,7 +158,7 @@ module RuboCop
         end
 
         def correctable
-          if @safe_auto_correct
+          if @safe_autocorrect
             text = pluralize(@correctable_count, 'more offense')
             "#{colorize(text, :yellow)} can be corrected with `rubocop -A`"
           else

data/lib/rubocop/formatter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    require_relative 'formatter/text_util'
+
+    require_relative 'formatter/base_formatter'
+    require_relative 'formatter/simple_text_formatter'
+    # relies on simple text
+    require_relative 'formatter/clang_style_formatter'
+    require_relative 'formatter/disabled_config_formatter'
+    require_relative 'formatter/emacs_style_formatter'
+    require_relative 'formatter/file_list_formatter'
+    require_relative 'formatter/fuubar_style_formatter'
+    require_relative 'formatter/git_hub_actions_formatter'
+    require_relative 'formatter/html_formatter'
+    require_relative 'formatter/json_formatter'
+    require_relative 'formatter/junit_formatter'
+    require_relative 'formatter/markdown_formatter'
+    require_relative 'formatter/offense_count_formatter'
+    require_relative 'formatter/progress_formatter'
+    require_relative 'formatter/quiet_formatter'
+    require_relative 'formatter/tap_formatter'
+    require_relative 'formatter/worst_offenders_formatter'
+    require_relative 'formatter/pacman_formatter'
+    # relies on progress formatter
+    require_relative 'formatter/auto_gen_config_formatter'
+
+    require_relative 'formatter/formatter_set'
+  end
+end

data/lib/rubocop/options.rb

@@ -63,6 +63,7 @@ module RuboCop
 
         add_check_options(opts)
         add_cache_options(opts)
+        add_server_options(opts)
         add_output_options(opts)
         add_autocorrection_options(opts)
         add_config_generation_options(opts)
@@ -129,6 +130,7 @@ module RuboCop
       end
     end
 
+    # rubocop:todo Naming/InclusiveLanguage
     # the autocorrect command-line arguments map to the autocorrect @options values like so:
     #                            :fix_layout  :autocorrect  :safe_autocorrect  :autocorrect_all
     # -x, --fix-layout           true         true          -                  -
@@ -156,6 +158,7 @@ module RuboCop
         option(opts, '--disable-uncorrectable')
       end
     end
+    # rubocop:enable Naming/InclusiveLanguage
 
     def add_config_generation_options(opts)
       section(opts, 'Config Generation') do
@@ -201,6 +204,16 @@ module RuboCop
       end
     end
 
+    def add_server_options(opts)
+      section(opts, 'Server Options') do
+        option(opts, '--[no-]server')
+        option(opts, '--restart-server')
+        option(opts, '--start-server')
+        option(opts, '--stop-server')
+        option(opts, '--server-status')
+      end
+    end
+
     def add_additional_modes(opts)
       section(opts, 'Additional Modes') do
         option(opts, '-L', '--list-target-files')
@@ -226,7 +239,7 @@ module RuboCop
     end
 
     def handle_deprecated_option(old_option, new_option)
-      warn "#{old_option} is deprecated; use #{new_option}"
+      warn rainbow.wrap("#{old_option} is deprecated; use #{new_option} instead.").yellow
       @options[long_opt_symbol([new_option])] = @options.delete(long_opt_symbol([old_option]))
     end
 
@@ -569,7 +582,17 @@ module RuboCop
                                          'parallel. Default is true.'],
       stdin:                            ['Pipe source from STDIN, using FILE in offense',
                                          'reports. This is useful for editor integration.'],
-      init:                             'Generate a .rubocop.yml file in the current directory.'
+      init:                             'Generate a .rubocop.yml file in the current directory.',
+      server:                           ['If a server process has not been started yet, start',
+                                         'the server process and execute inspection with server.',
+                                         'Default is false.',
+                                         'You can specify the server host and port with the',
+                                         '$RUBOCOP_SERVER_HOST and the $RUBOCOP_SERVER_PORT',
+                                         'environment variables.'],
+      restart_server:                   'Restart server process.',
+      start_server:                     'Start server process.',
+      stop_server:                      'Stop server process.',
+      server_status:                    'Show server status.'
     }.freeze
   end
 end

data/lib/rubocop/rake_task.rb

@@ -32,6 +32,15 @@ module RuboCop
 
     private
 
+    def perform(option)
+      options = full_options.unshift(option)
+      # `parallel` will automatically be removed from the options internally.
+      # This is a nice to have to suppress the warning message
+      # about --parallel and --autocorrect not being compatible.
+      options.delete('--parallel')
+      run_cli(verbose, options)
+    end
+
     def run_cli(verbose, options)
       # We lazy-load RuboCop so that the task doesn't dramatically impact the
       # load time of your Rakefile.
@@ -60,19 +69,31 @@ module RuboCop
       @formatters = []
     end
 
-    def setup_subtasks(name, *args, &task_block)
+    def setup_subtasks(name, *args, &task_block) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       namespace(name) do
-        desc 'Autocorrect RuboCop offenses'
+        # rubocop:todo Naming/InclusiveLanguage
+        task(:auto_correct, *args) do
+          warn Rainbow(
+            'rubocop:auto_correct task is deprecated; ' \
+            'use rubocop:autocorrect task or rubocop:autocorrect_all task instead.'
+          ).yellow
+          ::Rake::Task['rubocop:autocorrect'].invoke
+        end
+        # rubocop:enable Naming/InclusiveLanguage
+
+        desc "Autocorrect RuboCop offenses (only when it's safe)."
+        task(:autocorrect, *args) do |_, task_args|
+          RakeFileUtils.verbose(verbose) do
+            yield(*[self, task_args].slice(0, task_block.arity)) if task_block
+            perform('--autocorrect')
+          end
+        end
 
-        task(:auto_correct, *args) do |_, task_args|
+        desc 'Autocorrect RuboCop offenses (safe and unsafe).'
+        task(:autocorrect_all, *args) do |_, task_args|
           RakeFileUtils.verbose(verbose) do
             yield(*[self, task_args].slice(0, task_block.arity)) if task_block
-            options = full_options.unshift('--autocorrect-all')
-            # `parallel` will automatically be removed from the options internally.
-            # This is a nice to have to suppress the warning message
-            # about --parallel and --autocorrect not being compatible.
-            options.delete('--parallel')
-            run_cli(verbose, options)
+            perform('--autocorrect-all')
           end
         end
       end

data/lib/rubocop/runner.rb

@@ -382,7 +382,7 @@ module RuboCop
       if @options[:display_only_fail_level_offenses]
         offenses.select { |o| considered_failure?(o) }
       elsif @options[:display_only_safe_correctable]
-        offenses.select { |o| supports_safe_auto_correct?(o) }
+        offenses.select { |o| supports_safe_autocorrect?(o) }
       elsif @options[:display_only_correctable]
         offenses.select(&:correctable?)
       else
@@ -390,7 +390,7 @@ module RuboCop
       end
     end
 
-    def supports_safe_auto_correct?(offense)
+    def supports_safe_autocorrect?(offense)
       cop_class = Cop::Registry.global.find_by_cop_name(offense.cop_name)
       default_cfg = default_config(offense.cop_name)
 

data/lib/rubocop/server/cache.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+#
+# 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
+    # Caches the states of server process.
+    # @api private
+    class Cache
+      GEMFILE_NAMES = %w[Gemfile gems.rb].freeze
+
+      class << self
+        # Searches for Gemfile or gems.rb in the current dir or any parent dirs
+        def project_dir
+          current_dir = Dir.pwd
+          while current_dir != '/'
+            return current_dir if GEMFILE_NAMES.any? do |gemfile|
+              File.exist?(File.join(current_dir, gemfile))
+            end
+
+            current_dir = File.expand_path('..', current_dir)
+          end
+          # If we can't find a Gemfile, just use the current directory
+          Dir.pwd
+        end
+
+        def project_dir_cache_key
+          @project_dir_cache_key ||= project_dir[1..].tr('/', '+')
+        end
+
+        def dir
+          cache_path = File.expand_path('~/.cache/rubocop_cache/server')
+          Pathname.new(File.join(cache_path, project_dir_cache_key)).tap do |d|
+            d.mkpath unless d.exist?
+          end
+        end
+
+        def port_path
+          dir.join('port')
+        end
+
+        def token_path
+          dir.join('token')
+        end
+
+        def pid_path
+          dir.join('pid')
+        end
+
+        def lock_path
+          dir.join('lock')
+        end
+
+        def status_path
+          dir.join('status')
+        end
+
+        def version_path
+          dir.join('version')
+        end
+
+        def pid_running?
+          Process.kill(0, pid_path.read.to_i) == 1
+        rescue Errno::ESRCH
+          false
+        end
+
+        def acquire_lock
+          lock_file = File.open(lock_path, File::CREAT)
+          # flock returns 0 if successful, and false if not.
+          flock_result = lock_file.flock(File::LOCK_EX | File::LOCK_NB)
+          yield flock_result != false
+        ensure
+          lock_file.flock(File::LOCK_UN)
+          lock_file.close
+        end
+
+        def write_port_and_token_files(port:, token:)
+          port_path.write(port)
+          token_path.write(token)
+        end
+
+        def write_pid_file
+          pid_path.write(Process.pid)
+          yield
+        ensure
+          dir.rmtree
+        end
+
+        def write_status_file(status)
+          status_path.write(status)
+        end
+
+        def write_version_file(version)
+          version_path.write(version)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/server/cli.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'rainbow'
+
+#
+# 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 CLI is a class responsible of handling server command line interface logic.
+    # @api private
+    class CLI
+      # Same exit status value as `RuboCop::CLI`.
+      STATUS_SUCCESS = 0
+      STATUS_ERROR = 2
+
+      SERVER_OPTIONS = %w[
+        --server --no-server --server-status --restart-server --start-server --stop-server
+      ].freeze
+      EXCLUSIVE_OPTIONS = (SERVER_OPTIONS - %w[--server --no-server]).freeze
+
+      def initialize
+        @exit = false
+      end
+
+      def run(argv = ARGV)
+        unless Server.support_server?
+          return error('RuboCop server is not supported by this Ruby.') if use_server_option?(argv)
+
+          return STATUS_SUCCESS
+        end
+
+        deleted_server_arguments = delete_server_argument_from(argv)
+
+        if deleted_server_arguments.size >= 2
+          return error("#{deleted_server_arguments.join(', ')} cannot be specified together.")
+        end
+
+        server_command = deleted_server_arguments.first
+
+        if EXCLUSIVE_OPTIONS.include?(server_command) && argv.count >= 2
+          return error("#{server_command} cannot be combined with other options.")
+        end
+
+        run_command(server_command)
+
+        STATUS_SUCCESS
+      end
+
+      def exit?
+        @exit
+      end
+
+      private
+
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength:
+      def run_command(server_command)
+        case server_command
+        when '--server'
+          Server::ClientCommand::Start.new.run unless Server.running?
+        when '--no-server'
+          Server::ClientCommand::Stop.new.run if Server.running?
+        when '--restart-server'
+          @exit = true
+          Server::ClientCommand::Restart.new.run
+        when '--start-server'
+          @exit = true
+          Server::ClientCommand::Start.new.run
+        when '--stop-server'
+          @exit = true
+          Server::ClientCommand::Stop.new.run
+        when '--server-status'
+          @exit = true
+          Server::ClientCommand::Status.new.run
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength:
+
+      def delete_server_argument_from(all_arguments)
+        SERVER_OPTIONS.each_with_object([]) do |server_option, server_arguments|
+          server_arguments << all_arguments.delete(server_option)
+        end.compact
+      end
+
+      def use_server_option?(argv)
+        (argv & SERVER_OPTIONS).any?
+      end
+
+      def error(message)
+        @exit = true
+        warn Rainbow(message).red
+
+        STATUS_ERROR
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+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
+    module ClientCommand
+      # Abstract base class for server client command.
+      # @api private
+      class Base
+        def run
+          raise NotImplementedError
+        end
+
+        private
+
+        def send_request(command:, args: [], body: '')
+          TCPSocket.open('127.0.0.1', Cache.port_path.read) do |socket|
+            socket.puts [Cache.token_path.read, Dir.pwd, command, *args].shelljoin
+            socket.write body
+            socket.close_write
+            $stdout.write socket.read(4096) until socket.eof?
+          end
+        end
+
+        def check_running_server
+          Server.running?.tap do |running|
+            warn 'RuboCop server is not running.' unless running
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# 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 execute server process.
+      # @api private
+      class Exec < Base
+        def run
+          ensure_server!
+          Cache.status_path.delete if Cache.status_path.file?
+          send_request(
+            command: 'exec',
+            args: ARGV.dup,
+            body: $stdin.tty? ? '' : $stdin.read
+          )
+          status
+        end
+
+        private
+
+        def ensure_server!
+          if incompatible_version?
+            puts 'RuboCop version incompatibility found, RuboCop server restarting...'
+            ClientCommand::Stop.new.run
+          elsif check_running_server
+            return
+          end
+
+          ClientCommand::Start.new.run
+        end
+
+        def incompatible_version?
+          RuboCop::Version::STRING != Cache.version_path.read
+        end
+
+        def status
+          unless Cache.status_path.file?
+            raise "RuboCop server: Could not find status file at: #{Cache.status_path}"
+          end
+
+          status = Cache.status_path.read
+          raise "RuboCop server: '#{status}' is not a valid status!" if (status =~ /^\d+$/).nil?
+
+          status.to_i
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# 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 restart server process.
+      # @api private
+      class Restart < Base
+        def run
+          ClientCommand::Stop.new.run
+          ClientCommand::Start.new.run
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# 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 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)
+          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