rubocop 0.89.0 → 0.92.0

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

@@ -61,9 +61,10 @@ module RuboCop
       #     .each do
       #        baz
       #   end
-      class BlockAlignment < Cop
+      class BlockAlignment < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = '%<current>s is not aligned with %<prefer>s%<alt_prefer>s.'
 
@@ -84,19 +85,6 @@ module RuboCop
           'EnforcedStyleAlignWith'
         end
 
-        def autocorrect(node)
-          ancestor_node = start_for_block_node(node)
-          start_col = compute_start_col(ancestor_node, node)
-          loc_end = node.loc.end
-          delta = start_col - loc_end.column
-
-          if delta.positive?
-            add_space_before(loc_end, delta)
-          elsif delta.negative?
-            remove_space_before(loc_end.begin_pos, -delta)
-          end
-        end
-
         private
 
         def start_for_block_node(block_node)
@@ -163,7 +151,22 @@ module RuboCop
           message = format_message(start_loc, end_loc, do_source_line_column,
                                    error_source_line_column)
 
-          add_offense(block_node, location: end_loc, message: message)
+          add_offense(end_loc, message: message) do |corrector|
+            autocorrect(corrector, block_node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          ancestor_node = start_for_block_node(node)
+          start_col = compute_start_col(ancestor_node, node)
+          loc_end = node.loc.end
+          delta = start_col - loc_end.column
+
+          if delta.positive?
+            add_space_before(corrector, loc_end, delta)
+          elsif delta.negative?
+            remove_space_before(corrector, loc_end.begin_pos, -delta)
+          end
         end
 
         def format_message(start_loc, end_loc, do_source_line_column,
@@ -230,13 +233,14 @@ module RuboCop
           (ancestor_node || node).source_range.column
         end
 
-        def add_space_before(loc, delta)
-          ->(corrector) { corrector.insert_before(loc, ' ' * delta) }
+        def add_space_before(corrector, loc, delta)
+          corrector.insert_before(loc, ' ' * delta)
         end
 
-        def remove_space_before(end_pos, delta)
+        def remove_space_before(corrector, end_pos, delta)
           range = range_between(end_pos - delta, end_pos)
-          ->(corrector) { corrector.remove(range) }
+
+          corrector.remove(range)
         end
       end
     end

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

@@ -105,7 +105,10 @@ module RuboCop
         end
 
         def incorrect_style(when_node)
-          add_offense(when_node.loc.keyword) do |corrector|
+          depth = indent_one_step? ? 'one step more than' : 'as deep as'
+          message = format(MSG, depth: depth, base: style)
+
+          add_offense(when_node.loc.keyword, message: message) do |corrector|
             detect_incorrect_style(when_node)
 
             whitespace = whitespace_range(when_node)
@@ -125,12 +128,6 @@ module RuboCop
           end
         end
 
-        def find_message(*)
-          depth = indent_one_step? ? 'one step more than' : 'as deep as'
-
-          format(MSG, depth: depth, base: style)
-        end
-
         def base_column(case_node, base)
           case base
           when :case then case_node.location.keyword.column

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

@@ -133,8 +133,9 @@ module RuboCop
       #   end
       #
       # @see https://rubystyle.guide#consistent-classes
-      class ClassStructure < Cop
+      class ClassStructure < Base
         include VisibilityHelp
+        extend AutoCorrector
 
         HUMANIZED_NODE_TYPE = {
           casgn: :constants,
@@ -155,16 +156,20 @@ module RuboCop
             if index < previous
               message = format(MSG, category: category,
                                     previous: expected_order[previous])
-              add_offense(node, message: message)
+              add_offense(node, message: message) do |corrector|
+                autocorrect(corrector, node)
+              end
             end
             previous = index
           end
         end
 
+        private
+
         # Autocorrect by swapping between two nodes autocorrecting them
-        def autocorrect(node)
+        def autocorrect(corrector, node)
           node_classification = classify(node)
-          previous = left_siblings_of(node).find do |sibling|
+          previous = node.left_siblings.find do |sibling|
             classification = classify(sibling)
             !ignore?(classification) && node_classification != classification
           end
@@ -172,14 +177,10 @@ module RuboCop
           current_range = source_range_with_comment(node)
           previous_range = source_range_with_comment(previous)
 
-          lambda do |corrector|
-            corrector.insert_before(previous_range, current_range.source)
-            corrector.remove(current_range)
-          end
+          corrector.insert_before(previous_range, current_range.source)
+          corrector.remove(current_range)
         end
 
-        private
-
         # Classifies a node to match with something in the {expected_order}
         # @param node to be analysed
         # @return String when the node type is a `:block` then
@@ -269,15 +270,11 @@ module RuboCop
         end
 
         def begin_pos_with_comment(node)
-          annotation_line = node.first_line - 1
           first_comment = nil
+          (node.first_line - 1).downto(1) do |annotation_line|
+            break unless (comment = processed_source.comment_at_line(annotation_line))
 
-          processed_source.comments_before_line(annotation_line)
-                          .reverse_each do |comment|
-            if comment.location.line == annotation_line
-              first_comment = comment
-              annotation_line -= 1
-            end
+            first_comment = comment
           end
 
           start_line_position(first_comment || node)

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

@@ -46,8 +46,9 @@ module RuboCop
       #         Hi
       #       EOS
       #
-      class ClosingHeredocIndentation < Cop
+      class ClosingHeredocIndentation < Base
         include Heredoc
+        extend AutoCorrector
 
         SIMPLE_HEREDOC = '<<'
         MSG = '`%<closing>s` is not aligned with `%<opening>s`.'
@@ -59,11 +60,8 @@ module RuboCop
                     opening_indentation(node) == closing_indentation(node) ||
                     argument_indentation_correct?(node)
 
-          add_offense(node, location: :heredoc_end)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          message = message(node)
+          add_offense(node.loc.heredoc_end, message: message) do |corrector|
             corrector.replace(node.loc.heredoc_end, indented_end(node))
           end
         end

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

@@ -39,7 +39,7 @@ module RuboCop
           'instead of %<correct_comment_indentation>d).'
 
         def investigate(processed_source)
-          processed_source.each_comment { |comment| check(comment) }
+          processed_source.comments.each { |comment| check(comment) }
         end
 
         def autocorrect(comment)

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

@@ -22,8 +22,9 @@ module RuboCop
       #   if some_condition
       #     do_something
       #   end
-      class ConditionPosition < Cop
+      class ConditionPosition < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Place the condition on the same line as `%<keyword>s`.'
 
@@ -38,27 +39,24 @@ module RuboCop
         end
         alias on_until on_while
 
-        def autocorrect(node)
-          lambda do |corrector|
-            range = range_by_whole_lines(
-              node.source_range, include_final_newline: true
-            )
-
-            corrector.insert_after(node.parent.loc.keyword, " #{node.source}")
-            corrector.remove(range)
-          end
-        end
-
         private
 
         def check(node)
           return if node.modifier_form? || node.single_line_condition?
 
-          add_offense(node.condition)
+          condition = node.condition
+          message = message(condition)
+
+          add_offense(condition, message: message) do |corrector|
+            range = range_by_whole_lines(condition.source_range, include_final_newline: true)
+
+            corrector.insert_after(condition.parent.loc.keyword, " #{condition.source}")
+            corrector.remove(range)
+          end
         end
 
-        def message(node)
-          format(MSG, keyword: node.parent.keyword)
+        def message(condition)
+          format(MSG, keyword: condition.parent.keyword)
         end
       end
     end

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

@@ -33,9 +33,10 @@ module RuboCop
       #
       #   private def foo
       #           end
-      class DefEndAlignment < Cop
+      class DefEndAlignment < Base
         include EndKeywordAlignment
         include RangeHelp
+        extend AutoCorrector
 
         MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'
 
@@ -45,7 +46,7 @@ module RuboCop
         alias on_defs on_def
 
         def on_send(node)
-          return unless node.def_modifier?
+          return if !node.def_modifier? || node.method?(:using)
 
           method_def = node.each_descendant(:def, :defs).first
           expr = node.source_range
@@ -61,11 +62,13 @@ module RuboCop
           ignore_node(method_def) # Don't check the same `end` again.
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           if style == :start_of_line && node.parent && node.parent.send_type?
-            AlignmentCorrector.align_end(processed_source, node, node.parent)
+            AlignmentCorrector.align_end(corrector, processed_source, node, node.parent)
           else
-            AlignmentCorrector.align_end(processed_source, node, node)
+            AlignmentCorrector.align_end(corrector, processed_source, node, node)
           end
         end
       end

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

@@ -22,8 +22,9 @@ module RuboCop
       #   # good
       #   something.
       #     method
-      class DotPosition < Cop
+      class DotPosition < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         def on_send(node)
           return unless node.dot? || ampersand_dot?(node)
@@ -31,29 +32,32 @@ module RuboCop
           if proper_dot_position?(node)
             correct_style_detected
           else
-            add_offense(node, location: :dot) { opposite_style_detected }
-          end
-        end
-        alias on_csend on_send
+            return unless opposite_style_detected
 
-        def autocorrect(node)
-          lambda do |corrector|
-            dot = node.loc.dot.source
-            corrector.remove(node.loc.dot)
-            case style
-            when :leading
-              corrector.insert_before(selector_range(node), dot)
-            when :trailing
-              corrector.insert_after(node.receiver, dot)
+            dot = node.loc.dot
+            message = message(dot)
+
+            add_offense(dot, message: message) do |corrector|
+              autocorrect(corrector, dot, node)
             end
           end
         end
+        alias on_csend on_send
 
         private
 
-        def message(node)
-          dot = node.loc.dot.source
-          "Place the #{dot} on the " +
+        def autocorrect(corrector, dot, node)
+          corrector.remove(dot)
+          case style
+          when :leading
+            corrector.insert_before(selector_range(node), dot.source)
+          when :trailing
+            corrector.insert_after(node.receiver, dot.source)
+          end
+        end
+
+        def message(dot)
+          "Place the #{dot.source} on the " +
             case style
             when :leading
               'next line, together with the method name.'

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

@@ -60,47 +60,54 @@ module RuboCop
       #   class Foo
       #   end
       #
-      class EmptyComment < Cop
+      class EmptyComment < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Source code comment is empty.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           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
+            investigate(comments)
           else
             processed_source.comments.each do |comment|
               next unless empty_comment_only?(comment_text(comment))
 
-              add_offense(comment)
+              add_offense(comment) do |corrector|
+                autocorrect(corrector, comment)
+              end
             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)
+        private
+
+        def investigate(comments)
+          comments.each do |comment|
+            next unless empty_comment_only?(comment[0])
+
+            comment[1].each do |offense_comment|
+              add_offense(offense_comment) do |corrector|
+                autocorrect(corrector, offense_comment)
+              end
+            end
           end
         end
 
-        private
+        def autocorrect(corrector, node)
+          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
 
         def concat_consecutive_comments(comments)
           consecutive_comments =

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

@@ -35,8 +35,9 @@ module RuboCop
       #       return if need_return?
       #     end
       #   end
-      class EmptyLineAfterGuardClause < Cop
+      class EmptyLineAfterGuardClause < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Add empty line after guard clause.'
         END_OF_HEREDOC_LINE = 1
@@ -49,27 +50,29 @@ module RuboCop
 
             return if next_line_empty?(heredoc_line(node, heredoc_node))
 
-            add_offense(heredoc_node, location: :heredoc_end)
+            add_offense(heredoc_node.loc.heredoc_end) do |corrector|
+              autocorrect(corrector, heredoc_node)
+            end
           else
             return if next_line_empty?(node.last_line)
 
-            add_offense(node, location: offense_location(node))
+            add_offense(offense_location(node)) do |corrector|
+              autocorrect(corrector, node)
+            end
           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
+        private
 
-            corrector.insert_after(node_range, "\n")
-          end
-        end
+        def autocorrect(corrector, node)
+          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
 
-        private
+          corrector.insert_after(node_range, "\n")
+        end
 
         def correct_style?(node)
           !contains_guard_clause?(node) ||
@@ -92,7 +95,7 @@ module RuboCop
         end
 
         def next_sibling_parent_empty_or_else?(node)
-          next_sibling = node.parent.children[node.sibling_index + 1]
+          next_sibling = node.right_sibling
           return true if next_sibling.nil?
 
           parent = next_sibling.parent
@@ -101,7 +104,7 @@ module RuboCop
         end
 
         def next_sibling_empty_or_guard_clause?(node)
-          next_sibling = node.parent.children[node.sibling_index + 1]
+          next_sibling = node.right_sibling
           return true if next_sibling.nil?
 
           next_sibling.if_type? && contains_guard_clause?(next_sibling)
@@ -146,9 +149,9 @@ module RuboCop
 
         def offense_location(node)
           if node.loc.respond_to?(:end) && node.loc.end
-            :end
+            node.loc.end
           else
-            :expression
+            node
           end
         end
       end