rubocop 0.75.1

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_begin_body.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop 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`'
+
+        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/layout/empty_lines_around_block_body.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks if empty lines around the bodies of blocks match
+      # the configuration.
+      #
+      # @example EnforcedStyle: empty_lines
+      #   # good
+      #
+      #   foo do |bar|
+      #
+      #     # ...
+      #
+      #   end
+      #
+      # @example EnforcedStyle: no_empty_lines (default)
+      #   # good
+      #
+      #   foo do |bar|
+      #     # ...
+      #   end
+      class EmptyLinesAroundBlockBody < Cop
+        include EmptyLinesAroundBody
+
+        KIND = 'block'
+
+        def on_block(node)
+          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
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop 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: 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'
+
+        def on_class(node)
+          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)
+          check(node, node.body)
+        end
+
+        def autocorrect(node)
+          EmptyLineCorrector.correct(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # 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`
+      # can be used for this purpose.
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   rescue
+      #     do_something2
+      #   else
+      #     do_something3
+      #   ensure
+      #     do_something4
+      #   end
+      #
+      #   # good
+      #
+      #   def foo
+      #     do_something
+      #   rescue
+      #     do_something2
+      #   end
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #
+      #   rescue
+      #
+      #     do_something2
+      #
+      #   else
+      #
+      #     do_something3
+      #
+      #   ensure
+      #
+      #     do_something4
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo
+      #     do_something
+      #
+      #   rescue
+      #
+      #     do_something2
+      #   end
+      class EmptyLinesAroundExceptionHandlingKeywords < Cop
+        include EmptyLinesAroundBody
+
+        MSG = 'Extra empty line detected %<location>s the `%<keyword>s`.'
+
+        def on_def(node)
+          check_body(node.body)
+        end
+        alias on_defs on_def
+
+        def on_kwbegin(node)
+          body, = *node
+          check_body(body)
+        end
+
+        def autocorrect(node)
+          EmptyLineCorrector.correct(node)
+        end
+
+        private
+
+        def check_body(node)
+          locations = keyword_locations(node)
+          locations.each do |loc|
+            line = loc.line
+            keyword = loc.source
+            # below the keyword
+            check_line(style, line, message('after', keyword), &:empty?)
+            # above the keyword
+            check_line(style,
+                       line - 2,
+                       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)
+          when :ensure
+            keyword_locations_in_ensure(node)
+          else
+            []
+          end
+        end
+
+        def keyword_locations_in_rescue(node)
+          _begin_body, *resbodies, _else_body = *node
+          [
+            node.loc.else,
+            *resbodies.map { |body| body.loc.keyword }
+          ].compact
+        end
+
+        def keyword_locations_in_ensure(node)
+          ensure_body, = *node
+          [
+            node.loc.keyword,
+            *keyword_locations(ensure_body)
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # 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'
+
+        def on_def(node)
+          check(node, node.body)
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          EmptyLineCorrector.correct(node)
+        end
+
+        private
+
+        def style
+          :no_empty_lines
+        end
+      end
+    end
+  end
+end