rubocop 0.52.1 → 0.53.0

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

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    module Lint
+    module Layout
       # This cop checks whether the end keywords are aligned properly for do
       # end blocks.
       #
@@ -63,8 +63,9 @@ module RuboCop
       #   end
       class BlockAlignment < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
-        MSG = '%s is not aligned with %s%s.'.freeze
+        MSG = '%<current>s is not aligned with %<prefer>s%<alt_prefer>s.'.freeze
 
         def_node_matcher :block_end_align_target?, <<-PATTERN
           {assignment?
@@ -169,9 +170,11 @@ module RuboCop
                            error_source_line_column)
           format(
             MSG,
-            format_source_line_column(loc_to_source_line_column(end_loc)),
-            format_source_line_column(error_source_line_column),
-            alt_start_msg(start_loc, do_source_line_column)
+            current: format_source_line_column(
+              loc_to_source_line_column(end_loc)
+            ),
+            prefer: format_source_line_column(error_source_line_column),
+            alt_prefer: alt_start_msg(start_loc, do_source_line_column)
           )
         end
 

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

@@ -25,6 +25,8 @@ module RuboCop
       #     foo(i)
       #   }
       class BlockEndNewline < Cop
+        include Alignment
+
         MSG = 'Expression at %<line>d, %<column>d should be on its own line.'
               .freeze
 
@@ -41,9 +43,8 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            indentation = indentation_of_block_start_line(node)
-            new_block_end = "\n" + node.loc.end.source + (' ' * indentation)
-            corrector.replace(delimiter_range(node), new_block_end)
+            corrector.replace(delimiter_range(node),
+                              "\n#{node.loc.end.source}#{offset(node)}")
           end
         end
 
@@ -53,21 +54,10 @@ module RuboCop
           format(MSG, line: node.loc.end.line, column: node.loc.end.column + 1)
         end
 
-        def indentation_of_block_start_line(node)
-          match = /\S.*/.match(node.loc.begin.source_line)
-          match.begin(0)
-        end
-
         def delimiter_range(node)
-          Parser::Source::Range.new(
-            node.loc.end.source_buffer,
-            index_of_delimiter_with_whitespaces(node),
-            node.source.length
-          )
-        end
-
-        def index_of_delimiter_with_whitespaces(node)
-          node.source =~ /\s*#{node.closing_delimiter}/
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    node.children.last.loc.expression.end_pos,
+                                    node.loc.expression.end_pos)
         end
       end
     end

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

@@ -70,6 +70,7 @@ module RuboCop
       class CaseIndentation < Cop
         include Alignment
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         MSG = 'Indent `when` %<depth>s `%<base>s`.'.freeze
 

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

@@ -112,7 +112,8 @@ module RuboCop
         }.freeze
 
         VISIBILITY_SCOPES = %i[private protected public].freeze
-        MSG = '`%s` is supposed to appear before `%s`.'.freeze
+        MSG = '`%<category>s` is supposed to appear before ' \
+              '`%<previous>s`.'.freeze
 
         def_node_matcher :visibility_block?, <<-PATTERN
           (send nil? { :private :protected :public })
@@ -125,7 +126,8 @@ module RuboCop
           walk_over_nested_class_definition(class_node) do |node, category|
             index = expected_order.index(category)
             if index < previous
-              message = format(MSG, category, expected_order[previous])
+              message = format(MSG, category: category,
+                                    previous: expected_order[previous])
               add_offense(node, message: message)
             end
             previous = index
@@ -267,7 +269,8 @@ module RuboCop
           annotation_line = node.first_line - 1
           first_comment = nil
 
-          comments_before_line(annotation_line).reverse_each do |comment|
+          processed_source.comments_before_line(annotation_line)
+                          .reverse_each do |comment|
             if comment.location.line == annotation_line
               first_comment = comment
               annotation_line -= 1
@@ -281,10 +284,6 @@ module RuboCop
           buffer.line_range(node.first_line).begin_pos - 1
         end
 
