rubocop 0.82.0 → 1.18.4

data/lib/rubocop/cop/style/while_until_do.rb

@@ -28,31 +28,21 @@ module RuboCop
       #   until x.empty?
       #     do_something(x.pop)
       #   end
-      class WhileUntilDo < Cop
+      class WhileUntilDo < Base
+        extend AutoCorrector
+
         MSG = 'Do not use `do` with multi-line `%<keyword>s`.'
 
         def on_while(node)
-          handle(node)
-        end
-
-        def on_until(node)
-          handle(node)
-        end
-
-        def handle(node)
           return unless node.multiline? && node.do?
 
-          add_offense(node, location: :begin,
-                            message: format(MSG, keyword: node.keyword))
-        end
-
-        def autocorrect(node)
-          do_range = node.condition.source_range.end.join(node.loc.begin)
+          add_offense(node.loc.begin, message: format(MSG, keyword: node.keyword)) do |corrector|
+            do_range = node.condition.source_range.end.join(node.loc.begin)
 
-          lambda do |corrector|
             corrector.remove(do_range)
           end
         end
+        alias on_until on_while
       end
     end
   end

data/lib/rubocop/cop/style/while_until_modifier.rb

@@ -24,37 +24,29 @@ module RuboCop
       #
       #   # good
       #   x += 1 until x > 10
-      class WhileUntilModifier < Cop
+      #
+      # @example
+      #   # bad
+      #   x += 100 while x < 500 # a long comment that makes code too long if it were a single line
+      #
+      #   # good
+      #   while x < 500 # a long comment that makes code too long if it were a single line
+      #     x += 100
+      #   end
+      class WhileUntilModifier < Base
         include StatementModifier
+        extend AutoCorrector
 
-        MSG = 'Favor modifier `%<keyword>s` usage when ' \
-              'having a single-line body.'
+        MSG = 'Favor modifier `%<keyword>s` usage when having a single-line body.'
 
         def on_while(node)
-          check(node)
-        end
+          return unless single_line_as_modifier?(node)
 
-        def on_until(node)
-          check(node)
-        end
-
-        def autocorrect(node)
-          oneline = "#{node.body.source} #{node.keyword} " \
-                    "#{node.condition.source}"
-
-          lambda do |corrector|
-            corrector.replace(node, oneline)
+          add_offense(node.loc.keyword, message: format(MSG, keyword: node.keyword)) do |corrector|
+            corrector.replace(node, to_modifier_form(node))
           end
         end
-
-        private
-
-        def check(node)
-          return unless node.multiline? && single_line_as_modifier?(node)
-
-          add_offense(node, location: :keyword,
-                            message: format(MSG, keyword: node.keyword))
-        end
+        alias on_until on_while
       end
     end
   end

data/lib/rubocop/cop/style/word_array.rb

@@ -27,11 +27,12 @@ module RuboCop
       #
       #   # bad
       #   %w[foo bar baz]
-      class WordArray < Cop
+      class WordArray < Base
         include ArrayMinSize
         include ArraySyntax
         include ConfigurableEnforcedStyle
         include PercentArray
+        extend AutoCorrector
 
         PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'
         ARRAY_MSG = 'Use `[]` for an array of words.'
@@ -44,36 +45,18 @@ module RuboCop
           if bracketed_array_of?(:str, node)
             return if complex_content?(node.values)
 
-            check_bracketed_array(node)
+            check_bracketed_array(node, 'w')
           elsif node.percent_literal?(:string)
             check_percent_array(node)
           end
         end
 
-        def autocorrect(node)
-          if style == :percent
-            PercentLiteralCorrector
-              .new(@config, @preferred_delimiters)
-              .correct(node, 'w')
-          else
-            correct_bracketed(node)
-          end
-        end
-
         private
 
-        def check_bracketed_array(node)
-          return if allowed_bracket_array?(node)
-
-          array_style_detected(:brackets, node.values.size)
-          add_offense(node) if style == :percent
-        end
-
         def complex_content?(strings)
           strings.any? do |s|
             string = s.str_content.dup.force_encoding(::Encoding::UTF_8)
-            !string.valid_encoding? ||
-              string !~ word_regex || string =~ / /
+            !string.valid_encoding? || !word_regex.match?(string) || / /.match?(string)
           end
         end
 
