rubocop 0.78.0 → 1.13.0

data/lib/rubocop/string_interpreter.rb

@@ -17,6 +17,9 @@ module RuboCop
                             u\{[^}]*\}        |   # extended unicode escape
                             .                     # any other escaped char
                           )/x.freeze
+
+    private_constant :STRING_ESCAPES, :STRING_ESCAPE_REGEX
+
     class << self
       def interpret(string)
         # We currently don't handle \cx, \C-x, and \M-x

data/lib/rubocop/target_finder.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module RuboCop
   # 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}."
+
     def initialize(config_store, options = {})
       @config_store = config_store
       @options = options
@@ -27,7 +28,7 @@ module RuboCop
     # (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)
+    def find(args, mode)
       return target_files_in_dir if args.empty?
 
       files = []
@@ -36,7 +37,7 @@ module RuboCop
         files += if File.directory?(arg)
                    target_files_in_dir(arg.chomp(File::SEPARATOR))
                  else
-                   process_explicit_path(arg)
+                   process_explicit_path(arg, mode)
                  end
       end
 
@@ -54,23 +55,22 @@ module RuboCop
     # @return [Array] Array of filenames
     def target_files_in_dir(base_dir = Dir.pwd)
       # Support Windows: Backslashes from command-line -> forward slashes
-      if File::ALT_SEPARATOR
-        base_dir = base_dir.gsub(File::ALT_SEPARATOR, File::SEPARATOR)
-      end
+      base_dir = base_dir.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
       all_files = find_files(base_dir, File::FNM_DOTMATCH)
-      hidden_files = Set.new(all_files - find_files(base_dir, 0))
+      # use file.include? for performance optimization
+      hidden_files = all_files.select { |file| file.include?(HIDDEN_PATH_SUBSTRING) }.sort
       base_dir_config = @config_store.for(base_dir)
 
-      target_files = all_files.select do |file|
-        to_inspect?(file, hidden_files, base_dir_config)
-      end
+      target_files = all_files.select { |file| to_inspect?(file, hidden_files, base_dir_config) }
 
       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.include?(file) && ruby_file?(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
@@ -81,34 +81,36 @@ module RuboCop
     # the top level directories that are excluded in configuration in the
     # normal way (dir/**/*).
     def find_files(base_dir, flags)
-      wanted_toplevel_dirs = toplevel_dirs(base_dir, flags) -
-                             excluded_dirs(base_dir)
-      wanted_toplevel_dirs.map! { |dir| dir << '/**/*' }
-
-      pattern = if wanted_toplevel_dirs.empty?
-                  # We need this special case to avoid creating the pattern
-                  # /**/* which searches the entire file system.
-                  ["#{base_dir}/**/*"]
-                else
-                  # Search the non-excluded top directories, but also add files
-                  # on the top level, which would otherwise not be found.
-                  wanted_toplevel_dirs.unshift("#{base_dir}/*")
+      # get all wanted directories first to improve speed of finding all files
+      exclude_pattern = combined_exclude_glob_patterns(base_dir)
+      dir_flags = flags | File::FNM_PATHNAME | File::FNM_EXTGLOB
+      patterns = wanted_dir_patterns(base_dir, exclude_pattern, dir_flags)
+      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?
+
+      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)
+                .reject do |dir|
+                  next true if dir.end_with?('/./', '/../')
+                  next true if File.fnmatch?(exclude_pattern, dir, flags)
+
+                  File.symlink?(dir.chomp('/')) && File.fnmatch?(exclude_pattern,
+                                                                 "#{File.realpath(dir)}/", flags)
                 end
-      Dir.glob(pattern, flags).select { |path| FileTest.file?(path) }
+      dirs.flat_map { |dir| wanted_dir_patterns(dir, exclude_pattern, flags) }.unshift(base_dir)
     end
 
