rubocop 0.85.1 → 0.89.1

data/lib/rubocop/cop/team.rb

@@ -10,23 +10,16 @@ module RuboCop
     # first the ones needed for autocorrection (if any), then the rest
     # (unless autocorrections happened).
     class Team
-      DEFAULT_OPTIONS = {
-        auto_correct: false,
-        debug: false
-      }.freeze
-
-      Investigation = Struct.new(:offenses, :errors)
-
       attr_reader :errors, :warnings, :updated_source_file, :cops
 
       alias updated_source_file? updated_source_file
 
-      def initialize(cops, config = nil, options = nil)
+      def initialize(cops, config = nil, options = {})
         @cops = cops
         @config = config
-        @options = options || DEFAULT_OPTIONS
-        @errors = []
-        @warnings = []
+        @options = options
+        reset
+        @ready = true
 
         validate_config
       end
@@ -40,18 +33,17 @@ module RuboCop
       end
 
       # @return [Team] with cops assembled from the given `cop_classes`
-      def self.mobilize(cop_classes, config, options = nil)
-        options ||= DEFAULT_OPTIONS
+      def self.mobilize(cop_classes, config, options = {})
         cops = mobilize_cops(cop_classes, config, options)
         new(cops, config, options)
       end
 
       # @return [Array<Cop::Cop>]
-      def self.mobilize_cops(cop_classes, config, options = nil)
-        options ||= DEFAULT_OPTIONS
+      def self.mobilize_cops(cop_classes, config, options = {})
+        cop_classes = Registry.new(cop_classes.to_a) unless cop_classes.is_a?(Registry)
         only = options.fetch(:only, [])
         safe = options.fetch(:safe, false)
-        cop_classes.enabled(config, only, safe).map do |cop_class|
+        cop_classes.enabled(config, only, only_safe: safe).map do |cop_class|
           cop_class.new(config, options)
         end
       end
@@ -64,93 +56,102 @@ module RuboCop
         @options[:debug]
       end
 
+      # @deprecated. Use investigate
+      # @return Array<offenses>
       def inspect_file(processed_source)
-        # If we got any syntax errors, return only the syntax offenses.
-        unless processed_source.valid_syntax?
-          return Lint::Syntax.offenses_from_processed_source(
-            processed_source, @config, @options
-          )
+        investigate(processed_source).offenses
+      end
+
+      # @return [Commissioner::InvestigationReport]
+      def investigate(processed_source)
+        be_ready
+
+        # The autocorrection process may have to be repeated multiple times
+        # until there are no corrections left to perform
+        # To speed things up, run auto-correcting cops by themselves, and only
+        # run the other cops when no corrections are left
+        on_duty = roundup_relevant_cops(processed_source.file_path)
+
+        autocorrect_cops, other_cops = on_duty.partition(&:autocorrect?)
+
+        report = investigate_partial(autocorrect_cops, processed_source)
+
+        unless autocorrect(processed_source, report)
+          # If we corrected some errors, another round of inspection will be
+          # done, and any other offenses will be caught then, so only need
+          # to check other_cops if no correction was done
+          report = report.merge(investigate_partial(other_cops, processed_source))
         end
 
-        offenses(processed_source)
+        process_errors(processed_source.path, report.errors)
+
+        report
+      ensure
+        @ready = false
       end
 
+      # @deprecated
       def forces
-        @forces ||= forces_for(cops)
+        @forces ||= self.class.forces_for(cops)
       end
 
-      def forces_for(cops)
-        Force.all.each_with_object([]) do |force_class, forces|
-          joining_cops = cops.select { |cop| cop.join_force?(force_class) }
-          next if joining_cops.empty?
+      # @return [Array<Force>] needed for the given cops
+      def self.forces_for(cops)
+        needed = Hash.new { |h, k| h[k] = [] }
+        cops.each do |cop|
+          Array(cop.class.joining_forces).each { |force| needed[force] << cop }
+        end
 
