rubocop 0.76.0 → 1.50.0

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

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for extra/unnecessary whitespace.
+      # Checks for extra/unnecessary whitespace.
       #
       # @example
       #
@@ -13,12 +11,12 @@ module RuboCop
       #   name      = "RuboCop"
       #   # Some comment and an empty line
       #
-      #   website  += "/rubocop-hq/rubocop" unless cond
+      #   website  += "/rubocop/rubocop" unless cond
       #   puts        "rubocop"          if     debug
       #
       #   # bad for any configuration
       #   set_app("RuboCop")
-      #   website  = "https://github.com/rubocop-hq/rubocop"
+      #   website  = "https://github.com/rubocop/rubocop"
       #
       #   # good only if AllowBeforeTrailingComments is true
       #   object.method(arg)  # this is a comment
@@ -30,17 +28,18 @@ module RuboCop
       #   object.method(arg)         # this is a comment
       #   another_object.method(arg) # this is another comment
       #   some_object.method(arg)    # this is some comment
-      class ExtraSpacing < Cop
+      class ExtraSpacing < Base
+        extend AutoCorrector
         include PrecedingFollowingAlignment
         include RangeHelp
 
         MSG_UNNECESSARY = 'Unnecessary spacing detected.'
-        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s ' \
-                             'assignment.'
+        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s assignment.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.blank?
 
+          @aligned_comments = aligned_locations(processed_source.comments.map(&:loc))
           @corrected = Set.new if force_equal_sign_alignment?
 
           processed_source.tokens.each_cons(2) do |token1, token2|
@@ -48,17 +47,23 @@ module RuboCop
           end
         end
 
-        def autocorrect(range)
-          lambda do |corrector|
-            if range.source.end_with?('=')
-              align_equal_signs(range, corrector)
-            else
-              corrector.remove(range)
-            end
+        private
+
+        def aligned_locations(locs) # rubocop:disable Metrics/AbcSize
+          return [] if locs.empty?
+
+          aligned = Set[locs.first.line, locs.last.line]
+          locs.each_cons(3) do |before, loc, after|
+            col = loc.column
+            aligned << loc.line if col == before.column || col == after.column
           end
-        end
 
-        private
+          # if locs.size > 2 and the size of variable `aligned`
+          # has not increased from its initial value, there are not aligned lines.
+          return [] if locs.size > 2 && aligned.size == 2
+
+          aligned
+        end
 
         def check_tokens(ast, token1, token2)
           return if token2.type == :tNL
@@ -74,17 +79,18 @@ module RuboCop
           return unless aligned_with_preceding_assignment(token) == :no
 
           message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
-          add_offense(token.pos, location: token.pos, message: message)
+          add_offense(token.pos, message: message) do |corrector|
+            align_equal_signs(token.pos, corrector)
+          end
         end
 
         def check_other(token1, token2, ast)
-          return false if allow_for_trailing_comments? &&
-                          token2.text.start_with?('#')
+          return false if allow_for_trailing_comments? && token2.text.start_with?('#')
 
           extra_space_range(token1, token2) do |range|
             next if ignored_range?(ast, range.begin_pos)
 
-            add_offense(range, location: range, message: MSG_UNNECESSARY)
+            add_offense(range, message: MSG_UNNECESSARY) { |corrector| corrector.remove(range) }
           end
         end
 
@@ -102,7 +108,7 @@ module RuboCop
 
         def aligned_tok?(token)
           if token.comment?
-            aligned_comments?(token)
+            @aligned_comments.include?(token.line)
           else
             aligned_with_something?(token.pos)
           end
@@ -114,36 +120,20 @@ module RuboCop
 
         # Returns an array of ranges that should not be reported. It's the
         # extra spaces between the keys and values in a multiline hash,
-        # since those are handled by the Style/AlignHash cop.
+        # since those are handled by the Layout/HashAlignment cop.
         def ignored_ranges(ast)
           return [] unless ast
 
