rubocop 0.72.0 → 0.76.0

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -5,17 +5,25 @@ module RuboCop
     # This module encapsulates the logic for autocorrect behavior for a cop.
     module AutocorrectLogic
       def autocorrect?
-        autocorrect_requested? && support_autocorrect? && autocorrect_enabled?
+        autocorrect_requested? && correctable? && autocorrect_enabled?
       end
 
       def autocorrect_requested?
         @options.fetch(:auto_correct, false)
       end
 
+      def correctable?
+        support_autocorrect? || disable_uncorrectable?
+      end
+
       def support_autocorrect?
         respond_to?(:autocorrect)
       end
 
+      def disable_uncorrectable?
+        @options[:disable_uncorrectable] == true
+      end
+
       def autocorrect_enabled?
         # allow turning off autocorrect on a cop by cop basis
         return true unless cop_config
@@ -28,6 +36,68 @@ module RuboCop
 
         true
       end
+
+      def disable_offense(node)
+        range = node.location.expression
+        eol_comment = " # rubocop:todo #{cop_name}"
+        needed_line_length = range.column +
+                             (range.source_line + eol_comment).length
+        if needed_line_length <= max_line_length
+          disable_offense_at_end_of_line(range_of_first_line(range),
+                                         eol_comment)
+        else
+          disable_offense_before_and_after(range_by_lines(range))
+        end
+      end
+
+      private
+
+      def range_of_first_line(range)
+        begin_of_first_line = range.begin_pos - range.column
+        end_of_first_line = begin_of_first_line + range.source_line.length
+
+        Parser::Source::Range.new(range.source_buffer,
+                                  begin_of_first_line,
+                                  end_of_first_line)
+      end
+
+      # Expand the given range to include all of any lines it covers. Does not
+      # include newline at end of the last line.
+      def range_by_lines(range)
+        begin_of_first_line = range.begin_pos - range.column
+
+        last_line = range.source_buffer.source_line(range.last_line)
+        last_line_offset = last_line.length - range.last_column
+        end_of_last_line = range.end_pos + last_line_offset
+
+        Parser::Source::Range.new(range.source_buffer,
+                                  begin_of_first_line,
+                                  end_of_last_line)
+      end
+
+      def max_line_length
+        config.for_cop('Metrics/LineLength')['Max'] || 80
+      end
+
+      def disable_offense_at_end_of_line(range, eol_comment)
+        ->(corrector) { corrector.insert_after(range, eol_comment) }
+      end
+
+      def disable_offense_before_and_after(range_by_lines)
+        lambda do |corrector|
+          range_with_newline = range_by_lines.resize(range_by_lines.size + 1)
+          leading_whitespace = range_by_lines.source_line[/^\s*/]
+
+          corrector.insert_before(
+            range_with_newline,
+            "#{leading_whitespace}# rubocop:todo #{cop_name}\n"
+          )
+          corrector.insert_after(
+            range_with_newline,
+            "#{leading_whitespace}# rubocop:enable #{cop_name}\n"
+          )
+        end
+      end
     end
   end
 end

data/lib/rubocop/cop/bundler/insecure_protocol_source.rb

@@ -33,7 +33,7 @@ module RuboCop
               "Please change your source to 'https://rubygems.org' " \
               "if possible, or 'http://rubygems.org' if not."
 
-        def_node_matcher :insecure_protocol_source?, <<-PATTERN
+        def_node_matcher :insecure_protocol_source?, <<~PATTERN
           (send nil? :source
             (sym ${:gemcutter :rubygems :rubyforge}))
         PATTERN

data/lib/rubocop/cop/bundler/ordered_gems.rb

@@ -64,7 +64,7 @@ module RuboCop
           declarations.to_a[node_index - 1]
         end
 
-        def_node_search :gem_declarations, <<-PATTERN
+        def_node_search :gem_declarations, <<~PATTERN
           (:send nil? :gem str ...)
         PATTERN
       end

data/lib/rubocop/cop/commissioner.rb

@@ -7,8 +7,6 @@ module RuboCop
     class Commissioner
       include RuboCop::AST::Traversal
 
-      CopError = Struct.new(:error, :line, :column)
-
       attr_reader :errors
 
       def initialize(cops, forces = [], options = {})
@@ -62,21 +60,29 @@ module RuboCop
       end
 
       def reset_errors
-        @errors = Hash.new { |hash, k| hash[k] = [] }
+        @errors = []
       end
 
       def remove_irrelevant_cops(filename)
-        @cops.reject! { |cop| cop.excluded_file?(filename) }
-        @cops.reject! do |cop|
-          cop.class.respond_to?(:support_target_ruby_version?) &&
-            !cop.class.support_target_ruby_version?(cop.target_ruby_version)
-        end
         @cops.reject! do |cop|
-          cop.class.respond_to?(:support_target_rails_version?) &&
-            !cop.class.support_target_rails_version?(cop.target_rails_version)
+          cop.excluded_file?(filename) ||
+            !support_target_ruby_version?(cop) ||
+            !support_target_rails_version?(cop)
         end
       end
 
