rubocop 0.42.0 → 0.52.1

data/lib/rubocop/cop/{style → layout}/first_parameter_indentation.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks the indentation of the first parameter in a method call.
       # Parameters after the first one are checked by Style/AlignParameters, not
       # by this cop.
@@ -20,27 +19,27 @@ module RuboCop
       #     first_param,
       #   second_param)
       class FirstParameterIndentation < Cop
-        include AutocorrectAlignment
+        include Alignment
         include ConfigurableEnforcedStyle
 
+        MSG = 'Indent the first parameter one step more than %<base>s.'.freeze
+
         def on_send(node)
-          _receiver, method_name, *args = *node
-          return if args.empty?
-          return if operator?(method_name)
-
-          base_indentation = if special_inner_call_indentation?(node)
-                               column_of(base_range(node, args.first))
-                             else
-                               previous_code_line(args.first.loc.line) =~ /\S/
-                             end
-          check_alignment([args.first],
-                          base_indentation + configured_indentation_width)
+          return if !node.arguments? || node.operator_method?
+
+          indent = base_indentation(node) + configured_indentation_width
+
+          check_alignment([node.first_argument], indent)
+        end
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
         end
 
         private
 
         def message(arg_node)
-          return 'Bad indentation of the first parameter.' if arg_node.nil?
+          return 'Bad indentation of the first parameter.' unless arg_node
 
           send_node = arg_node.parent
           text = base_range(send_node, arg_node).source.strip
@@ -51,21 +50,25 @@ module RuboCop
                  else
                    'the start of the previous line'
                  end
-          format('Indent the first parameter one step more than %s.', base)
+
+          format(MSG, base: base)
+        end
+
+        def base_indentation(node)
+          if special_inner_call_indentation?(node)
+            column_of(base_range(node, node.first_argument))
+          else
+            previous_code_line(node.first_argument.first_line) =~ /\S/
+          end
         end
 
         def special_inner_call_indentation?(node)
           return false if style == :consistent
 
           parent = node.parent
-          return false unless parent
-          return false unless parent.send_type?
-
-          _receiver, method_name, *_args = *parent
-          # :[]= is a send node, but we want to treat it as an assignment.
-          return false if method_name == :[]=
 
-          return false if !parentheses?(parent) &&
+          return false unless eligible_method_call?(parent)
+          return false if !parent.parenthesized? &&
                           style == :special_for_inner_method_call_in_parentheses
 
           # The node must begin inside the parent, otherwise node is the first
@@ -73,10 +76,13 @@ module RuboCop
           node.source_range.begin_pos > parent.source_range.begin_pos
         end
 
+        def_node_matcher :eligible_method_call?, <<-PATTERN
+          (send _ !:[]= ...)
+        PATTERN
+
         def base_range(send_node, arg_node)
-          Parser::Source::Range.new(processed_source.buffer,
-                                    send_node.source_range.begin_pos,
-                                    arg_node.source_range.begin_pos)
+          range_between(send_node.source_range.begin_pos,
+                        arg_node.source_range.begin_pos)
         end
 
         # Returns the column of the given range. For single line ranges, this

data/lib/rubocop/cop/{style → layout}/indent_array.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks the indentation of the first element in an array literal
       # where the opening bracket and the first element are on separate lines.
       # The other elements' indentations are handled by the AlignArray cop.
@@ -20,30 +19,74 @@ module RuboCop
       # This default style is called 'special_inside_parentheses'. Alternative
       # styles are 'consistent' and 'align_brackets'. Here are examples:
       #
-      #     # special_inside_parentheses
-      #     array = [
-      #       :value
-      #     ]
-      #     but_in_a_method_call([
-      #                            :its_like_this
-      #                          ])
-      #     # consistent
-      #     array = [
-      #       :value
-      #     ]
-      #     and_in_a_method_call([
-      #       :no_difference
-      #     ])
-      #     # align_brackets
-      #     and_now_for_something = [
-      #                               :completely_different
-      #                             ]
+      # @example EnforcedStyle: special_inside_parentheses (default)
+      #   # The `special_inside_parentheses` style enforces that the first
+      #   # element in an array literal where the opening bracket and first
+      #   # element are on seprate lines is indented one step (two spaces) more
+      #   # than the position inside the opening parenthesis.
       #
