rubocop 0.51.0 → 0.87.0

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

@@ -3,38 +3,82 @@
 module RuboCop
   module Cop
     module Layout
-      # This cops checks the indentation of hanging closing parentheses in
+      # This cop checks the indentation of hanging closing parentheses in
       # method calls, method definitions, and grouped expressions. A hanging
       # closing parenthesis means `)` preceded by a line break.
       #
       # @example
       #
-      #   # good: when x is on its own line, indent this way
-      #   func(
-      #     x,
-      #     y
-      #   )
+      #   # bad
+      #   some_method(
+      #     a,
+      #     b
+      #     )
       #
-      #   # good: when x follows opening parenthesis, align parentheses
-      #   a = b * (x +
-      #            y
-      #           )
+      #   some_method(
+      #     a, b
+      #     )
       #
-      #   # bad
-      #   def func(
-      #     x,
-      #     y
+      #   some_method(a, b, c
+      #     )
+      #
+      #   some_method(a,
+      #               b,
+      #               c
       #     )
+      #
+      #   some_method(a,
+      #     x: 1,
+      #     y: 2
+      #     )
+      #
+      #   # Scenario 1: When First Parameter Is On Its Own Line
+      #
+      #   # good: when first param is on a new line, right paren is *always*
+      #   #       outdented by IndentationWidth
+      #   some_method(
+      #     a,
+      #     b
+      #   )
+      #
+      #   # good
+      #   some_method(
+      #     a, b
+      #   )
+      #
+      #   # Scenario 2: When First Parameter Is On The Same Line
+      #
+      #   # good: when all other params are also on the same line, outdent
+      #   #       right paren by IndentationWidth
+      #   some_method(a, b, c
+      #              )
+      #
+      #   # good: when all other params are on multiple lines, but are lined
+      #   #       up, align right paren with left paren
+      #   some_method(a,
+      #               b,
+      #               c
+      #              )
+      #
+      #   # good: when other params are not lined up on multiple lines, outdent
+      #   #       right paren by IndentationWidth
+      #   some_method(a,
+      #     x: 1,
+      #     y: 2
+      #   )
+      #
+      #
       class ClosingParenthesisIndentation < Cop
-        include AutocorrectAlignment
+        include Alignment
+
+        MSG_INDENT = 'Indent `)` to column %<expected>d (not %<actual>d)'
 
-        MSG_INDENT =
-          'Indent `)` the same as the start of the line where `(` is.'.freeze
-        MSG_ALIGN = 'Align `)` with `(`.'.freeze
+        MSG_ALIGN = 'Align `)` with `(`.'
 
         def on_send(node)
           check(node, node.arguments)
         end
+        alias on_csend on_send
 
         def on_begin(node)
           check(node, node.children)
@@ -45,38 +89,109 @@ module RuboCop
         end
         alias on_defs on_def
 
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
+        end
+
         private
 
         def check(node, elements)
+          if elements.empty?
+            check_for_no_elements(node)
+          else
+            check_for_elements(node, elements)
+          end
+        end
+
+        def check_for_elements(node, elements)
+          left_paren  = node.loc.begin
           right_paren = node.loc.end
 
           return unless right_paren && begins_its_line?(right_paren)
 
-          correct_column = expected_column(node, elements)
+          correct_column = expected_column(left_paren, elements)
+
           @column_delta = correct_column - right_paren.column
 
           return if @column_delta.zero?
 
+          add_offense(right_paren,
+                      location: right_paren,
+                      message:  message(correct_column,
+                                        left_paren,
+                                        right_paren))
+        end
+
+        def check_for_no_elements(node)
           left_paren = node.loc.begin
-          msg = correct_column == left_paren.column ? MSG_ALIGN : MSG_INDENT
+          right_paren = node.loc.end
+          return unless right_paren && begins_its_line?(right_paren)
+
+          candidates = correct_column_candidates(node, left_paren)
 
-          add_offense(right_paren, location: right_paren, message: msg)
+          return if candidates.include?(right_paren.column)
+
+          # Although there are multiple choices for a correct column,
+          # select the first one of candidates to determine a specification.
+          correct_column = candidates.first
+          @column_delta = correct_column - right_paren.column
+          add_offense(right_paren,
+                      location: right_paren,
+                      message:  message(correct_column,
+                                        left_paren,
+                                        right_paren))
         end
 
-        def expected_column(node, elements)
-          left_paren = node.loc.begin
+        def expected_column(left_paren, elements)
+          if line_break_after_left_paren?(left_paren, elements)
+            source_indent = processed_source
+                            .line_indentation(first_argument_line(elements))
+            new_indent    = source_indent - indentation_width
 
