rubocop 0.42.0 → 0.52.1

data/lib/rubocop/runner.rb

@@ -1,6 +1,7 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
+require 'parallel'
+
 module RuboCop
   # This class handles the processing of files, which includes dealing with
   # formatters and letting cops inspect the files.
@@ -16,6 +17,8 @@ module RuboCop
       end
     end
 
+    MAX_ITERATIONS = 200
+
     attr_reader :errors, :warnings, :aborting
     alias aborting? aborting
 
@@ -32,6 +35,7 @@ module RuboCop
       if @options[:list_target_files]
         list_files(target_files)
       else
+        warm_cache(target_files) if @options[:parallel]
         inspect_files(target_files)
       end
     end
@@ -42,6 +46,13 @@ module RuboCop
 
     private
 
+    # Warms up the RuboCop cache by forking a suitable number of rubocop
+    # instances that each inspects its allotted group of files.
+    def warm_cache(target_files)
+      puts 'Running parallel inspection' if @options[:debug]
+      Parallel.each(target_files, &method(:file_offenses))
+    end
+
     def find_target_files(paths)
       target_finder = TargetFinder.new(@config_store, @options)
       target_files = target_finder.find(paths)
@@ -50,25 +61,32 @@ module RuboCop
 
     def inspect_files(files)
       inspected_files = []
-      all_passed = true
 
       formatter_set.started(files)
 
-      files.each do |file|
-        break if aborting?
-        offenses = process_file(file)
-        all_passed = false if offenses.any? { |o| considered_failure?(o) }
-        inspected_files << file
-        break if @options[:fail_fast] && !all_passed
-      end
-
-      all_passed
+      each_inspected_file(files) { |file| inspected_files << file }
     ensure
       ResultCache.cleanup(@config_store, @options[:debug]) if cached_run?
       formatter_set.finished(inspected_files.freeze)
       formatter_set.close_output_files
     end
 
+    def each_inspected_file(files)
+      files.reduce(true) do |all_passed, file|
+        break false if aborting?
+
+        offenses = process_file(file)
+        yield file
+
+        if offenses.any? { |o| considered_failure?(o) }
+          break false if @options[:fail_fast]
+          next false
+        end
+
+        all_passed
+      end
+    end
+
     def list_files(paths)
       paths.each do |path|
         puts PathUtil.relative_path(path)
@@ -108,12 +126,9 @@ module RuboCop
     end
 
     def add_unneeded_disables(file, offenses, source)
-      if source.disabled_line_ranges.any? &&
-         # Don't check unneeded disable if --only or --except option is
-         # given, because these options override configuration.
-         (@options[:except] || []).empty? && (@options[:only] || []).empty?
+      if check_for_unneeded_disables?(source)
         config = @config_store.for(file)
-        if config.cop_enabled?(Cop::Lint::UnneededDisable)
+        if config.for_cop(Cop::Lint::UnneededDisable).fetch('Enabled')
           cop = Cop::Lint::UnneededDisable.new(config, @options)
           if cop.relevant_file?(file)
             cop.check(offenses, source.disabled_line_ranges, source.comments)
@@ -127,9 +142,22 @@ module RuboCop
       offenses.sort.reject(&:disabled?).freeze
     end
 
+    def check_for_unneeded_disables?(source)
+      !source.disabled_line_ranges.empty? && !filtered_run?
+    end
+
+    def filtered_run?
+      @options[:except] || @options[:only]
+    end
+
     def autocorrect_unneeded_disables(source, cop)
       cop.processed_source = source
-      Cop::Team.new([], nil, @options).autocorrect(source.buffer, [cop])
+
+      Cop::Team.new(
+        RuboCop::Cop::Registry.new,
+        nil,
+        @options
+      ).autocorrect(source.buffer, [cop])
     end
 
     def file_started(file)
@@ -166,27 +194,11 @@ module RuboCop
     def do_inspection_loop(file, processed_source)
       offenses = []
 
-      # Keep track of the state of the source. If a cop modifies the source
-      # and another cop undoes it producing identical source we have an
-      # infinite loop.
-      @processed_sources = []
-
-      # It is also possible for a cop to keep adding indefinitely to a file,
-      # making it bigger and bigger. If the inspection loop runs for an
-      # excessively high number of iterations, this is likely happening.
-      @iterations = 0
-
       # When running with --auto-correct, we need to inspect the file (which
       # includes writing a corrected version of it) until no more corrections
       # are made. This is because automatic corrections can introduce new
       # offenses. In the normal case the loop is only executed once.
