rubocop 0.42.0 → 0.52.1

data/lib/rubocop/options.rb

@@ -1,13 +1,14 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'optparse'
 require 'shellwords'
 
 module RuboCop
+  class IncorrectCopNameError < StandardError; end
+
   # This class handles command line options.
   class Options
-    EXITING_OPTIONS = [:version, :verbose_version, :show_cops].freeze
+    EXITING_OPTIONS = %i[version verbose_version show_cops].freeze
     DEFAULT_MAXIMUM_EXCLUSION_ITEMS = 15
 
     def initialize
@@ -18,14 +19,19 @@ module RuboCop
     def parse(command_line_args)
       args = args_from_file.concat(args_from_env).concat(command_line_args)
       define_options(args).parse!(args)
-      # The --no-color CLI option sets `color: false` so we don't want the
-      # `no_color` key, which is created automatically.
-      @options.delete(:no_color)
 
       @validator.validate_compatibility
 
-      if @options[:stdin] && !args.one?
-        raise ArgumentError, '-s/--stdin requires exactly one path.'
+      if @options[:stdin]
+        # The parser has put the file name given after --stdin into
+        # @options[:stdin]. The args array should be empty.
+        if args.any?
+          raise ArgumentError, '-s/--stdin requires exactly one path.'
+        end
+        # We want the STDIN contents in @options[:stdin] and the file name in
+        # args to simplify the rest of the processing.
+        args = [@options[:stdin]]
+        @options[:stdin] = $stdin.binmode.read
       end
 
       [@options, args]
@@ -34,7 +40,7 @@ module RuboCop
     private
 
     def args_from_file
-      if File.exist?('.rubocop')
+      if File.exist?('.rubocop') && !File.directory?('.rubocop')
         IO.readlines('.rubocop').map(&:strip)
       else
         []
@@ -59,6 +65,8 @@ module RuboCop
         add_severity_option(opts)
         add_flags_with_optional_args(opts)
         add_boolean_flags(opts)
+
+        option(opts, '-s', '--stdin FILE')
       end
     end
 
@@ -91,6 +99,9 @@ module RuboCop
       end
 
       option(opts, '--force-exclusion')
+      option(opts, '--ignore-parent-exclusion')
+
+      option(opts, '--force-default-config')
 
       option(opts, '--no-offense-counts') do
         @options[:no_offense_counts] = true
@@ -127,11 +138,11 @@ module RuboCop
       end
     end
 
-    def add_boolean_flags(opts)
+    def add_boolean_flags(opts) # rubocop:disable Metrics/MethodLength
       option(opts, '-F', '--fail-fast')
       option(opts, '-C', '--cache FLAG')
       option(opts, '-d', '--debug')
-      option(opts, '-D', '--display-cop-names')
+      option(opts, '-D', '--[no-]display-cop-names')
       option(opts, '-E', '--extra-details')
       option(opts, '-S', '--display-style-guide')
       option(opts, '-R', '--rails')
@@ -141,11 +152,11 @@ module RuboCop
       end
       option(opts, '-a', '--auto-correct')
 
-      option(opts, '-n', '--[no-]color') { |c| @options[:color] = c }
+      option(opts, '--[no-]color')
 
       option(opts, '-v', '--version')
       option(opts, '-V', '--verbose-version')
-      option(opts, '-s', '--stdin') { @options[:stdin] = $stdin.read }
+      option(opts, '-P', '--parallel')
     end
 
     def add_list_options(opts)
@@ -167,24 +178,47 @@ module RuboCop
     # e.g. [..., '--auto-correct', ...] to :auto_correct.
     def long_opt_symbol(args)
       long_opt = args.find { |arg| arg.start_with?('--') }
-      long_opt[2..-1].sub(/ .*/, '').tr('-', '_').gsub(/[\[\]]/, '').to_sym
+      long_opt[2..-1].sub('[no-]', '').sub(/ .*/, '')
+                     .tr('-', '_').gsub(/[\[\]]/, '').to_sym
     end
   end
 
   # Validates option arguments and the options' compatibility with each other.
   class OptionsValidator