-    def toplevel_dirs(base_dir, flags)
-      Dir.glob(File.join(base_dir, '*'), flags).select do |dir|
-        File.directory?(dir) && !dir.end_with?('/.', '/..')
-      end
-    end
-
-    def excluded_dirs(base_dir)
-      all_cops_config = @config_store.for(base_dir).for_all_cops
-      dir_tree_excludes = all_cops_config['Exclude'].select do |pattern|
-        pattern.is_a?(String) && pattern.end_with?('/**/*')
-      end
-      dir_tree_excludes.map { |pattern| pattern.sub(%r{/\*\*/\*$}, '') }
+    def combined_exclude_glob_patterns(base_dir)
+      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)
@@ -116,10 +118,10 @@ module RuboCop
     end
 
     def ruby_extensions
-      ext_patterns = all_cops_include.select do |pattern|
-        pattern.start_with?('**/*.')
+      @ruby_extensions ||= begin
+        ext_patterns = all_cops_include.select { |pattern| pattern.start_with?('**/*.') }
+        ext_patterns.map { |pattern| pattern.sub('**/*', '') }
       end
-      ext_patterns.map { |pattern| pattern.sub('**/*', '') }
     end
 
     def ruby_filename?(file)
@@ -127,21 +129,21 @@ module RuboCop
     end
 
     def ruby_filenames
-      file_patterns = all_cops_include.reject do |pattern|
-        pattern.start_with?('**/*.')
+      @ruby_filenames ||= begin
+        file_patterns = all_cops_include.reject { |pattern| pattern.start_with?('**/*.') }
+        file_patterns.map { |pattern| pattern.sub('**/', '') }
       end
-      file_patterns.map { |pattern| pattern.sub('**/', '') }
     end
 
     def all_cops_include
-      @config_store.for('.').for_all_cops['Include'].map(&:to_s)
+      @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)
 
       first_line = File.open(file, &:readline)
