rubocop 0.78.0 → 1.13.0

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

@@ -17,11 +17,11 @@ module RuboCop
       #       :a,
       #       :b]
       #
-      class FirstArrayElementLineBreak < Cop
+      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)
@@ -29,15 +29,11 @@ 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/first_hash_element_indentation.rb

@@ -77,10 +77,11 @@ module RuboCop
       #   and_now_for_something = {
       #                             completely: :different
       #                           }
-      class FirstHashElementIndentation < Cop
+      class FirstHashElementIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include MultilineElementIndentation
+        extend AutoCorrector
 
         MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
               'in a hash, relative to %<base_description>s.'
@@ -96,12 +97,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_braces
         end
@@ -116,8 +117,7 @@ module RuboCop
             return if first_pair.first_line == left_brace.line
 
             if separator_style?(first_pair)
-              check_based_on_longest_key(hash_node, left_brace,
-                                         left_parenthesis)
+              check_based_on_longest_key(hash_node, left_brace, left_parenthesis)
             else
               check_first(first_pair, left_brace, left_parenthesis, 0)
             end
@@ -128,22 +128,16 @@ 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
           return if @column_delta.zero?
 
-          msg = if style == :align_braces
-                  'Indent the right brace the same as the left brace.'
-                elsif style == :special_inside_parentheses && left_parenthesis
-                  'Indent the right brace the same as the first position ' \
-                  'after the preceding left parenthesis.'
-                else
-                  'Indent the right brace the same as the start of the line ' \
-                  'where the left brace is.'
-                end
-          add_offense(right_brace, location: right_brace, message: msg)
+          message = message_for_right_brace(left_parenthesis)
+          add_offense(right_brace, message: message) do |corrector|
+            autocorrect(corrector, right_brace)
+          end
         end
 
         def separator_style?(first_pair)
@@ -153,9 +147,7 @@ module RuboCop
         end
 
         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
+          key_lengths = hash_node.keys.map { |key| key.source_range.length }
           check_first(hash_node.pairs.first, left_brace, left_parenthesis,
                       key_lengths.max - key_lengths.first)
         end
@@ -178,6 +170,18 @@ module RuboCop
             base_description: base_description
           )
         end
+
+        def message_for_right_brace(left_parenthesis)
+          if style == :align_braces
+            'Indent the right brace the same as the left brace.'
+          elsif style == :special_inside_parentheses && left_parenthesis
+            'Indent the right brace the same as the first position ' \
+            'after the preceding left parenthesis.'
+          else
+            'Indent the right brace the same as the start of the line ' \
+            'where the left brace is.'
+          end
+        end
       end
     end
   end

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

@@ -16,21 +16,17 @@ module RuboCop
       #     {
       #       a: 1,
       #       b: 2 }
-      class FirstHashElementLineBreak < Cop
+      class FirstHashElementLineBreak < Base
         include FirstElementLineBreak
+        extend AutoCorrector
 
-        MSG = 'Add a line break before the first element of a ' \
-              'multi-line hash.'
+        MSG = 'Add a line break before the first element of a 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

@@ -20,14 +20,14 @@ module RuboCop
       #     # ignored
       #     method foo, bar,
       #       baz
-      class FirstMethodArgumentLineBreak < Cop
+      class FirstMethodArgumentLineBreak < Base
         include FirstElementLineBreak
+        extend AutoCorrector
 
-        MSG = 'Add a line break before the first argument of a ' \
-              'multi-line method argument list.'
+        MSG = 'Add a line break before the first argument of a multi-line method argument list.'
 
         def on_send(node)
-          args = node.arguments
+          args = node.arguments.dup
 
           # If there is a trailing hash arg without explicit braces, like this:
           #
@@ -35,20 +35,13 @@ 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
-          end
+          last_arg = args.last
+          args.concat(args.pop.children) if last_arg&.hash_type? && !last_arg&.braces?
 
           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

@@ -26,20 +26,16 @@ module RuboCop
       #         bar
       #       do_something
       #     end
