rubocop 0.78.0 → 1.13.0

data/lib/rubocop/cop/style/comment_annotation.rb

@@ -6,6 +6,12 @@ module RuboCop
       # This cop checks that comment annotation keywords are written according
       # to guidelines.
       #
+      # NOTE: With a multiline comment block (where each line is only a
+      # comment), only the first line will be able to register an offense, even
+      # if an annotation keyword starts another line. This is done to prevent
+      # incorrect registering of keywords (eg. `review`) inside a paragraph as an
+      # annotation.
+      #
       # @example
       #   # bad
       #   # TODO make better
@@ -30,48 +36,45 @@ module RuboCop
       #
       #   # good
       #   # OPTIMIZE: does not work
-      class CommentAnnotation < Cop
+      class CommentAnnotation < Base
         include AnnotationComment
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Annotation keywords like `%<keyword>s` should be all ' \
               'upper case, followed by a colon, and a space, ' \
               'then a note describing the problem.'
-        MISSING_NOTE = 'Annotation comment, with keyword `%<keyword>s`, ' \
-                       'is missing a note.'
+        MISSING_NOTE = 'Annotation comment, with keyword `%<keyword>s`, is missing a note.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           processed_source.comments.each_with_index do |comment, index|
             next unless first_comment_line?(processed_source.comments, index) ||
                         inline_comment?(comment)
 
             margin, first_word, colon, space, note = split_comment(comment)
-            next unless annotation?(comment) &&
-                        !correct_annotation?(first_word, colon, space, note)
+            next unless annotation?(comment) && !correct_annotation?(first_word, colon, space, note)
+
+            range = annotation_range(comment, margin, first_word, colon, space)
 
-            add_offense(
-              comment,
-              location: annotation_range(comment, margin,
-                                         first_word, colon, space),
-              message: format(note ? MSG : MISSING_NOTE, keyword: first_word)
-            )
+            register_offense(range, note, first_word)
           end
         end
 
-        def autocorrect(comment)
-          margin, first_word, colon, space, note = split_comment(comment)
-          return if note.nil?
+        private
 
-          range = annotation_range(comment, margin, first_word, colon, space)
+        def register_offense(range, note, first_word)
+          add_offense(
+            range,
+            message: format(note ? MSG : MISSING_NOTE, keyword: first_word)
+          ) do |corrector|
+            next if note.nil?
 
-          ->(corrector) { corrector.replace(range, "#{first_word.upcase}: ") }
+            corrector.replace(range, "#{first_word.upcase}: ")
+          end
         end
 
-        private
-
         def first_comment_line?(comments, index)
-          index.zero? ||
-            comments[index - 1].loc.line < comments[index].loc.line - 1
+          index.zero? || comments[index - 1].loc.line < comments[index].loc.line - 1
         end
 
         def inline_comment?(comment)

data/lib/rubocop/cop/style/commented_keyword.rb

@@ -4,12 +4,15 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for comments put on the same line as some keywords.
-      # These keywords are: `begin`, `class`, `def`, `end`, `module`.
+      # These keywords are: `class`, `module`, `def`, `begin`, `end`.
       #
       # Note that some comments
       # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`)
       # are allowed.
       #
+      # Auto-correction removes comments from `end` keyword and keeps comments
+      # for `class`, `module`, `def` and `begin` above the keyword.
+      #
       # @example
       #   # bad
       #   if condition
@@ -33,35 +36,45 @@ module RuboCop
       #   class X # :nodoc:
       #     y
       #   end
