rubocop 0.78.0 → 1.13.0

data/lib/rubocop/cop/layout/heredoc_indentation.rb

@@ -5,74 +5,38 @@ module RuboCop
     module Layout
       # This cop checks the indentation of the here document bodies. The bodies
       # are indented one step.
-      # In Ruby 2.3 or newer, squiggly heredocs (`<<~`) should be used. If you
-      # use the older rubies, you should introduce some library to your project
-      # (e.g. ActiveSupport, Powerpack or Unindent).
-      # Note: When `Layout/LineLength`'s `AllowHeredoc` is false (not default),
+      #
+      # Note: When ``Layout/LineLength``'s `AllowHeredoc` is false (not default),
       #       this cop does not add any offenses for long here documents to
       #       avoid `Layout/LineLength`'s offenses.
       #
-      # @example EnforcedStyle: squiggly (default)
+      # @example
       #   # bad
       #   <<-RUBY
       #   something
       #   RUBY
       #
       #   # good
-      #   # When EnforcedStyle is squiggly, bad code is auto-corrected to the
-      #   # following code.
       #   <<~RUBY
       #     something
       #   RUBY
       #
-      # @example EnforcedStyle: active_support
-      #   # good
-      #   # When EnforcedStyle is active_support, bad code is auto-corrected to
-      #   # the following code.
-      #   <<-RUBY.strip_heredoc
-      #     something
-      #   RUBY
-      #
-      # @example EnforcedStyle: powerpack
-      #   # good
-      #   # When EnforcedStyle is powerpack, bad code is auto-corrected to
-      #   # the following code.
-      #   <<-RUBY.strip_indent
-      #     something
-      #   RUBY
-      #
-      # @example EnforcedStyle: unindent
-      #   # good
-      #   # When EnforcedStyle is unindent, bad code is auto-corrected to
-      #   # the following code.
-      #   <<-RUBY.unindent
-      #     something
-      #   RUBY
-      #
-      class HeredocIndentation < Cop
+      class HeredocIndentation < Base
         include Heredoc
-        include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
-        RUBY23_TYPE_MSG = 'Use %<indentation_width>d spaces for indentation ' \
-                          'in a heredoc by using `<<~` instead of ' \
-                          '`%<current_indent_type>s`.'
-        RUBY23_WIDTH_MSG = 'Use %<indentation_width>d spaces for '\
-                           'indentation in a heredoc.'
-        LIBRARY_MSG = 'Use %<indentation_width>d spaces for indentation in a ' \
-                      'heredoc by using %<method>s.'
-        STRIP_METHODS = {
-          unindent: 'unindent',
-          active_support: 'strip_heredoc',
-          powerpack: 'strip_indent'
-        }.freeze
+        TYPE_MSG = 'Use %<indentation_width>d spaces for indentation in a ' \
+                   'heredoc by using `<<~` instead of `%<current_indent_type>s`.'
+        WIDTH_MSG = 'Use %<indentation_width>d spaces for indentation in a heredoc.'
 
         def on_heredoc(node)
           body = heredoc_body(node)
           return if body.strip.empty?
 
           body_indent_level = indent_level(body)
+          heredoc_indent_type = heredoc_indent_type(node)
 
-          if heredoc_indent_type(node) == '~'
+          if heredoc_indent_type == '~'
             expected_indent_level = base_indent_level(node) + indentation_width
             return if expected_indent_level == body_indent_level
           else
@@ -81,65 +45,43 @@ module RuboCop
 
           return if line_too_long?(node)
 
-          add_offense(node, location: :heredoc_body)
-        end
-
-        def autocorrect(node)
-          check_style!
-
-          case style
-          when :squiggly
-            correct_by_squiggly(node)
-          else
-            correct_by_library(node)
-          end
+          register_offense(node, heredoc_indent_type)
         end
 
         private
 
-        def message(node)
-          case style
-          when :squiggly
-            current_indent_type = "<<#{heredoc_indent_type(node)}"
-            ruby23_message(indentation_width, current_indent_type)
-          when nil
-            method = "some library(e.g. ActiveSupport's `String#strip_heredoc`)"
-            library_message(indentation_width, method)
-          else
-            method = "`String##{STRIP_METHODS[style]}`"
-            library_message(indentation_width, method)
+        def register_offense(node, heredoc_indent_type)
+          message = message(heredoc_indent_type)
+
+          add_offense(node.loc.heredoc_body, message: message) do |corrector|
+            if heredoc_indent_type == '~'
+              adjust_squiggly(corrector, node)
+            else
+              adjust_minus(corrector, node)
+            end
           end
         end
 
-        def library_message(indentation_width, method)
-          format(
-            LIBRARY_MSG,
-            indentation_width: indentation_width,
-            method: method
-          )
-        end
+        def message(heredoc_indent_type)
+          current_indent_type = "<<#{heredoc_indent_type}"
 
