rubocop 1.50.2 → 1.68.0

data/lib/rubocop/server/cache.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'digest'
 require 'pathname'
 require_relative '../cache_config'
 require_relative '../config_finder'
@@ -19,6 +20,7 @@ module RuboCop
     # @api private
     class Cache
       GEMFILE_NAMES = %w[Gemfile gems.rb].freeze
+      LOCKFILE_NAMES = %w[Gemfile.lock gems.locked].freeze
 
       class << self
         attr_accessor :cache_root_path
@@ -41,6 +43,19 @@ module RuboCop
           @project_dir_cache_key ||= project_dir[1..].tr('/', '+')
         end
 
+        # rubocop:disable Metrics/AbcSize
+        def restart_key
+          lockfile_path = LOCKFILE_NAMES.map do |lockfile_name|
+            Pathname(project_dir).join(lockfile_name)
+          end.find(&:exist?)
+          version_data = lockfile_path&.read || RuboCop::Version::STRING
+          config_data = Pathname(ConfigFinder.find_config_path(Dir.pwd)).read
+          todo_data = (rubocop_todo = Pathname('.rubocop_todo.yml')).exist? ? rubocop_todo.read : ''
+
+          Digest::SHA1.hexdigest(version_data + config_data + todo_data)
+        end
+        # rubocop:enable Metrics/AbcSize
+
         def dir
           Pathname.new(File.join(cache_path, project_dir_cache_key)).tap do |d|
             d.mkpath unless d.exist?
@@ -116,7 +131,7 @@ module RuboCop
 
         def pid_running?
           Process.kill(0, pid_path.read.to_i) == 1
-        rescue Errno::ESRCH, Errno::ENOENT, Errno::EACCES
+        rescue Errno::ESRCH, Errno::ENOENT, Errno::EACCES, Errno::EROFS, Errno::ENAMETOOLONG
           false
         end
 

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

@@ -17,11 +17,11 @@ module RuboCop
       class Exec < Base
         def run
           ensure_server!
-          Cache.status_path.delete if Cache.status_path.file?
+          read_stdin = ARGV.include?('-s') || ARGV.include?('--stdin')
           send_request(
             command: 'exec',
             args: ARGV.dup,
-            body: $stdin.tty? ? '' : $stdin.read
+            body: read_stdin ? $stdin.read : ''
           )
           warn stderr unless stderr.empty?
           status
@@ -31,7 +31,7 @@ module RuboCop
 
         def ensure_server!
           if incompatible_version?
-            puts 'RuboCop version incompatibility found, RuboCop server restarting...'
+            warn 'RuboCop version incompatibility found, RuboCop server restarting...'
             ClientCommand::Stop.new.run
           elsif check_running_server
             return
@@ -41,7 +41,7 @@ module RuboCop
         end
 
         def incompatible_version?
-          Cache.version_path.read != RuboCop::Version::STRING
+          Cache.version_path.read != Cache.restart_key
         end
 
         def stderr
@@ -54,7 +54,7 @@ module RuboCop
           end
 
           status = Cache.status_path.read
-          raise "RuboCop server: '#{status}' is not a valid status!" if (status =~ /^\d+$/).nil?
+          raise "RuboCop server: '#{status}' is not a valid status!" unless /\A\d+\z/.match?(status)
 
           status.to_i
         end

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

@@ -34,7 +34,7 @@ module RuboCop
               exit 0
             end
 
-            Cache.write_version_file(RuboCop::Version::STRING)
+            Cache.write_version_file(Cache.restart_key)
 
             host = ENV.fetch('RUBOCOP_SERVER_HOST', '127.0.0.1')
             port = ENV.fetch('RUBOCOP_SERVER_PORT', 0)

data/lib/rubocop/server/core.rb

@@ -2,6 +2,7 @@
 
 require 'securerandom'
 require 'socket'
+require 'stringio'
 
 #
 # This code is based on https://github.com/fohte/rubocop-daemon.
@@ -44,6 +45,10 @@ module RuboCop
         write_port_and_token_files
 
         pid = fork do
+          if defined?(RubyVM::YJIT.enable)
+            RubyVM::YJIT.enable
+          end
+
           Process.daemon(true)
           $stderr.reopen(Cache.stderr_path, 'w')
           process_input

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

@@ -16,7 +16,6 @@ module RuboCop
       # @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) }

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

data/lib/rubocop/target_finder.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 module RuboCop
-  # This class finds target files to inspect by scanning the directory tree
-  # and picking ruby files.
+  # This class finds target files to inspect by scanning the directory tree and picking ruby files.
   # @api private
   class TargetFinder
     HIDDEN_PATH_SUBSTRING = "#{File::SEPARATOR}."
@@ -12,21 +11,8 @@ module RuboCop
       @options = options
     end
 
