rubocop 0.88.0 → 0.91.1

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

@@ -75,8 +75,9 @@ module RuboCop
       # @example AllowInnerBackticks: true
       #   # good
       #   `echo \`ls\``
-      class CommandLiteral < Cop
+      class CommandLiteral < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG_USE_BACKTICKS = 'Use backticks around command string.'
         MSG_USE_PERCENT_X = 'Use `%x` around command string.'
@@ -85,43 +86,41 @@ module RuboCop
           return if node.heredoc?
 
           if backtick_literal?(node)
-            check_backtick_literal(node)
+            check_backtick_literal(node, MSG_USE_PERCENT_X)
           else
-            check_percent_x_literal(node)
-          end
-        end
-
-        def autocorrect(node)
-          return if contains_backtick?(node)
-
-          replacement = if backtick_literal?(node)
-                          ['%x', ''].zip(preferred_delimiter).map(&:join)
-                        else
-                          %w[` `]
-                        end
-
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, replacement.first)
-            corrector.replace(node.loc.end, replacement.last)
+            check_percent_x_literal(node, MSG_USE_BACKTICKS)
           end
         end
 
         private
 
-        def check_backtick_literal(node)
+        def check_backtick_literal(node, message)
           return if allowed_backtick_literal?(node)
 
-          add_offense(node)
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def check_percent_x_literal(node)
+        def check_percent_x_literal(node, message)
           return if allowed_percent_x_literal?(node)
 
-          add_offense(node)
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def message(node)
-          backtick_literal?(node) ? MSG_USE_PERCENT_X : MSG_USE_BACKTICKS
+        def autocorrect(corrector, node)
+          return if contains_backtick?(node)
+
+          replacement = if backtick_literal?(node)
+                          ['%x', ''].zip(preferred_delimiter).map(&:join)
+                        else
+                          %w[` `]
+                        end
+
+          corrector.replace(node.loc.begin, replacement.first)
+          corrector.replace(node.loc.end, replacement.last)
         end
 
         def allowed_backtick_literal?(node)

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

@@ -30,9 +30,10 @@ 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, ' \
@@ -40,7 +41,7 @@ module RuboCop
         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)
@@ -49,26 +50,25 @@ module RuboCop
             next unless annotation?(comment) &&
                         !correct_annotation?(first_word, colon, space, note)
 
-            add_offense(
-              comment,
-              location: annotation_range(comment, margin,
-                                         first_word, colon, space),
-              message: format(note ? MSG : MISSING_NOTE, keyword: first_word)
-            )
+            range = annotation_range(comment, margin, first_word, colon, space)
+
+            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

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

@@ -33,13 +33,17 @@ module RuboCop
       #   class X # :nodoc:
       #     y
       #   end
-      class CommentedKeyword < Cop
+      class CommentedKeyword < Base
         MSG = 'Do not place comments on the same line as the ' \
               '`%<keyword>s` keyword.'
 
-        def investigate(processed_source)
-          processed_source.each_comment do |comment|
-            add_offense(comment) if offensive?(comment)
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            next unless (match = line(comment).match(/(?<keyword>\S+).*#/))
+
+            if offensive?(comment)
+              add_offense(comment, message: format(MSG, keyword: match[:keyword]))
+            end
           end
         end
 
@@ -62,11 +66,6 @@ module RuboCop
             ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
         end
 
-        def message(comment)
-          keyword = line(comment).match(/(\S+).*#/)[1]
-          format(MSG, keyword: keyword)
-        end
-
         def line(comment)
           comment.location.expression.source_line
         end

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

@@ -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
@@ -67,7 +67,7 @@ module RuboCop
 
         private
 
-        def expand_elsif(node, elsif_branches = []) # rubocop:todo Metrics/CyclomaticComplexity
+        def expand_elsif(node, elsif_branches = [])
           return [] if node.nil? || !node.if_type? || !node.elsif?
 
           elsif_branches << node.if_branch
@@ -93,6 +93,15 @@ 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)
@@ -199,10 +208,11 @@ 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.'
@@ -224,7 +234,7 @@ module RuboCop
         def_node_matcher :assignment_type?, <<~PATTERN
           {
             #{ASSIGNMENT_TYPES.join(' ')}
-            (send _recv {:[]= :<< :=~ :!~ :<=> #end_with_eq?} ...)
+            (send _recv {:[]= :<< :=~ :!~ :<=> #end_with_eq? :< :>} ...)
           }
         PATTERN
 
@@ -266,14 +276,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,7 +291,9 @@ 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)
@@ -317,25 +321,25 @@ module RuboCop
           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
 
@@ -362,7 +366,17 @@ module RuboCop
           return if allowed_single_line?(branches)
           return if correction_exceeds_line_limit?(node, branches)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        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)
@@ -490,24 +504,20 @@ module RuboCop
           include ConditionalAssignmentHelper
           include ConditionalCorrectorHelper
 
-          def correct(node)
-            lambda do |corrector|
-              corrector.replace(node, 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
@@ -556,22 +566,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
 
@@ -605,31 +612,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, 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
 
@@ -647,17 +648,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,
-                                    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

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

@@ -26,7 +26,7 @@ module RuboCop
       #     public_constant :BAZ
       #   end
       #
-      class ConstantVisibility < Cop
+      class ConstantVisibility < Base
         MSG = 'Explicitly make `%<constant_name>s` public or private using ' \
               'either `#public_constant` or `#private_constant`.'
 
@@ -34,7 +34,8 @@ module RuboCop
           return unless class_or_module_scope?(node)
           return if visibility_declaration?(node)
 
-          add_offense(node)
+          message = message(node)
+          add_offense(node, message: message)
         end
 
         private

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

@@ -15,28 +15,24 @@ module RuboCop
       # that RuboCop scans, a comment that matches this regex must be found or
       # an offense is reported.
       #
-      class Copyright < Cop
+      class Copyright < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Include a copyright notice matching /%<notice>s/ before ' \
               'any code.'
         AUTOCORRECT_EMPTY_WARNING = 'An AutocorrectNotice must be defined in ' \
                                     'your RuboCop config'
 
-        def investigate(processed_source)
-          return if notice.empty?
-          return if notice_found?(processed_source)
+        def on_new_investigation
+          return if notice.empty? || notice_found?(processed_source)
 
-          range = source_range(processed_source.buffer, 1, 0)
-          add_offense(insert_notice_before(processed_source),
-                      location: range, message: format(MSG, notice: notice))
-        end
-
-        def autocorrect(token)
-          verify_autocorrect_notice!
+          add_offense(offense_range, message: format(MSG, notice: notice)) do |corrector|
+            verify_autocorrect_notice!
 
-          lambda do |corrector|
+            token = insert_notice_before(processed_source)
             range = token.nil? ? range_between(0, 0) : token.pos
+
             corrector.insert_before(range, "#{autocorrect_notice}\n")
           end
         end
@@ -51,6 +47,10 @@ module RuboCop
           cop_config['AutocorrectNotice']
         end
 
+        def offense_range
+          source_range(processed_source.buffer, 1, 0)
+        end
+
         def verify_autocorrect_notice!
           raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?