rubocop 0.51.0 → 0.87.0

data/lib/rubocop/target_finder.rb

@@ -3,58 +3,6 @@
 require 'set'
 
 module RuboCop
-  RUBY_EXTENSIONS = %w[.rb
-                       .builder
-                       .fcgi
-                       .gemspec
-                       .god
-                       .jb
-                       .jbuilder
-                       .mspec
-                       .opal
-                       .pluginspec
-                       .podspec
-                       .rabl
-                       .rake
-                       .rbuild
-                       .rbw
-                       .rbx
-                       .ru
-                       .ruby
-                       .spec
-                       .thor
-                       .watchr].freeze
-
-  RUBY_INTERPRETERS = %w[ruby
-                         macruby
-                         rake
-                         jruby
-                         rbx].freeze
-
-  RUBY_FILENAMES = %w[.irbrc
-                      .pryrc
-                      Appraisals
-                      Berksfile
-                      Brewfile
-                      Buildfile
-                      Capfile
-                      Cheffile
-                      Dangerfile
-                      Deliverfile
-                      Fastfile
-                      Gemfile
-                      Guardfile
-                      Jarfile
-                      Mavenfile
-                      Podfile
-                      Puppetfile
-                      Rakefile
-                      Snapfile
-                      Thorfile
-                      Vagabondfile
-                      Vagrantfile
-                      buildfile].freeze
-
   # This class finds target files to inspect by scanning the directory tree
   # and picking ruby files.
   class TargetFinder
@@ -79,7 +27,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 = []
@@ -88,7 +36,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
 
@@ -106,9 +54,7 @@ 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))
       base_dir_config = @config_store.for(base_dir)
@@ -117,15 +63,13 @@ module RuboCop
         to_inspect?(file, hidden_files, base_dir_config)
       end
 
-      # Most recently modified file first.
-      target_files.sort_by! { |path| -File.mtime(path).to_i } if fail_fast?
-
-      target_files
+      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)
+
       base_dir_config.file_to_include?(file)
     end
 
@@ -166,30 +110,69 @@ module RuboCop
     end
 
     def ruby_extension?(file)
-      RUBY_EXTENSIONS.include?(File.extname(file))
+      ruby_extensions.include?(File.extname(file))
+    end
+
+    def ruby_extensions
+      ext_patterns = all_cops_include.select do |pattern|
+        pattern.start_with?('**/*.')
+      end
+      ext_patterns.map { |pattern| pattern.sub('**/*', '') }
     end
 
     def ruby_filename?(file)
-      RUBY_FILENAMES.include?(File.basename(file))
+      ruby_filenames.include?(File.basename(file))
+    end
+
+    def ruby_filenames
+      file_patterns = all_cops_include.reject do |pattern|
+        pattern.start_with?('**/*.')
+      end
+      file_patterns.map { |pattern| pattern.sub('**/', '') }
+    end
+
+    def all_cops_include
+      @config_store.for('.').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.join('|')})/).nil?
+      /#!.*(#{ruby_interpreters(file).join('|')})/.match?(first_line)
     rescue EOFError, ArgumentError => e
-      warn "Unprocessable file #{file}: #{e.class}, #{e.message}" if debug?
+      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 stdin?
+      @options.key?(:stdin)
+    end
+
     def ruby_file?(file)
-      ruby_extension?(file) || ruby_filename?(file) || ruby_executable?(file)
+      stdin? || ruby_extension?(file) || ruby_filename?(file) ||
+        ruby_executable?(file)
     end
 
-    def process_explicit_path(path)
+    def configured_include?(file)
+      @config_store.for('.').file_to_include?(file)
+    end
+
+    def included_file?(file)
+      ruby_file?(file) || configured_include?(file)
+    end
+
+    def process_explicit_path(path, mode)
       files = path.include?('*') ? Dir[path] : [path]
 
-      files.select! { |file| ruby_file?(file) }
+      if mode == :only_recognized_file_types || force_exclusion?
+        files.select! { |file| included_file?(file) }
+      end
 
       return files unless force_exclusion?
 
@@ -198,5 +181,16 @@ module RuboCop
         config.file_to_exclude?(file)
       end
     end
+
+    private
+
+    def order
+      if fail_fast?
+        # Most recently modified file first.
+        ->(path) { -Integer(File.mtime(path)) }
+      else
+        :itself
+      end
+    end
   end
 end

data/lib/rubocop/target_ruby.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # The kind of Ruby that code inspected by RuboCop is written in.
+  class TargetRuby
+    KNOWN_RUBIES = [2.4, 2.5, 2.6, 2.7, 2.8].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'
+    }.freeze
+    private_constant :KNOWN_RUBIES, :OBSOLETE_RUBIES
+
+    # A place where information about a target ruby version is found.
+    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.
+    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.
+    class RubyVersionFile < Source
+      FILENAME = '.ruby-version'
+
+      def name
+        "`#{FILENAME}`"
+      end
+
+      private
+
+      def find_version
+        file = ruby_version_file
+        return unless file && File.file?(file)
+
+        # rubocop:disable Lint/MixedRegexpCaptureTypes
+        # `(ruby-)` is not a capture type.
+        File.read(file).match(/\A(ruby-)?(?<version>\d+\.\d+)/) do |md|
+          # rubocop:enable Lint/MixedRegexpCaptureTypes
+          md[:version].to_f
+        end
+      end
+
+      def ruby_version_file
+        @ruby_version_file ||=
+          @config.find_file_upwards(FILENAME,
+                                    @config.base_dir_for_path_parameters)
+      end
+    end
+
+    # The lock file of Bundler may identify the target ruby version.
+    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
+
+    # If all else fails, a default version will be picked.
+    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, BundlerLockFile, 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

data/lib/rubocop/version.rb

@@ -3,14 +3,18 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '0.51.0'.freeze
+    STRING = '0.87.0'
 
-    MSG = '%s (using Parser %s, running on %s %s %s)'.freeze
+    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)'
 
     def self.version(debug = false)
       if debug
-        format(MSG, STRING, Parser::VERSION,
-               RUBY_ENGINE, RUBY_VERSION, RUBY_PLATFORM)
+        format(MSG, version: STRING, parser_version: Parser::VERSION,
+                    rubocop_ast_version: RuboCop::AST::Version::STRING,
+                    ruby_engine: RUBY_ENGINE, ruby_version: RUBY_VERSION,
+                    ruby_platform: RUBY_PLATFORM)
       else
         STRING
       end

data/lib/rubocop/yaml_duplication_checker.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Find duplicated keys from YAML.
+  module YAMLDuplicationChecker
+    def self.check(yaml_string, filename, &on_duplicated)
+      # Ruby 2.6+
+      tree = if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0')
+               # Specify filename to display helpful message when it raises
+               # an error.
+               YAML.parse(yaml_string, filename: filename)
+             else
+               YAML.parse(yaml_string, filename)
+             end
+      return unless tree
+
+      traverse(tree, &on_duplicated)
+    end
+
+    def self.traverse(tree, &on_duplicated)
+      case tree
+      when Psych::Nodes::Mapping
+        tree.children.each_slice(2).with_object([]) do |(key, value), keys|
+          exist = keys.find { |key2| key2.value == key.value }
+          on_duplicated.call(exist, key) if exist
+          keys << key
+          traverse(value, &on_duplicated)
+        end
+      else
+        children = tree.children
+        return unless children
+
+        children.each { |c| traverse(c, &on_duplicated) }
+      end
+    end
+
+    private_class_method :traverse
+  end
+end