-    # Cop name validation must be done later than option parsing, so it's not
-    # called from within Options.
-    def self.validate_cop_list(names)
-      return unless names
-
-      namespaces = Cop::Cop.all.types.map { |t| t.to_s.capitalize }
-      names.each do |name|
-        next if Cop::Cop.all.any? { |c| c.cop_name == name }
-        next if namespaces.include?(name)
-        next if %w(Syntax Lint/Syntax).include?(name)
-
-        raise ArgumentError, "Unrecognized cop or namespace: #{name}."
+    class << self
+      # Cop name validation must be done later than option parsing, so it's not
+      # called from within Options.
+      def validate_cop_list(names)
+        return unless names
+
+        cop_names = Cop::Cop.registry.names
+        departments = Cop::Cop.registry.departments.map(&:to_s)
+
+        names.each do |name|
+          next if cop_names.include?(name)
+          next if departments.include?(name)
+          next if %w[Syntax Lint/Syntax].include?(name)
+
+          raise IncorrectCopNameError, format_message_from(name, cop_names)
+        end
+      end
+
+      private
+
+      def format_message_from(name, cop_names)
+        message = 'Unrecognized cop or department: %{name}.'
+        message_with_candidate = "#{message}\nDid you mean? %{candidate}"
+        corrections = cop_names.select do |cn|
+          score = StringUtil.similarity(cn, name)
+          score >= NameSimilarity::MINIMUM_SIMILARITY_TO_SUGGEST
+        end.sort
+
+        if corrections.empty?
+          format message, name: name
+        else
+          format message_with_candidate, name: name,
+                                         candidate: corrections.join(', ')
+        end
       end
     end
 
@@ -192,7 +226,7 @@ module RuboCop
       @options = options
     end
 
-    def validate_compatibility
+    def validate_compatibility # rubocop:disable Metrics/MethodLength
       if only_includes_unneeded_disable?
         raise ArgumentError, 'Lint/UnneededDisable can not be used with --only.'
       end
@@ -206,23 +240,45 @@ module RuboCop
         raise ArgumentError, '--no-offense-counts can only be used together ' \
                              'with --auto-gen-config.'
       end
+      validate_parallel
+
       return if incompatible_options.size <= 1
       raise ArgumentError, 'Incompatible cli options: ' \
                            "#{incompatible_options.inspect}"
     end
 
+    def validate_parallel
+      return unless @options.key?(:parallel)
+
+      if @options[:cache] == 'false'
+        raise ArgumentError, '-P/--parallel uses caching to speed up ' \
+                             'execution, so combining with --cache false is ' \
+                             'not allowed.'
+      end
+
+      combos = {
+        auto_gen_config: '-P/--parallel uses caching to speed up execution, ' \
+                         'while --auto-gen-config needs a non-cached run, ' \
+                         'so they cannot be combined.',
+        fail_fast: '-P/--parallel can not be combined with -F/--fail-fast.',
+        auto_correct: '-P/--parallel can not be combined with --auto-correct.'
+      }
+
+      combos.each { |key, msg| raise ArgumentError, msg if @options.key?(key) }
+    end
+
     def only_includes_unneeded_disable?
       @options.key?(:only) &&
-        (@options[:only] & %w(Lint/UnneededDisable UnneededDisable)).any?
+        (@options[:only] & %w[Lint/UnneededDisable UnneededDisable]).any?
     end
 
     def except_syntax?
       @options.key?(:except) &&
-        (@options[:except] & %w(Lint/Syntax Syntax)).any?
+        (@options[:except] & %w[Lint/Syntax Syntax]).any?
     end
 
     def boolean_or_empty_cache?
-      !@options.key?(:cache) || %w(true false).include?(@options[:cache])
+      !@options.key?(:cache) || %w[true false].include?(@options[:cache])
     end
 
     def no_offense_counts_without_auto_gen_config?
