rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,151 @@
+# 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.'
+
+        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|
+            previous_token = previous_token(node)
+            range = if previous_token && node.loc.line == previous_token.line
+                      range_with_surrounding_space(range: node.loc.expression,
+                                                   newlines: false)
+                    else
+                      range_by_whole_lines(node.loc.expression,
+                                           include_final_newline: true)
+                    end
+
+            corrector.remove(range)
+          end
+        end
+
+        private
+
+        def concat_consecutive_comments(comments)
+          consecutive_comments =
+            comments.chunk_while { |i, j| i.loc.line.succ == j.loc.line }
+
+          consecutive_comments.map do |chunk|
+            joined_text = chunk.map { |c| comment_text(c) }.join
+            [joined_text, chunk]
+          end
+        end
+
+        def empty_comment_only?(comment_text)
+          empty_comment_pattern = if allow_border_comment?
+                                    /\A(#\n)+\z/
+                                  else
+                                    /\A(#+\n)+\z/
+                                  end
+
+          empty_comment_pattern.match?(comment_text)
+        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
+
+        def current_token(comment)
+          processed_source.find_token do |token|
+            token.pos == comment.loc.expression
+          end
+        end
+
+        def previous_token(node)
+          current_token = current_token(node)
+          index = processed_source.tokens.index(current_token)
+          index.zero? ? nil : processed_source.tokens[index - 1]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop enforces empty line after guard clause
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo
+      #     return if need_return?
+      #     bar
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     return if need_return?
+      #
+      #     bar
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     return if something?
+      #     return if something_different?
+      #
+      #     bar
+      #   end
+      #
+      #   # also good
+      #   def foo
+      #     if something?
+      #       do_something
+      #       return if need_return?
+      #     end
+      #   end
+      class EmptyLineAfterGuardClause < Cop
+        include RangeHelp
+
+        MSG = 'Add empty line after guard clause.'
+        END_OF_HEREDOC_LINE = 1
+
+        def on_if(node)
+          return if correct_style?(node)
+
+          if node.modifier_form? && last_argument_is_heredoc?(node)
+            heredoc_node = last_heredoc_argument(node)
+
+            return if next_line_empty?(heredoc_line(node, heredoc_node))
+
+            add_offense(heredoc_node, location: :heredoc_end)
+          else
+            return if next_line_empty?(node.last_line)
+
+            add_offense(node, location: offense_location(node))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            node_range = if node.respond_to?(:heredoc?) && node.heredoc?
+                           range_by_whole_lines(node.loc.heredoc_body)
+                         else
+                           range_by_whole_lines(node.source_range)
+                         end
+
+            corrector.insert_after(node_range, "\n")
+          end
+        end
+
+        private
+
+        def correct_style?(node)
+          !contains_guard_clause?(node) ||
+            next_line_rescue_or_ensure?(node) ||
+            next_sibling_parent_empty_or_else?(node) ||
+            next_sibling_empty_or_guard_clause?(node)
+        end
+
+        def contains_guard_clause?(node)
+          node.if_branch&.guard_clause?
+        end
+
+        def next_line_empty?(line)
+          processed_source[line].blank?
+        end
+
+        def next_line_rescue_or_ensure?(node)
+          parent = node.parent
+          parent.nil? || parent.rescue_type? || parent.ensure_type?
+        end
+
+        def next_sibling_parent_empty_or_else?(node)
+          next_sibling = node.parent.children[node.sibling_index + 1]
+          return true if next_sibling.nil?
+
+          parent = next_sibling.parent
+
+          parent&.if_type? && parent&.else?
+        end
+
+        def next_sibling_empty_or_guard_clause?(node)
+          next_sibling = node.parent.children[node.sibling_index + 1]
+          return true if next_sibling.nil?
+
+          next_sibling.if_type? && contains_guard_clause?(next_sibling)
+        end
+
+        def last_argument_is_heredoc?(node)
+          last_children = node.if_branch
+          return false unless last_children&.send_type?
+
+          heredoc?(last_heredoc_argument(node))
+        end
+
+        def last_heredoc_argument(node)
+          n = if node.respond_to?(:if_branch)
+                node.if_branch.children.last
+              else
+                node
+              end
+
+          return n if heredoc?(n)
+          return unless n.respond_to?(:arguments)
+
+          n.arguments.each do |argument|
+            node = last_heredoc_argument(argument)
+            return node if node
+          end
+
+          return last_heredoc_argument(n.receiver) if n.respond_to?(:receiver)
+        end
+
+        def heredoc_line(node, heredoc_node)
+          heredoc_body = heredoc_node.loc.heredoc_body
+          num_of_heredoc_lines =
+            heredoc_body.last_line - heredoc_body.first_line
+
+          node.last_line + num_of_heredoc_lines + END_OF_HEREDOC_LINE
+        end
+
+        def heredoc?(node)
+          node.respond_to?(:heredoc?) && node.heredoc?
+        end
+
+        def offense_location(node)
+          if node.loc.respond_to?(:end) && node.loc.end
+            :end
+          else
+            :expression
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -21,13 +21,14 @@ module RuboCop
       #     # Some code
       #   end
       class EmptyLineAfterMagicComment < Cop
-        MSG = 'Add an empty line after magic comments.'.freeze
-        BLANK_LINE = /\A\s*\z/
+        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] =~ BLANK_LINE
+          return if source[last_magic_comment.loc.line].strip.empty?
 
           offending_range =
             source_range(source.buffer, last_magic_comment.loc.line + 1, 0)
@@ -54,8 +55,8 @@ module RuboCop
           source
             .comments
             .take_while { |comment| comment.loc.line < source.ast.loc.line }
-            .select     { |comment| MagicComment.parse(comment.text).any?  }
-            .last
+            .reverse
+            .find { |comment| MagicComment.parse(comment.text).any? }
         end
       end
     end

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

@@ -6,12 +6,12 @@ module RuboCop
       # 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.
+      # `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` can be used to configure is adjacent
-      # one line methods definitions are an offense
+      # `AllowAdjacentOneLineDefs` configures whether adjacent
+      # one-line method definitions are considered an offense.
       #
       # @example
       #
@@ -30,7 +30,9 @@ module RuboCop
       #   def b
       #   end
       class EmptyLineBetweenDefs < Cop
-        MSG = 'Use empty lines between method definitions.'.freeze
+        include RangeHelp
+
+        MSG = 'Use empty lines between method definitions.'
 
         def self.autocorrect_incompatible_with
           [Layout::EmptyLines]
@@ -54,13 +56,32 @@ module RuboCop
           return if nodes.all?(&:single_line?) &&
                     cop_config['AllowAdjacentOneLineDefs']
 
-          add_offense(nodes.last, location: :keyword)
+          location = nodes.last.loc.keyword.join(nodes.last.loc.name)
+          add_offense(nodes.last, location: location)
+        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
 
@@ -69,6 +90,7 @@ module RuboCop
           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
 
@@ -90,7 +112,7 @@ module RuboCop
         end
 
         def prev_node(node)
-          return nil unless node.sibling_index > 0
+          return nil unless node.sibling_index.positive?
 
           node.parent.children[node.sibling_index - 1]
         end
@@ -109,23 +131,6 @@ module RuboCop
           node.loc.end.line
         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
-
         def autocorrect_remove_lines(newline_pos, count)
           difference = count - maximum_empty_lines
           range_to_remove = range_between(newline_pos, newline_pos + difference)

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

@@ -5,17 +5,33 @@ require 'set'
 module RuboCop
   module Cop
     module Layout
-      # This cops checks for two or more consecutive blank lines.
+      # 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
-        MSG = 'Extra blank line detected.'.freeze
+        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.tokens.each do |token|
-            lines << token.pos.line
+          processed_source.each_token do |token|
+            lines << token.line
           end
 
           each_extra_empty_line(lines.sort) do |range|

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

@@ -5,7 +5,7 @@ module RuboCop
     module Layout
       # Access modifiers should be surrounded by blank lines.
       #
-      # @example
+      # @example EnforcedStyle: around (default)
       #
       #   # bad
       #   class Foo
@@ -22,82 +22,187 @@ module RuboCop
       #
       #     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
-        MSG_AFTER = 'Keep a blank line after `%s`.'.freeze
-        MSG_BEFORE_AND_AFTER = 'Keep a blank line before and after `%s`.'.freeze
+        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.access_modifier?
+          return unless node.bare_access_modifier?
 
-          return if empty_lines_around?(node)
+          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|
-            send_line = node.loc.line
-            previous_line = processed_source[send_line - 2]
-            next_line = processed_source[send_line]
             line = range_by_whole_lines(node.source_range)
 
-            unless previous_line_empty?(previous_line)
-              corrector.insert_before(line, "\n")
-            end
+            corrector.insert_before(line, "\n") unless previous_line_empty?(node.first_line)
 
-            unless next_line_empty?(next_line)
-              corrector.insert_after(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
+            corrector.insert_after(line, "\n") unless next_line_empty?(node.last_line)
+          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?(previous_line)
-          block_start?(previous_line) ||
-            class_def?(previous_line) ||
+        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?(next_line)
-          body_end?(next_line) || next_line.blank?
+        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)
-          send_line = node.loc.line
-          previous_line = previous_line_ignoring_comments(processed_source,
-                                                          send_line)
-          next_line = processed_source[send_line]
-
-          previous_line_empty?(previous_line) && next_line_empty?(next_line)
+          previous_line_empty?(node.first_line) &&
+            next_line_empty?(node.last_line)
         end
 
         def class_def?(line)
-          line =~ /^\s*(class|module)/
+          return false unless @class_or_module_def_first_line
+
+          line == @class_or_module_def_first_line + 1
         end
 
         def block_start?(line)
-          line.match(/ (do|{)( \|.*?\|)?\s?$/)
+          return false unless @block_line
+
+          line == @block_line + 1
         end
 
         def body_end?(line)
-          line =~ /^\s*end/
+          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)
-          previous_line = processed_source[node.loc.line - 2]
+          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 block_start?(previous_line) ||
-             class_def?(previous_line)
-            format(MSG_AFTER, node.loc.selector.source)
+          if next_line_empty?(node.last_line)
+            format(MSG_AFTER_FOR_ONLY_BEFORE, modifier: modifier)
           else
-            format(MSG_BEFORE_AND_AFTER, node.loc.selector.source)
+            format(MSG_BEFORE_FOR_ONLY_BEFORE, modifier: modifier)
           end
         end
       end