+      def support_target_ruby_version?(cop)
+        return true unless cop.class.respond_to?(:support_target_ruby_version?)
+
+        cop.class.support_target_ruby_version?(cop.target_ruby_version)
+      end
+
+      def support_target_rails_version?(cop)
+        return true unless cop.class.respond_to?(:support_target_rails_version?)
+
+        cop.class.support_target_rails_version?(cop.target_rails_version)
+      end
+
       def reset_callbacks
         @callbacks.clear
       end
@@ -131,12 +137,8 @@ module RuboCop
       rescue StandardError => e
         raise e if @options[:raise_error]
 
-        if node
-          line = node.first_line
-          column = node.loc.column
-        end
-        error = CopError.new(e, line, column)
-        @errors[cop] << error
+        err = ErrorWithAnalyzedFileLocation.new(cause: e, node: node, cop: cop)
+        @errors << err
       end
     end
   end

data/lib/rubocop/cop/cop.rb

@@ -31,6 +31,16 @@ module RuboCop
       include IgnoredNode
       include AutocorrectLogic
 
+      Correction = Struct.new(:lambda, :node, :cop) do
+        def call(corrector)
+          lambda.call(corrector)
+        rescue StandardError => e
+          raise ErrorWithAnalyzedFileLocation.new(
+            cause: e, node: node, cop: cop
+          )
+        end
+      end
+
       attr_reader :config, :offenses, :corrections
       attr_accessor :processed_source # TODO: Bad design.
 
@@ -113,23 +123,19 @@ module RuboCop
         self.class::MSG
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity
       def add_offense(node, location: :expression, message: nil, severity: nil)
         loc = find_location(node, location)
 
         return if duplicate_location?(loc)
 
-        severity = custom_severity || severity || default_severity
-
-        message ||= message(node)
-        message = annotate(message)
+        severity = find_severity(node, severity)
+        message = find_message(node, message)
 
         status = enabled_line?(loc.line) ? correct(node) : :disabled
 
         @offenses << Offense.new(severity, loc, message, name, status)
         yield if block_given? && status != :disabled
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
 
       def find_location(node, loc)
         # Location can be provided as a symbol, e.g.: `:keyword`
@@ -141,16 +147,37 @@ module RuboCop
       end
 
       def correct(node)
-        return :unsupported unless support_autocorrect?
+        reason = reason_to_not_correct(node)
+        return reason if reason
+
+        @corrected_nodes[node] = true
+        if support_autocorrect?
+          correction = autocorrect(node)
+          return :uncorrected unless correction
+
+          @corrections << Correction.new(correction, node, self)
+          :corrected
+        elsif disable_uncorrectable?
+          disable_uncorrectable(node)
+          :corrected_with_todo
+        end
+      end
+
+      def reason_to_not_correct(node)
+        return :unsupported unless correctable?
         return :uncorrected unless autocorrect?
         return :already_corrected if @corrected_nodes.key?(node)
 
-        @corrected_nodes[node] = true
-        correction = autocorrect(node)
-        return :uncorrected unless correction
+        nil
+      end
+
+      def disable_uncorrectable(node)
+        @disabled_lines ||= {}
+        line = node.location.line
+        return if @disabled_lines.key?(line)
 
-        @corrections << correction
-        :corrected
+        @disabled_lines[line] = true
+        @corrections << Correction.new(disable_offense(node), node, self)
       end
 
       def config_to_allow_offenses
@@ -192,10 +219,14 @@ module RuboCop
 
       private
 
+      def find_message(node, message)
+        annotate(message || message(node))
+      end
+
       def annotate(message)
         RuboCop::Cop::MessageAnnotator.new(
-          config, cop_config, @options
-        ).annotate(message, name)
+          config, cop_name, cop_config, @options
+        ).annotate(message)
       end
 
       def file_name_matches_any?(file, parameter, default_result)
@@ -219,6 +250,10 @@ module RuboCop
         @processed_source.comment_config.cop_enabled_at_line?(self, line_number)
       end
 
+      def find_severity(_node, severity)
+        custom_severity || severity || default_severity
+      end
+
       def default_severity
         self.class.lint? ? :warning : :convention
       end

data/lib/rubocop/cop/corrector.rb

@@ -57,16 +57,15 @@ module RuboCop
       #
       # @return [String]
       def rewrite
-        # rubocop:disable Lint/HandleExceptions
         @corrections.each do |correction|
           begin
             @source_rewriter.transaction do
               correction.call(self)
             end
-          rescue ::Parser::ClobberingError
+          rescue ErrorWithAnalyzedFileLocation => e
+            raise e unless e.cause.is_a?(::Parser::ClobberingError)
           end
         end
-        # rubocop:enable Lint/HandleExceptions
 
         @source_rewriter.process
       end
@@ -155,16 +154,17 @@ module RuboCop
 
       # :nodoc:
       def validate_range(range)
-        return if range.source_buffer == @source_buffer
+        buffer = range.source_buffer
+        return if buffer == @source_buffer
 