@@ -81,7 +64,7 @@ module RuboCop
           Regexp.new(cop_config['WordRegex'])
         end
 
-        def correct_bracketed(node)
+        def correct_bracketed(corrector, node)
           words = node.children.map do |word|
             if word.dstr_type?
               string_literal = to_string_literal(word.source)
@@ -92,9 +75,7 @@ module RuboCop
             end
           end
 
-          lambda do |corrector|
-            corrector.replace(node, "[#{words.join(', ')}]")
-          end
+          corrector.replace(node, "[#{words.join(', ')}]")
         end
       end
     end

data/lib/rubocop/cop/style/yoda_condition.rb

@@ -19,6 +19,8 @@ module RuboCop
       #   foo == "bar"
       #   foo <= 42
       #   bar > 10
+      #   "#{interpolation}" == foo
+      #   /#{interpolation}/ == foo
       #
       # @example EnforcedStyle: forbid_for_equality_operators_only
       #   # bad
@@ -50,18 +52,14 @@ module RuboCop
       #   # good
       #   99 == foo
       #   "bar" != foo
-      class YodaCondition < Cop
+      class YodaCondition < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Reverse the order of the operands `%<source>s`.'
 
-        REVERSE_COMPARISON = {
-          '<' => '>',
-          '<=' => '>=',
-          '>' => '<',
-          '>=' => '<='
-        }.freeze
+        REVERSE_COMPARISON = { '<' => '>', '<=' => '>=', '>' => '<', '>=' => '<=' }.freeze
 
         EQUALITY_OPERATORS = %i[== !=].freeze
 
@@ -69,6 +67,7 @@ module RuboCop
 
         PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
 