-          if node.send_type? && fixed_parameter_indentation? ||
-             line_break_after_left_paren?(left_paren, elements)
-            left_paren.source_line =~ /\S/
-          else
+            new_indent.negative? ? 0 : new_indent
+          elsif all_elements_aligned?(elements)
             left_paren.column
+          else
+            processed_source.line_indentation(first_argument_line(elements))
+          end
+        end
+
+        def all_elements_aligned?(elements)
+          elements
+            .map { |e| e.loc.column }
+            .uniq
+            .count == 1
+        end
+
+        def first_argument_line(elements)
+          elements
+            .first
+            .loc
+            .first_line
+        end
+
+        def correct_column_candidates(node, left_paren)
+          [
+            processed_source.line_indentation(left_paren.line),
+            left_paren.column,
+            node.loc.column
+          ]
+        end
+
+        def message(correct_column, left_paren, right_paren)
+          if correct_column == left_paren.column
+            MSG_ALIGN
+          else
+            format(
+              MSG_INDENT,
+              expected: correct_column,
+              actual: right_paren.column
+            )
           end
         end
 
-        def fixed_parameter_indentation?
-          config.for_cop('Layout/AlignParameters')['EnforcedStyle'] ==
-            'with_fixed_indentation'
+        def indentation_width
+          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
         end
 
         def line_break_after_left_paren?(left_paren, elements)

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

@@ -3,18 +3,78 @@
 module RuboCop
   module Cop
     module Layout
-      # This cops checks the indentation of comments.
+      # This cop checks the indentation of comments.
+      #
+      # @example
+      #   # bad
+      #     # comment here
+      #   def method_name
+      #   end
+      #
+      #     # comment here
+      #   a = 'hello'
+      #
+      #   # yet another comment
+      #     if true
+      #       true
+      #     end
+      #
+      #   # good
+      #   # comment here
+      #   def method_name
+      #   end
+      #
+      #   # comment here
+      #   a = 'hello'
+      #
+      #   # yet another comment
+      #   if true
+      #     true
+      #   end
+      #
       class CommentIndentation < Cop
-        include AutocorrectAlignment
+        include Alignment
 
-        MSG = 'Incorrect indentation detected (column %d instead of %d).'.freeze
+        MSG = 'Incorrect indentation detected (column %<column>d ' \
+          'instead of %<correct_comment_indentation>d).'
 
         def investigate(processed_source)
-          processed_source.comments.each { |comment| check(comment) }
+          processed_source.each_comment { |comment| check(comment) }
+        end
+
+        def autocorrect(comment)
+          corrections = autocorrect_preceding_comments(comment) <<
+                        autocorrect_one(comment)
+          ->(corrector) { corrections.each { |corr| corr.call(corrector) } }
         end
 
         private
 
+        # Corrects all comment lines that occur immediately before the given
+        # comment and have the same indentation. This is to avoid a long chain
+        # of correcting, saving the file, parsing and inspecting again, and
+        # then correcting one more line, and so on.
+        def autocorrect_preceding_comments(comment)
+          comments = processed_source.comments
+          index = comments.index(comment)
+
+          comments[0..index]
+            .reverse_each
+            .each_cons(2)
+            .take_while { |below, above| should_correct?(above, below) }
+            .map { |_, above| autocorrect_one(above) }
+        end
+
+        def should_correct?(preceding_comment, reference_comment)
+          loc = preceding_comment.loc
+          ref_loc = reference_comment.loc
+          loc.line == ref_loc.line - 1 && loc.column == ref_loc.column
+        end
+
+        def autocorrect_one(comment)
+          AlignmentCorrector.correct(processed_source, comment, @column_delta)
+        end
+
         def check(comment)
           return unless own_line_comment?(comment)
 
@@ -35,13 +95,21 @@ module RuboCop
 
           add_offense(
             comment,
-            message: format(MSG, column, correct_comment_indentation)
+            message: message(column, correct_comment_indentation)
+          )
+        end
+
+        def message(column, correct_comment_indentation)
+          format(
+            MSG,
+            column: column,
+            correct_comment_indentation: correct_comment_indentation
           )
         end
 
         def own_line_comment?(comment)
           own_line = processed_source.lines[comment.loc.line - 1]
-          own_line =~ /\A\s*#/
+          /\A\s*#/.match?(own_line)
         end
 
         def line_after_comment(comment)
@@ -61,11 +129,11 @@ module RuboCop
         end
 
         def less_indented?(line)
