rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the presence of `method_missing` without
+      # falling back on `super`.
+      #
+      # @example
+      #   #bad
+      #   def method_missing(name, *args)
+      #     # ...
+      #   end
+      #
+      #   #good
+      #
+      #   def method_missing(name, *args)
+      #     # ...
+      #     super
+      #   end
+      class MethodMissingSuper < Cop
+        MSG = 'When using `method_missing`, fall back on `super`.'
+
+        def on_def(node)
+          return unless node.method?(:method_missing)
+          return if node.descendants.any?(&:zsuper_type?)
+
+          add_offense(node)
+        end
+        alias on_defs on_def
+      end
+    end
+  end
+end

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

@@ -7,15 +7,15 @@ module RuboCop
       #
       # @example
       #
-      #   @bad
+      #   # bad
       #   bar = [foo.min, foo.max]
       #   return foo.min, foo.max
       #
-      #   @good
+      #   # good
       #   bar = foo.minmax
       #   return foo.minmax
       class MinMax < Cop
-        MSG = 'Use `%<receiver>s.minmax` instead of `%<offender>s`.'.freeze
+        MSG = 'Use `%<receiver>s.minmax` instead of `%<offender>s`.'
 
         def on_array(node)
           min_max_candidate(node) do |receiver|
@@ -27,17 +27,6 @@ module RuboCop
         end
         alias on_return on_array
 
-        private
-
-        def_node_matcher :min_max_candidate, <<-PATTERN
-          ({array return} (send $_receiver :min) (send $_receiver :max))
-        PATTERN
-
-        def message(offender, receiver)
-          format(MSG, offender: offender.source,
-                      receiver: receiver.source)
-        end
-
         def autocorrect(node)
           receiver = node.children.first.receiver
 
@@ -47,6 +36,17 @@ module RuboCop
           end
         end
 
+        private
+
+        def_node_matcher :min_max_candidate, <<~PATTERN
+          ({array return} (send [$_receiver !nil?] :min) (send [$_receiver !nil?] :max))
+        PATTERN
+
+        def message(offender, receiver)
+          format(MSG, offender: offender.source,
+                      receiver: receiver.source)
+        end
+
         def offending_range(node)
           case node.type
           when :return

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

@@ -4,38 +4,104 @@ module RuboCop
   module Cop
     module Style
       # Checks for `if` expressions that do not have an `else` branch.
-      # SupportedStyles
       #
-      # if
-      # @example
+      # Supported styles are: if, case, both.
+      #
+      # @example EnforcedStyle: if
+      #   # warn when an `if` expression is missing an `else` branch.
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     # the content of `else` branch will be determined by Style/EmptyElse
+      #   end
+      #
+      #   # good
+      #   case var
+      #   when condition
+      #     statement
+      #   end
+      #
+      #   # good
+      #   case var
+      #   when condition
+      #     statement
+      #   else
+      #     # the content of `else` branch will be determined by Style/EmptyElse
+      #   end
+      #
+      # @example EnforcedStyle: case
+      #   # warn when a `case` expression is missing an `else` branch.
+      #
+      #   # bad
+      #   case var
+      #   when condition
+      #     statement
+      #   end
+      #
+      #   # good
+      #   case var
+      #   when condition
+      #     statement
+      #   else
+      #     # the content of `else` branch will be determined by Style/EmptyElse
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     # the content of `else` branch will be determined by Style/EmptyElse
+      #   end
+      #
+      # @example EnforcedStyle: both (default)
+      #   # warn when an `if` or `case` expression is missing an `else` branch.
+      #
       #   # bad
       #   if condition
       #     statement
       #   end
       #
-      # case
-      # @example
       #   # bad
       #   case var
       #   when condition
       #     statement
       #   end
       #
-      # @example
       #   # good
       #   if condition
       #     statement
       #   else
-      #   # the content of the else branch will be determined by Style/EmptyElse
+      #     # the content of `else` branch will be determined by Style/EmptyElse
+      #   end
+      #
+      #   # good
+      #   case var
+      #   when condition
+      #     statement
+      #   else
+      #     # the content of `else` branch will be determined by Style/EmptyElse
       #   end
       class MissingElse < Cop
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
 
-        MSG = '`%s` condition requires an `else`-clause.'.freeze
-        MSG_NIL = '`%s` condition requires an `else`-clause with ' \
-                  '`nil` in it.'.freeze
-        MSG_EMPTY = '`%s` condition requires an empty `else`-clause.'.freeze
+        MSG = '`%<type>s` condition requires an `else`-clause.'
+        MSG_NIL = '`%<type>s` condition requires an `else`-clause with ' \
+                  '`nil` in it.'
+        MSG_EMPTY = '`%<type>s` condition requires an empty ' \
+                    '`else`-clause.'
 
         def on_normal_if_unless(node)
           return if case_style?
