rubocop 0.89.1 → 0.93.0

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

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/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,38 +22,39 @@ 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)
 
-          if proper_dot_position?(node)
-            correct_style_detected
-          else
-            add_offense(node, location: :dot) { opposite_style_detected }
+          return correct_style_detected if proper_dot_position?(node)
+
+          opposite_style_detected
+          dot = node.loc.dot
+          message = message(dot)
+
+          add_offense(dot, message: message) do |corrector|
+            autocorrect(corrector, dot, node)
           end
         end
         alias on_csend on_send
 
-        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)
-            end
+        private
+
+        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
 
-        private
-
-        def message(node)
-          dot = node.loc.dot.source
-          "Place the #{dot} on the " +
+        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

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

@@ -20,30 +20,30 @@ module RuboCop
       #   class Person
       #     # Some code
       #   end
-      class EmptyLineAfterMagicComment < Cop
+      class EmptyLineAfterMagicComment < Base
         include RangeHelp
+        extend AutoCorrector
 
         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?
+        def on_new_investigation
+          return unless processed_source.ast &&
+                        (last_magic_comment = last_magic_comment(processed_source))
+          return if processed_source[last_magic_comment.loc.line].strip.empty?
 
-          offending_range =
-            source_range(source.buffer, last_magic_comment.loc.line + 1, 0)
+          offending_range = offending_range(last_magic_comment)
 
-          add_offense(offending_range, location: offending_range)
-        end
-
-        def autocorrect(token)
-          lambda do |corrector|
-            corrector.insert_before(token, "\n")
+          add_offense(offending_range) do |corrector|
+            corrector.insert_before(offending_range, "\n")
           end
         end
 
         private
 
+        def offending_range(last_magic_comment)
+          source_range(processed_source.buffer, last_magic_comment.loc.line + 1, 0)
+        end
+
         # Find the last magic comment in the source file.
         #
         # Take all comments that precede the first line of code, select the