-          @ignored_ranges ||= on_node(:pair, ast).map do |pair|
-            next if pair.parent.single_line?
+          @ignored_ranges ||= begin
+            ranges = []
+            on_node(:pair, ast) do |pair|
+              next if pair.parent.single_line?
 
-            key, value = *pair
-            key.source_range.end_pos...value.source_range.begin_pos
-          end.compact
-        end
-
-        def aligned_comments?(comment_token)
-          ix = processed_source.comments.index do |comment|
-            comment.loc.expression.begin_pos == comment_token.begin_pos
+              key, value = *pair
+              ranges << (key.source_range.end_pos...value.source_range.begin_pos)
+            end
+            ranges
           end
-          aligned_with_previous_comment?(ix) || aligned_with_next_comment?(ix)
-        end
-
-        def aligned_with_previous_comment?(index)
-          index.positive? && comment_column(index - 1) == comment_column(index)
-        end
-
-        def aligned_with_next_comment?(index)
-          index < processed_source.comments.length - 1 &&
-            comment_column(index + 1) == comment_column(index)
-        end
-
-        def comment_column(index)
-          processed_source.comments[index].loc.column
         end
 
         def force_equal_sign_alignment?

data/lib/rubocop/cop/layout/{indent_first_argument.rb → first_argument_indentation.rb}

@@ -2,14 +2,16 @@
 
 module RuboCop
   module Cop
-    # rubocop:disable Metrics/LineLength
     module Layout
-      # This cop checks the indentation of the first argument in a method call.
-      # Arguments after the first one are checked by Layout/AlignArguments,
+      # 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/IndentFirstParameter.
+      # For indenting the first parameter of method _definitions_, check out
+      # `Layout/FirstParameterIndentation`.
+      #
+      # This cop will respect `Layout/ArgumentAlignment` and will not work when
+      # `EnforcedStyle: with_fixed_indentation` is specified for `Layout/ArgumentAlignment`.
       #
       # @example
       #
@@ -35,9 +37,10 @@ module RuboCop
       #   nested_first_param),
       #   second_param
       #
-      # @example EnforcedStyle: consistent
-      #   # The first argument should always be indented one step more than the
-      #   # preceding line.
+      # @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(
@@ -49,7 +52,7 @@ module RuboCop
       #   second_param)
       #
       #   foo = some_method(nested_call(
-      #     nested_first_param),
+      #                       nested_first_param),
       #   second_param)
       #
       #   foo = some_method(
@@ -61,9 +64,9 @@ module RuboCop
       #     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
+      # @example EnforcedStyle: consistent
+      #   # The first argument should always be indented one step more than the
+      #   # preceding line.
       #
       #   # good
       #   some_method(
@@ -71,27 +74,25 @@ module RuboCop
       #   second_param)
       #
       #   foo = some_method(
-      #           first_param,
+      #     first_param,
       #   second_param)
       #
       #   foo = some_method(nested_call(
-      #                       nested_first_param),
+      #     nested_first_param),
       #   second_param)
       #
       #   foo = some_method(
-      #           nested_call(
-      #             nested_first_param),
+      #     nested_call(
+      #       nested_first_param),
       #   second_param)
       #
       #   some_method nested_call(
-      #                 nested_first_param),
-      #   second_params
+      #     nested_first_param),
+      #   second_param
       #
-      # @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.
+      # @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(
@@ -99,7 +100,7 @@ module RuboCop
       #   second_param)
       #
       #   foo = some_method(
-      #     first_param,
+      #           first_param,
       #   second_param)
       #
       #   foo = some_method(nested_call(
@@ -107,18 +108,19 @@ module RuboCop
       #   second_param)
       #
       #   foo = some_method(
-      #     nested_call(
-      #       nested_first_param),
+      #           nested_call(
+      #             nested_first_param),
       #   second_param)
       #
       #   some_method nested_call(
       #                 nested_first_param),