@@ -76,7 +142,7 @@ module RuboCop
                        MSG
                      end
 
-          format(template, node.type)
+          format(template, type: node.type)
         end
 
         def if_style?
@@ -101,6 +167,7 @@ module RuboCop
 
         def empty_else_style
           return unless empty_else_config.key?('EnforcedStyle')
+
           empty_else_config['EnforcedStyle'].to_sym
         end
 

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the presence of `method_missing` without also
+      # defining `respond_to_missing?`.
+      #
+      # @example
+      #   #bad
+      #   def method_missing(name, *args)
+      #     # ...
+      #   end
+      #
+      #   #good
+      #   def respond_to_missing?(name, include_private)
+      #     # ...
+      #   end
+      #
+      #   def method_missing(name, *args)
+      #     # ...
+      #   end
+      #
+      class MissingRespondToMissing < Cop
+        MSG =
+          'When using `method_missing`, define `respond_to_missing?`.'
+
+        def on_def(node)
+          return unless node.method?(:method_missing)
+          return if implements_respond_to_missing?(node)
+
+          add_offense(node)
+        end
+        alias on_defs on_def
+
+        private
+
+        def implements_respond_to_missing?(node)
+          node.parent.each_child_node(node.type).any? do |sibling|
+            sibling.method?(:respond_to_missing?)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,30 +7,26 @@ module RuboCop
       # By default it enforces mixins to be placed in separate declarations,
       # but it can be configured to enforce grouping them in one declaration.
       #
-      # @example
-      #
-      #   EnforcedStyle: separated (default)
-      #
-      #   @bad
+      # @example EnforcedStyle: separated (default)
+      #   # bad
       #   class Foo
       #     include Bar, Qox
       #   end
       #
-      #   @good
+      #   # good
       #   class Foo
       #     include Qox
       #     include Bar
       #   end
       #
-      #   EnforcedStyle: grouped
-      #
-      #   @bad
+      # @example EnforcedStyle: grouped
+      #   # bad
       #   class Foo
       #     extend Bar
       #     extend Qox
       #   end
       #
-      #   @good
+      #   # good
       #   class Foo
       #     extend Qox, Bar
       #   end
@@ -38,24 +34,31 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         MIXIN_METHODS = %i[extend include prepend].freeze
-        MSG = 'Put `%s` mixins in %s.'.freeze
+        MSG = 'Put `%<mixin>s` mixins in %<suffix>s.'
 
-        def on_send(node)
-          return unless node.macro? && MIXIN_METHODS.include?(node.method_name)
+        def on_class(node)
+          begin_node = node.child_nodes.find(&:begin_type?) || node
+          begin_node.each_child_node(:send).select(&:macro?).each do |macro|
+            next unless MIXIN_METHODS.include?(macro.method_name)
 
-          check(node)
+            check(macro)
+          end
         end
 
+        alias on_module on_class
+
         def autocorrect(node)
+          range = node.loc.expression
           if separated_style?
-            range = node.loc.expression
             correction = separate_mixins(node)
           else
             mixins = sibling_mixins(node)
-            mixins.unshift(node)
-
-            range = node.loc.expression.join(mixins.last.loc.expression)
-            correction = group_mixins(node, mixins)
+            if node == mixins.first
+              correction = group_mixins(node, mixins)
+            else
+              range = range_to_remove_for_subsequent_mixin(mixins, node)
+              correction = ''
+            end
           end
 
           ->(corrector) { corrector.replace(range, correction) }
@@ -63,6 +66,18 @@ module RuboCop
 
         private
 
+        def range_to_remove_for_subsequent_mixin(mixins, node)
+          range = node.loc.expression
+          prev_mixin = mixins.each_cons(2) { |m, n| break m if n == node }
+          between = prev_mixin.loc.expression.end
+                              .join(range.begin)
+          # if separated from previous mixin with only whitespace?
+          unless /\S/.match?(between.source)
+            range = range.join(between) # then remove that too
+          end
+          range
+        end
+
         def check(send_node)
           if separated_style?
             check_separated_style(send_node)
@@ -72,7 +87,7 @@ module RuboCop
         end
 
         def check_grouped_style(send_node)
-          return if sibling_mixins(send_node).empty?
+          return if sibling_mixins(send_node).size == 1
 
           add_offense(send_node)
         end
@@ -85,10 +100,10 @@ module RuboCop
 
         def sibling_mixins(send_node)
           siblings = send_node.parent.each_child_node(:send)