-      !(first_line =~ /#!.*(#{ruby_interpreters(file).join('|')})/).nil?
+      /#!.*(#{ruby_interpreters(file).join('|')})/.match?(first_line)
     rescue EOFError, ArgumentError => e
       warn("Unprocessable file #{file}: #{e.class}, #{e.message}") if debug?
 
@@ -157,22 +159,23 @@ module RuboCop
     end
 
     def ruby_file?(file)
-      stdin? || ruby_extension?(file) || ruby_filename?(file) ||
-        ruby_executable?(file)
+      stdin? || ruby_extension?(file) || ruby_filename?(file) || ruby_executable?(file)
     end
 
     def configured_include?(file)
-      @config_store.for('.').file_to_include?(file)
+      @config_store.for_pwd.file_to_include?(file)
     end
 
     def included_file?(file)
       ruby_file?(file) || configured_include?(file)
     end
 
-    def process_explicit_path(path)
+    def process_explicit_path(path, mode)
       files = path.include?('*') ? Dir[path] : [path]
 
-      files.select! { |file| included_file?(file) }
+      if mode == :only_recognized_file_types || force_exclusion?
+        files.select! { |file| included_file?(file) }
+      end
 
       return files unless force_exclusion?
 

data/lib/rubocop/target_ruby.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+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].freeze
+    DEFAULT_VERSION = KNOWN_RUBIES.first
+
+    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'
+    }.freeze
+    private_constant :KNOWN_RUBIES, :OBSOLETE_RUBIES
+
+    # A place where information about a target ruby version is found.
+    # @api private
+    class Source
+      attr_reader :version, :name
+
+      def initialize(config)
+        @config = config
+        @version = find_version
+      end
+
+      def to_s
+        name
+      end
+    end
+
+    # The target ruby version may be configured in RuboCop's config.
+    # @api private
+    class RuboCopConfig < Source
+      def name
+        "`TargetRubyVersion` parameter (in #{@config.smart_loaded_path})"
+      end
+
+      private
+
+      def find_version
+        @config.for_all_cops['TargetRubyVersion']&.to_f
+      end
+    end
+
+    # The target ruby version may be found in a .ruby-version file.
+    # @api private
+    class RubyVersionFile < Source
+      RUBY_VERSION_FILENAME = '.ruby-version'
+      RUBY_VERSION_PATTERN = /\A(?:ruby-)?(?<version>\d+\.\d+)/.freeze
+
+      def name
+        "`#{RUBY_VERSION_FILENAME}`"
+      end
+
+      private
+
+      def filename
+        RUBY_VERSION_FILENAME
+      end
+
+      def pattern
+        RUBY_VERSION_PATTERN
+      end
+
+      def find_version
+        file = version_file
+        return unless file && File.file?(file)
+
+        File.read(file).match(pattern) { |md| md[:version].to_f }
+      end
+
+      def version_file
+        @version_file ||= @config.find_file_upwards(filename, @config.base_dir_for_path_parameters)
+      end
+    end
+
+    # The target ruby version may be found in a .tool-versions file, in a line
+    # starting with `ruby`.
+    # @api private
+    class ToolVersionsFile < RubyVersionFile
+      TOOL_VERSIONS_FILENAME = '.tool-versions'
+      TOOL_VERSIONS_PATTERN = /\Aruby (?:ruby-)?(?<version>\d+\.\d+)/.freeze
+
+      def name
+        "`#{TOOL_VERSIONS_FILENAME}`"
+      end
+
+      private
+
+      def filename
+        TOOL_VERSIONS_FILENAME
+      end
+
+      def pattern
+        TOOL_VERSIONS_PATTERN
+      end
+    end
+
+    # The lock file of Bundler may identify the target ruby version.
+    # @api private
+    class BundlerLockFile < Source
+      def name
+        "`#{bundler_lock_file_path}`"
+      end
+
+      private
+
+      def find_version
+        lock_file_path = bundler_lock_file_path
+        return nil unless lock_file_path
+
+        in_ruby_section = false
+        File.foreach(lock_file_path) do |line|
+          # If ruby is in Gemfile.lock or gems.lock, there should be two lines
+          # towards the bottom of the file that look like:
+          #     RUBY VERSION
+          #       ruby W.X.YpZ
+          # We ultimately want to match the "ruby W.X.Y.pZ" line, but there's
+          # extra logic to make sure we only start looking once we've seen the
+          # "RUBY VERSION" line.
+          in_ruby_section ||= line.match(/^\s*RUBY\s*VERSION\s*$/)
+          next unless in_ruby_section
+
+          # We currently only allow this feature to work with MRI ruby. If
+          # jruby (or something else) is used by the project, it's lock file
+          # will have a line that looks like:
+          #     RUBY VERSION
+          #       ruby W.X.YpZ (jruby x.x.x.x)
+          # The regex won't match in this situation.
+          result = line.match(/^\s*ruby\s+(\d+\.\d+)[p.\d]*\s*$/)
+          return result.captures.first.to_f if result
+        end
+      end
+
+      def bundler_lock_file_path
+        @config.bundler_lock_file_path
+      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_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_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")) }
+      end
+    end
+
+    # If all else fails, a default version will be picked.
+    # @api private
+    class Default < Source
+      def name
+        'default'
+      end
+
+      private
+
+      def find_version
+        DEFAULT_VERSION
+      end
+    end
+
+    def self.supported_versions
+      KNOWN_RUBIES
+    end
+
+    SOURCES = [
+      RuboCopConfig,
+      RubyVersionFile,
+      ToolVersionsFile,
+      BundlerLockFile,
+      GemspecFile,
+      Default
+    ].freeze
+
+    private_constant :SOURCES
+
+    def initialize(config)
+      @config = config
+    end
+
+    def source
+      @source ||= SOURCES.each.lazy.map { |c| c.new(@config) }.detect(&:version)
+    end
+
+    def version
+      source.version
+    end
+
+    def supported?
+      KNOWN_RUBIES.include?(version)
+    end
+
+    def rubocop_version_with_support
+      if supported?
+        RuboCop::Version.version
+      else
+        OBSOLETE_RUBIES[version]
+      end
+    end
+  end
+end