rubocop 0.49.1 → 0.52.0

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

@@ -25,9 +25,9 @@ module RuboCop
       #     x,
       #     y
       #     )
+      #   end
       class ClosingParenthesisIndentation < Cop
         include AutocorrectAlignment
-        include OnMethodDef
 
         MSG_INDENT =
           'Indent `)` the same as the start of the line where `(` is.'.freeze
@@ -41,11 +41,12 @@ module RuboCop
           check(node, node.children)
         end
 
-        private
-
-        def on_method_def(_node, _method_name, args, _body)
-          check(args, args.children)
+        def on_def(node)
+          check(node.arguments, node.arguments)
         end
+        alias on_defs on_def
+
+        private
 
         def check(node, elements)
           right_paren = node.loc.end
@@ -60,7 +61,7 @@ module RuboCop
           left_paren = node.loc.begin
           msg = correct_column == left_paren.column ? MSG_ALIGN : MSG_INDENT
 
-          add_offense(right_paren, right_paren, msg)
+          add_offense(right_paren, location: right_paren, message: msg)
         end
 
         def expected_column(node, elements)

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

@@ -4,10 +4,39 @@ module RuboCop
   module Cop
     module Layout
       # This cops 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
 
-        MSG = 'Incorrect indentation detected (column %d instead of %d).'.freeze
+        MSG = 'Incorrect indentation detected (column %<column>d ' \
+          'instead of %<correct_comment_indentation>d).'.freeze
 
         def investigate(processed_source)
           processed_source.comments.each { |comment| check(comment) }
@@ -33,8 +62,18 @@ module RuboCop
             return if column == correct_comment_indentation
           end
 
-          add_offense(comment, comment.loc.expression,
-                      format(MSG, column, correct_comment_indentation))
+          add_offense(
+            comment,
+            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)

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

@@ -4,6 +4,24 @@ module RuboCop
   module Cop
     module Layout
       # This cop checks the . position in multi-line method calls.
+      #
+      # @example EnforcedStyle: leading (default)
+      #   # bad
+      #   something.
+      #     mehod
+      #
+      #   # good
+      #   something
+      #     .method
+      #
+      # @example EnforcedStyle: trailing
+      #   # bad
+      #   something
+      #     .method
+      #
+      #   # good
+      #   something.
+      #     mehod
       class DotPosition < Cop
         include ConfigurableEnforcedStyle
 
@@ -13,7 +31,19 @@ module RuboCop
           if proper_dot_position?(node)
             correct_style_detected
           else
-            add_offense(node, :dot) { opposite_style_detected }
+            add_offense(node, location: :dot) { opposite_style_detected }
+          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
         end
 
@@ -58,18 +88,6 @@ 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
-        end
-
         def selector_range(node)
           if node.loc.selector
             node.loc.selector

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

@@ -7,12 +7,34 @@ module RuboCop
       # 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.
+      #
+      # @example
+      #   # bad
+      #   if something
+      #     code
+      #    else
+      #     code
+      #   end
+      #
+      #   # bad
+      #   if something
+      #     code
+      #    elsif something
+      #     code
+      #   end
+      #
+      #   # good
+      #   if something
+      #     code
+      #   else
+      #     code
+      #   end
       class ElseAlignment < Cop
         include EndKeywordAlignment
         include AutocorrectAlignment
         include CheckAssignment
 
-        MSG = 'Align `%s` with `%s`.'.freeze
+        MSG = 'Align `%<else_range>s` with `%<base_range>s`.'.freeze
 
         def on_if(node, base = nil)
           return if ignored_node?(node)
@@ -20,18 +42,9 @@ module RuboCop
 
           check_alignment(base_range(node, base), node.loc.else)
 
-          else_branch = node.else_branch
+          return unless node.elsif_conditional?
 
-          return unless else_branch && else_branch.if_type? &&
-                        else_branch.elsif?
-
-          # If the `else` part is actually an `elsif`, we check the `elsif`
-          # node in case it contains an `else` within, because that `else`
-          # should have the same alignment (base).
-          on_if(else_branch, base)
-          # The `elsif` node will get an `on_if` call from the framework later,
-          # but we're done here, so we set it to ignored.
-          ignore_node(else_branch)
+          check_nested(node.else_branch, base)
         end
 
         def on_rescue(node)
@@ -55,6 +68,11 @@ module RuboCop
 
         private
 
+        def check_nested(node, base)
+          on_if(node, base)
+          ignore_node(node)
+        end
+
         def base_range(node, base)
           if base
             base.source_range
@@ -86,8 +104,7 @@ module RuboCop
 
           return unless rhs.if_type?
 
-          on_if(rhs, base)
-          ignore_node(rhs)
+          check_nested(rhs, base)
         end
 
         def check_alignment(base_range, else_range)
@@ -95,9 +112,12 @@ module RuboCop
 
           @column_delta = effective_column(base_range) - else_range.column
           return if @column_delta.zero?
