rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks the indentation of the first argument in a method call.
+      # Arguments after the first one are checked by Layout/ArgumentAlignment,
+      # not by this cop.
+      #
+      # For indenting the first parameter of method _definitions_, check out
+      # Layout/FirstParameterIndentation.
+      #
+      # @example
+      #
+      #   # bad
+      #   some_method(
+      #   first_param,
+      #   second_param)
+      #
+      #   foo = some_method(
+      #   first_param,
+      #   second_param)
+      #
+      #   foo = some_method(nested_call(
+      #   nested_first_param),
+      #   second_param)
+      #
+      #   foo = some_method(
+      #   nested_call(
+      #   nested_first_param),
+      #   second_param)
+      #
+      #   some_method nested_call(
+      #   nested_first_param),
+      #   second_param
+      #
+      # @example EnforcedStyle: consistent
+      #   # The first argument should always be indented one step more than the
+      #   # preceding line.
+      #
+      #   # good
+      #   some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(nested_call(
+      #     nested_first_param),
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     nested_call(
+      #       nested_first_param),
+      #   second_param)
+      #
+      #   some_method nested_call(
+      #     nested_first_param),
+      #   second_param
+      #
+      # @example EnforcedStyle: consistent_relative_to_receiver
+      #   # The first argument should always be indented one level relative to
+      #   # the parent that is receiving the argument
+      #
+      #   # good
+      #   some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(
+      #           first_param,
+      #   second_param)
+      #
+      #   foo = some_method(nested_call(
+      #                       nested_first_param),
+      #   second_param)
+      #
+      #   foo = some_method(
+      #           nested_call(
+      #             nested_first_param),
+      #   second_param)
+      #
+      #   some_method nested_call(
+      #                 nested_first_param),
+      #   second_params
+      #
+      # @example EnforcedStyle: special_for_inner_method_call
+      #   # The first argument should normally be indented one step more than
+      #   # the preceding line, but if it's a argument for a method call that
+      #   # is itself a argument in a method call, then the inner argument
+      #   # should be indented relative to the inner method.
+      #
+      #   # good
+      #   some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(nested_call(
+      #                       nested_first_param),
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     nested_call(
+      #       nested_first_param),
+      #   second_param)
+      #
+      #   some_method nested_call(
+      #                 nested_first_param),
+      #   second_param
+      #
+      # @example EnforcedStyle: special_for_inner_method_call_in_parentheses (default)
+      #   # Same as `special_for_inner_method_call` except that the special rule
+      #   # only applies if the outer method call encloses its arguments in
+      #   # parentheses.
+      #
+      #   # good
+      #   some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(nested_call(
+      #                       nested_first_param),
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     nested_call(
+      #       nested_first_param),
+      #   second_param)
+      #
+      #   some_method nested_call(
+      #     nested_first_param),
+      #   second_param
+      #
+      class FirstArgumentIndentation < Cop
+        include Alignment
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG = 'Indent the first argument one step more than %<base>s.'
+
+        def on_send(node)
+          return if !node.arguments? || node.operator_method?
+
+          indent = base_indentation(node) + configured_indentation_width
+
+          check_alignment([node.first_argument], indent)
+        end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
+        end
+
+        private
+
+        def message(arg_node)
+          return 'Bad indentation of the first argument.' unless arg_node
+
+          send_node = arg_node.parent
+          text = base_range(send_node, arg_node).source.strip
+          base = if !/\n/.match?(text) && special_inner_call_indentation?(send_node)
+                   "`#{text}`"
+                 elsif comment_line?(text.lines.reverse_each.first)
+                   'the start of the previous line (not counting the comment)'
+                 else
+                   'the start of the previous line'
+                 end
+
+          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
+          return true  if style == :consistent_relative_to_receiver
+
+          parent = node.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
+          # part of a chained method call.
+          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)
+          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
+        # is simple. For ranges with line breaks, we look a the last code line.
+        def column_of(range)
+          source = range.source.strip
+          if source.include?("\n")
+            previous_code_line(range.line + source.count("\n") + 1) =~ /\S/
+          else
+            display_column(range)
+          end
+        end
+
+        # Takes the line number of a given code line and returns a string
+        # containing the previous line that's not a comment line or a blank
+        # line.
+        def previous_code_line(line_number)
+          line = ''
+          while line.blank? || comment_lines.include?(line_number)
+            line_number -= 1
+            line = processed_source.lines[line_number - 1]
+          end
+          line
+        end
+
+        def comment_lines
+          @comment_lines ||=
+            processed_source
+            .comments
+            .select { |c| begins_its_line?(c.loc.expression) }
+            .map { |c| c.loc.line }
+        end
+
+        def on_new_investigation
+          @comment_lines = nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    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 ArrayAlignment cop.
+      #
+      # By default, array literals that are arguments in a method call with
+      # parentheses, and where the opening square bracket of the array is on the
+      # same line as the opening parenthesis of the method call, shall have
+      # their first element indented one step (two spaces) more than the
+      # position inside the opening parenthesis.
+      #
+      # Other array literals shall have their first element indented one step
+      # more than the start of the line where the opening square bracket is.
+      #
+      # This default style is called 'special_inside_parentheses'. Alternative
+      # styles are 'consistent' and 'align_brackets'. Here are examples:
+      #
+      # @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 separate 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
+      #   # separate 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 FirstArrayElementIndentation < Cop
+        include Alignment
+        include ConfigurableEnforcedStyle
+        include MultilineElementIndentation
+
+        MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
+              'in an array, relative to %<base_description>s.'
+
+        def on_array(node)
+          check(node, nil) if node.loc.begin
+        end
+
+        def on_send(node)
+          each_argument_node(node, :array) do |array_node, left_parenthesis|
+            check(array_node, left_parenthesis)
+          end
+        end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
+        end
+
+        private
+
+        def brace_alignment_style
+          :align_brackets
+        end
+
+        def check(array_node, left_parenthesis)
+          return if ignored_node?(array_node)
+
+          left_bracket = array_node.loc.begin
+          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)
+          end
+
+          check_right_bracket(array_node.loc.end, left_bracket,
+                              left_parenthesis)
+        end
+
+        def check_right_bracket(right_bracket, left_bracket, left_parenthesis)
+          # if the right bracket is on the same line as the last value, accept
+          return if /\S/.match?(right_bracket.source_line[0...right_bracket.column])
+
+          expected_column = base_column(left_bracket, left_parenthesis)
+          @column_delta = expected_column - right_bracket.column
+          return if @column_delta.zero?
+
+          msg = msg(left_parenthesis)
+          add_offense(right_bracket, location: right_bracket, message: msg)
+        end
+
+        # Returns the description of what the correct indentation is based on.
+        def base_description(left_parenthesis)
+          if style == :align_brackets
+            'the position of the opening bracket'
+          elsif left_parenthesis && style == :special_inside_parentheses
+            'the first position after the preceding left parenthesis'
+          else
+            'the start of the line where the left square bracket is'
+          end
+        end
+
+        def message(base_description)
+          format(
+            MSG,
+            configured_indentation_width: configured_indentation_width,
+            base_description: base_description
+          )
+        end
+
+        def msg(left_parenthesis)
+          if style == :align_brackets
+            'Indent the right bracket the same as the left bracket.'
+          elsif style == :special_inside_parentheses && left_parenthesis
+            'Indent the right bracket the same as the first position ' \
+            'after the preceding left parenthesis.'
+          else
+            'Indent the right bracket the same as the start of the line' \
+            ' where the left bracket is.'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ module RuboCop
         include FirstElementLineBreak
 
         MSG = 'Add a line break before the first element of a ' \
-              'multi-line array.'.freeze
+              'multi-line array.'
 
         def on_array(node)
           return if !node.loc.begin && !assignment_on_same_line?(node)
@@ -29,11 +29,15 @@ module RuboCop
           check_children_line_break(node, node.children)
         end
 
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
+        end
+
         private
 
         def assignment_on_same_line?(node)
           source = node.source_range.source_line[0...node.loc.column]
-          source =~ /\s*\=\s*$/
+          /\s*=\s*$/.match?(source)
         end
       end
     end

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

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Layout
-      # This cops checks the indentation of the first key in a hash literal
+      # This cop 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.
+      # other keys' indentations are handled by the HashAlignment cop.
       #
       # By default, Hash literals that are arguments in a method call with
       # parentheses, and where the opening curly brace of the hash is on the
@@ -19,29 +19,71 @@ 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.
       #
-      class IndentHash < Cop
-        include AutocorrectAlignment
+      #   # 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
+      #   # separate 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 FirstHashElementIndentation < Cop
+        include Alignment
         include ConfigurableEnforcedStyle
-        include ArrayHashIndentation
+        include MultilineElementIndentation
+
+        MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
+              'in a hash, relative to %<base_description>s.'
 
         def on_hash(node)
           check(node, nil) if node.loc.begin
@@ -52,6 +94,11 @@ module RuboCop
             check(hash_node, left_parenthesis)
           end
         end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
+        end
 
         private
 
@@ -66,10 +113,10 @@ module RuboCop
           first_pair = hash_node.pairs.first
 
           if first_pair
-            return if first_pair.source_range.line == left_brace.line
+            return if first_pair.first_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)
@@ -81,7 +128,7 @@ module RuboCop
 
         def check_right_brace(right_brace, left_brace, left_parenthesis)
           # if the right brace is on the same line as the last value, accept
