rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop 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
+        include RangeHelp
+
+        MSG = 'Empty line detected around arguments.'
+
+        def on_send(node)
+          return if node.single_line? || node.arguments.empty?
+
+          extra_lines(node) { |range| add_offense(node, location: range) }
+        end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          lambda do |corrector|
+            extra_lines(node) { |range| corrector.remove(range) }
+          end
+        end
+
+        private
+
+        def empty_lines(node)
+          lines = processed_lines(node)
+          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 processed_lines(node)
+          line_numbers(node).each_with_object([]) do |num, array|
+            array << [processed_source.lines[num - 1], num]
+          end
+        end
+
+        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 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
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for a newline after an attribute accessor or a group of them.
+      # `alias` syntax and `alias_method`, `public`, `protected`, and `private` methods are allowed
+      # by default. These are customizable with `AllowAliasSyntax` and `AllowedMethods` options.
+      #
+      # @example
+      #   # bad
+      #   attr_accessor :foo
+      #   def do_something
+      #   end
+      #
+      #   # good
+      #   attr_accessor :foo
+      #
+      #   def do_something
+      #   end
+      #
+      #   # good
+      #   attr_accessor :foo
+      #   attr_reader :bar
+      #   attr_writer :baz
+      #   attr :qux
+      #
+      #   def do_something
+      #   end
+      #
+      # @example AllowAliasSyntax: true (default)
+      #   # good
+      #   attr_accessor :foo
+      #   alias :foo? :foo
+      #
+      #   def do_something
+      #   end
+      #
+      # @example AllowAliasSyntax: false
+      #   # bad
+      #   attr_accessor :foo
+      #   alias :foo? :foo
+      #
+      #   def do_something
+      #   end
+      #
+      #   # good
+      #   attr_accessor :foo
+      #
+      #   alias :foo? :foo
+      #
+      #   def do_something
+      #   end
+      #
+      # @example AllowedMethods: ['private']
+      #   # good
+      #   attr_accessor :foo
+      #   private :foo
+      #
+      #   def do_something
+      #   end
+      #
+      class EmptyLinesAroundAttributeAccessor < Cop
+        include RangeHelp
+        include AllowedMethods
+
+        MSG = 'Add an empty line after attribute accessor.'
+
+        def on_send(node)
+          return unless node.attribute_accessor?
+          return if next_line_empty?(node.last_line)
+
+          next_line_node = next_line_node(node)
+          return unless require_empty_line?(next_line_node)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            range = range_by_whole_lines(node.source_range)
+
+            corrector.insert_after(range, "\n")
+          end
+        end
+
+        private
+
+        def next_line_empty?(line)
+          processed_source[line].blank?
+        end
+
+        def require_empty_line?(node)
+          return false unless node&.respond_to?(:type)
+
+          !allow_alias?(node) && !attribute_or_allowed_method?(node)
+        end
+
+        def next_line_node(node)
+          return if node.parent.if_type?
+
+          node.parent.children[node.sibling_index + 1]
+        end
+
+        def allow_alias?(node)
+          allow_alias_syntax? && node.alias_type?
+        end
+
+        def attribute_or_allowed_method?(node)
+          return false unless node.send_type?
+
+          node.attribute_accessor? || allowed_method?(node.method_name)
+        end
+
+        def allow_alias_syntax?
+          cop_config.fetch('AllowAliasSyntax', true)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -3,35 +3,37 @@
 module RuboCop
   module Cop
     module Layout
-      # This cops checks if empty lines around the bodies of blocks match
+      # This cop 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
 
-        KIND = 'block'.freeze
+        KIND = 'block'
 
         def on_block(node)
-          check(node, node.body)
+          first_line = node.send_node.last_line
+
+          check(node, node.body, adjusted_first_line: first_line)
+        end
+
+        def autocorrect(node)
+          EmptyLineCorrector.correct(node)
         end
       end
     end

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

@@ -3,35 +3,84 @@
 module RuboCop
   module Cop
     module Layout
-      # This cops checks if empty lines around the bodies of classes match
+      # This cop checks if empty lines around the bodies of classes match
       # the configuration.
       #
-      # @example
+      # @example EnforcedStyle: empty_lines
+      #   # good
+      #
+      #   class Foo
+      #
+      #     def bar
+      #       # ...
+      #     end
       #
-      #   EnforcedStyle: empty_lines
+      #   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
+      #     def bar; end
       #
       #   end