-        def ruby23_message(indentation_width, current_indent_type)
           if current_indent_type == '<<~'
-            ruby23_width_message(indentation_width)
+            width_message(indentation_width)
           else
-            ruby23_type_message(indentation_width, current_indent_type)
+            type_message(indentation_width, current_indent_type)
           end
         end
 
-        def ruby23_type_message(indentation_width, current_indent_type)
+        def type_message(indentation_width, current_indent_type)
           format(
-            RUBY23_TYPE_MSG,
+            TYPE_MSG,
             indentation_width: indentation_width,
             current_indent_type: current_indent_type
           )
         end
 
-        def ruby23_width_message(indentation_width)
-          format(
-            RUBY23_WIDTH_MSG,
-            indentation_width: indentation_width
-          )
+        def width_message(indentation_width)
+          format(WIDTH_MSG, indentation_width: indentation_width)
         end
 
         def line_too_long?(node)
@@ -166,16 +108,6 @@ module RuboCop
           config.for_cop('Layout/LineLength')['Max']
         end
 
-        def correct_by_squiggly(node)
-          lambda do |corrector|
-            if heredoc_indent_type(node) == '~'
-              adjust_squiggly(corrector, node)
-            else
-              adjust_minus(corrector, node)
-            end
-          end
-        end
-
         def adjust_squiggly(corrector, node)
           corrector.replace(node.loc.heredoc_body, indented_body(node))
           corrector.replace(node.loc.heredoc_end, indented_end(node))
@@ -184,30 +116,14 @@ module RuboCop
         def adjust_minus(corrector, node)
           heredoc_beginning = node.loc.expression.source
           corrected = heredoc_beginning.sub(/<<-?/, '<<~')
-          corrector.replace(node.loc.expression, corrected)
-        end
-
-        def correct_by_library(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.heredoc_body, indented_body(node))
-            corrected = ".#{STRIP_METHODS[style]}"
-            corrector.insert_after(node.loc.expression, corrected)
-          end
-        end
-
-        def check_style!
-          return if style
-
-          raise Warning, "Auto-correction does not work for #{cop_name}. " \
-                         'Please configure EnforcedStyle.'
+          corrector.replace(node, corrected)
         end
 
         def indented_body(node)
           body = heredoc_body(node)
           body_indent_level = indent_level(body)
           correct_indent_level = base_indent_level(node) + indentation_width