-      class FirstMethodParameterLineBreak < Cop
+      class FirstMethodParameterLineBreak < Base
         include FirstElementLineBreak
+        extend AutoCorrector
 
-        MSG = 'Add a line break before the first parameter of a ' \
-              'multi-line method parameter list.'
+        MSG = 'Add a line break before the first parameter of a 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

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

@@ -7,9 +7,9 @@ module RuboCop
       # definition. Parameters after the first one are checked by
       # Layout/ParameterAlignment, not by this cop.
       #
-      # For indenting the first argument of method *calls*, check out
+      # For indenting the first argument of method _calls_, check out
       # Layout/FirstArgumentIndentation, which supports options related to
-      # nesting that are irrelevant for method *definitions*.
+      # nesting that are irrelevant for method _definitions_.
       #
       # @example
       #
@@ -41,10 +41,11 @@ module RuboCop
       #   second_param)
       #     123
       #   end
-      class FirstParameterIndentation < Cop
+      class FirstParameterIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include MultilineElementIndentation
+        extend AutoCorrector
 
         MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
              'in method args, relative to %<base_description>s.'
@@ -57,12 +58,12 @@ module RuboCop
         end
         alias on_defs on_def
 
-        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_parentheses
         end

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

@@ -7,16 +7,16 @@ module RuboCop
       # literal are aligned according to configuration. The configuration
       # options are:
       #
-      #   - key (left align keys, one space before hash rockets and values)
-      #   - separator (align hash rockets and colons, right align keys)
-      #   - table (left align keys, hash rockets, and values)
+      # * key (left align keys, one space before hash rockets and values)
+      # * separator (align hash rockets and colons, right align keys)
+      # * table (left align keys, hash rockets, and values)
       #
       # The treatment of hashes passed as the last argument to a method call
       # can also be configured. The options are:
       #
-      #   - always_inspect
-      #   - always_ignore
-      #   - ignore_implicit (without curly braces)
+      # * always_inspect
+      # * always_ignore
+      # * ignore_implicit (without curly braces)
       #
       # Alternatively you can specify multiple allowed styles. That's done by
       # passing a list of styles to EnforcedStyles.
@@ -175,12 +175,17 @@ module RuboCop
       #   do_something({foo: 1,
       #     bar: 2})
       #
-      class HashAlignment < Cop
+      class HashAlignment < Base
         include HashAlignmentStyles
         include RangeHelp
+        extend AutoCorrector
 
-        MSG = 'Align the elements of a hash literal if they span more than ' \
-              'one line.'
+        MESSAGES = { KeyAlignment => 'Align the keys of a hash literal if ' \
+                      'they span more than one line.',
+                     SeparatorAlignment => 'Align the separators of a hash ' \
+                       'literal if they span more than one line.',
+                     TableAlignment => 'Align the keys and values of a hash ' \
+                       'literal if they span more than one line.' }.freeze
 
         def on_send(node)
           return if double_splat?(node)
@@ -188,15 +193,14 @@ module RuboCop
 
           last_argument = node.last_argument
 
-          return unless last_argument.hash_type? &&
-                        ignore_hash_argument?(last_argument)
+          return unless last_argument.hash_type? && ignore_hash_argument?(last_argument)
 
           ignore_node(last_argument)
         end
         alias on_super on_send
         alias on_yield on_send
 
-        def on_hash(node)
+        def on_hash(node) # rubocop:todo Metrics/CyclomaticComplexity
           return if ignored_node?(node)
           return if node.pairs.empty? || node.single_line?
 
@@ -208,15 +212,7 @@ module RuboCop
           check_pairs(node)
         end
 
-        def autocorrect(node)
-          delta = column_deltas[alignment_for(node).first.class][node]
-          return if delta.nil?
-
-          correct_node(node, delta)
-        end
-
-        attr_accessor :offences_by
-        attr_accessor :column_deltas
+        attr_accessor :offences_by, :column_deltas
 
         private
 
@@ -249,9 +245,13 @@ module RuboCop
         end
 
         def add_offences
-          _format, offences = offences_by.min_by { |_, v| v.length }
+          format, offences = offences_by.min_by { |_, v| v.length }
           (offences || []).each do |offence|
