rubocop 0.86.0 → 0.89.1

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

@@ -22,7 +22,7 @@ module RuboCop
 
         def_node_matcher :stderr_puts?, <<~PATTERN
           (send
-            {(gvar #stderr_gvar?) (const nil? :STDERR)}
+            {(gvar #stderr_gvar?) (const {nil? cbase} :STDERR)}
             :puts $_
             ...)
         PATTERN

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where string concatenation
+      # can be replaced with string interpolation.
+      #
+      # @example
+      #   # bad
+      #   email_with_name = user.name + ' <' + user.email + '>'
+      #
+      #   # good
+      #   email_with_name = "#{user.name} <#{user.email}>"
+      #   email_with_name = format('%s <%s>', user.name, user.email)
+      #
+      class StringConcatenation < Base
+        include Util
+        extend AutoCorrector
+
+        MSG = 'Prefer string interpolation to string concatenation.'
+
+        def_node_matcher :string_concatenation?, <<~PATTERN
+          {
+            (send str_type? :+ _)
+            (send _ :+ str_type?)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless node.method?(:+)
+          return unless string_concatenation?(node)
+
+          topmost_plus_node = find_topmost_plus_node(node)
+
+          parts = []
+          collect_parts(topmost_plus_node, parts)
+
+          add_offense(topmost_plus_node) do |corrector|
+            corrector.replace(topmost_plus_node, replacement(parts))
+          end
+        end
+
+        private
+
+        def find_topmost_plus_node(node)
+          current = node
+          while (parent = current.parent) && plus_node?(parent)
+            current = parent
+          end
+          current
+        end
+
+        def collect_parts(node, parts)
+          return unless node
+
+          if plus_node?(node)
+            collect_parts(node.receiver, parts)
+            collect_parts(node.first_argument, parts)
+          else
+            parts << node
+          end
+        end
+
+        def plus_node?(node)
+          node.send_type? && node.method?(:+)
+        end
+
+        def replacement(parts)
+          interpolated_parts =
+            parts.map do |part|
+              if part.str_type?
+                if single_quoted?(part)
+                  part.value.gsub('\\') { '\\\\' }
+                else
+                  escape_string(part.value)
+                end
+              else
+                "\#{#{part.source}}"
+              end
+            end
+
+          "\"#{interpolated_parts.join}\""
+        end
+
+        def single_quoted?(str_node)
+          str_node.source.start_with?("'")
+        end
+      end
+    end
+  end
+end

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

@@ -33,7 +33,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.remove(range_with_surrounding_space(range: node.loc.keyword))
+            corrector.remove(range_with_surrounding_space(range: node.loc.keyword, newlines: false))
             corrector.replace(node.loc.operator, '=')
 
             correct_parent(node.parent_class, corrector)
@@ -41,8 +41,8 @@ module RuboCop
         end
 
         def_node_matcher :struct_constructor?, <<~PATTERN
-          {(send (const nil? :Struct) :new ...)
-           (block (send (const nil? :Struct) :new ...) ...)}
+          {(send (const {nil? cbase} :Struct) :new ...)
+           (block (send (const {nil? cbase} :Struct) :new ...) ...)}
         PATTERN
 
         private

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

@@ -74,7 +74,7 @@ module RuboCop
             if c.dsym_type?
               string_literal = to_string_literal(c.source)
 
-              ':' + trim_string_interporation_escape_character(string_literal)
+              ":#{trim_string_interporation_escape_character(string_literal)}"
             else
               to_symbol_literal(c.value.to_s)
             end

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

@@ -19,7 +19,7 @@ module RuboCop
               'instead of a block.'
         SUPER_TYPES = %i[super zsuper].freeze
 
-        def_node_matcher :proc_node?, '(send (const nil? :Proc) :new)'
+        def_node_matcher :proc_node?, '(send (const {nil? cbase} :Proc) :new)'
         def_node_matcher :symbol_proc?, <<~PATTERN
           (block
             ${(send ...) (super ...) zsuper}
@@ -84,7 +84,7 @@ module RuboCop
           arg_range = args.last.source_range
           arg_range = range_with_surrounding_comma(arg_range, :right)
           replacement = " &:#{method_name}"
-          replacement = ',' + replacement unless arg_range.source.end_with?(',')
+          replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
           corrector.insert_after(arg_range, replacement)
           corrector.remove(block_range_with_space(node))
         end

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

@@ -33,8 +33,8 @@ module RuboCop
       #     end
       #   end
       #
-      class TrailingMethodEndStatement < Cop
-        include Alignment
+      class TrailingMethodEndStatement < Base
+        extend AutoCorrector
 
         MSG = 'Place the end statement of a multi-line method on ' \
               'its own line.'
@@ -42,13 +42,11 @@ module RuboCop
         def on_def(node)
           return unless trailing_end?(node)
 
-          add_offense(node, location: end_token(node).pos)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            break_line_before_end(node, corrector)
-            remove_semicolon(node, corrector)
+          add_offense(node.loc.end) do |corrector|
+            corrector.insert_before(
+              node.loc.end,
+              "\n#{' ' * node.loc.keyword.column}"
+            )
           end
         end
 
@@ -60,30 +58,9 @@ module RuboCop
             body_and_end_on_same_line?(node)
         end
 
-        def end_token(node)
-          tokens(node).reverse.find(&:end?)
-        end
-
         def body_and_end_on_same_line?(node)
-          end_token(node).line == token_before_end(node).line
-        end
-
-        def token_before_end(node)
-          i = tokens(node).index(end_token(node))
-          tokens(node)[i - 1]
-        end
-
-        def break_line_before_end(node, corrector)
-          corrector.insert_before(
-            end_token(node).pos,
-            "\n" + ' ' * configured_indentation_width
-          )
-        end
-
-        def remove_semicolon(node, corrector)
-          return unless token_before_end(node).semicolon?
-
-          corrector.remove(token_before_end(node).pos)
+          last_child = node.children.last
+          last_child.loc.last_line == node.loc.end.last_line
         end
       end
     end

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

@@ -28,6 +28,8 @@ module RuboCop
       #     attr_reader :baz
       #   end
       class TrivialAccessors < Cop
+        include AllowedMethods
+
         MSG = 'Use `attr_%<kind>s` to define trivial %<kind>s methods.'
 
         def on_def(node)
@@ -95,9 +97,8 @@ module RuboCop
           cop_config['IgnoreClassMethods']
         end
 
-        def allowed_methods
-          allowed_methods = cop_config['AllowedMethods']
-          Array(allowed_methods).map(&:to_sym) + [:initialize]
+        def allowed_method_names
+          allowed_methods.map(&:to_sym) + [:initialize]
         end
 
         def dsl_writer?(method_name)
@@ -106,7 +107,7 @@ module RuboCop
 
         def trivial_reader?(node)
           looks_like_trivial_reader?(node) &&
-            !allowed_method?(node) && !allowed_reader?(node)
+            !allowed_method_name?(node) && !allowed_reader?(node)
         end
 
         def looks_like_trivial_reader?(node)
@@ -115,7 +116,7 @@ module RuboCop
 
         def trivial_writer?(node)
           looks_like_trivial_writer?(node) &&
-            !allowed_method?(node) && !allowed_writer?(node.method_name)
+            !allowed_method_name?(node) && !allowed_writer?(node.method_name)
         end
 
         def_node_matcher :looks_like_trivial_writer?, <<~PATTERN
@@ -123,8 +124,8 @@ module RuboCop
            (defs _ _ (args (arg ...)) (ivasgn _ (lvar _)))}
         PATTERN
 
-        def allowed_method?(node)
-          allowed_methods.include?(node.method_name) ||
+        def allowed_method_name?(node)
+          allowed_method_names.include?(node.method_name) ||
             exact_name_match? && !names_match?(node)
         end
 

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

@@ -30,6 +30,8 @@ module RuboCop
         NONZERO_MSG = 'Use `!empty?` instead of ' \
                       '`%<lhs>s %<opr>s %<rhs>s`.'
 
+        LENGTH_METHODS = %i[size length].freeze
+
         def on_send(node)
           check_zero_length_predicate(node)
           check_nonzero_length_predicate(node)
@@ -44,31 +46,33 @@ module RuboCop
         private
 
         def check_zero_length_predicate(node)
-          zero_length_predicate = zero_length_predicate(node)
+          return unless LENGTH_METHODS.include?(node.method_name)
 
+          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,
+            node.parent,
             message: format(ZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
           )
         end
 
         def check_nonzero_length_predicate(node)
-          nonzero_length_predicate = nonzero_length_predicate(node)
+          return unless LENGTH_METHODS.include?(node.method_name)
 
+          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,
+            node.parent,
             message: format(NONZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
           )
         end
@@ -108,8 +112,8 @@ module RuboCop
         # implement `#size`, but not `#empty`. We ignore those to
         # reduce false positives.
         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

@@ -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)