-          body.gsub(/^[^\S\r\n]{#{body_indent_level}}/,
-                    ' ' * correct_indent_level)
+          body.gsub(/^[^\S\r\n]{#{body_indent_level}}/, ' ' * correct_indent_level)
         end
 
         def indented_end(node)
@@ -230,7 +146,7 @@ module RuboCop
         def indent_level(str)
           indentations = str.lines
                             .map { |line| line[/^\s*/] }
-                            .reject { |line| line == "\n" }
+                            .reject { |line| line.end_with?("\n") }
           indentations.empty? ? 0 : indentations.min_by(&:size).size
         end
 
@@ -244,11 +160,11 @@ module RuboCop
         end
 
         def heredoc_body(node)
-          node.loc.heredoc_body.source.scrub
+          node.loc.heredoc_body.source
         end
 
         def heredoc_end(node)
-          node.loc.heredoc_end.source.scrub
+          node.loc.heredoc_end.source
         end
       end
     end

data/lib/rubocop/cop/layout/indentation_consistency.rb

@@ -118,9 +118,10 @@ module RuboCop
       #       def bar
       #       end
       #   end
-      class IndentationConsistency < Cop
+      class IndentationConsistency < Base
         include Alignment
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Inconsistent indentation detected.'
 
@@ -132,12 +133,12 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, column_delta)
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
+
         # Not all nodes define `bare_access_modifier?` (for example,
         # `RuboCop::AST::DefNode` does not), so we must check `send_type?` first
         # to avoid a NoMethodError.
@@ -161,8 +162,10 @@ module RuboCop
           # to the level of the module (see `AccessModifierIndentation` cop) we
           # return nil so that `check_alignment` will derive the correct
           # indentation from the first child that is not an access modifier.
-          module_indent = display_column(node.parent.source_range)
           access_modifier_indent = display_column(first_child.source_range)
+          return access_modifier_indent unless node.parent
+
+          module_indent = display_column(node.parent.source_range)
           access_modifier_indent if access_modifier_indent > module_indent
         end
 

data/lib/rubocop/cop/layout/indentation_style.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks that the indentation method is consistent.
+      # Either tabs only or spaces only are used for indentation.
+      #
+      # @example EnforcedStyle: spaces (default)
+      #   # bad
+      #   # This example uses a tab to indent bar.
+      #   def foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   # This example uses spaces to indent bar.
+      #   def foo
+      #     bar
+      #   end
+      #
+      # @example EnforcedStyle: tabs
+      #   # bad
+      #   # This example uses spaces to indent bar.
+      #   def foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #   # This example uses a tab to indent bar.
+      #   def foo
+      #     bar
+      #   end
+      class IndentationStyle < Base
+        include Alignment
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = '%<type>s detected in indentation.'
+
+        def on_new_investigation
+          str_ranges = string_literal_ranges(processed_source.ast)
+
+          processed_source.lines.each.with_index(1) do |line, lineno|
+            next unless (range = find_offence(line, lineno))
+            next if in_string_literal?(str_ranges, range)
+
+            add_offense(range) { |corrector| autocorrect(corrector, range) }
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, range)
+          if range.source.include?("\t")
+            autocorrect_lambda_for_tabs(corrector, range)
+          else
+            autocorrect_lambda_for_spaces(corrector, range)
+          end
+        end
+
+        def find_offence(line, lineno)
+          match = if style == :spaces
+                    line.match(/\A\s*\t+/)
+                  else
+                    line.match(/\A\s* +/)
+                  end
+          return unless match
+
+          source_range(processed_source.buffer, lineno, match.begin(0)...match.end(0))
+        end
+
+        def autocorrect_lambda_for_tabs(corrector, range)
+          spaces = ' ' * configured_indentation_width
+          corrector.replace(range, range.source.gsub(/\t/, spaces))
+        end
+
+        def autocorrect_lambda_for_spaces(corrector, range)
+          corrector.replace(range, range.source.gsub(/\A\s+/) do |match|
+            "\t" * (match.size / configured_indentation_width)
+          end)
+        end
+
+        def in_string_literal?(ranges, tabs_range)
+          ranges.any? { |range| range.contains?(tabs_range) }
+        end
+
+        def string_literal_ranges(ast)
+          # which lines start inside a string literal?
+          return [] if ast.nil?
+
+          ast.each_node(:str, :dstr).each_with_object(Set.new) do |str, ranges|
+            loc = str.location
+
+            if str.heredoc?
+              ranges << loc.heredoc_body
+            elsif loc.respond_to?(:begin) && loc.begin
+              ranges << loc.expression
+            end
+          end
+        end
+
+        def message(_node)
+          format(MSG, type: style == :spaces ? 'Tab' : 'Space')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/indentation_width.rb

@@ -42,16 +42,18 @@ module RuboCop
       #     end
       #   end
       #   end
-      class IndentationWidth < Cop # rubocop:disable Metrics/ClassLength
+      class IndentationWidth < Base # rubocop:disable Metrics/ClassLength
         include EndKeywordAlignment
         include Alignment
         include CheckAssignment
         include IgnoredPattern
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use %<configured_indentation_width>d (not %<indentation>d) ' \
               'spaces for%<name>s indentation.'
 
+        # @!method access_modifier?(node)
         def_node_matcher :access_modifier?, <<~PATTERN
           [(send ...) access_modifier?]
         PATTERN
@@ -133,8 +135,7 @@ module RuboCop
             check_indentation(when_node.loc.keyword, when_node.body)
           end
 
-          check_indentation(case_node.when_branches.last.loc.keyword,
-                            case_node.else_branch)
+          check_indentation(case_node.when_branches.last.loc.keyword, case_node.else_branch)
         end
 
         def on_if(node, base = node)
@@ -144,12 +145,12 @@ module RuboCop
           check_if(node, node.body, node.else_branch, base.loc)
         end
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, @column_delta)
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
         def check_members(base, members)
           check_indentation(base, select_check_member(members.first))
 
@@ -263,9 +264,7 @@ module RuboCop
         def offense(body_node, indentation, style)
           # This cop only auto-corrects the first statement in a def body, for
           # example.
-          if body_node.begin_type? && !parentheses?(body_node)
-            body_node = body_node.children.first
-          end
+          body_node = body_node.children.first if body_node.begin_type? && !parentheses?(body_node)
 
           # Since autocorrect changes a number of lines, and not only the line
           # where the reported offending range is, we avoid auto-correction if
@@ -281,8 +280,9 @@ module RuboCop
           name = style == 'normal' ? '' : " #{style}"
           message = message(configured_indentation_width, indentation, name)
 
-          add_offense(node, location: offending_range(body_node, indentation),
-                            message: message)
+          add_offense(offending_range(body_node, indentation), message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def message(configured_indentation_width, indentation, name)
@@ -309,12 +309,20 @@ module RuboCop
         def indentation_to_check?(base_loc, body_node)
           return false if skip_check?(base_loc, body_node)
 
-          if %i[rescue ensure].include?(body_node.type)
+          if body_node.rescue_type?
+            check_rescue?(body_node)
+          elsif body_node.ensure_type?
             block_body, = *body_node
             return unless block_body
+
+            check_rescue?(block_body) if block_body.rescue_type?
+          else
+            true
           end
+        end
 
-          true
+        def check_rescue?(rescue_node)
+          rescue_node.body
         end
 
         def skip_check?(base_loc, body_node)