@@ -253,65 +309,75 @@ module RuboCop
   module OptionsHelp
     MAX_EXCL = RuboCop::Options::DEFAULT_MAXIMUM_EXCLUSION_ITEMS.to_s
     TEXT = {
-      only:                 'Run only the given cop(s).',
-      only_guide_cops:     ['Run only cops for rules that link to a',
-                            'style guide.'],
-      except:               'Disable the given cop(s).',
-      require:              'Require Ruby file.',
-      config:               'Specify configuration file.',
-      auto_gen_config:     ['Generate a configuration file acting as a',
-                            'TODO list.'],
-      no_offense_counts:   ['Do not include offense counts in configuration',
-                            'file generated by --auto-gen-config.'],
-      exclude_limit:       ['Used together with --auto-gen-config to',
-                            'set the limit for how many Exclude',
-                            "properties to generate. Default is #{MAX_EXCL}."],
-      force_exclusion:     ['Force excluding files specified in the',
-                            'configuration `Exclude` even if they are',
-                            'explicitly passed as arguments.'],
-      format:              ['Choose an output formatter. This option',
-                            'can be specified multiple times to enable',
-                            'multiple formatters at the same time.',
-                            '  [p]rogress (default)',
-                            '  [s]imple',
-                            '  [c]lang',
-                            '  [d]isabled cops via inline comments',
-                            '  [fu]ubar',
-                            '  [e]macs',
-                            '  [j]son',
-                            '  [h]tml',
-                            '  [fi]les',
-                            '  [o]ffenses',
-                            '  [w]orst',
-                            '  custom formatter class name'],
-      out:                 ['Write output to a file instead of STDOUT.',
-                            'This option applies to the previously',
-                            'specified --format, or the default format',
-                            'if no format is specified.'],
-      fail_level:          ['Minimum severity (A/R/C/W/E/F) for exit',
-                            'with error code.'],
-      show_cops:           ['Shows the given cops, or all cops by',
-                            'default, and their configurations for the',
-                            'current directory.'],
-      fail_fast:           ['Inspect files in order of modification',
-                            'time and stop after the first file',
-                            'containing offenses.'],
-      cache:               ["Use result caching (FLAG=true) or don't",
-                            '(FLAG=false), default determined by',
-                            'configuration parameter AllCops: UseCache.'],
-      debug:                'Display debug info.',
-      display_cop_names:    'Display cop names in offense messages.',
-      display_style_guide:  'Display style guide URLs in offense messages.',
-      extra_details:        'Display extra details in offense messages.',
-      rails:                'Run extra Rails cops.',
-      lint:                 'Run only lint cops.',
-      list_target_files:    'List all files RuboCop will inspect.',
-      auto_correct:         'Auto-correct offenses.',
-      no_color:             'Force color output on or off.',
-      version:              'Display version.',
-      verbose_version:      'Display verbose version.',
-      stdin:                ['Pipe source from STDIN.',
-                             'This is useful for editor integration.']
+      only:                  'Run only the given cop(s).',
+      only_guide_cops:      ['Run only cops for rules that link to a',
+                             'style guide.'],
+      except:                'Disable the given cop(s).',
+      require:               'Require Ruby file.',
+      config:                'Specify configuration file.',
+      auto_gen_config:      ['Generate a configuration file acting as a',
+                             'TODO list.'],
+      no_offense_counts:    ['Do not include offense counts in configuration',
+                             'file generated by --auto-gen-config.'],
+      exclude_limit:        ['Used together with --auto-gen-config to',
+                             'set the limit for how many Exclude',
+                             "properties to generate. Default is #{MAX_EXCL}."],
+      force_exclusion:      ['Force excluding files specified in the',
+                             'configuration `Exclude` even if they are',
+                             'explicitly passed as arguments.'],
+      ignore_parent_exclusion:
+                            ['Prevent from inheriting AllCops/Exclude from',
+                             'parent folders.'],
+      force_default_config: ['Use default configuration even if configuration',
+                             'files are present in the directory tree.'],
+      format:               ['Choose an output formatter. This option',
+                             'can be specified multiple times to enable',
+                             'multiple formatters at the same time.',
+                             '  [p]rogress (default)',
+                             '  [s]imple',
+                             '  [c]lang',
+                             '  [d]isabled cops via inline comments',
+                             '  [fu]ubar',
+                             '  [e]macs',
+                             '  [j]son',
+                             '  [h]tml',
+                             '  [fi]les',
+                             '  [o]ffenses',
+                             '  [w]orst',
+                             '  [t]ap',
+                             '  [q]uiet',
+                             '  custom formatter class name'],
+      out:                  ['Write output to a file instead of STDOUT.',
+                             'This option applies to the previously',
+                             'specified --format, or the default format',
+                             'if no format is specified.'],
+      fail_level:           ['Minimum severity (A/R/C/W/E/F) for exit',
+                             'with error code.'],
+      show_cops:            ['Shows the given cops, or all cops by',
+                             'default, and their configurations for the',
+                             'current directory.'],
+      fail_fast:            ['Inspect files in order of modification',
+                             'time and stop after the first file',
+                             'containing offenses.'],
+      cache:                ["Use result caching (FLAG=true) or don't",
+                             '(FLAG=false), default determined by',
+                             'configuration parameter AllCops: UseCache.'],
+      debug:                 'Display debug info.',
+      display_cop_names:     ['Display cop names in offense messages.',
+                              'Default is true.'],
+      display_style_guide:   'Display style guide URLs in offense messages.',
+      extra_details:         'Display extra details in offense messages.',
+      rails:                 'Run extra Rails cops.',
+      lint:                  'Run only lint cops.',
+      list_target_files:     'List all files RuboCop will inspect.',
+      auto_correct:          'Auto-correct offenses.',
+      color:                 'Force color output on or off.',
+      version:               'Display version.',
+      verbose_version:       'Display verbose version.',
+      parallel:             ['Use available CPUs to execute inspection in',
+                             'parallel.'],
+      stdin:                ['Pipe source from STDIN, using FILE in offense',
+                             'reports. This is useful for editor integration.']
     }.freeze
   end
 end