-        def comments_before_line(line)
-          processed_source.comments.select { |c| c.location.line <= line }
-        end
-
         def buffer
           processed_source.buffer
         end

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

@@ -39,7 +39,7 @@ module RuboCop
           'instead of %<correct_comment_indentation>d).'.freeze
 
         def investigate(processed_source)
-          processed_source.comments.each { |comment| check(comment) }
+          processed_source.each_comment { |comment| check(comment) }
         end
 
         def autocorrect(node)

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,7 @@ module RuboCop
       #     do_something
       #   end
       class ConditionPosition < Cop
-        MSG = 'Place the condition on the same line as `%s`.'.freeze
+        MSG = 'Place the condition on the same line as `%<keyword>s`.'.freeze
 
         def on_if(node)
           return if node.ternary?
@@ -48,7 +48,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.
       #
@@ -35,6 +35,7 @@ module RuboCop
       #           end
       class DefEndAlignment < Cop
         include EndKeywordAlignment
+        include RangeHelp
 
         MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'.freeze
 

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

@@ -102,7 +102,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
 

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks empty comment.
+      #
+      # @example
+      #   # bad
+      #
+      #   #
+      #   class Foo
+      #   end
+      #
+      #   # good
+      #
+      #   #
+      #   # Description of `Foo` class.
+      #   #
+      #   class Foo
+      #   end
+      #
+      # @example AllowBorderComment: true (default)
+      #   # good
+      #
+      #   def foo
+      #   end
+      #
+      #   #################
+      #
+      #   def bar
+      #   end
+      #
+      # @example AllowBorderComment: false
+      #   # bad
+      #
+      #   def foo
+      #   end
+      #
+      #   #################
+      #
+      #   def bar
+      #   end
+      #
+      # @example AllowMarginComment: true (default)
+      #   # good
+      #
+      #   #
+      #   # Description of `Foo` class.
+      #   #
+      #   class Foo
+      #   end
+      #
+      # @example AllowMarginComment: false
+      #   # bad
+      #
+      #   #
+      #   # Description of `Foo` class.
+      #   #
+      #   class Foo
+      #   end
+      #
+      class EmptyComment < Cop
+        include RangeHelp
+
+        MSG = 'Source code comment is empty.'.freeze
+
+        def investigate(processed_source)
+          if allow_margin_comment?
+            comments = concat_consecutive_comments(processed_source.comments)
+
+            comments.each do |comment|
+              next unless empty_comment_only?(comment[0])
+
+              comment[1].each do |offense_comment|
+                add_offense(offense_comment)
+              end
+            end
+          else
+            processed_source.comments.each do |comment|
+              next unless empty_comment_only?(comment_text(comment))
+
+              add_offense(comment)
+            end
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            range = range_by_whole_lines(node.loc.expression,
+                                         include_final_newline: true)
+
+            corrector.remove(range)
+          end
+        end
+
+        private
+
+        def concat_consecutive_comments(comments)
+          prev_line = nil
+
+          comments.each_with_object([]) do |comment, concatenated_comments|
+            if prev_line && comment.loc.line == prev_line.next
+              last_concatenated_comment = concatenated_comments.last
+
+              last_concatenated_comment[0] << comment_text(comment)
+              last_concatenated_comment[1] << comment
+            else
+              concatenated_comments << [comment_text(comment).dup, [comment]]
+            end
+
+            prev_line = comment.loc.line
+          end
+        end
+
+        def empty_comment_only?(comment_text)
+          empty_comment_pattern = if allow_border_comment?
+                                    /\A(#\n)+\z/
+                                  else
+                                    /\A(#+\n)+\z/
+                                  end
+
+          !(comment_text =~ empty_comment_pattern).nil?
+        end
+
+        def comment_text(comment)
+          "#{comment.text.strip}\n"
+        end
+
+        def allow_border_comment?
+          cop_config['AllowBorderComment']
+        end
+
+        def allow_margin_comment?
+          cop_config['AllowMarginComment']
+        end
+      end
+    end
+  end
+end

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

@@ -21,6 +21,8 @@ module RuboCop
       #     # Some code
       #   end
       class EmptyLineAfterMagicComment < Cop
+        include RangeHelp
+
         MSG = 'Add an empty line after magic comments.'.freeze
         BLANK_LINE = /\A\s*\z/
 

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

@@ -30,6 +30,8 @@ module RuboCop
       #   def b
       #   end
       class EmptyLineBetweenDefs < Cop
+        include RangeHelp
+
         MSG = 'Use empty lines between method definitions.'.freeze
 
         def self.autocorrect_incompatible_with

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

@@ -21,6 +21,8 @@ module RuboCop
       #   some_method
       #
       class EmptyLines < Cop
+        include RangeHelp
+
         MSG = 'Extra blank line detected.'.freeze
         LINE_OFFSET = 2
 
@@ -28,7 +30,7 @@ module RuboCop
           return if processed_source.tokens.empty?
 
           lines = Set.new
-          processed_source.tokens.each do |token|
+          processed_source.each_token do |token|
             lines << token.line
           end
 

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

@@ -23,9 +23,11 @@ module RuboCop
       #     def baz; end
       #   end
       class EmptyLinesAroundAccessModifier < Cop
-        MSG_AFTER = 'Keep a blank line after `%s`.'.freeze
-        MSG_BEFORE_AND_AFTER = 'Keep a blank line before and after `%<node>s`.'
-                               .freeze
+        include RangeHelp
+
+        MSG_AFTER = 'Keep a blank line after `%<modifier>s`.'.freeze
+        MSG_BEFORE_AND_AFTER = 'Keep a blank line before and after ' \
+                               '`%<modifier>s`.'.freeze
 
         def on_send(node)
           return unless node.access_modifier?
@@ -96,9 +98,9 @@ module RuboCop
 
           if block_start?(previous_line) ||
              class_def?(previous_line)
-            format(MSG_AFTER, node.loc.selector.source)
+            format(MSG_AFTER, modifier: node.loc.selector.source)
           else
-            format(MSG_BEFORE_AND_AFTER, node: node.loc.selector.source)
+            format(MSG_BEFORE_AND_AFTER, modifier: node.loc.selector.source)
           end
         end
       end

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

@@ -39,6 +39,8 @@ module RuboCop
       #   )
       #
       class EmptyLinesAroundArguments < Cop
+        include RangeHelp
+
         MSG = 'Empty line detected around arguments.'.freeze
 
         def on_send(node)
@@ -55,7 +57,7 @@ module RuboCop
         private
 
         def empty_lines(node)
-          lines = processed_lines(node).map.with_index(first_line(node)).to_a
+          lines = processed_lines(node)
           lines.select! { |code, _| code.empty? }
           lines.map { |_, line| line }
         end
@@ -67,19 +69,27 @@ module RuboCop
           end
         end
 
-        def first_line(node)
-          node.receiver ? node.receiver.last_line : node.first_line
+        def processed_lines(node)
+          line_numbers(node).each_with_object([]) do |num, array|
+            array << [processed_source.lines[num - 1], num]
+          end
         end
 
-        def last_line(node)
-          last_arg = node.arguments.last
-          last_arg.block_type? ? last_arg.first_line : node.last_line
+        def line_numbers(node)
+          inner_lines = []
+          line_nums = node.arguments.each_with_object([]) do |arg_node, lines|
+            lines << outer_lines(arg_node)
+            inner_lines << inner_lines(arg_node) if arg_node.multiline?
+          end
+          line_nums.flatten.uniq - inner_lines.flatten - outer_lines(node)
         end
 
-        def processed_lines(node)
-          start = first_line(node) - 1
-          stop = last_line(node) - 1
-          processed_source.lines[start..stop]
+        def inner_lines(node)
+          [node.first_line + 1, node.last_line - 1]
+        end
+
+        def outer_lines(node)
+          [node.first_line - 1, node.last_line + 1]
         end
       end
     end