+      #   #bad
+      #   array = [
+      #     :value
+      #   ]
+      #   and_in_a_method_call([
+      #     :no_difference
+      #                        ])
+      #
+      #   #good
+      #   array = [
+      #     :value
+      #   ]
+      #   but_in_a_method_call([
+      #                          :its_like_this
+      #                        ])
+      #
+      # @example EnforcedStyle: consistent
+      #   # The `consistent` style enforces that the first element in an array
+      #   # literal where the opening bracket and the first element are on
+      #   # seprate lines is indented the same as an array literal which is not
+      #   # defined inside a method call.
+      #
+      #   #bad
+      #   # consistent
+      #   array = [
+      #     :value
+      #   ]
+      #   but_in_a_method_call([
+      #                          :its_like_this
+      #   ])
+      #
+      #   #good
+      #   array = [
+      #     :value
+      #   ]
+      #   and_in_a_method_call([
+      #     :no_difference
+      #   ])
+      #
+      # @example EnforcedStyle: align_brackets
+      #   # The `align_brackets` style enforces that the opening and closing
+      #   # brackets are indented to the same position.
+      #
+      #   #bad
+      #   # align_brackets
+      #   and_now_for_something = [
+      #                             :completely_different
+      #   ]
+      #
+      #   #good
+      #   # align_brackets
+      #   and_now_for_something = [
+      #                             :completely_different
+      #                           ]
       class IndentArray < Cop
-        include AutocorrectAlignment
+        include Alignment
         include ConfigurableEnforcedStyle
         include ArrayHashIndentation
 
+        MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
+              'in an array, relative to %<base_description>s.'.freeze
+
         def on_array(node)
           check(node, nil) if node.loc.begin
         end
@@ -54,6 +97,10 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
+        end
+
         private
 
         def brace_alignment_style
@@ -64,7 +111,7 @@ module RuboCop
           return if ignored_node?(array_node)
 
           left_bracket = array_node.loc.begin
-          first_elem = array_node.children.first
+          first_elem = array_node.values.first
           if first_elem
             return if first_elem.source_range.line == left_bracket.line
             check_first(first_elem, left_bracket, left_parenthesis, 0)
@@ -91,7 +138,7 @@ module RuboCop
                   'Indent the right bracket the same as the start of the line' \
                   ' where the left bracket is.'
                 end
-          add_offense(right_bracket, right_bracket, msg)
+          add_offense(right_bracket, location: right_bracket, message: msg)
         end
 
         # Returns the description of what the correct indentation is based on.
@@ -106,8 +153,11 @@ module RuboCop
         end
 
         def message(base_description)
-          format('Use %d spaces for indentation in an array, relative to %s.',
-                 configured_indentation_width, base_description)
+          format(
+            MSG,
+            configured_indentation_width: configured_indentation_width,
+            base_description: base_description
+          )
         end
       end
     end

data/lib/rubocop/cop/{style → layout}/indent_assignment.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cop checks the indentation of the first line of the
       # right-hand-side of a multi-line assignment.
       #
@@ -17,14 +16,14 @@ module RuboCop
       #   # good
       #   value =
       #     if foo
-      #     'bar'
-      #   end
+      #       'bar'
+      #     end
       #
       # The indentation of the remaining lines can be corrected with
       # other cops such as `IndentationConsistency` and `EndAlignment`.
       class IndentAssignment < Cop
         include CheckAssignment
-        include AutocorrectAlignment
+        include Alignment
 
         MSG = 'Indent the first line of the right-hand-side of a ' \
               'multi-line assignment.'.freeze
@@ -32,11 +31,15 @@ module RuboCop
         def check_assignment(node, rhs)
           return unless rhs
           return unless node.loc.operator
-          return if node.loc.operator.line == rhs.loc.line
+          return if node.loc.operator.line == rhs.first_line
 
           base = display_column(node.source_range)
           check_alignment([rhs], base + configured_indentation_width)
         end
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
+        end
       end
     end
   end

data/lib/rubocop/cop/{style → layout}/indent_hash.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cops checks the indentation of the first key in a hash literal
       # where the opening brace and the first key are on separate lines. The
       # other keys' indentations are handled by the AlignHash cop.
@@ -20,30 +19,72 @@ module RuboCop
       # This default style is called 'special_inside_parentheses'. Alternative
       # styles are 'consistent' and 'align_braces'. Here are examples:
       #