-          line =~ /^\s*(end\b|[)}\]])/
+          /^\s*(end\b|[)}\]])/.match?(line)
         end
 
         def two_alternatives?(line)
-          line =~ /^\s*(else|elsif|when|rescue|ensure)\b/
+          /^\s*(else|elsif|when|rescue|ensure)\b/.match?(line)
         end
       end
     end

data/lib/rubocop/cop/{lint → layout}/condition_position.rb

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    module Lint
+    module Layout
       # This cop checks for conditions that are not on the same line as
       # if/while/until.
       #
@@ -23,7 +23,9 @@ module RuboCop
       #     do_something
       #   end
       class ConditionPosition < Cop
-        MSG = 'Place the condition on the same line as `%s`.'.freeze
+        include RangeHelp
+
+        MSG = 'Place the condition on the same line as `%<keyword>s`.'
 
         def on_if(node)
           return if node.ternary?
@@ -34,9 +36,17 @@ module RuboCop
         def on_while(node)
           check(node)
         end
+        alias on_until on_while
 
-        def on_until(node)
-          check(node)
+        def autocorrect(node)
+          lambda do |corrector|
+            range = range_by_whole_lines(
+              node.source_range, include_final_newline: true
+            )
+
+            corrector.insert_after(node.parent.loc.keyword, " #{node.source}")
+            corrector.remove(range)
+          end
         end
 
         private
@@ -48,7 +58,7 @@ module RuboCop
         end
 
         def message(node)
-          format(MSG, node.parent.keyword)
+          format(MSG, keyword: node.parent.keyword)
         end
       end
     end

data/lib/rubocop/cop/{lint → layout}/def_end_alignment.rb

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    module Lint
+    module Layout
       # This cop checks whether the end keywords of method definitions are
       # aligned properly.
       #
@@ -12,25 +12,22 @@ module RuboCop
       # keyword is. If it's set to `def`, the `end` shall be aligned with the
       # `def` keyword.
       #
-      # @example
-      #
+      # @example EnforcedStyleAlignWith: start_of_line (default)
       #   # bad
       #
       #   private def foo
       #               end
       #
-      # @example
-      #
-      #   # EnforcedStyleAlignWith: start_of_line (default)
-      #
       #   # good
       #
       #   private def foo
       #   end
       #
-      # @example
+      # @example EnforcedStyleAlignWith: def
+      #   # bad
       #
-      #   # EnforcedStyleAlignWith: def
+      #   private def foo
+      #               end
       #
       #   # good
       #
@@ -38,8 +35,9 @@ module RuboCop
       #           end
       class DefEndAlignment < Cop
         include EndKeywordAlignment
+        include RangeHelp
 
-        MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'.freeze
+        MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'
 
         def on_def(node)
           check_end_kw_in_node(node)
@@ -63,13 +61,11 @@ module RuboCop
           ignore_node(method_def) # Don't check the same `end` again.
         end
 
-        private
-
         def autocorrect(node)
           if style == :start_of_line && node.parent && node.parent.send_type?
-            align(node, node.parent)
+            AlignmentCorrector.align_end(processed_source, node, node.parent)
           else
-            align(node, node)
+            AlignmentCorrector.align_end(processed_source, node, node)
           end
         end
       end

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

@@ -5,19 +5,28 @@ module RuboCop
     module Layout
       # This cop checks the . position in multi-line method calls.
       #
-      # @example
+      # @example EnforcedStyle: leading (default)
       #   # bad
       #   something.
-      #     mehod
+      #     method
       #
       #   # good
       #   something
       #     .method
+      #
+      # @example EnforcedStyle: trailing
+      #   # bad
+      #   something
+      #     .method
+      #
+      #   # good
+      #   something.
+      #     method
       class DotPosition < Cop
         include ConfigurableEnforcedStyle
 
         def on_send(node)
-          return unless node.dot?
+          return unless node.dot? || ampersand_dot?(node)
 
           if proper_dot_position?(node)
             correct_style_detected
@@ -25,11 +34,26 @@ module RuboCop
             add_offense(node, location: :dot) { opposite_style_detected }
           end
         end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          lambda do |corrector|
+            dot = node.loc.dot.source
+            corrector.remove(node.loc.dot)
+            case style
+            when :leading
+              corrector.insert_before(selector_range(node), dot)
+            when :trailing
+              corrector.insert_after(node.receiver, dot)
+            end
+          end
+        end
 
         private
 
-        def message(_node)
-          'Place the . on the ' +
+        def message(node)
+          dot = node.loc.dot.source
+          "Place the #{dot} on the " +
             case style
             when :leading
               'next line, together with the method name.'