-
-          add_offense(else_range, else_range,
-                      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

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

@@ -32,7 +32,7 @@ module RuboCop
           offending_range =
             source_range(source.buffer, last_magic_comment.loc.line + 1, 0)
 
-          add_offense(offending_range, offending_range)
+          add_offense(offending_range, location: offending_range)
         end
 
         def autocorrect(token)

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

@@ -32,6 +32,10 @@ module RuboCop
       class EmptyLineBetweenDefs < Cop
         MSG = 'Use empty lines between method definitions.'.freeze
 
+        def self.autocorrect_incompatible_with
+          [Layout::EmptyLines]
+        end
+
         # We operate on `begin` nodes, instead of using `OnMethodDef`,
         # so that we can walk over pairs of consecutive nodes and
         # efficiently access a node's predecessor; #prev_node ends up
@@ -50,7 +54,24 @@ module RuboCop
           return if nodes.all?(&:single_line?) &&
                     cop_config['AllowAdjacentOneLineDefs']
 
-          add_offense(nodes.last, :keyword)
+          add_offense(nodes.last, location: :keyword)
+        end
+
+        def autocorrect(node)
+          prev_def = prev_node(node)
+
+          # finds position of first newline
+          end_pos = prev_def.loc.end.end_pos
+          source_buffer = prev_def.loc.end.source_buffer
+          newline_pos = source_buffer.source.index("\n", end_pos)
+
+          count = blank_lines_count_between(prev_def, node)
+
+          if count > maximum_empty_lines
+            autocorrect_remove_lines(newline_pos, count)
+          else
+            autocorrect_insert_lines(newline_pos, count)
+          end
         end
 
         private
@@ -105,23 +126,6 @@ module RuboCop
           node.loc.end.line
         end
 
-        def autocorrect(node)
-          prev_def = prev_node(node)
-
-          # finds position of first newline
-          end_pos = prev_def.loc.end.end_pos
-          source_buffer = prev_def.loc.end.source_buffer
-          newline_pos = source_buffer.source.index("\n", end_pos)
-
-          count = blank_lines_count_between(prev_def, node)
-
-          if count > maximum_empty_lines
-            autocorrect_remove_lines(newline_pos, count)
-          else
-            autocorrect_insert_lines(newline_pos, count)
-          end
-        end
-
         def autocorrect_remove_lines(newline_pos, count)
           difference = count - maximum_empty_lines
           range_to_remove = range_between(newline_pos, newline_pos + difference)

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

@@ -6,6 +6,20 @@ module RuboCop
   module Cop
     module Layout
       # This cops checks for two or more consecutive blank lines.
+      #
+      # @example
+      #
+      #   # bad - It has two empty lines.
+      #   some_method
+      #   # one empty line
+      #   # two empty lines
+      #   some_method
+      #
+      #   # good
+      #   some_method
+      #   # one empty line
+      #   some_method
+      #
       class EmptyLines < Cop
         MSG = 'Extra blank line detected.'.freeze
         LINE_OFFSET = 2
@@ -15,11 +29,11 @@ module RuboCop
 
           lines = Set.new
           processed_source.tokens.each do |token|
-            lines << token.pos.line
+            lines << token.line
           end
 
           each_extra_empty_line(lines.sort) do |range|
-            add_offense(range, range)
+            add_offense(range, location: range)
           end
         end
 

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

@@ -4,18 +4,35 @@ module RuboCop
   module Cop
     module Layout
       # Access modifiers should be surrounded by blank lines.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     def bar; end
+      #     private
+      #     def baz; end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def bar; end
+      #
+      #     private
+      #
+      #     def baz; end
+      #   end
       class EmptyLinesAroundAccessModifier < Cop
-        include AccessModifierNode
-
         MSG_AFTER = 'Keep a blank line after `%s`.'.freeze
-        MSG_BEFORE_AND_AFTER = 'Keep a blank line before and after `%s`.'.freeze
+        MSG_BEFORE_AND_AFTER = 'Keep a blank line before and after `%<node>s`.'
+                               .freeze
 
         def on_send(node)
-          return unless modifier_node?(node)
+          return unless node.access_modifier?
 
           return if empty_lines_around?(node)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)
@@ -81,7 +98,7 @@ module RuboCop
              class_def?(previous_line)
             format(MSG_AFTER, node.loc.selector.source)
           else
-            format(MSG_BEFORE_AND_AFTER, node.loc.selector.source)
+            format(MSG_BEFORE_AND_AFTER, node: node.loc.selector.source)
           end
         end
       end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cops checks if empty lines exist around the arguments
+      # of a method invocation.
+      #
+      # @example
+      #   # bad
+      #   do_something(
+      #     foo
+      #
+      #   )
+      #
+      #   process(bar,
+      #
+      #           baz: qux,
+      #           thud: fred)
+      #
+      #   some_method(
+      #
+      #     [1,2,3],
+      #     x: y
+      #   )
+      #
+      #   # good
+      #   do_something(
+      #     foo
+      #   )
+      #
+      #   process(bar,
+      #           baz: qux,
+      #           thud: fred)
+      #
+      #   some_method(
+      #     [1,2,3],
+      #     x: y
+      #   )
+      #
+      class EmptyLinesAroundArguments < Cop
+        MSG = 'Empty line detected around arguments.'.freeze
+
+        def on_send(node)
+          return if node.single_line?
+          return if empty_lines(node).empty?
+          extra_lines(node) { |range| add_offense(node, location: range) }
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            extra_lines(node) { |range| corrector.remove(range) }
+          end
+        end
+
+        private
+
+        def empty_lines(node)
+          @empty_lines ||= begin
+            lines = source_lines(node).map.with_index(1).to_a
+            lines.select! { |code, _| code == '' }
+            lines.map { |_, line| line }
+          end
+        end
+
+        def source_lines(node)
+          source =
+            if node.arguments.last && node.arguments.last.block_type?
+              source_without_block(node, node.arguments.last)
+            else
+              node.source
+            end
+          source.lines.map { |line| line.delete("\n") }
+        end
+
+        def extra_lines(node)
+          empty_lines(node).each do |line|
+            range = source_range(processed_source.buffer, line, 0)
+            yield(range)
+          end
+        end
+
+        def source_without_block(node, block_node)
+          node.source.split(block_node.source).first
+        end
+      end
+    end
+  end
+end