+      #
+      # @example EnforcedStyle: beginning_only
+      #   # good
+      #
+      #   class Foo
+      #
+      #     def bar
+      #       # ...
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: ending_only
+      #   # 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
+        KIND = 'class'
 
         def on_class(node)
-          _name, _superclass, body = *node
-          check(node, body)
+          first_line = node.parent_class.first_line if node.parent_class
+
+          check(node, node.body, adjusted_first_line: first_line)
         end
 
         def on_sclass(node)
-          _obj, body = *node
-          check(node, body)
+          check(node, node.body)
+        end
+
+        def autocorrect(node)
+          EmptyLineCorrector.correct(node)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # This cops checks if empty lines exist around the bodies of `begin`
+      # This cop checks if empty lines exist around the bodies of `begin`
       # sections. This cop doesn't check empty lines at `begin` body
       # beginning/end and around method definition body.
       # `Style/EmptyLinesAroundBeginBody` or `Style/EmptyLinesAroundMethodBody`
@@ -61,7 +61,7 @@ module RuboCop
       class EmptyLinesAroundExceptionHandlingKeywords < Cop
         include EmptyLinesAroundBody
 
-        MSG = 'Extra empty line detected %s the `%s`.'.freeze
+        MSG = 'Extra empty line detected %<location>s the `%<keyword>s`.'
 
         def on_def(node)
           check_body(node.body)
@@ -73,6 +73,10 @@ module RuboCop
           check_body(body)
         end
 
+        def autocorrect(node)
+          EmptyLineCorrector.correct(node)
+        end
+
         private
 
         def check_body(node)
@@ -81,21 +85,26 @@ module RuboCop
             line = loc.line
             keyword = loc.source
             # below the keyword
-            check_line(style, line, format(MSG, 'after', keyword), &:empty?)
+            check_line(style, line, message('after', keyword), &:empty?)
             # above the keyword
             check_line(style,
                        line - 2,
-                       format(MSG, 'before', keyword),
+                       message('before', keyword),
                        &:empty?)
           end
         end
 
+        def message(location, keyword)
+          format(MSG, location: location, keyword: keyword)
+        end
+
         def style
           :no_empty_lines
         end
 
         def keyword_locations(node)
           return [] unless node
+
           case node.type
           when :rescue
             keyword_locations_in_rescue(node)

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

@@ -3,33 +3,37 @@
 module RuboCop
   module Cop
     module Layout
-      # This cops checks if empty lines exist around the bodies of methods.
+      # This cop checks if empty lines exist around the bodies of methods.
       #
       # @example
       #
       #   # good
       #
       #   def foo
-      #     ...
+      #     # ...
       #   end
       #
       #   # bad
       #
       #   def bar
       #
-      #     ...
+      #     # ...
       #
       #   end
       class EmptyLinesAroundMethodBody < Cop
         include EmptyLinesAroundBody
 
-        KIND = 'method'.freeze
+        KIND = 'method'
 
         def on_def(node)
           check(node, node.body)
         end
         alias on_defs on_def
 
+        def autocorrect(node)
+          EmptyLineCorrector.correct(node)
+        end
+
         private
 
         def style

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

@@ -3,40 +3,58 @@
 module RuboCop
   module Cop
     module Layout
-      # This cops checks if empty lines around the bodies of modules match
+      # This cop checks if empty lines around the bodies of modules match
       # the configuration.
       #
-      # @example
-      #
-      #   EnforcedStyle: empty_lines
-      #
+      # @example EnforcedStyle: empty_lines
       #   # good
       #
       #   module Foo
       #
       #     def bar
-      #       ...
+      #       # ...
       #     end
       #
       #   end
       #
-      #   EnforcedStyle: no_empty_lines
+      # @example EnforcedStyle: empty_lines_except_namespace
+      #   # good
+      #
+      #   module Foo
+      #     module Bar
+      #
+      #       # ...
+      #
+      #     end
+      #   end
       #
+      # @example EnforcedStyle: empty_lines_special
+      #   # good
+      #   module Foo
+      #
+      #     def bar; end
+      #
+      #   end
+      #
+      # @example EnforcedStyle: no_empty_lines (default)
       #   # good
       #
       #   module Foo
       #     def bar
-      #       ...
+      #       # ...
       #     end
       #   end
       class EmptyLinesAroundModuleBody < Cop
         include EmptyLinesAroundBody
 
-        KIND = 'module'.freeze
+        KIND = 'module'
 
         def on_module(node)
-          _name, body = *node
-          check(node, body)
+          check(node, node.body)
+        end
+
+        def autocorrect(node)
+          EmptyLineCorrector.correct(node)
         end
       end
     end