-          forces << force_class.new(joining_cops)
+        needed.map do |force_class, joining_cops|
+          force_class.new(joining_cops)
         end
       end
 
-      def autocorrect(buffer, cops)
+      def external_dependency_checksum
+        keys = cops.map(&:external_dependency_checksum).compact
+        Digest::SHA1.hexdigest(keys.join)
+      end
+
+      private
+
+      def autocorrect(processed_source, report)
         @updated_source_file = false
         return unless autocorrect?
 
-        new_source = autocorrect_all_cops(buffer, cops)
+        new_source = autocorrect_report(report)
 
-        return if new_source == buffer.source
+        return unless new_source
 
         if @options[:stdin]
           # holds source read in from stdin, when --stdin option is used
           @options[:stdin] = new_source
         else
-          filename = buffer.name
+          filename = processed_source.buffer.name
           File.open(filename, 'w') { |f| f.write(new_source) }
         end
         @updated_source_file = true
-      rescue RuboCop::ErrorWithAnalyzedFileLocation => e
-        process_errors(buffer.name, [e])
-        raise e.cause
-      end
-
-      def external_dependency_checksum
-        keys = cops.map(&:external_dependency_checksum).compact
-        Digest::SHA1.hexdigest(keys.join)
       end
 
-      private
-
-      def offenses(processed_source) # rubocop:disable Metrics/AbcSize
-        # The autocorrection process may have to be repeated multiple times
-        # until there are no corrections left to perform
-        # To speed things up, run auto-correcting cops by themselves, and only
-        # run the other cops when no corrections are left
-        on_duty = roundup_relevant_cops(processed_source.file_path)
-
-        autocorrect_cops, other_cops = on_duty.partition(&:autocorrect?)
-
-        autocorrect = investigate(autocorrect_cops, processed_source)
-
-        if autocorrect(processed_source.buffer, autocorrect_cops)
-          # We corrected some errors. Another round of inspection will be
-          # done, and any other offenses will be caught then, so we don't
-          # need to continue.
-          return autocorrect.offenses
-        end
-
-        other = investigate(other_cops, processed_source)
+      def be_ready
+        return if @ready
 
-        errors = [*autocorrect.errors, *other.errors]
-        process_errors(processed_source.path, errors)
-
-        autocorrect.offenses.concat(other.offenses)
+        reset
+        @cops.map!(&:ready)
+        @ready = true
       end
 
-      def investigate(cops, processed_source)
-        return Investigation.new([], {}) if cops.empty?
-
-        commissioner = Commissioner.new(cops, forces_for(cops), @options)
-        offenses = commissioner.investigate(processed_source)
+      def reset
+        @errors = []
+        @warnings = []
+      end
 
-        Investigation.new(offenses, commissioner.errors)
+      # @return [Commissioner::InvestigationReport]
+      def investigate_partial(cops, processed_source)
+        commissioner = Commissioner.new(cops, self.class.forces_for(cops), @options)
+        commissioner.investigate(processed_source)
       end
 
+      # @return [Array<cop>]
       def roundup_relevant_cops(filename)
         cops.reject do |cop|
           cop.excluded_file?(filename) ||
@@ -171,30 +172,45 @@ module RuboCop
         cop.class.support_target_rails_version?(cop.target_rails_version)
       end
 
-      def autocorrect_all_cops(buffer, cops)
-        corrector = Corrector.new(buffer)
+      def autocorrect_report(report)
+        corrector = collate_corrections(report)
 
-        collate_corrections(corrector, cops)
+        corrector.rewrite unless corrector.empty?
+      end
 
-        if !corrector.corrections.empty?
-          corrector.rewrite
-        else
-          buffer.source
+      def collate_corrections(report)
+        corrector = Corrector.new(report.processed_source)
+
+        each_corrector(report) do |to_merge|
+          suppress_clobbering do
+            corrector.merge!(to_merge)
+          end
         end
