rubocop 0.78.0 → 1.13.0

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 = {
@@ -55,6 +56,9 @@ module RuboCop
           SystemExit
         ].freeze
 
+        RESTRICT_ON_SEND = %i[new].freeze
+
+        # @!method class_new_call?(node)
         def_node_matcher :class_new_call?, <<~PATTERN
           (send
             (const {cbase nil?} :Class) :new
@@ -62,22 +66,23 @@ module RuboCop
         PATTERN
 
         def on_class(node)
-          return unless node.parent_class &&
-                        illegal_class_name?(node.parent_class)
+          return unless node.parent_class && illegal_class_name?(node.parent_class)
+
+          message = message(node.parent_class)
 
-          add_offense(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)
           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.loc.expression, 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,23 +16,36 @@ 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 node.parent&.regexp_type?
+          return unless /(?<!\\)#\{.*\}/.match?(node.source)
           return if heredoc?(node)
+          return unless node.loc.begin && node.loc.end
+
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
+        end
+
+        private
 
-          parent = node.parent
-          return if parent && (parent.dstr_type? || parent.regexp_type?)
-          return unless node.source.scrub =~ /(?<!\\)#\{.*\}/
+        def autocorrect(corrector, node)
+          starting_token, ending_token = if node.source.include?('"')
+                                           ['%{', '}']
+                                         else
+                                           ['"', '"']
+                                         end
 
-          add_offense(node)
+          corrector.replace(node.loc.begin, starting_token)
+          corrector.replace(node.loc.end, ending_token)
         end
 
         def heredoc?(node)
-          node.loc.is_a?(Parser::Source::Map::Heredoc) ||
-            (node.parent && heredoc?(node.parent))
+          node.loc.is_a?(Parser::Source::Map::Heredoc) || (node.parent && heredoc?(node.parent))
         end
       end
     end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks uses of lambda without a literal block.
+      # It emulates the following warning in Ruby 3.0:
+      #
+      #   % ruby -vwe 'lambda(&proc {})'
+      #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
+      #   -e:1: warning: lambda without a literal block is deprecated; use the proc without
+      #   lambda instead
+      #
+      # This way, proc object is never converted to lambda.
+      # Auto-correction replaces with compatible proc argument.
+      #
+      # @example
+      #
+      #   # bad
+      #   lambda(&proc { do_something })
+      #   lambda(&Proc.new { do_something })
+      #
+      #   # good
+      #   proc { do_something }
+      #   Proc.new { do_something }
+      #   lambda { do_something } # If you use lambda.
+      #
+      class LambdaWithoutLiteralBlock < Base
+        extend AutoCorrector
+
+        MSG = 'lambda without a literal block is deprecated; use the proc without lambda instead.'
+        RESTRICT_ON_SEND = %i[lambda].freeze
+
+        def on_send(node)
+          return if node.parent&.block_type? || !node.first_argument
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, node.first_argument.source.delete('&'))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -10,27 +10,28 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   if 20
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # bad
-      #
       #   if some_var && true
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   if some_var && some_condition
       #     do_something
       #   end
-      class LiteralAsCondition < Cop
+      #
+      #   # good
+      #   # When using a boolean value for an infinite loop.
+      #   while true
+      #     break if condition
+      #   end
+      class LiteralAsCondition < Base
+        include RangeHelp
+
         MSG = 'Literal `%<literal>s` appeared as a condition.'
 
         def on_if(node)
@@ -38,20 +39,18 @@ module RuboCop
         end
 
         def on_while(node)
-          check_for_literal(node)
-        end
+          return if condition(node).true_type?
 
-        def on_while_post(node)
           check_for_literal(node)
         end
+        alias on_while_post on_while
 
         def on_until(node)
-          check_for_literal(node)
-        end
+          return if condition(node).false_type?
 
-        def on_until_post(node)
           check_for_literal(node)
         end
+        alias on_until_post on_until
 
         def on_case(case_node)
           if case_node.condition
@@ -60,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
@@ -132,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,36 +16,46 @@ 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
 
         def on_interpolation(begin_node)
           final_node = begin_node.children.last
-          return unless final_node
-          return if special_keyword?(final_node)
-          return unless prints_as_self?(final_node)
+          return unless offending?(final_node)
 
-          add_offense(final_node)
-        end
+          # %W and %I split the content into words before expansion
+          # treating each interpolation as a word component, so
+          # interpolation should not be removed if the expanded value
+          # contains a space character.
+          expanded_value = autocorrected_value(final_node)
+          return if in_array_percent_literal?(begin_node) && /\s/.match?(expanded_value)
 
-        def autocorrect(node)
-          return if node.dstr_type? # nested, fixed in next iteration
+          add_offense(final_node) do |corrector|
+            return if final_node.dstr_type? # nested, fixed in next iteration
 
-          value = autocorrected_value(node)
-          ->(corrector) { corrector.replace(node.parent.source_range, value) }
+            corrector.replace(final_node.parent, expanded_value)
+          end
         end
 
         private
 
+        def offending?(node)
+          node &&
+            !special_keyword?(node) &&
+            prints_as_self?(node) &&
+            # Special case for Layout/TrailingWhitespace
+            !(space_literal?(node) && ends_heredoc_line?(node))
+        end
+
         def special_keyword?(node)
           # handle strings like __FILE__
-          (node.str_type? && !node.loc.respond_to?(:begin)) ||
-            node.source_range.is?('__LINE__')
+          (node.str_type? && !node.loc.respond_to?(:begin)) || node.source_range.is?('__LINE__')
         end
 
         def autocorrected_value(node)
@@ -83,14 +93,33 @@ module RuboCop
         def autocorrected_value_for_array(node)
           return node.source.gsub('"', '\"') unless node.percent_literal?
 
-          contents_range(node).source.split(' ').to_s.gsub('"', '\"')
+          contents_range(node).source.split.to_s.gsub('"', '\"')
         end
 
         # Does node print its own source when converted to a string?
         def prints_as_self?(node)
           node.basic_literal? ||
-            (COMPOSITE.include?(node.type) &&
-              node.children.all? { |child| prints_as_self?(child) })
+            (COMPOSITE.include?(node.type) && node.children.all? { |child| prints_as_self?(child) })
+        end
+
+        def space_literal?(node)
+          node.str_type? && node.value.blank?
+        end
+
+        def ends_heredoc_line?(node)
+          grandparent = node.parent.parent
+          return false unless grandparent&.dstr_type? && grandparent&.heredoc?
+
+          line = processed_source.lines[node.last_line - 1]
+          line.size == node.loc.last_column + 1
+        end
+
+        def in_array_percent_literal?(node)
+          parent = node.parent
+          return false unless parent.dstr_type? || parent.dsym_type?
+
+          grandparent = parent.parent
+          grandparent&.array_type? && grandparent&.percent_literal?
         end
       end
     end

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

@@ -3,7 +3,11 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for uses of *begin...end while/until something*.
+      # This cop checks for uses of `begin...end while/until something`.
+      #
+      # The cop is marked as unsafe because behaviour can change in some cases, including
+      # if a local variable inside the loop body is accessed outside of it, or if the
+      # loop body raises a `StopIteration` exception (which `Kernel#loop` rescues).
       #
       # @example
       #
@@ -27,22 +31,25 @@ module RuboCop
       #
       #   # good
       #
-      #   # using while
-      #   while some_condition
+      #   # while replacement
+      #   loop do
       #     do_something
+      #     break unless some_condition
       #   end
       #
       # @example
       #
       #   # good
       #
-      #   # using until
-      #   until some_condition
+      #   # until replacement
+      #   loop do
       #     do_something
+      #     break if some_condition
       #   end
-      class Loop < Cop
-        MSG = 'Use `Kernel#loop` with `break` rather than ' \
-              '`begin/end/until`(or `while`).'
+      class Loop < Base
+        extend AutoCorrector
+
+        MSG = 'Use `Kernel#loop` with `break` rather than `begin/end/until`(or `while`).'
 
         def on_while_post(node)
           register_offense(node)
@@ -55,7 +62,22 @@ 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
       end
     end

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

@@ -42,15 +42,14 @@ 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 ' \
-              'disabling it.'
-        MSG_BOUND = 'Re-enable %<cop>s cop within %<max_range>s lines after ' \
-                    'disabling it.'
+        MSG = 'Re-enable %<cop>s cop with `# rubocop:enable` after disabling it.'
+        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|
@@ -58,15 +57,13 @@ module RuboCop
               # the case when max_range is Float::INFINITY
               next if line_range.max - line_range.min < max_range + 2
 
-              range = source_range(processed_source.buffer,
-                                   line_range.min,
-                                   (0..0))
-              add_offense(range,
-                          location: range,
-                          message: message(max_range: max_range, cop: cop))
+              range = source_range(processed_source.buffer, line_range.min, (0..0))
+
+              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,101 @@
+# 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`.
+      #
+      # This cop does not consider `method_missing` (and `respond_to_missing?`)
+      # because in some cases it makes sense to overtake what is considered a
+      # missing method. In other cases, the theoretical ideal handling could be
+      # challenging or verbose for no actual gain.
+      #
+      # @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
+
+        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 = (CLASS_LIFECYCLE_CALLBACKS + METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
+
+        def on_def(node)
+          return unless offender?(node)
+
+          if node.method?(:initialize) && inside_class_with_stateful_parent?(node)
+            add_offense(node, message: CONSTRUCTOR_MSG)
+          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