rubocop 0.70.0 → 0.75.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,7 +60,7 @@ module RuboCop
       end
 
       def reset_errors
-        @errors = Hash.new { |hash, k| hash[k] = [] }
+        @errors = []
       end
 
       def remove_irrelevant_cops(filename)
@@ -131,12 +129,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.
 
@@ -48,10 +58,6 @@ module RuboCop
         registry.qualified_cop_name(name, origin)
       end
 
-      def self.non_rails
-        registry.without_department(:Rails)
-      end
-
       def self.inherited(subclass)
         registry.enlist(subclass)
       end
@@ -145,16 +151,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
@@ -198,8 +225,8 @@ module RuboCop
 
       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)

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

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

data/lib/rubocop/cop/gemspec/duplicated_assignment.rb

@@ -40,7 +40,7 @@ module RuboCop
         MSG = '`%<assignment>s` method calls already given on line '\
               '%<line_of_first_occurrence>d of the gemspec.'
 
-        def_node_search :gem_specification, <<-PATTERN
+        def_node_search :gem_specification, <<~PATTERN
           (block
             (send
               (const
@@ -49,7 +49,7 @@ module RuboCop
               (arg $_)) ...)
         PATTERN
 
-        def_node_search :assignment_method_declarations, <<-PATTERN
+        def_node_search :assignment_method_declarations, <<~PATTERN
           (send
             (lvar #match_block_variable_name?) #assignment_method? ...)
         PATTERN

data/lib/rubocop/cop/gemspec/ordered_dependencies.rb

@@ -97,7 +97,7 @@ module RuboCop
           node.method_name
         end
 
-        def_node_search :dependency_declarations, <<-PATTERN
+        def_node_search :dependency_declarations, <<~PATTERN
           (send (lvar _) {:add_dependency :add_runtime_dependency :add_development_dependency} ...)
         PATTERN
       end

data/lib/rubocop/cop/gemspec/required_ruby_version.rb

@@ -41,7 +41,7 @@ module RuboCop
               '(%<target_ruby_version>s, which may be specified in ' \
               '.rubocop.yml) should be equal.'
 
-        def_node_search :required_ruby_version, <<-PATTERN
+        def_node_search :required_ruby_version, <<~PATTERN
           (send _ :required_ruby_version= ${(str _) (array (str _))})
         PATTERN
 

data/lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Checks that `RUBY_VERSION` constant is not used in gemspec.
+      # Using `RUBY_VERSION` is dangerous because value of the
+      # constant is determined by `rake release`.
+      # It's possible to have dependency based on ruby version used
+      # to execute `rake release` and not user's ruby version.
+      #
+      # @example
+      #
+      #   # bad
+      #   Gem::Specification.new do |spec|
+      #     if RUBY_VERSION >= '2.5'
+      #       spec.add_runtime_dependency 'gem_a'
+      #     else
+      #       spec.add_runtime_dependency 'gem_b'
+      #     end
+      #   end
+      #
+      #   # good
+      #   Gem::Specification.new do |spec|
+      #     spec.add_runtime_dependency 'gem_a'
+      #   end
+      #
+      class RubyVersionGlobalsUsage < Cop
+        MSG = 'Do not use `RUBY_VERSION` in gemspec file.'
+
+        def_node_matcher :ruby_version?, '(const nil? :RUBY_VERSION)'
+
+        def_node_search :gem_specification?, <<~PATTERN
+          (block
+            (send
+              (const
+                (const {cbase nil?} :Gem) :Specification) :new)
+            ...)
+        PATTERN
+
+        def on_const(node)
+          return unless gem_spec_with_ruby_version?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def gem_spec_with_ruby_version?(node)
+          gem_specification?(processed_source.ast) && ruby_version?(node)
+        end
+      end
+    end
+  end
+end