-      #     # special_inside_parentheses
-      #     hash = {
-      #       key: :value
-      #     }
-      #     but_in_a_method_call({
-      #                            its_like: :this
-      #                          })
-      #     # consistent
-      #     hash = {
-      #       key: :value
-      #     }
-      #     and_in_a_method_call({
-      #       no: :difference
-      #     })
-      #     # align_braces
-      #     and_now_for_something = {
-      #                               completely: :different
-      #                             }
+      # @example EnforcedStyle: special_inside_parentheses (default)
+      #   # The `special_inside_parentheses` style enforces that the first key
+      #   # in a hash literal where the opening brace and the first key are on
+      #   # separate lines is indented one step (two spaces) more than the
+      #   # position inside the opening parentheses.
       #
+      #   # bad
+      #   hash = {
+      #     key: :value
+      #   }
+      #   and_in_a_method_call({
+      #     no: :difference
+      #                        })
+      #
+      #   # good
+      #   special_inside_parentheses
+      #   hash = {
+      #     key: :value
+      #   }
+      #   but_in_a_method_call({
+      #                          its_like: :this
+      #                        })
+      #
+      # @example EnforcedStyle: consistent
+      #   # The `consistent` style enforces that the first key in a hash
+      #   # literal where the opening brace and the first key are on
+      #   # seprate lines is indented the same as a hash literal which is not
+      #   # defined inside a method call.
+      #
+      #   # bad
+      #   hash = {
+      #     key: :value
+      #   }
+      #   but_in_a_method_call({
+      #                          its_like: :this
+      #                         })
+      #
+      #   # good
+      #   hash = {
+      #     key: :value
+      #   }
+      #   and_in_a_method_call({
+      #     no: :difference
+      #   })
+      #
+      # @example EnforcedStyle: align_braces
+      #   # The `align_brackets` style enforces that the opening and closing
+      #   # braces are indented to the same position.
+      #
+      #   # bad
+      #   and_now_for_something = {
+      #                             completely: :different
+      #   }
+      #
+      #   # good
+      #   and_now_for_something = {
+      #                             completely: :different
+      #                           }
       class IndentHash < Cop
-        include AutocorrectAlignment
+        include Alignment
         include ConfigurableEnforcedStyle
         include ArrayHashIndentation
 
+        MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
+              'in a hash, relative to %<base_description>s.'.freeze
+
         def on_hash(node)
           check(node, nil) if node.loc.begin
         end
@@ -54,6 +95,10 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
+        end
+
         private
 
         def brace_alignment_style
@@ -64,12 +109,13 @@ module RuboCop
           return if ignored_node?(hash_node)
 
           left_brace = hash_node.loc.begin
-          first_pair = hash_node.children.first
+          first_pair = hash_node.pairs.first
+
           if first_pair
             return if first_pair.source_range.line == left_brace.line
 
             if separator_style?(first_pair)