data/lib/rubocop/path_util.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,21 +5,48 @@ module RuboCop
   module PathUtil
     module_function
 
-    def relative_path(path, base_dir = Dir.pwd)
+    def relative_path(path, base_dir = PathUtil.pwd)
       # Optimization for the common case where path begins with the base
       # dir. Just cut off the first part.
-      return path[(base_dir.length + 1)..-1] if path.start_with?(base_dir)
+      if path.start_with?(base_dir)
+        base_dir_length = base_dir.length
+        result_length = path.length - base_dir_length - 1
+        return path[base_dir_length + 1, result_length]
+      end
 
       path_name = Pathname.new(File.expand_path(path))
       path_name.relative_path_from(Pathname.new(base_dir)).to_s
     end
 
+    def smart_path(path)
+      # Ideally, we calculate this relative to the project root.
+      base_dir = PathUtil.pwd
+
+      if path.start_with? base_dir
+        relative_path(path, base_dir)
+      else
+        path
+      end
+    end
+
     def match_path?(pattern, path)
       case pattern
       when String
         File.fnmatch?(pattern, path, File::FNM_PATHNAME)
       when Regexp
-        path =~ pattern
+        begin
+          path =~ pattern
+        rescue ArgumentError => e
+          return false if e.message.start_with?('invalid byte sequence')
+          raise e
+        end
+      end
+    end
+
+    def find_file_upwards(filename, start_dir = PathUtil.pwd)
+      Pathname(File.expand_path(start_dir)).ascend do |dir|
+        file = File.join(dir, filename)
+        return file if File.exist?(file)
       end
     end
 
@@ -28,5 +54,13 @@ module RuboCop
     def absolute?(path)
       path =~ %r{\A([A-Z]:)?/}
     end
+
+    def self.pwd
+      @pwd ||= Dir.pwd
+    end
+
+    def self.reset_pwd
+      @pwd = nil
+    end
   end
 end

data/lib/rubocop/platform.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # This module provides information on the platform that RuboCop is being run
+  # on.
+  module Platform
+    def self.windows?
+      RUBY_PLATFORM =~ /cygwin|mswin|mingw|bccwin|wince|emx/
+    end
+  end
+end

data/lib/rubocop/processed_source.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'digest/md5'
@@ -14,16 +13,16 @@ module RuboCop
                 :parser_error, :raw_source, :ruby_version
 
     def self.from_file(path, ruby_version)
-      file = File.read(path)
+      file = File.read(path, mode: 'rb')
       new(file, ruby_version, path)
     rescue Errno::ENOENT
       raise RuboCop::Error, "No such file or directory: #{path}"
     end
 
     def initialize(source, ruby_version, path = nil)
-      # In Ruby 2, source code encoding defaults to UTF-8. We follow the same
-      # principle regardless of which Ruby version we're running under.
-      # Encoding comments will override this setting.
+      # Defaults source encoding to UTF-8, regardless of the encoding it has
+      # been read with, which could be non-utf8 depending on the default
+      # external encoding.
       unless source.encoding == Encoding::UTF_8
         source.force_encoding(Encoding::UTF_8)
       end
@@ -32,6 +31,7 @@ module RuboCop
       @path = path
       @diagnostics = []
       @ruby_version = ruby_version
+      @parser_error = nil
 
       parse(source, ruby_version)
     end
@@ -54,7 +54,7 @@ module RuboCop
     def lines
       @lines ||= begin
         all_lines = @buffer.source_lines
-        last_token_line = tokens.any? ? tokens.last.pos.line : all_lines.size
+        last_token_line = tokens.any? ? tokens.last.line : all_lines.size
         result = []
         all_lines.each_with_index do |line, ix|
           break if ix >= last_token_line && line == '__END__'
@@ -70,7 +70,7 @@ module RuboCop
 
     def valid_syntax?
       return false if @parser_error
-      @diagnostics.none? { |d| [:error, :fatal].include?(d.level) }
+      @diagnostics.none? { |d| %i[error fatal].include?(d.level) }
     end
 
     # Raw source checksum for tracking infinite loops.