-            add_offense offence
+            add_offense(offence, message: MESSAGES[format]) do |corrector|
+              delta = column_deltas[alignment_for(offence).first.class][offence]
+
+              correct_node(corrector, offence, delta) unless delta.nil?
+            end
           end
         end
 
@@ -281,34 +281,33 @@ module RuboCop
         end
 
         def alignment_for_hash_rockets
-          @alignment_for_hash_rockets ||=
-            new_alignment('EnforcedHashRocketStyle')
+          @alignment_for_hash_rockets ||= new_alignment('EnforcedHashRocketStyle')
         end
 
         def alignment_for_colons
-          @alignment_for_colons ||=
-            new_alignment('EnforcedColonStyle')
+          @alignment_for_colons ||= new_alignment('EnforcedColonStyle')
         end
 
-        def correct_node(node, delta)
+        def correct_node(corrector, node, delta)
           # We can't use the instance variable inside the lambda. That would
           # just give each lambda the same reference and they would all get the
           # last value of each. A local variable fixes the problem.
 
-          if !node.value
-            correct_no_value(delta[:key] || 0, node.source_range)
-          else
-            correct_key_value(delta, node.key.source_range,
+          if node.value
+            correct_key_value(corrector, delta, node.key.source_range,
                               node.value.source_range,
                               node.loc.operator)
+          else
+            delta_value = delta[:key] || 0
+            correct_no_value(corrector, delta_value, node.source_range)
           end
         end
 
-        def correct_no_value(key_delta, key)
-          ->(corrector) { adjust(corrector, key_delta, key) }
+        def correct_no_value(corrector, key_delta, key)
+          adjust(corrector, key_delta, key)
         end
 
-        def correct_key_value(delta, key, value, separator)
+        def correct_key_value(corrector, delta, key, value, separator)
           # We can't use the instance variable inside the lambda. That would
           # just give each lambda the same reference and they would all get the
           # last value of each. Some local variables fix the problem.
@@ -319,11 +318,9 @@ module RuboCop
           key_column = key.column
           key_delta = -key_column if key_delta < -key_column
 
-          lambda do |corrector|
-            adjust(corrector, key_delta, key)
-            adjust(corrector, separator_delta, separator)
-            adjust(corrector, value_delta, value)
-          end
+          adjust(corrector, key_delta, key)
+          adjust(corrector, separator_delta, separator)
+          adjust(corrector, value_delta, value)
         end
 
         def new_alignment(key)

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

@@ -50,12 +50,17 @@ module RuboCop
       #        123,
       #      )
       #
-      class HeredocArgumentClosingParenthesis < Cop
+      class HeredocArgumentClosingParenthesis < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Put the closing parenthesis for a method call with a ' \
         'HEREDOC parameter on the same line as the HEREDOC opening.'
 
+        def self.autocorrect_incompatible_with
+          [Style::TrailingCommaInArguments]
+        end
+
         def on_send(node)
           heredoc_arg = extract_heredoc_argument(node)
           return unless heredoc_arg
@@ -64,10 +69,16 @@ module RuboCop
           return unless outermost_send
           return unless outermost_send.loc.end
           return unless heredoc_arg.first_line != outermost_send.loc.end.line
+          return if subsequent_closing_parentheses_in_same_line?(outermost_send)
+          return if exist_argument_between_heredoc_end_and_closing_parentheses?(node)
 
-          add_offense(outermost_send, location: :end)
+          add_offense(outermost_send.loc.end) do |corrector|
+            autocorrect(corrector, outermost_send)
+          end
         end
 
+        private
+
         # Autocorrection note:
         #
         # Commas are a bit tricky to handle when the method call is
@@ -94,26 +105,14 @@ module RuboCop
         #   SQL
         #   third_array_value,
         # ]
-        def autocorrect(node)
-          lambda do |corrector|
-            fix_closing_parenthesis(node, corrector)
+        def autocorrect(corrector, node)
+          fix_closing_parenthesis(node, corrector)
 
-            if internal_trailing_comma?(node)
-              remove_internal_trailing_comma(node, corrector)
-            end
+          remove_internal_trailing_comma(node, corrector) if internal_trailing_comma?(node)
 
-            if external_trailing_comma?(node)
-              fix_external_trailing_comma(node, corrector)
-            end
-          end
+          fix_external_trailing_comma(node, corrector) if external_trailing_comma?(node)
         end
 
-        def self.autocorrect_incompatible_with
-          [Style::TrailingCommaInArguments]
-        end
-
-        private
-
         def outermost_send_on_same_line(heredoc)
           previous = heredoc
           current = previous.parent
@@ -133,9 +132,7 @@ module RuboCop
         end
 
         def extract_heredoc_argument(node)
-          node.arguments.find do |arg_node|
-            extract_heredoc(arg_node)
-          end
+          node.arguments.find { |arg_node| extract_heredoc(arg_node) }
         end
 
         def extract_heredoc(node)
@@ -163,13 +160,24 @@ module RuboCop
 
         # Closing parenthesis helpers.
 
+        def subsequent_closing_parentheses_in_same_line?(outermost_send)
+          last_arg_of_outer_send = outermost_send.last_argument
+          return false unless last_arg_of_outer_send&.loc.respond_to?(:end) &&
+                              (end_of_last_arg_of_outer_send = last_arg_of_outer_send.loc.end)
+
+          end_of_outer_send = outermost_send.loc.end
+
+          end_of_outer_send.line == end_of_last_arg_of_outer_send.line &&
+            end_of_outer_send.column == end_of_last_arg_of_outer_send.column + 1
+        end
+
         def fix_closing_parenthesis(node, corrector)
           remove_incorrect_closing_paren(node, corrector)
           add_correct_closing_paren(node, corrector)
         end
 
         def add_correct_closing_paren(node, corrector)
-          corrector.insert_after(node.arguments.last.source_range, ')')
+          corrector.insert_after(node.arguments.last, ')')
         end
 
         def remove_incorrect_closing_paren(node, corrector)
@@ -194,7 +202,7 @@ module RuboCop
         def safe_to_remove_line_containing_closing_paren?(node)
           last_line = processed_source[node.loc.end.line - 1]
           # Safe to remove if last line only contains `)`, `,`, and whitespace.
-          last_line.match(/^[ ]*\)[ ]{0,20},{0,1}[ ]*$/)
+          last_line.match?(/^ *\) {0,20},{0,1} *$/)
         end
 
         def incorrect_parenthesis_removal_end(node)