+
+        corrector
       end
 
-      def collate_corrections(corrector, cops)
+      def each_corrector(report)
         skips = Set.new
+        report.cop_reports.each do |cop_report|
+          cop = cop_report.cop
+          corrector = cop_report.corrector
 
-        cops.each do |cop|
-          next if cop.corrections.empty?
+          next if corrector.nil? || corrector.empty?
           next if skips.include?(cop.class)
 
-          corrector.corrections.concat(cop.corrections)
+          yield corrector
+
           skips.merge(cop.class.autocorrect_incompatible_with)
         end
       end
 
+      def suppress_clobbering
+        yield
+      rescue ::Parser::ClobberingError
+        # ignore Clobbering errors
+      end
+
       def validate_config
         cops.each do |cop|
           cop.validate_config if cop.respond_to?(:validate_config)

data/lib/rubocop/cop/tokens_util.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Common methods and behaviors for dealing with tokens.
+  module TokensUtil
+    module_function
+
+    # rubocop:disable Metrics/AbcSize
+    def tokens(node)
+      @tokens ||= {}
+      return @tokens[node.object_id] if @tokens[node.object_id]
+
+      @tokens[node.object_id] =
+        # The tokens list is always sorted by token position,
+        # except for cases when heredoc is passed as a method argument.
+        # In this case tokens are interleaved by heredoc contents' tokens.
+        # We can try a fast (binary) search, assuming the mentioned cases are rare,
+        # and fallback to linear search if failed.
+        if (tokens = fast_tokens(node))
+          tokens
+        else
+          begin_pos = node.source_range.begin_pos
+          end_pos   = node.source_range.end_pos
+
+          processed_source.tokens.select do |token|
+            token.end_pos <= end_pos && token.begin_pos >= begin_pos
+          end
+        end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def index_of_first_token(node)
+      index = fast_index_of_first_token(node)
+      return index if index
+
+      begin_pos = node.source_range.begin_pos
+      processed_source.tokens.index { |token| token.begin_pos == begin_pos }
+    end
+
+    def index_of_last_token(node)
+      index = fast_index_of_last_token(node)
+      return index if index
+
+      end_pos = node.source_range.end_pos
+      processed_source.tokens.index { |token| token.end_pos == end_pos }
+    end
+
+    private
+
+    def fast_index_of_first_token(node)
+      begin_pos = node.source_range.begin_pos
+      tokens = processed_source.tokens
+
+      index = tokens.bsearch_index { |token| token.begin_pos >= begin_pos }
+      index if index && tokens[index].begin_pos == begin_pos
+    end
+
+    def fast_index_of_last_token(node)
+      end_pos = node.source_range.end_pos
+      tokens = processed_source.tokens
+
+      index = tokens.bsearch_index { |token| token.end_pos >= end_pos }
+      index if index && tokens[index].end_pos == end_pos
+    end
+
+    def fast_tokens(node)
+      begin_index = index_of_first_token(node)
+      end_index   = index_of_last_token(node)
+
+      tokens = processed_source.tokens[begin_index..end_index]
+      tokens if sorted_tokens?(tokens)
+    end
+
+    def sorted_tokens?(tokens)
+      prev_begin_pos = -1
+      tokens.each do |token|
+        return false if token.begin_pos < prev_begin_pos
+
+        prev_begin_pos = token.begin_pos
+      end
+      true
+    end
+  end
+end

data/lib/rubocop/cop/util.rb

@@ -5,6 +5,7 @@ module RuboCop
     # This module contains a collection of useful utility methods.
     module Util
       include PathUtil
+      include TokensUtil
 
       # Match literal regex characters, not including anchors, character
       # classes, alternatives, groups, repetitions, references, etc
@@ -13,10 +14,12 @@ module RuboCop
 
       module_function
 
