rubocop 0.88.0 → 0.89.0

data/lib/rubocop/cop/lint/interpolation_check.rb

@@ -16,31 +16,34 @@ module RuboCop
       #   # good
       #
       #   foo = "something with #{interpolation} inside"
-      class InterpolationCheck < Cop
+      class InterpolationCheck < Base
+        extend AutoCorrector
+
         MSG = 'Interpolation in single quoted string detected. '\
               'Use double quoted strings if you need interpolation.'
 
         def on_str(node)
-          return if heredoc?(node)
-
           parent = node.parent
           return if parent && (parent.dstr_type? || parent.regexp_type?)
-          return unless /(?<!\\)#\{.*\}/.match?(node.source.scrub)
+          return unless /(?<!\\)#\{.*\}/.match?(node.source)
+          return if heredoc?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            starting_token, ending_token = if node.source.include?('"')
-                                             ['%{', '}']
-                                           else
-                                             ['"', '"']
-                                           end
+        private
 
-            corrector.replace(node.loc.begin, starting_token)
-            corrector.replace(node.loc.end, ending_token)
-          end
+        def autocorrect(corrector, node)
+          starting_token, ending_token = if node.source.include?('"')
+                                           ['%{', '}']
+                                         else
+                                           ['"', '"']
+                                         end
+
+          corrector.replace(node.loc.begin, starting_token)
+          corrector.replace(node.loc.end, ending_token)
         end
 
         def heredoc?(node)

data/lib/rubocop/cop/lint/literal_as_condition.rb

@@ -29,7 +29,7 @@ module RuboCop
       #   while true
       #     break if condition
       #   end
-      class LiteralAsCondition < Cop
+      class LiteralAsCondition < Base
         include RangeHelp
 
         MSG = 'Literal `%<literal>s` appeared as a condition.'
@@ -60,7 +60,9 @@ module RuboCop
               next unless when_node.conditions.all?(&:literal?)
 
               range = when_conditions_range(when_node)
-              add_offense(when_node, location: range, message: message(range))
+              message = message(range)
+
+              add_offense(range, message: message)
             end
           end
         end

data/lib/rubocop/cop/lint/literal_in_interpolation.rb

@@ -16,10 +16,11 @@ module RuboCop
       #   # good
       #
       #   "result is 10"
-      class LiteralInInterpolation < Cop
+      class LiteralInInterpolation < Base
         include Interpolation
         include RangeHelp
         include PercentLiteral
+        extend AutoCorrector
 
         MSG = 'Literal interpolation detected.'
         COMPOSITE = %i[array hash pair irange erange].freeze
@@ -30,14 +31,13 @@ module RuboCop
           return if special_keyword?(final_node)
           return unless prints_as_self?(final_node)
 
-          add_offense(final_node)
-        end
+          add_offense(final_node) do |corrector|
+            return if final_node.dstr_type? # nested, fixed in next iteration
 
-        def autocorrect(node)
-          return if node.dstr_type? # nested, fixed in next iteration
+            value = autocorrected_value(final_node)
 
-          value = autocorrected_value(node)
-          ->(corrector) { corrector.replace(node.parent, value) }
+            corrector.replace(final_node.parent, value)
+          end
         end
 
         private

data/lib/rubocop/cop/lint/loop.rb

@@ -42,7 +42,9 @@ module RuboCop
       #     do_something
       #     break if some_condition
       #   end
-      class Loop < Cop
+      class Loop < Base
+        extend AutoCorrector
+
         MSG = 'Use `Kernel#loop` with `break` rather than ' \
               '`begin/end/until`(or `while`).'
 
@@ -57,7 +59,26 @@ module RuboCop
         private
 
         def register_offense(node)
-          add_offense(node, location: :keyword)
+          body = node.body
+
+          add_offense(node.loc.keyword) do |corrector|
+            corrector.replace(body.loc.begin, 'loop do')
+            corrector.remove(keyword_and_condition_range(node))
+            corrector.insert_before(body.loc.end, build_break_line(node))
+          end
+        end
+
+        def keyword_and_condition_range(node)
+          node.body.loc.end.end.join(node.source_range.end)
+        end
+
+        def build_break_line(node)
+          conditional_keyword = node.while_post_type? ? 'unless' : 'if'
+          "break #{conditional_keyword} #{node.condition.source}\n#{indent(node)}"
+        end
+
+        def indent(node)
+          ' ' * node.loc.column
         end
       end
     end

data/lib/rubocop/cop/lint/missing_cop_enable_directive.rb

@@ -42,7 +42,7 @@ module RuboCop
       #   # Including this, that's 3 lines on which the cop is disabled.
       #   # rubocop:enable Layout/SpaceAroundOperators
       #
-      class MissingCopEnableDirective < Cop
+      class MissingCopEnableDirective < Base
         include RangeHelp
 
         MSG = 'Re-enable %<cop>s cop with `# rubocop:enable` after ' \