@@ -206,17 +214,25 @@ module RuboCop
           end
         end
 
+        def exist_argument_between_heredoc_end_and_closing_parentheses?(node)
+          return false unless (heredoc_end = find_most_bottom_of_heredoc_end(node.arguments))
+
+          heredoc_end < node.loc.end.begin_pos &&
+            range_between(heredoc_end, node.loc.end.begin_pos).source.strip != ''
+        end
+
+        def find_most_bottom_of_heredoc_end(arguments)
+          arguments.map do |argument|
+            argument.loc.heredoc_end.end_pos if argument.loc.respond_to?(:heredoc_end)
+          end.compact.max
+        end
+
         # Internal trailing comma helpers.
 
         def remove_internal_trailing_comma(node, corrector)
           offset = internal_trailing_comma_offset_from_last_arg(node)
           last_arg_end_pos = node.children.last.source_range.end_pos
-          corrector.remove(
-            range_between(
-              last_arg_end_pos,
-              last_arg_end_pos + offset
-            )
-          )
+          corrector.remove(range_between(last_arg_end_pos, last_arg_end_pos + offset))
         end
 
         def internal_trailing_comma?(node)
@@ -249,7 +265,7 @@ module RuboCop
         def add_correct_external_trailing_comma(node, corrector)
           return unless external_trailing_comma?(node)
 
-          corrector.insert_after(node.arguments.last.source_range, ',')
+          corrector.insert_after(node.arguments.last, ',')
         end
 
         def remove_incorrect_external_trailing_comma(node, corrector)