rubocop 0.75.1

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

@@ -0,0 +1,64 @@
+# 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
+        include RangeHelp
+
+        MSG = 'Add an empty line after magic comments.'
+
+        def investigate(source)
+          return unless source.ast &&
+                        (last_magic_comment = last_magic_comment(source))
+          return if source[last_magic_comment.loc.line].strip.empty?
+
+          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 }
+            .reverse
+            .find { |comment| MagicComment.parse(comment.text).any? }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+# 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 an integer (default is 1) or
+      # an array (e.g. [1, 2]) to specify a minimum and maximum
+      # number of empty lines permitted.
+      #
+      # `AllowAdjacentOneLineDefs` configures whether adjacent
+      # one-line method definitions are considered an offense.
+      #
+      # @example
+      #
+      #   # bad
+      #   def a
+      #   end
+      #   def b
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #   def a
+      #   end
+      #
+      #   def b
+      #   end
+      class EmptyLineBetweenDefs < Cop
+        include RangeHelp
+
+        MSG = 'Use empty lines between method definitions.'
+
+        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.positive?
+
+          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/layout/empty_lines.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop 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
+        include RangeHelp
+
+        MSG = 'Extra blank line detected.'
+        LINE_OFFSET = 2
+
+        def investigate(processed_source)
+          return if processed_source.tokens.empty?
+
+          lines = Set.new
+          processed_source.each_token do |token|
+            lines << token.line
+          end
+
+          each_extra_empty_line(lines.sort) do |range|
+            add_offense(range, location: range)
+          end
+        end
+
+        def autocorrect(range)
+          ->(corrector) { corrector.remove(range) }
+        end
+
+        private
+
+        def each_extra_empty_line(lines)
+          prev_line = 1
+
+          lines.each do |cur_line|
+            if exceeds_line_offset?(cur_line - prev_line)
+              # we need to be wary of comments since they
+              # don't show up in the tokens
+              ((prev_line + 1)...cur_line).each do |line|
+                next unless previous_and_current_lines_empty?(line)
+
+                yield source_range(processed_source.buffer, line, 0)
+              end
+            end
+
+            prev_line = cur_line
+          end
+        end
+
+        def exceeds_line_offset?(line_diff)
+          line_diff > LINE_OFFSET
+        end
+
+        def previous_and_current_lines_empty?(line)
+          processed_source[line - 2].empty? && processed_source[line - 1].empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Access modifiers should be surrounded by blank lines.
+      #
+      # @example EnforcedStyle: around (default)
+      #
+      #   # bad
+      #   class Foo
+      #     def bar; end
+      #     private
+      #     def baz; end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def bar; end
+      #
+      #     private
+      #
+      #     def baz; end
+      #   end
+      #
+      # @example EnforcedStyle: only_before
+      #
+      #   # 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 ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG_AFTER = 'Keep a blank line after `%<modifier>s`.'
+        MSG_BEFORE_AND_AFTER = 'Keep a blank line before and after ' \
+                               '`%<modifier>s`.'
+
+        MSG_BEFORE_FOR_ONLY_BEFORE = 'Keep a blank line before `%<modifier>s`.'
+        MSG_AFTER_FOR_ONLY_BEFORE = 'Remove a blank line after `%<modifier>s`.'
+
+        def initialize(config = nil, options = nil)
+          super
+
+          @block_line = nil
+        end
+
+        def on_class(node)
+          @class_or_module_def_first_line = if node.parent_class
+                                              node.parent_class.first_line
+                                            else
+                                              node.source_range.first_line
+                                            end
+          @class_or_module_def_last_line = node.source_range.last_line
+        end
+
+        def on_module(node)
+          @class_or_module_def_first_line = node.source_range.first_line
+          @class_or_module_def_last_line = node.source_range.last_line
+        end
+
+        def on_sclass(node)
+          @class_or_module_def_first_line =
+            node.identifier.source_range.first_line
+          @class_or_module_def_last_line =
+            node.source_range.last_line
+        end
+
+        def on_block(node)
+          @block_line = node.source_range.first_line
+        end
+
+        def on_send(node)
+          return unless node.bare_access_modifier?
+
+          case style
+          when :around
+            return if empty_lines_around?(node)
+          when :only_before
+            return if allowed_only_before_style?(node)
+          end
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            line = range_by_whole_lines(node.source_range)
+
+            unless previous_line_empty?(node.first_line)
+              corrector.insert_before(line, "\n")
+            end
+
+            correct_next_line_if_denied_style(corrector, node, line)
+          end
+        end
+
+        private
+
+        def allowed_only_before_style?(node)
+          if node.special_modifier?
+            return false if next_line_empty?(node.last_line)
+          end
+
+          previous_line_empty?(node.first_line)
+        end
+
+        def correct_next_line_if_denied_style(corrector, node, line)
+          case style
+          when :around
+            unless next_line_empty?(node.last_line)
+              corrector.insert_after(line, "\n")
+            end
+          when :only_before
+            if next_line_empty?(node.last_line)
+              range = next_empty_line_range(node)
+
+              corrector.remove(range)
+            end
+          end
+        end
+
+        def previous_line_ignoring_comments(processed_source, send_line)
+          processed_source[0..send_line - 2].reverse.find do |line|
+            !comment_line?(line)
+          end
+        end
+
+        def previous_line_empty?(send_line)
+          previous_line = previous_line_ignoring_comments(processed_source,
+                                                          send_line)
+
+          block_start?(send_line) ||
+            class_def?(send_line) ||
+            previous_line.blank?
+        end
+
+        def next_line_empty?(last_send_line)
+          next_line = processed_source[last_send_line]
+
+          body_end?(last_send_line) || next_line.blank?
+        end
+
+        def empty_lines_around?(node)
+          previous_line_empty?(node.first_line) &&
+            next_line_empty?(node.last_line)
+        end
+
+        def class_def?(line)
+          return false unless @class_or_module_def_first_line
+
+          line == @class_or_module_def_first_line + 1
+        end
+
+        def block_start?(line)
+          return false unless @block_line
+
+          line == @block_line + 1
+        end
+
+        def body_end?(line)
+          return false unless @class_or_module_def_last_line
+
+          line == @class_or_module_def_last_line - 1
+        end
+
+        def next_empty_line_range(node)
+          source_range(processed_source.buffer, node.last_line + 1, 0)
+        end
+
+        def message(node)
+          case style
+          when :around
+            message_for_around_style(node)
+          when :only_before
+            message_for_only_before_style(node)
+          end
+        end
+
+        def message_for_around_style(node)
+          send_line = node.first_line
+
+          if block_start?(send_line) ||
+             class_def?(send_line)
+            format(MSG_AFTER, modifier: node.loc.selector.source)
+          else
+            format(MSG_BEFORE_AND_AFTER, modifier: node.loc.selector.source)
+          end
+        end
+
+        def message_for_only_before_style(node)
+          modifier = node.loc.selector.source
+
+          if next_line_empty?(node.last_line)
+            format(MSG_AFTER_FOR_ONLY_BEFORE, modifier: modifier)
+          else
+            format(MSG_BEFORE_FOR_ONLY_BEFORE, modifier: modifier)
+          end
+        end
+      end
+    end
+  end
+end