-    def force_exclusion?
-      @options[:force_exclusion]
-    end
-
-    def debug?
-      @options[:debug]
-    end
-
-    def fail_fast?
-      @options[:fail_fast]
-    end
-
-    # Generate a list of target files by expanding globbing patterns
-    # (if any). If args is empty, recursively find all Ruby source
-    # files under the current directory
+    # Generate a list of target files by expanding globbing patterns (if any). If args is empty,
+    # recursively find all Ruby source files under the current directory
     # @return [Array] array of file paths
     def find(args, mode)
       return target_files_in_dir if args.empty?
@@ -44,12 +30,11 @@ module RuboCop
       files.map { |f| File.expand_path(f) }.uniq
     end
 
-    # Finds all Ruby source files under the current or other supplied
-    # directory. A Ruby source file is defined as a file with the `.rb`
-    # extension or a file with no extension that has a ruby shebang line
-    # as its first line.
-    # It is possible to specify includes and excludes using the config file,
-    # so you can include other Ruby files like Rakefiles and gemspecs.
+    # Finds all Ruby source files under the current or other supplied directory. A Ruby source file
+    # is defined as a file with the `.rb` extension or a file with no extension that has a ruby
+    # shebang line as its first line.
+    # It is possible to specify includes and excludes using the config file, so you can include
+    # other Ruby files like Rakefiles and gemspecs.
     # @param base_dir Root directory under which to search for
     #   ruby source files
     # @return [Array] Array of filenames
@@ -66,20 +51,10 @@ module RuboCop
       target_files.sort_by!(&order)
     end
 
-    def to_inspect?(file, hidden_files, base_dir_config)
-      return false if base_dir_config.file_to_exclude?(file)
-      return true if !hidden_files.bsearch do |hidden_file|
-        file <=> hidden_file
-      end && ruby_file?(file)
-
-      base_dir_config.file_to_include?(file)
-    end
-
-    # Search for files recursively starting at the given base directory using
-    # the given flags that determine how the match is made. Excluded files will
-    # be removed later by the caller, but as an optimization find_files removes
-    # the top level directories that are excluded in configuration in the
-    # normal way (dir/**/*).
+    # Search for files recursively starting at the given base directory using the given flags that
+    # determine how the match is made. Excluded files will be removed later by the caller, but as an
+    # optimization find_files removes the top level directories that are excluded in configuration
+    # in the normal way (dir/**/*).
     def find_files(base_dir, flags)
       # get all wanted directories first to improve speed of finding all files
       exclude_pattern = combined_exclude_glob_patterns(base_dir)
@@ -93,9 +68,24 @@ module RuboCop
       Dir.glob(patterns, flags).select { |path| FileTest.file?(path) }
     end
 
+    private
+
+    def to_inspect?(file, hidden_files, base_dir_config)
+      return false if base_dir_config.file_to_exclude?(file)
+      return true if !hidden_files.bsearch do |hidden_file|
+        file <=> hidden_file
+      end && ruby_file?(file)
+
+      base_dir_config.file_to_include?(file)
+    end
+
     def wanted_dir_patterns(base_dir, exclude_pattern, flags)
-      base_dir = base_dir.gsub('/{}/', '/\{}/')
-      dirs = Dir.glob(File.join(base_dir.gsub('/*/', '/\*/').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,27 +104,12 @@ 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(',')}}"
     end
 
-    def ruby_extension?(file)
-      ruby_extensions.include?(File.extname(file))
-    end
-
-    def ruby_extensions
-      @ruby_extensions ||= begin
-        ext_patterns = all_cops_include.select { |pattern| pattern.start_with?('**/*.') }
-        ext_patterns.map { |pattern| pattern.sub('**/*', '') }
-      end
-    end
-
-    def ruby_filename?(file)
-      ruby_filenames.include?(File.basename(file))
-    end
-
     def ruby_filenames
       @ruby_filenames ||= begin
         file_patterns = all_cops_include.reject { |pattern| pattern.start_with?('**/*.') }
@@ -146,53 +121,72 @@ module RuboCop
       @all_cops_include ||= @config_store.for_pwd.for_all_cops['Include'].map(&:to_s)
     end
 
-    def ruby_executable?(file)
-      return false unless File.extname(file).empty? && File.exist?(file)
+    def process_explicit_path(path, mode)
+      files = path.include?('*') ? Dir[path] : [path]
 
-      first_line = File.open(file, &:readline)
-      /#!.*(#{ruby_interpreters(file).join('|')})/.match?(first_line)
-    rescue EOFError, ArgumentError => e
-      warn("Unprocessable file #{file}: #{e.class}, #{e.message}") if debug?
+      if mode == :only_recognized_file_types || force_exclusion?
+        files.select! { |file| included_file?(file) }
+      end
 
-      false
+      force_exclusion? ? without_excluded(files) : files
     end
 