+      # This is a bad API
       def comment_line?(line_source)
-        line_source =~ /^\s*#/
+        /^\s*#/.match?(line_source)
       end
 
+      # @deprecated Use `ProcessedSource#line_with_comment?`, `contains_comment` or similar
       def comment_lines?(node)
         processed_source[line_range(node)].any? { |line| comment_line?(line) }
       end
@@ -88,7 +91,7 @@ module RuboCop
 
         # Regex matches IF there is a ' or there is a \\ in the string that is
         # not preceded/followed by another \\ (e.g. "\\x34") but not "\\\\".
-        string =~ /'|(?<! \\) \\{2}* \\ (?![\\"])/x
+        /'|(?<! \\) \\{2}* \\ (?![\\"])/x.match?(string)
       end
 
       def needs_escaping?(string)
@@ -127,19 +130,6 @@ module RuboCop
           .sub('Style', 'Styles')
       end
 
-      def tokens(node)
-        @tokens ||= {}
-        return @tokens[node.object_id] if @tokens[node.object_id]
-
-        source_range = node.source_range
-        begin_pos = source_range.begin_pos
-        end_pos = source_range.end_pos
-
-        @tokens[node.object_id] = processed_source.tokens.select do |token|
-          token.end_pos <= end_pos && token.begin_pos >= begin_pos
-        end
-      end
-
       private
 
       def compatible_external_encoding_for?(src)

data/lib/rubocop/cop/utils/format_string.rb

@@ -41,8 +41,7 @@ module RuboCop
         #
         # @see https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-format
         class FormatSequence
-          attr_reader :begin_pos, :end_pos
-          attr_reader :flags, :width, :precision, :name, :type
+          attr_reader :begin_pos, :end_pos, :flags, :width, :precision, :name, :type
 
           def initialize(match)
             @source = match[0]
@@ -120,7 +119,7 @@ module RuboCop
         end
 
         def mixed_formats?
-          formats = format_sequences.map do |seq|
+          formats = format_sequences.reject(&:percent?).map do |seq|
             if seq.name
               :named
             elsif seq.max_digit_dollar_num

data/lib/rubocop/cop/variable_force/branch.rb

@@ -49,6 +49,7 @@ module RuboCop
           end
 
           def self.inherited(subclass)
+            super
             classes << subclass
           end
 

data/lib/rubocop/cop/variable_force/variable.rb

@@ -38,14 +38,14 @@ module RuboCop
           !@references.empty?
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def reference!(node)
           reference = Reference.new(node, @scope)
           @references << reference
-          consumed_branches = Set.new
+          consumed_branches = nil
 
           @assignments.reverse_each do |assignment|
-            next if consumed_branches.include?(assignment.branch)
+            next if consumed_branches&.include?(assignment.branch)
 
             assignment.reference!(node) unless assignment.run_exclusively_with?(reference)
 
@@ -58,10 +58,12 @@ module RuboCop
 
             break if !assignment.branch || assignment.branch == reference.branch
 
-            consumed_branches << assignment.branch unless assignment.branch.may_run_incompletely?
+            unless assignment.branch.may_run_incompletely?
+              (consumed_branches ||= Set.new) << assignment.branch
+            end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def in_modifier_if?(assignment)
           parent = assignment.node.parent

data/lib/rubocop/cop/variable_force.rb

@@ -197,7 +197,6 @@ module RuboCop
         regexp.named_captures.keys
       end
 
-      # rubocop:disable Metrics/AbcSize
       def process_variable_operator_assignment(node)
         if LOGICAL_OPERATOR_ASSIGNMENT_TYPES.include?(node.type)
           asgn_node, rhs_node = *node
@@ -232,7 +231,6 @@ module RuboCop
 
         skip_children!
       end
-      # rubocop:enable Metrics/AbcSize
 
       def process_variable_multiple_assignment(node)
         lhs_node, rhs_node = *node