@@ -67,25 +91,13 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.loc.dot)
-            case style
-            when :leading
-              corrector.insert_before(selector_range(node), '.')
-            when :trailing
-              corrector.insert_after(node.receiver.source_range, '.')
-            end
-          end
+        def selector_range(node)
+          # l.(1) has no selector, so we use the opening parenthesis instead
+          node.loc.selector || node.loc.begin
         end
 
-        def selector_range(node)
-          if node.loc.selector
-            node.loc.selector
-          else
-            # l.(1) has no selector, so we use the opening parenthesis instead
-            node.loc.begin
-          end
+        def ampersand_dot?(node)
+          node.loc.respond_to?(:dot) && node.loc.dot && node.loc.dot.is?('&.')
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cops checks the alignment of else keywords. Normally they should
+      # This cop checks the alignment of else keywords. Normally they should
       # be aligned with an if/unless/while/until/begin/def keyword, but there
       # are special cases when they should follow the same rules as the
       # alignment of end.
@@ -31,16 +31,16 @@ module RuboCop
       #   end
       class ElseAlignment < Cop
         include EndKeywordAlignment
-        include AutocorrectAlignment
+        include Alignment
         include CheckAssignment
 
-        MSG = 'Align `%s` with `%s`.'.freeze
+        MSG = 'Align `%<else_range>s` with `%<base_range>s`.'
 
         def on_if(node, base = nil)
           return if ignored_node?(node)
           return unless node.else? && begins_its_line?(node.loc.else)
 
-          check_alignment(base_range(node, base), node.loc.else)
+          check_alignment(base_range_of_if(node, base), node.loc.else)
 
           return unless node.elsif_conditional?
 
@@ -50,14 +50,7 @@ module RuboCop
         def on_rescue(node)
           return unless node.loc.respond_to?(:else) && node.loc.else
 
-          parent = node.parent
-          parent = parent.parent if parent.ensure_type?
-          base = case parent.type
-                 when :def, :defs then base_for_method_definition(parent)
-                 when :kwbegin then parent.loc.begin
-                 else node.loc.keyword
-                 end
-          check_alignment(base, node.loc.else)
+          check_alignment(base_range_of_rescue(node), node.loc.else)
         end
 
         def on_case(node)
@@ -66,6 +59,18 @@ module RuboCop
           check_alignment(node.when_branches.last.loc.keyword, node.loc.else)
         end
 
+        def on_case_match(node)
+          return unless node.else?
+
+          check_alignment(
+            node.in_pattern_branches.last.loc.keyword, node.loc.else
+          )
+        end
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
+        end
+
         private
 
         def check_nested(node, base)
@@ -73,7 +78,7 @@ module RuboCop
           ignore_node(node)
         end
 
-        def base_range(node, base)
+        def base_range_of_if(node, base)
           if base
             base.source_range
           else
@@ -82,9 +87,20 @@ module RuboCop
           end
         end
 
+        def base_range_of_rescue(node)
+          parent = node.parent
+          parent = parent.parent if parent.ensure_type?
+          case parent.type
+          when :def, :defs then base_for_method_definition(parent)
+          when :kwbegin then parent.loc.begin
+          when :block then parent.send_node.source_range
+          else node.loc.keyword
+          end
+        end
+
         def base_for_method_definition(node)
           parent = node.parent
-          if parent && parent.send_type?
+          if parent&.send_type?
             parent.loc.selector # For example "private def ..."
           else
             node.loc.keyword
@@ -98,7 +114,7 @@ module RuboCop
           rhs = first_part_of_call_chain(rhs)
           return unless rhs
 
-          end_config = config.for_cop('Lint/EndAlignment')
+          end_config = config.for_cop('Layout/EndAlignment')
           style = end_config['EnforcedStyleAlignWith'] || 'keyword'
           base = variable_alignment?(node.loc, rhs, style.to_sym) ? node : rhs
 
@@ -110,14 +126,15 @@ module RuboCop
         def check_alignment(base_range, else_range)
           return unless begins_its_line?(else_range)
 
-          @column_delta = effective_column(base_range) - else_range.column
+          @column_delta = column_offset_between(base_range, else_range)
           return if @column_delta.zero?
 
-          add_offense(
-            else_range,
-            location: else_range,
-            message: format(MSG, else_range.source, base_range.source[/^\S*/])
+          message = format(
+            MSG,
+            else_range: else_range.source,
+            base_range: base_range.source[/^\S*/]
           )
+          add_offense(else_range, location: else_range, message: message)
         end
       end
     end