-    def ruby_interpreters(file)
-      @config_store.for(file).for_all_cops['RubyInterpreters']
+    def without_excluded(files)
+      files.reject do |file|
+        # When --ignore-parent-exclusion is given, we must look at the configuration associated with
+        # the file, but in the default case when --ignore-parent-exclusion is not given, can safely
+        # look only at the configuration for the current directory, since it's only the Exclude
+        # parameters we're going to check.
+        config = @config_store.for(ignore_parent_exclusion? ? file : '.')
+        config.file_to_exclude?(file)
+      end
     end
 
-    def stdin?
-      @options.key?(:stdin)
+    def included_file?(file)
+      ruby_file?(file) || configured_include?(file)
     end
 
     def ruby_file?(file)
       stdin? || ruby_extension?(file) || ruby_filename?(file) || ruby_executable?(file)
     end
 
-    def configured_include?(file)
-      @config_store.for_pwd.file_to_include?(file)
+    def stdin?
+      @options.key?(:stdin)
     end
 
-    def included_file?(file)
-      ruby_file?(file) || configured_include?(file)
+    def ruby_extension?(file)
+      ruby_extensions.include?(File.extname(file))
     end
 
-    def process_explicit_path(path, mode)
-      files = path.include?('*') ? Dir[path] : [path]
-
-      if mode == :only_recognized_file_types || force_exclusion?
-        files.select! { |file| included_file?(file) }
+    def ruby_extensions
+      @ruby_extensions ||= begin
+        ext_patterns = all_cops_include.select { |pattern| pattern.start_with?('**/*.') }
+        ext_patterns.map { |pattern| pattern.sub('**/*', '') }
       end
+    end
 
-      return files unless force_exclusion?
+    def ruby_filename?(file)
+      ruby_filenames.include?(File.basename(file))
+    end
 
-      files.reject do |file|
-        config = @config_store.for(file)
-        config.file_to_exclude?(file)
-      end
+    def configured_include?(file)
+      @config_store.for_pwd.file_to_include?(file)
     end
 
-    private
+    def ruby_executable?(file)
+      return false unless File.extname(file).empty? && File.exist?(file)
+
+      first_line = File.open(file, &:readline)
+      /#!.*(#{ruby_interpreters(file).join('|')})/.match?(first_line)
+    rescue EOFError, ArgumentError => e
+      warn("Unprocessable file #{file}: #{e.class}, #{e.message}") if debug?
+
+      false
+    end
+
+    def ruby_interpreters(file)
+      @config_store.for(file).for_all_cops['RubyInterpreters']
+    end
 
     def order
       if fail_fast?
@@ -202,5 +196,21 @@ module RuboCop
         :itself
       end
     end
+
+    def force_exclusion?
+      @options[:force_exclusion]
+    end
+
+    def ignore_parent_exclusion?
+      @options[:ignore_parent_exclusion]
+    end
+
+    def debug?
+      @options[:debug]
+    end
+
+    def fail_fast?
+      @options[:fail_fast]
+    end
   end
 end

data/lib/rubocop/target_ruby.rb

@@ -4,8 +4,8 @@ module RuboCop
   # The kind of Ruby that code inspected by RuboCop is written in.
   # @api private
   class TargetRuby
-    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.6
+    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, 3.4].freeze
+    DEFAULT_VERSION = 2.7
 
     OBSOLETE_RUBIES = {
       1.9 => '0.41',
@@ -14,7 +14,8 @@ module RuboCop
       2.2 => '0.68',
       2.3 => '0.81',
       2.4 => '1.12',
-      2.5 => '1.28'
+      2.5 => '1.28',
+      2.6 => '1.50'
     }.freeze
     private_constant :KNOWN_RUBIES, :OBSOLETE_RUBIES
 
@@ -47,6 +48,90 @@ module RuboCop
       end
     end
 