-              check_based_on_longest_key(hash_node.children, left_brace,
+              check_based_on_longest_key(hash_node, left_brace,
                                          left_parenthesis)
             else
               check_first(first_pair, left_brace, left_parenthesis, 0)
@@ -96,20 +142,20 @@ module RuboCop
                   'Indent the right brace the same as the start of the line ' \
                   'where the left brace is.'
                 end
-          add_offense(right_brace, right_brace, msg)
+          add_offense(right_brace, location: right_brace, message: msg)
         end
 
         def separator_style?(first_pair)
           separator = first_pair.loc.operator
           key = "Enforced#{separator.is?(':') ? 'Colon' : 'HashRocket'}Style"
-          config.for_cop('Style/AlignHash')[key] == 'separator'
+          config.for_cop('Layout/AlignHash')[key] == 'separator'
         end
 
-        def check_based_on_longest_key(pairs, left_brace, left_parenthesis)
-          key_lengths = pairs.map do |pair|
-            pair.children.first.source_range.length
+        def check_based_on_longest_key(hash_node, left_brace, left_parenthesis)
+          key_lengths = hash_node.keys.map do |key|
+            key.source_range.length
           end
-          check_first(pairs.first, left_brace, left_parenthesis,
+          check_first(hash_node.pairs.first, left_brace, left_parenthesis,
                       key_lengths.max - key_lengths.first)
         end
 
@@ -125,8 +171,11 @@ module RuboCop
         end
 
         def message(base_description)
-          format('Use %d spaces for indentation in a hash, relative to %s.',
-                 configured_indentation_width, base_description)
+          format(
+            MSG,
+            configured_indentation_width: configured_indentation_width,
+            base_description: base_description
+          )
         end
       end
     end

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

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cops 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 `Metrics/LineLength`'s `AllowHeredoc` is false(not default),
+      #       this cop does not add any offenses for long here documents to
+      #       avoid `Metrics/LineLength`'s offenses.
+      #
+      # @example
+      #
+      #   # bad
+      #   <<-RUBY
+      #   something
+      #   RUBY
+      #
+      #   # good
+      #   # When EnforcedStyle is squiggly, bad code is auto-corrected to the
+      #   # following code.
+      #   <<~RUBY
+      #     something
+      #   RUBY
+      #
+      #   # good
+      #   # When EnforcedStyle is active_support, bad code is auto-corrected to
+      #   # the following code.
+      #   <<-RUBY.strip_heredoc
+      #     something
+      #   RUBY
+      class IndentHeredoc < Cop
+        include Heredoc
+        include ConfigurableEnforcedStyle
+        include SafeMode
+
+        RUBY23_MSG = 'Use %<indentation_width>d spaces for indentation in a ' \
+                     'heredoc by using `<<~` instead of ' \
+                     '`%<current_indent_type>s`.'.freeze
+        LIBRARY_MSG = 'Use %<indentation_width>d spaces for indentation in a ' \
+                      'heredoc by using %<method>s.'.freeze
+        STRIP_METHODS = {
+          unindent: 'unindent',
+          active_support: 'strip_heredoc',
+          powerpack: 'strip_indent'
+        }.freeze
+
+        def on_heredoc(node)
+          body = heredoc_body(node)
+          return if body =~ /\A\s*\z/
+
+          body_indent_level = indent_level(body)
+
+          if heredoc_indent_type(node) == '~'
+            expected_indent_level = base_indent_level(node) + indentation_width
+            return if expected_indent_level == body_indent_level
+          else
+            return unless body_indent_level.zero?
+          end
+
+          return if too_long_line?(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
+        end
+
+        private
+
+        def style
+          style = super
+          return style unless style == :auto_detection
+
+          if target_ruby_version >= 2.3
+            :squiggly
+          elsif rails?
+            :active_support
+          end
+        end
+
+        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)
+          end
+        end
+
+        def library_message(indentation_width, method)
+          format(
+            LIBRARY_MSG,
+            indentation_width: indentation_width,
+            method: method
+          )
+        end
+
+        def ruby23_message(indentation_width, current_indent_type)
+          format(
+            RUBY23_MSG,
+            indentation_width: indentation_width,
+            current_indent_type: current_indent_type
+          )
+        end
+
+        def too_long_line?(node)
+          return false if config.for_cop('Metrics/LineLength')['AllowHeredoc']
+          body = heredoc_body(node)
+
+          expected_indent = base_indent_level(node) + indentation_width
+          actual_indent = indent_level(body)
+          increase_indent_level = expected_indent - actual_indent
+
+          max_line = body.each_line.map { |line| line.chomp.size }.max
+
+          max_line + increase_indent_level >= max_line_length
+        end
+
+        def max_line_length
+          config.for_cop('Metrics/LineLength')['Max']
+        end
+
+        def correct_by_squiggly(node)
+          return if target_ruby_version < 2.3
+          lambda do |corrector|
+            if heredoc_indent_type(node) == '~'
+              corrector.replace(node.loc.heredoc_body, indented_body(node))
+            else
+              heredoc_beginning = node.loc.expression.source
+              corrected = heredoc_beginning.sub(/<<-?/, '<<~')
+              corrector.replace(node.loc.expression, corrected)
+            end
+          end
+        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!
+          case style
+          when nil
+            raise Warning, "Auto-correction does not work for #{cop_name}. " \
+                           'Please configure EnforcedStyle.'
+          when :squiggly
+            if target_ruby_version < 2.3
+              raise Warning, '`squiggly` style is selectable only on Ruby ' \
+                             "2.3 or higher for #{cop_name}."
+            end
+          end
+        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{#{body_indent_level}}/, ' ' * correct_indent_level)
+        end
+
+        def base_indent_level(node)
+          base_line_num = node.loc.expression.line
+          base_line = processed_source.lines[base_line_num - 1]
+          indent_level(base_line)
+        end
+
+        def indent_level(str)
+          indentations = str.lines
+                            .map { |line| line[/^\s*/] }
+                            .reject { |line| line == "\n" }
+          indentations.empty? ? 0 : indentations.min_by(&:size).size
+        end
+
+        # Returns '~', '-' or nil
+        def heredoc_indent_type(node)
+          node.source[/^<<([~-])/, 1]
+        end
+
+        def indentation_width
+          @config.for_cop('IndentationWidth')['Width'] || 2
+        end
+
+        def heredoc_body(node)
+          node.loc.heredoc_body.source.scrub
+        end
+      end
+    end
+  end
+end