-      #   second_param
+      #   second_params
       #
-      # @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.
+      # @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(
@@ -139,38 +141,50 @@ module RuboCop
       #   second_param)
       #
       #   some_method nested_call(
-      #     nested_first_param),
+      #                 nested_first_param),
       #   second_param
       #
-      class IndentFirstArgument < Cop
-        # rubocop:enable Metrics/LineLength
+      class FirstArgumentIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Indent the first argument one step more than %<base>s.'
 
         def on_send(node)
-          return if !node.arguments? || node.operator_method?
+          return unless should_check?(node)
+          return if same_line?(node, node.first_argument)
+          return if style != :consistent && enforce_first_argument_with_fixed_indentation? &&
+                    !enable_layout_first_method_argument_line_break?
 
           indent = base_indentation(node) + configured_indentation_width
 
           check_alignment([node.first_argument], indent)
         end
         alias on_csend on_send
+        alias on_super on_send
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, column_delta)
+        private
+
+        def should_check?(node)
+          node.arguments? && !bare_operator?(node) && !node.setter_method?
         end
 
-        private
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
+
+        def bare_operator?(node)
+          node.operator_method? && !node.dot?
+        end
 
         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 text !~ /\n/ && special_inner_call_indentation?(send_node)
+          base = if !text.include?("\n") && 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)'
@@ -204,13 +218,19 @@ module RuboCop
           node.source_range.begin_pos > parent.source_range.begin_pos
         end
 
+        # @!method eligible_method_call?(node)
         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)
+          parent = send_node.parent
+          start_node = if parent && (parent.splat_type? || parent.kwsplat_type?)
+                         send_node.parent
+                       else
+                         send_node
+                       end
+          range_between(start_node.source_range.begin_pos, arg_node.source_range.begin_pos)
         end
 
         # Returns the column of the given range. For single line ranges, this
@@ -240,9 +260,27 @@ module RuboCop
           @comment_lines ||=
             processed_source
             .comments
-            .select { |c| begins_its_line?(c.loc.expression) }
+            .select { |c| begins_its_line?(c.source_range) }
             .map { |c| c.loc.line }
         end
+
+        def on_new_investigation
+          @comment_lines = nil
+        end
+
+        def enforce_first_argument_with_fixed_indentation?
+          return false unless argument_alignment_config['Enabled']
+
+          argument_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def enable_layout_first_method_argument_line_break?
+          config.for_cop('Layout/FirstMethodArgumentLineBreak')['Enabled']
+        end
+
+        def argument_alignment_config
+          config.for_cop('Layout/ArgumentAlignment')
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/{indent_first_array_element.rb → first_array_element_indentation.rb}

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks the indentation of the first element in an array literal
+      # 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.
+      # 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
@@ -22,7 +22,7 @@ module RuboCop
       # @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
+      #   # element are on separate lines is indented one step (two spaces) more
       #   # than the position inside the opening parenthesis.
       #
       #   #bad
@@ -44,7 +44,7 @@ module RuboCop
       # @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
+      #   # separate lines is indented the same as an array literal which is not
       #   # defined inside a method call.
       #
       #   #bad
@@ -79,10 +79,11 @@ module RuboCop
       #   and_now_for_something = [
       #                             :completely_different
       #                           ]
-      class IndentFirstArrayElement < Cop
+      class FirstArrayElementIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include MultilineElementIndentation
+        extend AutoCorrector
 
         MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
               'in an array, relative to %<base_description>s.'
@@ -98,12 +99,12 @@ module RuboCop
         end
         alias on_csend on_send
 
-        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 brace_alignment_style
           :align_brackets
         end
@@ -114,41 +115,38 @@ module RuboCop
           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
+            return if same_line?(first_elem, left_bracket)
 
             check_first(first_elem, left_bracket, left_parenthesis, 0)
           end
 