+    # The target ruby version may be found in a .gemspec file.
+    # @api private
+    class GemspecFile < Source
+      extend NodePattern::Macros
+
+      # @!method required_ruby_version(node)
+      def_node_search :required_ruby_version, <<~PATTERN
+        (send _ :required_ruby_version= $_)
+      PATTERN
+
+      # @!method gem_requirement_versions(node)
+      def_node_matcher :gem_requirement_versions, <<~PATTERN
+        (send (const(const _ :Gem):Requirement) :new
+          {$str+ | (send $str :freeze)+ | (array $str+) | (array (send $str :freeze)+)}
+        )
+      PATTERN
+
+      def name
+        "`required_ruby_version` parameter (in #{gemspec_filepath})"
+      end
+
+      private
+
+      def find_version
+        file = gemspec_filepath
+        return unless file && File.file?(file)
+
+        right_hand_side = version_from_gemspec_file(file)
+        return if right_hand_side.nil?
+
+        find_minimal_known_ruby(right_hand_side)
+      end
+
+      def gemspec_filepath
+        return @gemspec_filepath if defined?(@gemspec_filepath)
+
+        @gemspec_filepath =
+          @config.traverse_directories_upwards(@config.base_dir_for_path_parameters) do |dir|
+            # NOTE: Can't use `dir.glob` because of JRuby 9.4.8.0 incompatibility:
+            # https://github.com/jruby/jruby/issues/8358
+            candidates = Pathname.glob("#{dir}/*.gemspec")
+            # Bundler will use a gemspec whatever the filename is, as long as its the only one in
+            # the folder.
+            break candidates.first if candidates.one?
+          end
+      end
+
+      def version_from_gemspec_file(file)
+        processed_source = ProcessedSource.from_file(
+          file, DEFAULT_VERSION, parser_engine: @config.parser_engine
+        )
+        return unless processed_source.valid_syntax?
+
+        required_ruby_version(processed_source.ast).first
+      end
+
+      def version_from_right_hand_side(right_hand_side)
+        gem_requirement_versions = gem_requirement_versions(right_hand_side)
+
+        if right_hand_side.array_type? && right_hand_side.children.all?(&:str_type?)
+          version_from_array(right_hand_side)
+        elsif gem_requirement_versions
+          gem_requirement_versions.map(&:value)
+        elsif right_hand_side.str_type?
+          right_hand_side.value
+        end
+      end
+
+      def version_from_array(array)
+        array.children.map(&:value)
+      end
+
+      def find_minimal_known_ruby(right_hand_side)
+        version = version_from_right_hand_side(right_hand_side)
+        return unless version
+
+        requirement = Gem::Requirement.new(version)
+
+        KNOWN_RUBIES.detect do |v|
+          requirement.satisfied_by?(Gem::Version.new("#{v}.99"))
+        end
+      end
+    end
+
     # The target ruby version may be found in a .ruby-version file.
     # @api private
     class RubyVersionFile < Source
@@ -142,80 +227,6 @@ module RuboCop
       end
     end
 
-    # The target ruby version may be found in a .gemspec file.
-    # @api private
-    class GemspecFile < Source
-      extend NodePattern::Macros
-
-      GEMSPEC_EXTENSION = '.gemspec'
-
-      # @!method required_ruby_version(node)
-      def_node_search :required_ruby_version, <<~PATTERN
-        (send _ :required_ruby_version= $_)
-      PATTERN
-
-      # @!method gem_requirement?(node)
-      def_node_matcher :gem_requirement?, <<~PATTERN
-        (send (const(const _ :Gem):Requirement) :new $str)
-      PATTERN
-
-      def name
-        "`required_ruby_version` parameter (in #{gemspec_filename})"
-      end
-
-      private
-
-      def find_version
-        file = gemspec_filepath
-        return unless file && File.file?(file)
-
-        right_hand_side = version_from_gemspec_file(file)
-        return if right_hand_side.nil?
-
-        find_default_minimal_known_ruby(right_hand_side)
-      end
-
-      def gemspec_filename
-        @gemspec_filename ||= begin
-          basename = Pathname.new(@config.base_dir_for_path_parameters).basename.to_s
-          "#{basename}#{GEMSPEC_EXTENSION}"
-        end
-      end
-
-      def gemspec_filepath
-        @gemspec_filepath ||=
-          @config.find_file_upwards(gemspec_filename, @config.base_dir_for_path_parameters)
-      end
-
-      def version_from_gemspec_file(file)
-        processed_source = ProcessedSource.from_file(file, DEFAULT_VERSION)
-        required_ruby_version(processed_source.ast).first
-      end
-
-      def version_from_right_hand_side(right_hand_side)
-        if right_hand_side.array_type?
-          version_from_array(right_hand_side)
-        elsif gem_requirement?(right_hand_side)
-          right_hand_side.children.last.value
-        else
-          right_hand_side.value
-        end
-      end
-
-      def version_from_array(array)
-        array.children.map(&:value)
-      end
-
-      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 do |v|
-          v >= DEFAULT_VERSION && requirement.satisfied_by?(Gem::Version.new("#{v}.99"))
-        end
-      end
-    end
-
     # If all else fails, a default version will be picked.
     # @api private
     class Default < Source
@@ -236,10 +247,10 @@ module RuboCop
 
     SOURCES = [
       RuboCopConfig,
+      GemspecFile,
       RubyVersionFile,
       ToolVersionsFile,
       BundlerLockFile,
-      GemspecFile,
       Default
     ].freeze
 
@@ -262,7 +273,7 @@ module RuboCop
 
     def rubocop_version_with_support
       if supported?
-        RuboCop::Version.version
+        RuboCop::Version::STRING
       else
         OBSOLETE_RUBIES[version]
       end