-        unless range.source_buffer.is_a?(Parser::Source::Buffer)
+        unless buffer.is_a?(Parser::Source::Buffer)
           # actually this should be enforced by parser gem
-          raise 'Corrector expected range source buffer to be a '\
-                "Parser::Source::Buffer, but got #{range.source_buffer.class}"
+          raise 'Corrector expected range source buffer to be a ' \
+                "Parser::Source::Buffer, but got #{buffer.class}"
         end
-        raise "Correction target buffer #{range.source_buffer.object_id} "\
-              "name:#{range.source_buffer.name.inspect}"\
-              " is not current #{@source_buffer.object_id} "\
+        raise "Correction target buffer #{buffer.object_id} " \
+              "name:#{buffer.name.inspect}" \
+              " is not current #{@source_buffer.object_id} " \
               "name:#{@source_buffer.name.inspect} under investigation"
       end
     end

data/lib/rubocop/cop/correctors/alignment_corrector.rb

@@ -19,10 +19,12 @@ module RuboCop
           expr = node.respond_to?(:loc) ? node.loc.expression : node
           return if block_comment_within?(expr)
 
+          taboo_ranges = inside_string_ranges(node)
+
           lambda do |corrector|
             each_line(expr) do |line_begin_pos|
               autocorrect_line(corrector, line_begin_pos, expr, column_delta,
-                               heredoc_ranges(node))
+                               taboo_ranges)
             end
           end
         end
@@ -39,27 +41,48 @@ module RuboCop
         private
 
         def autocorrect_line(corrector, line_begin_pos, expr, column_delta,
-                             heredoc_ranges)
+                             taboo_ranges)
           range = calculate_range(expr, line_begin_pos, column_delta)
-          # We must not change indentation of heredoc strings.
-          return if heredoc_ranges.any? { |h| within?(range, h) }
+          # We must not change indentation of heredoc strings or inside other
+          # string literals
+          return if taboo_ranges.any? { |t| within?(range, t) }
 
           if column_delta.positive?
-            unless range.source == "\n"
-              # TODO: Fix ranges instead of using `begin`
-              corrector.insert_before(range.begin, ' ' * column_delta)
+            unless range.resize(1).source == "\n"
+              corrector.insert_before(range, ' ' * column_delta)
             end
           elsif range.source =~ /\A[ \t]+\z/
             remove(range, corrector)
           end
         end
 
-        def heredoc_ranges(node)
+        def inside_string_ranges(node)
           return [] unless node.is_a?(Parser::AST::Node)
 
-          node.each_node(:dstr)
-              .select(&:heredoc?)
-              .map { |n| n.loc.heredoc_body.join(n.loc.heredoc_end) }
+          node.each_node(:str, :dstr, :xstr).map { |n| inside_string_range(n) }
+              .compact
+        end
+
+        def inside_string_range(node)
+          loc = node.location
+
+          if node.heredoc?
+            loc.heredoc_body.join(loc.heredoc_end)
+          elsif delimited_string_literal?(node)
+            loc.begin.end.join(loc.end.begin)
+          end
+        end
+
+        # Some special kinds of string literals are not composed of literal
+        # characters between two delimiters:
+        # - The source map of `?a` responds to :begin and :end but its end is
+        #   nil.
+        # - The source map of `__FILE__` responds to neither :begin nor :end.
+        def delimited_string_literal?(node)
+          loc = node.location
+
+          loc.respond_to?(:begin) && loc.begin &&
+            loc.respond_to?(:end) && loc.end
         end
 
         def block_comment_within?(expr)
@@ -69,15 +92,18 @@ module RuboCop
         end
 
         def calculate_range(expr, line_begin_pos, column_delta)
+          if column_delta.positive?
+            return range_between(line_begin_pos, line_begin_pos)
+          end
+
           starts_with_space =
             expr.source_buffer.source[line_begin_pos].start_with?(' ')
-          pos_to_remove = if column_delta.positive? || starts_with_space
-                            line_begin_pos
-                          else
-                            line_begin_pos - column_delta.abs
-                          end
 
-          range_between(pos_to_remove, pos_to_remove + column_delta.abs)
+          if starts_with_space
+            range_between(line_begin_pos, line_begin_pos + column_delta.abs)
+          else
+            range_between(line_begin_pos - column_delta.abs, line_begin_pos)
+          end
         end
 
         def remove(range, corrector)

data/lib/rubocop/cop/correctors/empty_line_corrector.rb

@@ -9,9 +9,9 @@ module RuboCop
           offense_style, range = node
           lambda do |corrector|
             case offense_style
-            when :no_empty_lines then
+            when :no_empty_lines
               corrector.remove(range)
-            when :empty_lines then
+            when :empty_lines
               corrector.insert_before(range, "\n")
             end
           end

data/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb

@@ -40,8 +40,8 @@ module RuboCop
           range_with_surrounding_space(range: node.loc.end, side: :left)
         )
 
-        corrector.insert_after(
-          last_element_range_with_trailing_comma(node),
+        corrector.insert_before(
+          last_element_range_with_trailing_comma(node).end,
           node.loc.end.source
         )
       end