-          return if right_brace.source_line[0...right_brace.column] =~ /\S/
+          return if /\S/.match?(right_brace.source_line[0...right_brace.column])
 
           expected_column = base_column(left_brace, left_parenthesis)
           @column_delta = expected_column - right_brace.column
@@ -102,14 +149,14 @@ module RuboCop
         def separator_style?(first_pair)
           separator = first_pair.loc.operator
           key = "Enforced#{separator.is?(':') ? 'Colon' : 'HashRocket'}Style"
-          config.for_cop('Layout/AlignHash')[key] == 'separator'
+          config.for_cop('Layout/HashAlignment')[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 +172,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/first_hash_element_line_break.rb

@@ -20,13 +20,17 @@ module RuboCop
         include FirstElementLineBreak
 
         MSG = 'Add a line break before the first element of a ' \
-              'multi-line hash.'.freeze
+              'multi-line hash.'
 
         def on_hash(node)
           # node.loc.begin tells us whether the hash opens with a {
           # If it doesn't, Style/FirstMethodArgumentLineBreak will handle it
           check_children_line_break(node, node.children) if node.loc.begin
         end
+
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
+        end
       end
     end
   end

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

@@ -24,7 +24,7 @@ module RuboCop
         include FirstElementLineBreak
 
         MSG = 'Add a line break before the first argument of a ' \
-              'multi-line method argument list.'.freeze
+              'multi-line method argument list.'
 
         def on_send(node)
           args = node.arguments
@@ -36,13 +36,17 @@ module RuboCop
           # ...then each key/value pair is treated as a method 'argument'
           # when determining where line breaks should appear.
           if (last_arg = args.last)
-            if last_arg.hash_type? && !last_arg.braces?
-              args = args.concat(args.pop.children)
-            end
+            args = args.concat(args.pop.children) if last_arg.hash_type? && !last_arg.braces?
           end
 
           check_method_line_break(node, args)
         end
+        alias on_csend on_send
+        alias on_super on_send
+
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
+        end
       end
     end
   end

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

@@ -30,12 +30,16 @@ module RuboCop
         include FirstElementLineBreak
 
         MSG = 'Add a line break before the first parameter of a ' \
-              'multi-line method parameter list.'.freeze
+              'multi-line method parameter list.'
 
         def on_def(node)
           check_method_line_break(node, node.arguments)
         end
         alias on_defs on_def
+
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
+        end
       end
     end
   end