+        # @!method file_constant_equal_program_name?(node)
         def_node_matcher :file_constant_equal_program_name?, <<~PATTERN
           (send #source_file_path_constant? {:== :!=} (gvar #program_name?))
         PATTERN
@@ -78,11 +77,7 @@ module RuboCop
           return if equality_only? && non_equality_operator?(node) ||
                     file_constant_equal_program_name?(node)
 
-          valid_yoda?(node) || add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          valid_yoda?(node) || add_offense(node) do |corrector|
             corrector.replace(actual_code_range(node), corrected_code(node))
           end
         end
@@ -100,8 +95,7 @@ module RuboCop
         end
 
         def yoda_compatible_condition?(node)
-          node.comparison_method? &&
-            !noncommutative_operator?(node)
+          node.comparison_method? && !noncommutative_operator?(node)
         end
 
         def valid_yoda?(node)
@@ -109,7 +103,8 @@ module RuboCop
           rhs = node.first_argument
 
           return true if lhs.literal? && rhs.literal? ||
-                         !lhs.literal? && !rhs.literal?
+                         !lhs.literal? && !rhs.literal? ||
+                         interpolation?(lhs)
 
           enforce_yoda? ? lhs.literal? : rhs.literal?
         end
@@ -126,9 +121,7 @@ module RuboCop
         end
 
         def actual_code_range(node)
-          range_between(
-            node.loc.expression.begin_pos, node.loc.expression.end_pos
-          )
+          range_between(node.loc.expression.begin_pos, node.loc.expression.end_pos)
         end
 
         def reverse_comparison(operator)
@@ -150,6 +143,12 @@ module RuboCop
         def program_name?(name)
           PROGRAM_NAMES.include?(name)
         end
+
+        def interpolation?(node)
+          return true if node.dstr_type?
+
+          node.regexp_type? && node.interpolation?
+        end
       end
     end
   end

data/lib/rubocop/cop/style/zero_length_predicate.rb

@@ -25,54 +25,52 @@ module RuboCop
       #   !{a: 1, b: 2}.empty?
       #   !string.empty?
       #   !hash.empty?
-      class ZeroLengthPredicate < Cop
+      class ZeroLengthPredicate < Base
+        extend AutoCorrector
+
         ZERO_MSG = 'Use `empty?` instead of `%<lhs>s %<opr>s %<rhs>s`.'
-        NONZERO_MSG = 'Use `!empty?` instead of ' \
-                      '`%<lhs>s %<opr>s %<rhs>s`.'
+        NONZERO_MSG = 'Use `!empty?` instead of `%<lhs>s %<opr>s %<rhs>s`.'
+
+        RESTRICT_ON_SEND = %i[size length].freeze
 
         def on_send(node)
           check_zero_length_predicate(node)
           check_nonzero_length_predicate(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node, replacement(node))
-          end
-        end
-
         private
 
         def check_zero_length_predicate(node)
-          zero_length_predicate = zero_length_predicate(node)
-
+          zero_length_predicate = zero_length_predicate(node.parent)
           return unless zero_length_predicate
 
           lhs, opr, rhs = zero_length_predicate
 
-          return if non_polymorphic_collection?(node)
+          return if non_polymorphic_collection?(node.parent)
 
           add_offense(
-            node,
-            message: format(ZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
-          )
+            node.parent, message: format(ZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
+          ) do |corrector|
+            corrector.replace(node.parent, replacement(node.parent))
+          end
         end
 
         def check_nonzero_length_predicate(node)
-          nonzero_length_predicate = nonzero_length_predicate(node)
-
+          nonzero_length_predicate = nonzero_length_predicate(node.parent)
           return unless nonzero_length_predicate
 
           lhs, opr, rhs = nonzero_length_predicate
 
-          return if non_polymorphic_collection?(node)
+          return if non_polymorphic_collection?(node.parent)
 
           add_offense(
-            node,
-            message: format(NONZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
-          )
+            node.parent, message: format(NONZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
+          ) do |corrector|
+            corrector.replace(node.parent, replacement(node.parent))
+          end
         end
 
+        # @!method zero_length_predicate(node)
         def_node_matcher :zero_length_predicate, <<~PATTERN
           {(send (send (...) ${:length :size}) $:== (int $0))
            (send (int $0) $:== (send (...) ${:length :size}))
@@ -80,6 +78,7 @@ module RuboCop
            (send (int $1) $:> (send (...) ${:length :size}))}
         PATTERN
 
+        # @!method nonzero_length_predicate(node)
         def_node_matcher :nonzero_length_predicate, <<~PATTERN
           {(send (send (...) ${:length :size}) ${:> :!=} (int $0))
            (send (int $0) ${:< :!=} (send (...) ${:length :size}))}
@@ -92,6 +91,7 @@ module RuboCop
           "!#{other_receiver(node).source}.empty?"
         end
 
+        # @!method zero_length_receiver(node)
         def_node_matcher :zero_length_receiver, <<~PATTERN
           {(send (send $_ _) :== (int 0))
            (send (int 0) :== (send $_ _))
@@ -99,6 +99,7 @@ module RuboCop
            (send (int 1) :> (send $_ _))}
         PATTERN
 
+        # @!method other_receiver(node)
         def_node_matcher :other_receiver, <<~PATTERN
           {(send (send $_ _) _ _)
            (send _ _ (send $_ _))}
@@ -107,9 +108,10 @@ module RuboCop
         # Some collection like objects in the Ruby standard library
         # implement `#size`, but not `#empty`. We ignore those to
         # reduce false positives.
+        # @!method non_polymorphic_collection?(node)
         def_node_matcher :non_polymorphic_collection?, <<~PATTERN
-          {(send (send (send (const nil? :File) :stat _) ...) ...)
-           (send (send (send (const nil? {:Tempfile :StringIO}) {:new :open} ...) ...) ...)}
+          {(send (send (send (const {nil? cbase} :File) :stat _) ...) ...)
+           (send (send (send (const {nil? cbase} {:Tempfile :StringIO}) {:new :open} ...) ...) ...)}
         PATTERN
       end
     end

data/lib/rubocop/cop/team.rb

@@ -2,29 +2,52 @@
 
 module RuboCop
   module Cop
-    # FIXME
+    # A group of cops, ready to be called on duty to inspect files.
+    # Team is responsible for selecting only relevant cops to be sent on duty,
+    # as well as insuring that the needed forces are sent along with them.
+    #
+    # For performance reasons, Team will first dispatch cops & forces in two groups,
+    # 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
+      attr_reader :errors, :warnings, :updated_source_file, :cops
 
       alias updated_source_file? updated_source_file
 
-      def initialize(cop_classes, config, options = nil)
-        @cop_classes = cop_classes
+      def initialize(cops, config = nil, options = {})
+        @cops = cops
         @config = config
-        @options = options || DEFAULT_OPTIONS
-        @errors = []
-        @warnings = []
+        @options = options
+        reset
+        @ready = true
 
         validate_config
       end
 
+      # @return [Team]
+      def self.new(cop_or_classes, config, options = {})
+        # Support v0 api:
+        return mobilize(cop_or_classes, config, options) if cop_or_classes.first.is_a?(Class)
+
+        super
+      end
+
+      # @return [Team] with cops assembled from the given `cop_classes`
+      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 = {})
+        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, only_safe: safe).map do |cop_class|
+          cop_class.new(config, options)
+        end
+      end
+
       def autocorrect?
         @options[:auto_correct]
       end
@@ -33,124 +56,165 @@ 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
-          )
-        end
-
-        offenses(processed_source)
+        investigate(processed_source).offenses
       end
 