@@ -91,26 +91,25 @@ module RuboCop
         return
       end
 
-      parser = create_parser(ruby_version)
+      @ast, @comments, @tokens = tokenize(create_parser(ruby_version))
+    end
 
+    def tokenize(parser)
       begin
-        @ast, @comments, tokens = parser.tokenize(@buffer)
-        @ast.complete! if @ast
+        ast, comments, tokens = parser.tokenize(@buffer)
+        ast.complete! if ast
       rescue Parser::SyntaxError # rubocop:disable Lint/HandleExceptions
         # All errors are in diagnostics. No need to handle exception.
       end
 
-      @tokens = tokens.map { |t| Token.from_parser_token(t) } if tokens
+      tokens = tokens.map { |t| Token.from_parser_token(t) } if tokens
+
+      [ast, comments, tokens]
     end
 
-    def parser_class(ruby_version) # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/MethodLength
+    def parser_class(ruby_version)
       case ruby_version
-      when 1.9
-        require 'parser/ruby19'
-        Parser::Ruby19
-      when 2.0
-        require 'parser/ruby20'
-        Parser::Ruby20
       when 2.1
         require 'parser/ruby21'
         Parser::Ruby21
@@ -123,16 +122,20 @@ module RuboCop
       when 2.4
         require 'parser/ruby24'
         Parser::Ruby24
+      when 2.5
+        require 'parser/ruby25'
+        Parser::Ruby25
       else
         raise ArgumentError, "Unknown Ruby version: #{ruby_version.inspect}"
       end
     end
+    # rubocop:enable Metrics/MethodLength
 
     def create_parser(ruby_version)
-      builder = RuboCop::Node::Builder.new
+      builder = RuboCop::AST::Builder.new
 
       parser_class(ruby_version).new(builder).tap do |parser|
-        # On JRuby and Rubinius, there's a risk that we hang in tokenize() if we
+        # On JRuby there's a risk that we hang in tokenize() if we
         # don't set the all errors as fatal flag. The problem is caused by a bug
         # in Racc that is discussed in issue #93 of the whitequark/parser
         # project on GitHub.

data/lib/rubocop/rake_task.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'rake'
@@ -18,25 +17,21 @@ module RuboCop
     attr_accessor :requires
     attr_accessor :options
 
-    def initialize(*args, &task_block)
-      setup_ivars(args)
+    def initialize(name = :rubocop, *args, &task_block)
+      setup_ivars(name)
 
       desc 'Run RuboCop' unless ::Rake.application.last_description
 
       task(name, *args) do |_, task_args|
-        RakeFileUtils.send(:verbose, verbose) do
+        RakeFileUtils.verbose(verbose) do
           yield(*[self, task_args].slice(0, task_block.arity)) if block_given?
-          run_main_task(verbose)
+          run_cli(verbose, full_options)
         end
       end
 
       setup_subtasks(name, *args, &task_block)
     end
 
-    def run_main_task(verbose)
-      run_cli(verbose, full_options)
-    end
-
     private
 
     def run_cli(verbose, options)
@@ -51,19 +46,14 @@ module RuboCop
     end
 
     def full_options
-      [].tap do |result|
-        result.concat(formatters.map { |f| ['--format', f] }.flatten)
-        result.concat(requires.map { |r| ['--require', r] }.flatten)
-        result.concat(options.flatten)
-        result.concat(patterns)
-      end
+      formatters.map { |f| ['--format', f] }.flatten
+                .concat(requires.map { |r| ['--require', r] }.flatten)
+                .concat(options.flatten)
+                .concat(patterns)
     end
 
-    def setup_ivars(args)
-      # More lazy-loading to keep load time down.
-      require 'rubocop/options'
-
-      @name = args.shift || :rubocop
+    def setup_ivars(name)
+      @name = name
       @verbose = true
       @fail_on_error = true
       @patterns = []
@@ -73,13 +63,15 @@ module RuboCop
     end
 
     def setup_subtasks(name, *args, &task_block)
-      namespace name do
+      namespace(name) do
         desc 'Auto-correct RuboCop offenses'
 
         task(:auto_correct, *args) do |_, task_args|
-          yield(*[self, task_args].slice(0, task_block.arity)) if block_given?
-          options = full_options.unshift('--auto-correct')
-          run_cli(verbose, options)
+          RakeFileUtils.verbose(verbose) do
+            yield(*[self, task_args].slice(0, task_block.arity)) if block_given?
+            options = full_options.unshift('--auto-correct')
+            run_cli(verbose, options)
+          end
         end
       end
     end