-      loop do
-        check_for_infinite_loop(processed_source, offenses)
-
-        if (@iterations += 1) > 200
-          raise InfiniteCorrectionLoop.new(processed_source.path, offenses)
-        end
-
+      iterate_until_no_changes(processed_source, offenses) do
         # The offenses that couldn't be corrected will be found again so we
         # only keep the corrected ones in order to avoid duplicate reporting.
         offenses.select!(&:corrected?)
@@ -204,6 +216,29 @@ module RuboCop
       [processed_source, offenses]
     end
 
+    def iterate_until_no_changes(source, offenses)
+      # Keep track of the state of the source. If a cop modifies the source
+      # and another cop undoes it producing identical source we have an
+      # infinite loop.
+      @processed_sources = []
+
+      # It is also possible for a cop to keep adding indefinitely to a file,
+      # making it bigger and bigger. If the inspection loop runs for an
+      # excessively high number of iterations, this is likely happening.
+      iterations = 0
+
+      loop do
+        check_for_infinite_loop(source, offenses)
+
+        if (iterations += 1) > MAX_ITERATIONS
+          raise InfiniteCorrectionLoop.new(source.path, offenses)
+        end
+
+        source = yield
+        break unless source
+      end
+    end
+
     # Check whether a run created source identical to a previous run, which
     # means that we definitely have an infinite loop.
     def check_for_infinite_loop(processed_source, offenses)
@@ -236,7 +271,7 @@ module RuboCop
       @mobilized_cop_classes[config.object_id] ||= begin
         cop_classes = Cop::Cop.all
 
-        [:only, :except].each do |opt|
+        %i[only except].each do |opt|
           OptionsValidator.validate_cop_list(@options[opt])
         end
 
@@ -248,15 +283,15 @@ module RuboCop
 
         cop_classes.reject! { |c| c.match?(@options[:except]) }
 
-        cop_classes
+        Cop::Registry.new(cop_classes)
       end
     end
 
     def filter_cop_classes(cop_classes, config)
       # use only cops that link to a style guide if requested
-      if style_guide_cops_only?(config)
-        cop_classes.select! { |cop| config.for_cop(cop)['StyleGuide'] }
-      end
+      return unless style_guide_cops_only?(config)
+
+      cop_classes.select! { |cop| config.for_cop(cop)['StyleGuide'] }
     end
 
     def style_guide_cops_only?(config)

data/lib/rubocop/string_interpreter.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop

data/lib/rubocop/string_util.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -44,13 +43,10 @@ module RuboCop
         transposition_count =
           count_transpositions(common_chars_a, common_chars_b)
 
-        sum = (matched_count / shorter.size.to_f) +
-              (matched_count / longer.size.to_f) +
-              ((matched_count - transposition_count / 2) / matched_count.to_f)
-
-        sum / 3.0
+        compute_non_zero_distance(matched_count.to_f, transposition_count)
       end
 
+      # rubocop:disable Metrics/AbcSize
       def find_common_characters
         common_chars_of_shorter = Array.new(shorter.size)
         common_chars_of_longer = Array.new(longer.size)
@@ -73,6 +69,7 @@ module RuboCop
 
         [common_chars_of_shorter, common_chars_of_longer].map(&:compact)
       end
+      # rubocop:enable Metrics/AbcSize
 
       def count_transpositions(common_chars_a, common_chars_b)
         common_chars_a.size.times.count do |index|
@@ -80,6 +77,14 @@ module RuboCop
         end
       end
 
+      def compute_non_zero_distance(matched_count, transposition_count)
+        sum = (matched_count / shorter.size.to_f) +
+              (matched_count / longer.size.to_f) +
+              ((matched_count - transposition_count / 2) / matched_count)
+
+        sum / 3.0
+      end
+
       def matching_index_range(origin)
         min = origin - matching_window
         min = 0 if min < 0

data/lib/rubocop/target_finder.rb

@@ -1,9 +1,60 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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
@@ -56,7 +107,7 @@ module RuboCop
     def target_files_in_dir(base_dir = Dir.pwd)
       # Support Windows: Backslashes from command-line -> forward slashes
       if File::ALT_SEPARATOR