@@ -50,7 +50,8 @@ module RuboCop
         MSG_BOUND = 'Re-enable %<cop>s cop within %<max_range>s lines after ' \
                     'disabling it.'
 
-        def investigate(processed_source)
+        # rubocop:disable Metrics/AbcSize
+        def on_new_investigation
           max_range = cop_config['MaximumRangeSize']
           processed_source.disabled_line_ranges.each do |cop, line_ranges|
             line_ranges.each do |line_range|
@@ -61,12 +62,12 @@ module RuboCop
               range = source_range(processed_source.buffer,
                                    line_range.min,
                                    (0..0))
-              add_offense(range,
-                          location: range,
-                          message: message(max_range: max_range, cop: cop))
+
+              add_offense(range, message: message(max_range: max_range, cop: cop))
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 

data/lib/rubocop/cop/lint/missing_super.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the presence of constructors and lifecycle callbacks
+      # without calls to `super`.
+      #
+      # @example
+      #   # bad
+      #   class Employee < Person
+      #     def initialize(name, salary)
+      #       @salary = salary
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Employee < Person
+      #     def initialize(name, salary)
+      #       super(name)
+      #       @salary = salary
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class Parent
+      #     def self.inherited(base)
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Parent
+      #     def self.inherited(base)
+      #       super
+      #       do_something
+      #     end
+      #   end
+      #
+      class MissingSuper < Base
+        CONSTRUCTOR_MSG = 'Call `super` to initialize state of the parent class.'
+        CALLBACK_MSG    = 'Call `super` to invoke callback defined in the parent class.'
+
+        STATELESS_CLASSES = %w[BasicObject Object].freeze
+
+        OBJECT_LIFECYCLE_CALLBACKS  = %i[method_missing respond_to_missing?].freeze
+        CLASS_LIFECYCLE_CALLBACKS   = %i[inherited].freeze
+        MODULE_LIFECYCLE_CALLBACKS  = %i[included extended prepended].freeze
+
+        def on_def(node)
+          return unless offender?(node)
+
+          if node.method?(:initialize)
+            add_offense(node, message: CONSTRUCTOR_MSG) if inside_class_with_stateful_parent?(node)
+          elsif callback_method_def?(node)
+            add_offense(node, message: CALLBACK_MSG)
+          end
+        end
+
+        def on_defs(node)
+          return if !callback_method_def?(node) || contains_super?(node)
+
+          add_offense(node, message: CALLBACK_MSG)
+        end
+
+        private
+
+        def offender?(node)
+          (node.method?(:initialize) || callback_method_def?(node)) && !contains_super?(node)
+        end
+
+        def callback_method_def?(node)
+          method_name = node.method_name
+
+          if OBJECT_LIFECYCLE_CALLBACKS.include?(method_name) ||
+             CLASS_LIFECYCLE_CALLBACKS.include?(method_name)
+
+            node.each_ancestor(:class, :sclass, :module).first
+          elsif MODULE_LIFECYCLE_CALLBACKS.include?(method_name)
+            node.each_ancestor(:module).first
+          end
+        end
+
+        def contains_super?(node)
+          node.each_descendant(:super, :zsuper).any?
+        end
+
+        def inside_class_with_stateful_parent?(node)
+          class_node = node.each_ancestor(:class).first
+          class_node&.parent_class && !stateless_class?(class_node.parent_class)
+        end
+
+        def stateless_class?(node)
+          STATELESS_CLASSES.include?(node.const_name)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/mixed_regexp_capture_types.rb

@@ -20,7 +20,7 @@ module RuboCop
       #   # good
       #   /(FOO)(BAR)/
       #
-      class MixedRegexpCaptureTypes < Cop
+      class MixedRegexpCaptureTypes < Base
         MSG = 'Do not mix named captures and numbered captures ' \
               'in a Regexp literal.'
 

data/lib/rubocop/cop/lint/multiple_comparison.rb

@@ -21,7 +21,9 @@ module RuboCop
       #
       #   x < y && y < z
       #   10 <= x && x <= 20
-      class MultipleComparison < Cop
+      class MultipleComparison < Base
+        extend AutoCorrector
+
         MSG = 'Use the `&&` operator to compare multiple values.'
 
         def_node_matcher :multiple_compare?, <<~PATTERN
@@ -29,16 +31,11 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless multiple_compare?(node)
-
-          add_offense(node)
-        end
+          return unless (center = multiple_compare?(node))
 
-        def autocorrect(node)
-          center = multiple_compare?(node)
-          new_center = "#{center.source} && #{center.source}"
+          add_offense(node) do |corrector|
+            new_center = "#{center.source} && #{center.source}"
 
-          lambda do |corrector|
             corrector.replace(center, new_center)
           end
         end

data/lib/rubocop/cop/lint/nested_method_definition.rb

@@ -54,7 +54,7 @@ module RuboCop
       #       end
       #     end
       #   end
-      class NestedMethodDefinition < Cop
+      class NestedMethodDefinition < Base
         MSG = 'Method definitions must not be nested. ' \
               'Use `lambda` instead.'
 

