rubocop 0.42.0 → 0.52.1

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for a newline after the final magic comment.
+      #
+      # @example
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #   # Some documentation for Person
+      #   class Person
+      #     # Some code
+      #   end
+      #
+      #   # bad
+      #   # frozen_string_literal: true
+      #   # Some documentation for Person
+      #   class Person
+      #     # Some code
+      #   end
+      class EmptyLineAfterMagicComment < Cop
+        MSG = 'Add an empty line after magic comments.'.freeze
+        BLANK_LINE = /\A\s*\z/
+
+        def investigate(source)
+          return unless source.ast &&
+                        (last_magic_comment = last_magic_comment(source))
+          return if source[last_magic_comment.loc.line] =~ BLANK_LINE
+
+          offending_range =
+            source_range(source.buffer, last_magic_comment.loc.line + 1, 0)
+
+          add_offense(offending_range, location: offending_range)
+        end
+
+        def autocorrect(token)
+          lambda do |corrector|
+            corrector.insert_before(token, "\n")
+          end
+        end
+
+        private
+
+        # Find the last magic comment in the source file.
+        #
+        # Take all comments that precede the first line of code, select the
+        # magic comments, and return the last magic comment in the file.
+        #
+        # @return [Parser::Source::Comment] if magic comments exist before code
+        # @return [nil] otherwise
+        def last_magic_comment(source)
+          source
+            .comments
+            .take_while { |comment| comment.loc.line < source.ast.loc.line }
+            .select     { |comment| MagicComment.parse(comment.text).any?  }
+            .last
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks whether method definitions are
+      # separated by one empty line.
+      #
+      # `NumberOfEmptyLines` can be and integer (e.g. 1 by default) or
+      # an array (e.g. [1, 2]) to specificy a minimum and a maximum of
+      # empty lines.
+      #
+      # `AllowAdjacentOneLineDefs` can be used to configure is adjacent
+      # one line methods definitions are an offense
+      #
+      # @example
+      #
+      #   # bad
+      #   def a
+      #   end
+      #   def b
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #   def a
+      #   end
+      #
+      #   def b
+      #   end
+      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
+        # doing a linear scan over siblings, so we don't want to call
+        # it on each def.
+        def on_begin(node)
+          node.children.each_cons(2) do |prev, n|
+            nodes = [prev, n]
+            check_defs(nodes) if nodes.all?(&method(:def_node?))
+          end
+        end
+
+        def check_defs(nodes)
+          return if blank_lines_between?(*nodes)
+          return if multiple_blank_lines_groups?(*nodes)
+          return if nodes.all?(&:single_line?) &&
+                    cop_config['AllowAdjacentOneLineDefs']
+
+          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
+
+        def def_node?(node)
+          return unless node
+          node.def_type? || node.defs_type?
+        end
+
+        def multiple_blank_lines_groups?(first_def_node, second_def_node)
+          lines = lines_between_defs(first_def_node, second_def_node)
+          blank_start = lines.each_index.select { |i| lines[i].blank? }.max
+          non_blank_end = lines.each_index.reject { |i| lines[i].blank? }.min
+          return false if blank_start.nil? || non_blank_end.nil?
+          blank_start > non_blank_end
+        end
+
+        def blank_lines_between?(first_def_node, second_def_node)
+          count = blank_lines_count_between(first_def_node, second_def_node)
+          (minimum_empty_lines..maximum_empty_lines).cover?(count)
+        end
+
+        def blank_lines_count_between(first_def_node, second_def_node)
+          lines_between_defs(first_def_node, second_def_node).count(&:blank?)
+        end
+
+        def minimum_empty_lines
+          Array(cop_config['NumberOfEmptyLines']).first
+        end
+
+        def maximum_empty_lines
+          Array(cop_config['NumberOfEmptyLines']).last
+        end
+
+        def prev_node(node)
+          return nil unless node.sibling_index > 0
+
+          node.parent.children[node.sibling_index - 1]
+        end
+
+        def lines_between_defs(first_def_node, second_def_node)
+          line_range = def_end(first_def_node)..(def_start(second_def_node) - 2)
+
+          processed_source.lines[line_range]
+        end
+
+        def def_start(node)
+          node.loc.keyword.line
+        end
+
+        def def_end(node)
+          node.loc.end.line
+        end
+
+        def autocorrect_remove_lines(newline_pos, count)
+          difference = count - maximum_empty_lines
+          range_to_remove = range_between(newline_pos, newline_pos + difference)
+          lambda do |corrector|
+            corrector.remove(range_to_remove)
+          end
+        end
+
+        def autocorrect_insert_lines(newline_pos, count)
+          difference = minimum_empty_lines - count
+          where_to_insert = range_between(newline_pos, newline_pos + 1)
+          lambda do |corrector|
+            corrector.insert_after(where_to_insert, "\n" * difference)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/{style → layout}/empty_lines.rb

@@ -1,12 +1,25 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'set'
 
 module RuboCop
   module Cop
-    module Style
+    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
@@ -16,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/{style → layout}/empty_lines_around_access_modifier.rb

@@ -1,29 +1,46 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    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 = 'Keep a blank line before and after `%s`.'.freeze
+        MSG_AFTER = 'Keep a blank line 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)
           lambda do |corrector|
-            send_line = node.loc.line
+            send_line = node.first_line
             previous_line = processed_source[send_line - 2]
             next_line = processed_source[send_line]
-            line = line_range(node)
+            line = range_by_whole_lines(node.source_range)
 
             unless previous_line_empty?(previous_line)
               corrector.insert_before(line, "\n")
@@ -37,14 +54,6 @@ module RuboCop
 
         private
 
-        def line_range(node)
-          Parser::Source::Range.new(
-            processed_source.buffer,
-            node.source_range.begin_pos - node.loc.column,
-            node.source_range.end_pos
-          )
-        end
-
         def previous_line_ignoring_comments(processed_source, send_line)
           processed_source[0..send_line - 2].reverse.find do |line|
             !comment_line?(line)
@@ -52,17 +61,17 @@ module RuboCop
         end
 
         def previous_line_empty?(previous_line)
-          block_start?(previous_line.lstrip) ||
-            class_def?(previous_line.lstrip) ||
+          block_start?(previous_line) ||
+            class_def?(previous_line) ||
             previous_line.blank?
         end
 
         def next_line_empty?(next_line)
-          body_end?(next_line.lstrip) || next_line.blank?
+          body_end?(next_line) || next_line.blank?
         end
 
         def empty_lines_around?(node)
-          send_line = node.loc.line
+          send_line = node.first_line
           previous_line = previous_line_ignoring_comments(processed_source,
                                                           send_line)
           next_line = processed_source[send_line]
@@ -71,7 +80,7 @@ module RuboCop
         end
 
         def class_def?(line)
-          line.start_with?('class', 'module')
+          line =~ /^\s*(class|module)/
         end
 
         def block_start?(line)
@@ -79,11 +88,18 @@ module RuboCop
         end
 
         def body_end?(line)
-          line.start_with?('end')
+          line =~ /^\s*end/
         end
 
         def message(node)
-          format(MSG, node.loc.selector.source)
+          previous_line = processed_source[node.first_line - 2]
+
+          if block_start?(previous_line) ||
+             class_def?(previous_line)
+            format(MSG_AFTER, node.loc.selector.source)
+          else
+            format(MSG_BEFORE_AND_AFTER, node: node.loc.selector.source)
+          end
         end
       end
     end

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

@@ -0,0 +1,87 @@
+# 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? || node.arguments.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)
+          lines = processed_lines(node).map.with_index(first_line(node)).to_a
+          lines.select! { |code, _| code.empty? }
+          lines.map { |_, line| line }
+        end
+
+        def extra_lines(node)
+          empty_lines(node).each do |line|
+            range = source_range(processed_source.buffer, line, 0)
+            yield(range)
+          end
+        end
+
+        def first_line(node)
+          node.receiver ? node.receiver.last_line : node.first_line
+        end
+
+        def last_line(node)
+          last_arg = node.arguments.last
+          last_arg.block_type? ? last_arg.first_line : node.last_line
+        end
+
+        def processed_lines(node)
+          start = first_line(node) - 1
+          stop = last_line(node) - 1
+          processed_source.lines[start..stop]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cops checks if empty lines exist around the bodies of begin-end
+      # blocks.
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #
+      #   begin
+      #
+      #     # ...
+      #
+      #   end
+      class EmptyLinesAroundBeginBody < Cop
+        include EmptyLinesAroundBody
+
+        KIND = '`begin`'.freeze
+
+        def on_kwbegin(node)
+          check(node, nil)
+        end
+
+        def autocorrect(node)
+          EmptyLineCorrector.correct(node)
+        end
+
+        private
+
+        def style
+          :no_empty_lines
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/{style → layout}/empty_lines_around_block_body.rb

@@ -1,30 +1,25 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # This cops checks if empty lines around the bodies of blocks match
       # the configuration.
       #
-      # @example
-      #
-      #   # EnforcedStyle: empty_lines
-      #
+      # @example EnforcedStyle: empty_lines
       #   # good
       #
       #   foo do |bar|
       #
-      #     ...
+      #     # ...
       #
       #   end
       #
-      #   # EnforcedStyle: no_empty_lines
-      #
+      # @example EnforcedStyle: no_empty_lines (default)
       #   # good
       #
       #   foo do |bar|
-      #     ...
+      #     # ...
       #   end
       class EmptyLinesAroundBlockBody < Cop
         include EmptyLinesAroundBody
@@ -32,9 +27,11 @@ module RuboCop
         KIND = 'block'.freeze
 
         def on_block(node)
-          _send, _args, body = *node
+          check(node, node.body)
+        end
 
-          check(node, body)
+        def autocorrect(node)
+          EmptyLineCorrector.correct(node)
         end
       end
     end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cops checks if empty lines around the bodies of classes match
+      # the configuration.
+      #
+      # @example EnforcedStyle: empty_lines
+      #   # good
+      #
+      #   class Foo
+      #
+      #     def bar
+      #       # ...
+      #     end
+      #
+      #   end
+      #
+      # @example EnforcedStyle: empty_lines_except_namespace
+      #   # good
+      #
+      #   class Foo
+      #     class Bar
+      #
+      #       # ...
+      #
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: empty_lines_special
+      #   # good
+      #   class Foo
+      #
+      #     def bar; end
+      #
+      #   end
+      #
+      # @example EnforcedStyle: no_empty_lines (default)
+      #   # good
+      #
+      #   class Foo
+      #     def bar
+      #       # ...
+      #     end
+      #   end
+      class EmptyLinesAroundClassBody < Cop
+        include EmptyLinesAroundBody
+
+        KIND = 'class'.freeze
+
+        def on_class(node)
+          _name, _superclass, body = *node
+          check(node, body)
+        end
+
+        def on_sclass(node)
+          _obj, body = *node
+          check(node, body)
+        end
+
+        def autocorrect(node)
+          EmptyLineCorrector.correct(node)
+        end
+      end
+    end
+  end
+end