-        base_dir.gsub!(File::ALT_SEPARATOR, File::SEPARATOR)
+        base_dir = base_dir.gsub(File::ALT_SEPARATOR, File::SEPARATOR)
       end
       all_files = find_files(base_dir, File::FNM_DOTMATCH)
       hidden_files = Set.new(all_files - find_files(base_dir, 0))
@@ -74,10 +125,7 @@ module RuboCop
 
     def to_inspect?(file, hidden_files, base_dir_config)
       return false if base_dir_config.file_to_exclude?(file)
-      unless hidden_files.include?(file)
-        return true if File.extname(file) == '.rb'
-        return true if ruby_executable?(file)
-      end
+      return true if !hidden_files.include?(file) && ruby_file?(file)
       base_dir_config.file_to_include?(file)
     end
 
@@ -117,18 +165,32 @@ module RuboCop
       dir_tree_excludes.map { |pattern| pattern.sub(%r{/\*\*/\*$}, '') }
     end
 
+    def ruby_extension?(file)
+      RUBY_EXTENSIONS.include?(File.extname(file))
+    end
+
+    def ruby_filename?(file)
+      RUBY_FILENAMES.include?(File.basename(file))
+    end
+
     def ruby_executable?(file)
-      return false unless File.extname(file).empty?
+      return false unless File.extname(file).empty? && File.exist?(file)
       first_line = File.open(file, &:readline)
-      first_line =~ /#!.*ruby/
+      !(first_line =~ /#!.*(#{RUBY_INTERPRETERS.join('|')})/).nil?
     rescue EOFError, ArgumentError => e
       warn "Unprocessable file #{file}: #{e.class}, #{e.message}" if debug?
       false
     end
 
+    def ruby_file?(file)
+      ruby_extension?(file) || ruby_filename?(file) || ruby_executable?(file)
+    end
+
     def process_explicit_path(path)
       files = path.include?('*') ? Dir[path] : [path]
 
+      files.select! { |file| ruby_file?(file) }
+
       return files unless force_exclusion?
 
       files.reject do |file|

data/lib/rubocop/token.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -15,12 +14,90 @@ module RuboCop
     def initialize(pos, type, text)
       @pos = pos
       @type = type
-      # Parser token "text" may be a Fixnum
+      # Parser token "text" may be an Integer
       @text = text.to_s
     end
 
+    def line
+      pos.line
+    end
+
+    def column
+      pos.column
+    end
+
+    def begin_pos
+      pos.begin_pos
+    end
+
+    def end_pos
+      pos.end_pos
+    end
+
+    def comment?
+      type == :tCOMMENT
+    end
+
+    def semicolon?
+      type == :tSEMI
+    end
+
+    def left_array_bracket?
+      type == :tLBRACK
+    end
+
+    def left_ref_bracket?
+      type == :tLBRACK2
+    end
+
+    def left_bracket?
+      %i[tLBRACK tLBRACK2].include?(type)
+    end
+
+    def right_bracket?
+      type == :tRBRACK
+    end
+
+    def left_brace?
+      type == :tLBRACE
+    end
+
+    def left_curly_brace?
+      type == :tLCURLY
+    end
+
+    def right_curly_brace?
+      type == :tRCURLY
+    end
+
+    def left_parens?
+      %i[tLPAREN tLPAREN2].include?(type)
+    end
+
+    def right_parens?
+      type == :tRPAREN
+    end
+
+    def comma?
+      type == :tCOMMA
+    end
+
+    def equal_sign?
+      %i[tEQL tOP_ASGN].include?(type)
+    end
+
     def to_s
       "[[#{@pos.line}, #{@pos.column}], #{@type}, #{@text.inspect}]"
     end
+
+    # Checks if there is whitespace after token
+    def space_after?
+      pos.source_buffer.source.match(/\G\s/, end_pos)
+    end
+
+    # Checks if there is whitespace before token
+    def space_before?
+      pos.source_buffer.source.match(/\G\s/, begin_pos - 1)
+    end
   end
 end

data/lib/rubocop/version.rb

@@ -1,16 +1,13 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '0.42.0'.freeze
+    STRING = '0.52.1'.freeze
 
     MSG = '%s (using Parser %s, running on %s %s %s)'.freeze
 
-    module_function
-
-    def version(debug = false)
+    def self.version(debug = false)
       if debug
         format(MSG, STRING, Parser::VERSION,
                RUBY_ENGINE, RUBY_VERSION, RUBY_PLATFORM)

data/lib/rubocop/warning.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop