rubocop 0.87.1 → 0.89.1

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

@@ -18,7 +18,7 @@ module RuboCop
       #   # good
       #
       #   float = 42.9
-      class FloatOutOfRange < Cop
+      class FloatOutOfRange < Base
         MSG = 'Float out of range.'
 
         def on_float(node)

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

@@ -34,7 +34,7 @@ module RuboCop
       #   # good
       #
       #   format('Numbered format: %1$s and numbered %2$s', a_value, another)
-      class FormatParameterMismatch < Cop
+      class FormatParameterMismatch < Base
         # http://rubular.com/r/CvpbxkcTzy
         MSG = "Number of arguments (%<arg_num>i) to `%<method>s` doesn't " \
               'match the number of fields (%<field_num>i).'
@@ -44,18 +44,19 @@ module RuboCop
         KERNEL = 'Kernel'
         SHOVEL = '<<'
         STRING_TYPES = %i[str dstr].freeze
+        FORMAT_METHODS = %i[format sprintf %].freeze
 
         def on_send(node)
-          return unless format_string?(node)
+          return unless FORMAT_METHODS.include?(node.method_name) && format_string?(node)
 
           if invalid_format_string?(node)
-            add_offense(node, location: :selector, message: MSG_INVALID)
+            add_offense(node.loc.selector, message: MSG_INVALID)
             return
           end
 
           return unless offending_node?(node)
 
-          add_offense(node, location: :selector)
+          add_offense(node.loc.selector, message: message(node))
         end
 
         private

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

@@ -30,8 +30,9 @@ module RuboCop
       #        bar
       #      SQL
       #
-      class HeredocMethodCallPosition < Cop
+      class HeredocMethodCallPosition < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Put a method call with a HEREDOC receiver on the ' \
         'same line as the HEREDOC opening.'
@@ -41,25 +42,23 @@ module RuboCop
           return unless heredoc
           return if correctly_positioned?(node, heredoc)
 
-          add_offense(node, location: call_after_heredoc_range(heredoc))
+          add_offense(call_after_heredoc_range(heredoc)) do |corrector|
+            autocorrect(corrector, node, heredoc)
+          end
         end
         alias on_csend on_send
 
-        def autocorrect(node)
-          heredoc = heredoc_node_descendent_receiver(node)
+        private
 
-          lambda do |corrector|
-            call_range = call_range_to_safely_reposition(node, heredoc)
-            return if call_range.nil?
+        def autocorrect(corrector, node, heredoc)
+          call_range = call_range_to_safely_reposition(node, heredoc)
+          return if call_range.nil?
 
-            call_source = call_range.source.strip
-            corrector.remove(call_range)
-            corrector.insert_after(heredoc_begin_line_range(node), call_source)
-          end
+          call_source = call_range.source.strip
+          corrector.remove(call_range)
+          corrector.insert_after(heredoc_begin_line_range(node), call_source)
         end
 
-        private
-
         def heredoc_node_descendent_receiver(node)
           while send_node?(node)
             return node.receiver if heredoc_node?(node.receiver)
@@ -148,7 +147,7 @@ module RuboCop
         end
 
         def trailing_comma?(call_source, call_line_source)
-          call_source + ',' == call_line_source
+          "#{call_source}," == call_line_source
         end
       end
     end

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

@@ -22,7 +22,7 @@ module RuboCop
       #     'Item 1' \
       #     'Item 2'
       #   ]
-      class ImplicitStringConcatenation < Cop
+      class ImplicitStringConcatenation < Base
         MSG = 'Combine %<string1>s and %<string2>s into a single string ' \
               'literal, rather than using implicit string concatenation.'
         FOR_ARRAY = ' Or, if they were intended to be separate array ' \
@@ -41,7 +41,7 @@ module RuboCop
             elsif node.parent&.send_type?
               message << FOR_METHOD
             end
-            add_offense(node, location: range, message: message)
+            add_offense(range, message: message)
           end
         end
 
@@ -64,9 +64,10 @@ module RuboCop
 
         def ending_delimiter(str)
           # implicit string concatenation does not work with %{}, etc.
-          if str.source[0] == "'"
+          case str.source[0]
+          when "'"
             "'"
-          elsif str.source[0] == '"'
+          when '"'
             '"'
           end
         end

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

@@ -45,7 +45,7 @@ module RuboCop
       #       end
       #     end
       #   end
-      class IneffectiveAccessModifier < Cop
+      class IneffectiveAccessModifier < Base
         MSG = '`%<modifier>s` (on line %<line>d) does not make singleton ' \
               'methods %<modifier>s. Use %<alternative>s instead.'
         ALTERNATIVE_PRIVATE = '`private_class_method` or `private` inside a ' \
@@ -70,12 +70,8 @@ module RuboCop
         def check_node(node)
           return unless node&.begin_type?
 
-          ignored_methods = private_class_method_names(node)
-
-          ineffective_modifier(node, ignored_methods) do |defs_node, modifier|
-            add_offense(defs_node,
-                        location: :keyword,
-                        message: format_message(modifier))
+          ineffective_modifier(node) do |defs_node, modifier|
+            add_offense(defs_node.loc.keyword, message: format_message(modifier))
           end
         end
 
@@ -97,20 +93,24 @@ module RuboCop
                       alternative: alternative)
         end
 
-        def ineffective_modifier(node, ignored_methods, modifier = nil, &block)
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def ineffective_modifier(node, ignored_methods = nil, modifier = nil, &block)
           node.each_child_node do |child|
             case child.type
             when :send
               modifier = child if access_modifier?(child)
             when :defs
+              ignored_methods ||= private_class_method_names(node)
               next if correct_visibility?(child, modifier, ignored_methods)
 
               yield child, modifier
             when :kwbegin
+              ignored_methods ||= private_class_method_names(node)
               ineffective_modifier(child, ignored_methods, modifier, &block)
             end
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def access_modifier?(node)
           node.bare_access_modifier? && !node.method?(:module_function)

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

@@ -33,8 +33,9 @@ module RuboCop
       #   class C < StandardError; end
       #
       #   C = Class.new(StandardError)
-      class InheritException < Cop
+      class InheritException < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Inherit from `%<prefer>s` instead of `%<current>s`.'
         PREFERRED_BASE_CLASS = {
@@ -65,19 +66,23 @@ module RuboCop
           return unless node.parent_class &&
                         illegal_class_name?(node.parent_class)
 
-          add_offense(node.parent_class)
+          message = message(node.parent_class)
+
+          add_offense(node.parent_class, message: message) do |corrector|
+            corrector.replace(node.parent_class, preferred_base_class)
+          end
         end
 
         def on_send(node)
+          return unless node.method?(:new)
+
           constant = class_new_call?(node)
           return unless constant && illegal_class_name?(constant)
 
-          add_offense(constant)
-        end
+          message = message(constant)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node, preferred_base_class)
+          add_offense(constant, message: message) do |corrector|
+            corrector.replace(constant, preferred_base_class)
           end
         end
 

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,9 @@ module RuboCop
       #   while true
       #     break if condition
       #   end
-      class LiteralAsCondition < Cop
+      class LiteralAsCondition < Base
+        include RangeHelp
+
         MSG = 'Literal `%<literal>s` appeared as a condition.'
 
         def on_if(node)
@@ -57,7 +59,10 @@ module RuboCop
             case_node.each_when do |when_node|
               next unless when_node.conditions.all?(&:literal?)
 
-              add_offense(when_node)
+              range = when_conditions_range(when_node)
+              message = message(range)
+
+              add_offense(range, message: message)
             end
           end
         end
@@ -129,6 +134,13 @@ module RuboCop
             node.condition
           end
         end
+
+        def when_conditions_range(when_node)
+          range_between(
+            when_node.conditions.first.source_range.begin_pos,
+            when_node.conditions.last.source_range.end_pos
+          )
+        end
       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
+        METHOD_LIFECYCLE_CALLBACKS  = %i[method_added method_removed method_undefined
+                                         singleton_method_added singleton_method_removed
+                                         singleton_method_undefined].freeze
+
+        CALLBACKS = (OBJECT_LIFECYCLE_CALLBACKS +
+                      CLASS_LIFECYCLE_CALLBACKS +
+                      METHOD_LIFECYCLE_CALLBACKS).to_set.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)
+          return unless CALLBACKS.include?(node.method_name)
+
+          node.each_ancestor(:class, :sclass, :module).first
+        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