-          check_right_bracket(array_node.loc.end, left_bracket,
-                              left_parenthesis)
+          check_right_bracket(array_node.loc.end, first_elem, left_bracket, left_parenthesis)
         end
 
-        def check_right_bracket(right_bracket, left_bracket, left_parenthesis)
+        def check_right_bracket(right_bracket, first_elem, left_bracket, left_parenthesis)
           # if the right bracket is on the same line as the last value, accept
-          return if right_bracket.source_line[0...right_bracket.column] =~ /\S/
+          return if /\S/.match?(right_bracket.source_line[0...right_bracket.column])
 
-          expected_column = base_column(left_bracket, left_parenthesis)
+          expected_column, indent_base_type = indent_base(left_bracket, first_elem,
+                                                          left_parenthesis)
           @column_delta = expected_column - right_bracket.column
           return if @column_delta.zero?
 
-          msg = 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
-          add_offense(right_bracket, location: right_bracket, message: msg)
+          msg = message_for_right_bracket(indent_base_type)
+          add_offense(right_bracket, message: msg) do |corrector|
+            autocorrect(corrector, right_bracket)
+          end
         end
 
         # Returns the description of what the correct indentation is based on.
-        def base_description(left_parenthesis)
-          if style == :align_brackets
+        def base_description(indent_base_type)
+          case indent_base_type
+          when :left_brace_or_bracket
             'the position of the opening bracket'
-          elsif left_parenthesis && style == :special_inside_parentheses
+          when :first_column_after_left_parenthesis
             'the first position after the preceding left parenthesis'
+          when :parent_hash_key
+            'the parent hash key'
           else
             'the start of the line where the left square bracket is'
           end
@@ -161,6 +159,21 @@ module RuboCop
             base_description: base_description
           )
         end
+
+        def message_for_right_bracket(indent_base_type)
+          case indent_base_type
+          when :left_brace_or_bracket
+            'Indent the right bracket the same as the left bracket.'
+          when :first_column_after_left_parenthesis
+            'Indent the right bracket the same as the first position ' \
+            'after the preceding left parenthesis.'
+          when :parent_hash_key
+            'Indent the right bracket the same as the parent hash key.' \
+          else
+            'Indent the right bracket the same as the start of the line ' \
+            'where the left bracket is.'
+          end
+        end
       end
     end
   end

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

@@ -3,41 +3,73 @@
 module RuboCop
   module Cop
     module Layout
-      # This cop checks for a line break before the first element in a
+      # Checks for a line break before the first element in a
       # multi-line array.
       #
-      # @example
+      # @example AllowMultilineFinalElement: false (default)
       #
       #     # bad
       #     [ :a,
       #       :b]
       #
+      #     # bad
+      #     [ :a, {
+      #       :b => :c
+      #     }]
+      #
+      #     # good
+      #     [:a, :b]
+      #
+      #     # good
+      #     [
+      #       :a,
+      #       :b]
+      #
+      #     # good
+      #     [
+      #       :a, {
+      #       :b => :c
+      #     }]
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #     # bad
+      #     [ :a,
+      #       :b]
+      #
+      #     # good
+      #     [ :a, {
+      #       :b => :c
+      #     }]
+      #
       #     # good
       #     [
       #       :a,
       #       :b]
       #
-      class FirstArrayElementLineBreak < Cop
+      #     # good
+      #     [:a, :b]
+      class FirstArrayElementLineBreak < Base
         include FirstElementLineBreak
+        extend AutoCorrector
 
-        MSG = 'Add a line break before the first element of a ' \
-              'multi-line array.'
+        MSG = 'Add a line break before the first element of a multi-line array.'
 
         def on_array(node)
           return if !node.loc.begin && !assignment_on_same_line?(node)
 
-          check_children_line_break(node, node.children)
-        end
-
-        def autocorrect(node)
-          EmptyLineCorrector.insert_before(node)
+          check_children_line_break(node, node.children, ignore_last: ignore_last_element?)
         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
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
         end
       end
     end