data/lib/rubocop/cop/lint/nested_percent_literal.rb

@@ -15,7 +15,7 @@ module RuboCop
       #     valid_attributes: %i[name content],
       #     nested_attributes: %i[name content %i[incorrectly nested]]
       #   }
-      class NestedPercentLiteral < Cop
+      class NestedPercentLiteral < Base
         include PercentLiteral
 
         MSG = 'Within percent literals, nested percent literals do not ' \

data/lib/rubocop/cop/lint/next_without_accumulator.rb

@@ -22,7 +22,7 @@ module RuboCop
       #     next acc if i.odd?
       #     acc + i
       #   end
-      class NextWithoutAccumulator < Cop
+      class NextWithoutAccumulator < Base
         MSG = 'Use `next` with an accumulator argument in a `reduce`.'
 
         def_node_matcher :on_body_of_reduce, <<~PATTERN

data/lib/rubocop/cop/lint/non_deterministic_require_order.rb

@@ -51,7 +51,9 @@ module RuboCop
       #   # good
       #   Dir.glob(Rails.root.join('test', '*.rb')).sort.each(&method(:require))
       #
-      class NonDeterministicRequireOrder < Cop
+      class NonDeterministicRequireOrder < Base
+        extend AutoCorrector
+
         MSG = 'Sort files before requiring them.'
 
         def on_block(node)
@@ -61,7 +63,9 @@ module RuboCop
           loop_variable(node.arguments) do |var_name|
             return unless var_is_required?(node.body, var_name)
 
-            add_offense(node.send_node)
+            add_offense(node.send_node) do |corrector|
+              correct_block(corrector, node.send_node)
+            end
           end
         end
 
@@ -69,37 +73,37 @@ module RuboCop
           return unless method_require?(node)
           return unless unsorted_dir_pass?(node.parent)
 
-          add_offense(node.parent)
+          parent_node = node.parent
+
+          add_offense(parent_node) do |corrector|
+            if parent_node.arguments.last&.block_pass_type?
+              correct_block_pass(corrector, parent_node)
+            else
+              correct_block(corrector, parent_node)
+            end
+          end
         end
 
-        def autocorrect(node)
-          return correct_block_pass(node) if node.arguments.last&.block_pass_type?
+        private
 
+        def correct_block(corrector, node)
           if unsorted_dir_block?(node)
-            lambda do |corrector|
-              corrector.replace(node, "#{node.source}.sort.each")
-            end
+            corrector.replace(node, "#{node.source}.sort.each")
           else
-            lambda do |corrector|
-              source = node.receiver.source
-              corrector.replace(node, "#{source}.sort.each")
-            end
+            source = node.receiver.source
+
+            corrector.replace(node, "#{source}.sort.each")
           end
         end
 
-        private
-
-        def correct_block_pass(node)
+        def correct_block_pass(corrector, node)
           if unsorted_dir_glob_pass?(node)
-            lambda do |corrector|
-              block_arg = node.arguments.last
-              corrector.remove(last_arg_range(node))
-              corrector.insert_after(node, ".sort.each(#{block_arg.source})")
-            end
+            block_arg = node.arguments.last
+
+            corrector.remove(last_arg_range(node))
+            corrector.insert_after(node, ".sort.each(#{block_arg.source})")
           else
-            lambda do |corrector|
-              corrector.replace(node.loc.selector, 'sort.each')
-            end
+            corrector.replace(node.loc.selector, 'sort.each')
           end
         end
 

data/lib/rubocop/cop/lint/non_local_exit_from_iterator.rb

@@ -38,7 +38,7 @@ module RuboCop
       #     end
       #   end
       #
-      class NonLocalExitFromIterator < Cop
+      class NonLocalExitFromIterator < Base
         MSG = 'Non-local exit from iterator, without return value. ' \
               '`next`, `break`, `Array#find`, `Array#any?`, etc. ' \
               'is preferred.'
@@ -57,7 +57,7 @@ module RuboCop
             next unless node.arguments?
 
             if chained_send?(node.send_node)
-              add_offense(return_node, location: :keyword)
+              add_offense(return_node.loc.keyword)
               break
             end
           end

data/lib/rubocop/cop/lint/number_conversion.rb

@@ -20,7 +20,9 @@ module RuboCop
       #   Integer('10', 10)
       #   Float('10.2')
       #   Complex('10')
-      class NumberConversion < Cop
+      class NumberConversion < Base
+        extend AutoCorrector
+
         CONVERSION_METHOD_CLASS_MAPPING = {
           to_i: "#{Integer.name}(%<number_object>s, 10)",
           to_f: "#{Float.name}(%<number_object>s)",
@@ -49,14 +51,9 @@ module RuboCop
               to_method: to_method,
               corrected_method: correct_method(node, receiver)
             )
-            add_offense(node, message: message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node,
-                              correct_method(node, node.receiver))
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, correct_method(node, node.receiver))
+            end
           end
         end