-      def cops
-        only = @options.fetch(:only, [])
-        safe = @options.fetch(:safe, false)
-        @cops ||= @cop_classes.enabled(@config, only, safe).map do |cop_class|
-          cop_class.new(@config, @options)
+      # @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
+
+        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?
-
-          forces << force_class.new(joining_cops)
+      # @return [Array<Force>] needed for the given cops
+      def self.forces_for(cops)
+        needed = Hash.new { |h, k| h[k] = [] }
+        cops.each do |cop|
+          forces = cop.class.joining_forces
+          if forces.is_a?(Array)
+            forces.each { |force| needed[force] << cop }
+          elsif forces
+            needed[forces] << cop
+          end
         end
+
+        needed.map { |force_class, joining_cops| force_class.new(joining_cops) }
       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?
+        return if report.processed_source.parser_error
 
-        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)
+      def be_ready
+        return if @ready
+
+        reset
+        @cops.map!(&:ready)
+        @ready = true
       end
 
-      private
+      def reset
+        @errors = []
+        @warnings = []
+      end
 
-      def offenses(processed_source)
-        # 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
-        autocorrect_cops, other_cops = cops.partition(&:autocorrect?)
-
-        autocorrect =
-          investigate(autocorrect_cops, processed_source) do |offenses|
-            # 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 offenses if autocorrect(processed_source.buffer,
-                                           autocorrect_cops)
-          end
+      # @return [Commissioner::InvestigationReport]
+      def investigate_partial(cops, processed_source)
+        commissioner = Commissioner.new(cops, self.class.forces_for(cops), @options)
+        commissioner.investigate(processed_source)
+      end
 
-        other = investigate(other_cops, processed_source)
+      # @return [Array<cop>]
+      def roundup_relevant_cops(filename)
+        cops.reject do |cop|
+          cop.excluded_file?(filename) ||
+            !support_target_ruby_version?(cop) ||
+            !support_target_rails_version?(cop)
+        end
+      end
 
-        errors = [*autocorrect.errors, *other.errors]
-        process_errors(processed_source.path, errors)
+      def support_target_ruby_version?(cop)
+        return true unless cop.class.respond_to?(:support_target_ruby_version?)
 
-        autocorrect.offenses.concat(other.offenses)
+        cop.class.support_target_ruby_version?(cop.target_ruby_version)
       end
 
-      def investigate(cops, processed_source)
-        return Investigation.new([], {}) if cops.empty?
-
-        commissioner = Commissioner.new(cops, forces_for(cops))
-        offenses = commissioner.investigate(processed_source)
-        yield offenses if block_given?
+      def support_target_rails_version?(cop)
+        return true unless cop.class.respond_to?(:support_target_rails_version?)
 
-        Investigation.new(offenses, commissioner.errors)
+        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)
@@ -181,8 +245,7 @@ module RuboCop
       end
 
       def handle_error(error, location, cop)
-        message = Rainbow("An error occurred while #{cop.name}" \
-                           " cop was inspecting #{location}.").red
+        message = Rainbow("An error occurred while #{cop.name} cop was inspecting #{location}.").red
         @errors << message
         warn message
         if debug?