-                              .reject { |sibling| sibling == send_node }
+                              .select(&:macro?)
 
           siblings.select do |sibling_node|
-            sibling_node.method_name == send_node.method_name
+            sibling_node.method?(send_node.method_name)
           end
         end
 
@@ -96,7 +111,7 @@ module RuboCop
           suffix =
             separated_style? ? 'separate statements' : 'a single statement'
 
-          format(MSG, send_node.method_name, suffix)
+          format(MSG, mixin: send_node.method_name, suffix: suffix)
         end
 
         def grouped_style?
@@ -108,22 +123,20 @@ module RuboCop
         end
 
         def separate_mixins(node)
-          _receiver, mixin, *args = *node
-          args.reverse!
-          first_mixin = String.new("#{mixin} #{args.first.source}")
+          arguments = node.arguments.reverse
+          mixins = ["#{node.method_name} #{arguments.first.source}"]
 
-          args[1..-1].inject(first_mixin) do |replacement, arg|
-            replacement << "\n#{indent(node)}#{mixin} #{arg.source}"
-          end
+          arguments[1..-1].inject(mixins) do |replacement, arg|
+            replacement << "#{indent(node)}#{node.method_name} #{arg.source}"
+          end.join("\n")
         end
 
         def group_mixins(node, mixins)
-          _receiver, mixin, *_args = *node
-          all_mixin_arguments = mixins.reverse.flat_map do |m|
-            m.arguments.map(&:source)
+          mixin_names = mixins.reverse.flat_map do |mixin|
+            mixin.arguments.map(&:source)
           end
 
-          "#{mixin} #{all_mixin_arguments.join(', ')}"
+          "#{node.method_name} #{mixin_names.join(', ')}"
         end
 
         def indent(node)

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

@@ -3,11 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks that `include`, `extend` and `prepend` exists at
-      # the top level.
-      # Using these at the top level affects the behavior of `Object`.
-      # There will not be using `include`, `extend` and `prepend` at
-      # the top level. Let's use it inside `class` or `module`.
+      # This cop checks that `include`, `extend` and `prepend` statements appear
+      # inside classes and modules, not at the top level, so as to not affect
+      # the behavior of `Object`.
       #
       # @example
       #   # bad
@@ -44,27 +42,46 @@ module RuboCop
       #   end
       class MixinUsage < Cop
         MSG = '`%<statement>s` is used at the top level. Use inside `class` ' \
-              'or `module`.'.freeze
+              'or `module`.'
 
-        def_node_matcher :include_statement, <<-PATTERN
+        def_node_matcher :include_statement, <<~PATTERN
           (send nil? ${:include :extend :prepend}
-            (const nil? _))
+            const)
+        PATTERN
+
+        def_node_matcher :wrapped_macro_scope?, <<~PATTERN
+          {({sclass class module block} ... ({begin if} ...))}
         PATTERN
 
         def on_send(node)
-          return unless (statement = include_statement(node))
-          return unless top_level_node?(node)
+          include_statement(node) do |statement|
+            return if node.argument? ||
+                      accepted_include?(node) ||
+                      belongs_to_class_or_module?(node)
 
-          add_offense(node, message: format(MSG, statement: statement))
+            add_offense(node, message: format(MSG, statement: statement))
+          end
         end
 
         private
 
-        def top_level_node?(node)
-          if node.parent.parent.nil?
-            node.sibling_index.zero?
+        def accepted_include?(node)
+          node.parent && (node.macro? || ascend_macro_scope?(node.parent))
+        end
+
+        def ascend_macro_scope?(ancestor)
+          return true if wrapped_macro_scope?(ancestor)
+
+          ancestor.parent && ascend_macro_scope?(ancestor.parent)
+        end
+
+        def belongs_to_class_or_module?(node)
+          if !node.parent
+            false
           else
-            top_level_node?(node.parent)
+            return true if node.parent.class_type? || node.parent.module_type?
+
+            belongs_to_class_or_module?(node.parent)
           end
         end
       end

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

@@ -3,63 +3,145 @@
 module RuboCop
   module Cop
     module Style
-      # This cops checks for use of `extend self` or `module_function` in a
+      # This cop checks for use of `extend self` or `module_function` in a
       # module.
       #
-      # Supported styles are: module_function, extend_self.
+      # Supported styles are: module_function, extend_self, forbidden.
       #
-      # @example
+      # @example EnforcedStyle: module_function (default)
+      #   # bad
+      #   module Test
+      #     extend self
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   module Test
+      #     module_function
+      #     # ...
+      #   end
+      #
+      # In case there are private methods, the cop won't be activated.
+      # Otherwise, it forces to change the flow of the default code.
+      #
+      # @example EnforcedStyle: module_function (default)
+      #   # good
+      #   module Test
+      #     extend self
+      #     # ...
+      #     private
+      #     # ...
+      #   end
       #