-      class CommentedKeyword < Cop
-        MSG = 'Do not place comments on the same line as the ' \
-              '`%<keyword>s` keyword.'
+      class CommentedKeyword < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Do not place comments on the same line as the `%<keyword>s` keyword.'
+
+        KEYWORDS = %w[begin class def end module].freeze
+        KEYWORD_REGEXES = KEYWORDS.map { |w| /^\s*#{w}\s/ }.freeze
+
+        ALLOWED_COMMENTS = %w[:nodoc: :yields: rubocop:disable rubocop:todo].freeze
+        ALLOWED_COMMENT_REGEXES = ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ }.freeze
+
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            next unless (match = line(comment).match(/(?<keyword>\S+).*#/)) && offensive?(comment)
 
-        def investigate(processed_source)
-          processed_source.each_comment do |comment|
-            add_offense(comment) if offensive?(comment)
+            register_offense(comment, match[:keyword])
           end
         end
 
         private
 
-        KEYWORDS = %w[begin class def end module].freeze
-        ALLOWED_COMMENTS = %w[
-          :nodoc:
-          :yields:
-          rubocop:disable
-          rubocop:todo
-        ].freeze
+        def register_offense(comment, matched_keyword)
+          add_offense(comment, message: format(MSG, keyword: matched_keyword)) do |corrector|
+            range = range_with_surrounding_space(range: comment.loc.expression, newlines: false)
+            corrector.remove(range)
 
-        def offensive?(comment)
-          line = line(comment)
-          KEYWORDS.any? { |word| line =~ /^\s*#{word}\s/ } &&
-            ALLOWED_COMMENTS.none? { |c| line =~ /#\s*#{c}/ }
+            unless matched_keyword == 'end'
+              corrector.insert_before(
+                range.source_buffer.line_range(comment.loc.line), "#{comment.text}\n"
+              )
+            end
+          end
         end
 
-        def message(comment)
-          keyword = line(comment).match(/(\S+).*#/)[1]
-          format(MSG, keyword: keyword)
+        def offensive?(comment)
+          line = line(comment)
+          KEYWORD_REGEXES.any? { |r| r.match?(line) } &&
+            ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
         end
 
         def line(comment)

data/lib/rubocop/cop/style/conditional_assignment.rb

@@ -30,7 +30,7 @@ module RuboCop
         end
 
         def tail(branch)
-          branch.begin_type? ? [*branch].last : branch
+          branch.begin_type? ? Array(branch).last : branch
         end
 
         # rubocop:disable Metrics/AbcSize
@@ -43,7 +43,7 @@ module RuboCop
           when :and_asgn, :or_asgn
             "#{node.children[0].source} #{node.loc.operator.source} "
           when :casgn
-            "#{node.children[1]} = "
+            lhs_for_casgn(node)
           when *ConditionalAssignment::VARIABLE_ASSIGNMENT_TYPES
             "#{node.children[0]} = "
           else
@@ -93,9 +93,17 @@ module RuboCop
           end
         end
 
+        def lhs_for_casgn(node)
+          namespace = node.children[0]
+          if namespace.nil? || namespace.cbase_type?
+            "#{namespace&.source}#{node.children[1]} = "
+          else
+            "#{namespace.source}::#{node.children[1]} = "
+          end
+        end
+
         def setter_method?(method_name)
-          method_name.to_s.end_with?(EQUAL) &&
-            !%i[!= == === >= <=].include?(method_name)
+          method_name.to_s.end_with?(EQUAL) && !%i[!= == === >= <=].include?(method_name)
         end
 
         def assignment_rhs_exist?(node)
@@ -199,19 +207,16 @@ module RuboCop
       #     some_other_method
       #     bar = 2
       #   end
-      class ConditionalAssignment < Cop
+      class ConditionalAssignment < Base
         include ConditionalAssignmentHelper
         include ConfigurableEnforcedStyle
         include IgnoredNode
+        extend AutoCorrector
 
-        MSG = 'Use the return of the conditional for variable assignment ' \
-              'and comparison.'
-        ASSIGN_TO_CONDITION_MSG =
-          'Assign variables inside of conditionals'
-        VARIABLE_ASSIGNMENT_TYPES =
-          %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
-        ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES +
-                           %i[and_asgn or_asgn op_asgn masgn].freeze
+        MSG = 'Use the return of the conditional for variable assignment and comparison.'
+        ASSIGN_TO_CONDITION_MSG = 'Assign variables inside of conditionals'
+        VARIABLE_ASSIGNMENT_TYPES = %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
+        ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES + %i[and_asgn or_asgn op_asgn masgn].freeze
         LINE_LENGTH = 'Layout/LineLength'
         INDENTATION_WIDTH = 'Layout/IndentationWidth'
         ENABLED = 'Enabled'
@@ -221,10 +226,11 @@ module RuboCop
 
         # The shovel operator `<<` does not have its own type. It is a `send`
         # type.
+        # @!method assignment_type?(node)
         def_node_matcher :assignment_type?, <<~PATTERN
           {
             #{ASSIGNMENT_TYPES.join(' ')}
-            (send _recv {:[]= :<< :=~ :!~ :<=> #end_with_eq?} ...)
+            (send _recv {:[]= :<< :=~ :!~ :<=> #end_with_eq? :< :>} ...)
           }
         PATTERN
 
@@ -266,14 +272,6 @@ module RuboCop
           check_node(node, branches)
         end
 
-        def autocorrect(node)
-          if assignment_type?(node)
-            move_assignment_inside_condition(node)
-          else
-            move_assignment_outside_condition(node)
-          end
-        end
-
         private
 
         def check_assignment_to_condition(node)
@@ -289,13 +287,16 @@ module RuboCop
           return unless else_branch
           return if allowed_single_line?([*branches, else_branch])
 
-          add_offense(node, message: ASSIGN_TO_CONDITION_MSG)
+          add_offense(node, message: ASSIGN_TO_CONDITION_MSG) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def candidate_node?(node)
           style == :assign_inside_condition && assignment_rhs_exist?(node)
         end
 
+        # @!method candidate_condition?(node)
         def_node_matcher :candidate_condition?, '[{if case} !#allowed_ternary?]'
 
         def allowed_ternary?(assignment)
@@ -312,32 +313,30 @@ module RuboCop
           # ignore pseudo-assignments without rhs in for nodes
           return if node.parent&.for_type?
 
-          if assignment.begin_type? && assignment.children.one?
-            assignment, = *assignment
-          end
+          assignment, = *assignment if assignment.begin_type? && assignment.children.one?
 
           assignment
         end
 
-        def move_assignment_outside_condition(node)
+        def move_assignment_outside_condition(corrector, node)
           if node.case_type?
-            CaseCorrector.correct(self, node)
+            CaseCorrector.correct(corrector, self, node)
           elsif node.ternary?
-            TernaryCorrector.correct(node)
+            TernaryCorrector.correct(corrector, node)
           elsif node.if? || node.unless?
-            IfCorrector.correct(self, node)
+            IfCorrector.correct(corrector, self, node)
           end
         end
 
-        def move_assignment_inside_condition(node)
+        def move_assignment_inside_condition(corrector, node)
           *_assignment, condition = *node
 
           if ternary_condition?(condition)
-            TernaryCorrector.move_assignment_inside_condition(node)
+            TernaryCorrector.move_assignment_inside_condition(corrector, node)
           elsif condition.case_type?
-            CaseCorrector.move_assignment_inside_condition(node)
+            CaseCorrector.move_assignment_inside_condition(corrector, node)
           elsif condition.if_type?
-            IfCorrector.move_assignment_inside_condition(node)
+            IfCorrector.move_assignment_inside_condition(corrector, node)
           end
         end
 
@@ -364,7 +363,15 @@ module RuboCop
           return if allowed_single_line?(branches)
           return if correction_exceeds_line_limit?(node, branches)
 
-          add_offense(node)
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
+        end
+
+        def autocorrect(corrector, node)
+          if assignment_type?(node)
+            move_assignment_inside_condition(corrector, node)
+          else
+            move_assignment_outside_condition(corrector, node)
+          end
         end
 
         def allowed_statements?(branches)
@@ -397,9 +404,7 @@ module RuboCop
 
         def longest_line(node, assignment)
           assignment_regex = /\s*#{Regexp.escape(assignment).gsub('\ ', '\s*')}/
-          lines = node.source.lines.map do |line|
-            line.chomp.sub(assignment_regex, '')
-          end
+          lines = node.source.lines.map { |line| line.chomp.sub(assignment_regex, '') }
           longest_line = lines.max_by(&:length)
           assignment + longest_line
         end
@@ -443,9 +448,7 @@ module RuboCop
           expression = node.loc.expression
           begin_pos = expression.begin_pos - (expression.column - column - 2)
 
-          Parser::Source::Range.new(expression.source_buffer,
-                                    begin_pos,
-                                    expression.begin_pos)
+          Parser::Source::Range.new(expression.source_buffer, begin_pos, expression.begin_pos)
         end
 
         def assignment(node)
@@ -458,7 +461,7 @@ module RuboCop
         def correct_if_branches(corrector, cop, node)
           if_branch, elsif_branches, else_branch = extract_tail_branches(node)
 
-          corrector.insert_before(node.source_range, lhs(if_branch))
+          corrector.insert_before(node, lhs(if_branch))
           replace_branch_assignment(corrector, if_branch)
           correct_branches(corrector, elsif_branches)
           replace_branch_assignment(corrector, else_branch)
@@ -475,13 +478,13 @@ module RuboCop
                           source
                         end
 
-          corrector.replace(branch.source_range, replacement)
+          corrector.replace(branch, replacement)
         end
 
         def correct_branches(corrector, branches)
           branches.each do |branch|
             *_, assignment = *branch
-            corrector.replace(branch.source_range, assignment.source)
+            corrector.replace(branch, assignment.source)
           end
         end
       end
@@ -492,24 +495,20 @@ module RuboCop
           include ConditionalAssignmentHelper
           include ConditionalCorrectorHelper
 
-          def correct(node)
-            lambda do |corrector|
-              corrector.replace(node.source_range, correction(node))
-            end
+          def correct(corrector, node)
+            corrector.replace(node, correction(node))
           end
 
-          def move_assignment_inside_condition(node)
+          def move_assignment_inside_condition(corrector, node)
             *_var, rhs = *node
             if_branch, else_branch = extract_branches(node)
             assignment = assignment(node)
 
-            lambda do |corrector|
-              remove_parentheses(corrector, rhs) if Util.parentheses?(rhs)
-              corrector.remove(assignment)
+            remove_parentheses(corrector, rhs) if Util.parentheses?(rhs)
+            corrector.remove(assignment)
 
-              move_branch_inside_condition(corrector, if_branch, assignment)
-              move_branch_inside_condition(corrector, else_branch, assignment)
-            end
+            move_branch_inside_condition(corrector, if_branch, assignment)
+            move_branch_inside_condition(corrector, else_branch, assignment)
           end
 
           private
@@ -522,9 +521,7 @@ module RuboCop
             _variable, *_operator, if_rhs = *node.if_branch
             _else_variable, *_operator, else_rhs = *node.else_branch
 
-            expr = "#{node.condition.source} ? " \
-                   "#{if_rhs.source} : " \
-                   "#{else_rhs.source}"
+            expr = "#{node.condition.source} ? #{if_rhs.source} : #{else_rhs.source}"
 
             element_assignment?(node.if_branch) ? "(#{expr})" : expr
           end
@@ -547,7 +544,7 @@ module RuboCop
           end
 
           def move_branch_inside_condition(corrector, branch, assignment)
-            corrector.insert_before(branch.loc.expression, assignment.source)
+            corrector.insert_before(branch, assignment.source)
           end
         end
       end
@@ -558,22 +555,19 @@ module RuboCop
           include ConditionalAssignmentHelper
           include ConditionalCorrectorHelper
 
-          def correct(cop, node)
-            ->(corrector) { correct_if_branches(corrector, cop, node) }
+          def correct(corrector, cop, node)
+            correct_if_branches(corrector, cop, node)
           end
 
-          def move_assignment_inside_condition(node)
+          def move_assignment_inside_condition(corrector, node)
             column = node.loc.expression.column
             *_var, condition = *node
             assignment = assignment(node)
 
-            lambda do |corrector|
-              corrector.remove(assignment)
+            corrector.remove(assignment)
 
-              condition.branches.flatten.each do |branch|
-                move_branch_inside_condition(corrector, branch, condition,
-                                             assignment, column)
-              end
+            condition.branches.flatten.each do |branch|
+              move_branch_inside_condition(corrector, branch, condition, assignment, column)
             end
           end
 
@@ -589,8 +583,7 @@ module RuboCop
           def move_branch_inside_condition(corrector, branch, condition,
                                            assignment, column)
             branch_assignment = tail(branch)
-            corrector.insert_before(branch_assignment.loc.expression,
-                                    assignment.source)
+            corrector.insert_before(branch_assignment, assignment.source)
 
             remove_whitespace_in_branches(corrector, branch, condition, column)
 
@@ -607,31 +600,25 @@ module RuboCop
           include ConditionalAssignmentHelper
           include ConditionalCorrectorHelper
 
-          def correct(cop, node)
+          def correct(corrector, cop, node)
             when_branches, else_branch = extract_tail_branches(node)
 
-            lambda do |corrector|
-              corrector.insert_before(node.source_range, lhs(else_branch))
-              correct_branches(corrector, when_branches)
-              replace_branch_assignment(corrector, else_branch)
+            corrector.insert_before(node, lhs(else_branch))
+            correct_branches(corrector, when_branches)
+            replace_branch_assignment(corrector, else_branch)
 
-              corrector.insert_before(node.loc.end,
-                                      indent(cop, lhs(else_branch)))
-            end
+            corrector.insert_before(node.loc.end, indent(cop, lhs(else_branch)))
           end
 
-          def move_assignment_inside_condition(node)
+          def move_assignment_inside_condition(corrector, node)
             column = node.loc.expression.column
             *_var, condition = *node
             assignment = assignment(node)
 
-            lambda do |corrector|
-              corrector.remove(assignment)
+            corrector.remove(assignment)
 
-              extract_branches(condition).flatten.each do |branch|
-                move_branch_inside_condition(corrector, branch, condition,
-                                             assignment, column)
-              end
+            extract_branches(condition).flatten.each do |branch|
+              move_branch_inside_condition(corrector, branch, condition, assignment, column)
             end
           end
 
@@ -649,17 +636,14 @@ module RuboCop
             [when_branches, case_node.else_branch]
           end
 
-          def move_branch_inside_condition(corrector, branch, condition,
-                                           assignment, column)
+          def move_branch_inside_condition(corrector, branch, condition, assignment, column)
             branch_assignment = tail(branch)
-            corrector.insert_before(branch_assignment.loc.expression,
-                                    assignment.source)
+            corrector.insert_before(branch_assignment, assignment.source)
 
             remove_whitespace_in_branches(corrector, branch, condition, column)
 
             parent_keyword = branch.parent.loc.keyword
-            corrector.remove_preceding(parent_keyword,
-                                       parent_keyword.column - column)
+            corrector.remove_preceding(parent_keyword, parent_keyword.column - column)
           end
         end
       end