-      #   # Good if EnforcedStyle is module_function
+      # @example EnforcedStyle: extend_self
+      #   # bad
       #   module Test
       #     module_function
-      #     ...
+      #     # ...
       #   end
       #
-      #   # Good if EnforcedStyle is extend_self
+      #   # good
       #   module Test
       #     extend self
-      #     ...
+      #     # ...
+      #   end
+      #
+      # The option `forbidden` prohibits the usage of both styles.
+      #
+      # @example EnforcedStyle: forbidden
+      #   # bad
+      #   module Test
+      #     module_function
+      #     # ...
       #   end
       #
-      # These offenses are not auto-corrected since there are different
+      #   # bad
+      #   module Test
+      #     extend self
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   module Test
+      #     extend self
+      #     # ...
+      #     private
+      #     # ...
+      #   end
+      #
+      # These offenses are not safe to auto-correct since there are different
       # implications to each approach.
       class ModuleFunction < Cop
         include ConfigurableEnforcedStyle
 
         MODULE_FUNCTION_MSG =
-          'Use `module_function` instead of `extend self`.'.freeze
+          'Use `module_function` instead of `extend self`.'
         EXTEND_SELF_MSG =
-          'Use `extend self` instead of `module_function`.'.freeze
+          'Use `extend self` instead of `module_function`.'
+        FORBIDDEN_MSG =
+          'Do not use `module_function` or `extend self`.'
 
         def_node_matcher :module_function_node?, '(send nil? :module_function)'
         def_node_matcher :extend_self_node?, '(send nil? :extend self)'
+        def_node_matcher :private_directive?, '(send nil? :private ...)'
 
         def on_module(node)
-          _name, body = *node
-          return unless body && body.begin_type?
+          return unless node.body&.begin_type?
 
-          each_wrong_style(body.children) do |child_node|
+          each_wrong_style(node.body.children) do |child_node|
             add_offense(child_node)
           end
         end
 
+        def autocorrect(node)
+          return if style == :forbidden
+
+          lambda do |corrector|
+            if extend_self_node?(node)
+              corrector.replace(node, 'module_function')
+            else
+              corrector.replace(node, 'extend self')
+            end
+          end
+        end
+
         private
 
-        def each_wrong_style(nodes)
+        def each_wrong_style(nodes, &block)
           case style
           when :module_function
-            nodes.each do |node|
-              yield node if extend_self_node?(node)
-            end
+            check_module_function(nodes, &block)
           when :extend_self
-            nodes.each do |node|
-              yield node if module_function_node?(node)
-            end
+            check_extend_self(nodes, &block)
+          when :forbidden
+            check_forbidden(nodes, &block)
+          end
+        end
+
+        def check_module_function(nodes)
+          private_directive = nodes.any? { |node| private_directive?(node) }
+
+          nodes.each do |node|
+            yield node if extend_self_node?(node) && !private_directive
+          end
+        end
+
+        def check_extend_self(nodes)
+          nodes.each do |node|
+            yield node if module_function_node?(node)
+          end
+        end
+
+        def check_forbidden(nodes)
+          nodes.each do |node|
+            yield node if extend_self_node?(node)
+            yield node if module_function_node?(node)
           end
         end
 
         def message(_node)
+          return FORBIDDEN_MSG if style == :forbidden
+
           style == :module_function ? MODULE_FUNCTION_MSG : EXTEND_SELF_MSG
         end
       end

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

@@ -8,19 +8,30 @@ module RuboCop
       #
       # @example
       #
-      #   Thread.list.find_all do |t|
+      #   # bad
+      #   Thread.list.select do |t|
       #     t.alive?
       #   end.map do |t|
       #     t.object_id
       #   end
+      #
+      #   # good
+      #   alive_threads = Thread.list.select do |t|
+      #     t.alive?
+      #   end
+      #   alive_threads.map do |t|
+      #     t.object_id
+      #   end
       class MultilineBlockChain < Cop
-        MSG = 'Avoid multi-line chains of blocks.'.freeze
+        include RangeHelp
+
+        MSG = 'Avoid multi-line chains of blocks.'
 
         def on_block(node)
           node.send_node.each_node(:send) do |send_node|
             receiver = send_node.receiver
 
-            next unless receiver && receiver.block_type? && receiver.multiline?
+            next unless receiver&.block_type? && receiver&.multiline?
 
             range = range_between(receiver.loc.end.begin_pos,
                                   node.send_node.source_range.end_pos)