rubocop 0.78.0 → 1.13.0

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

@@ -93,15 +93,13 @@ module RuboCop
       #   else
       #     # the content of `else` branch will be determined by Style/EmptyElse
       #   end
-      class MissingElse < Cop
+      class MissingElse < Base
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
 
         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.'
+        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?
@@ -121,28 +119,18 @@ module RuboCop
         def check(node)
           return if node.else?
 
-          if empty_else_cop_enabled?
-            if empty_else_style == :empty
-              add_offense(node)
-            elsif empty_else_style == :nil
-              add_offense(node)
-            end
-          end
-
-          add_offense(node)
+          add_offense(node, message: format(message_template, type: node.type))
         end
 
-        def message(node)
-          template = case empty_else_style
-                     when :empty
-                       MSG_NIL
-                     when :nil
-                       MSG_EMPTY
-                     else
-                       MSG
-                     end
-
-          format(template, type: node.type)
+        def message_template
+          case empty_else_style
+          when :empty
+            MSG_NIL
+          when :nil
+            MSG_EMPTY
+          else
+            MSG
+          end
         end
 
         def if_style?

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

@@ -21,9 +21,8 @@ module RuboCop
       #     # ...
       #   end
       #
-      class MissingRespondToMissing < Cop
-        MSG =
-          'When using `method_missing`, define `respond_to_missing?`.'
+      class MissingRespondToMissing < Base
+        MSG = 'When using `method_missing`, define `respond_to_missing?`.'
 
         def on_def(node)
           return unless node.method?(:method_missing)
@@ -36,9 +35,16 @@ module RuboCop
         private
 
         def implements_respond_to_missing?(node)
-          node.parent.each_child_node(node.type).any? do |sibling|
-            sibling.method?(:respond_to_missing?)
+          return false unless (grand_parent = node.parent.parent)
+
+          grand_parent.each_descendant(node.type) do |descendant|
+            return true if descendant.method?(:respond_to_missing?)
+
+            child = descendant.children.first
+            return true if child.respond_to?(:method?) && child.method?(:respond_to_missing?)
           end
+
+          false
         end
       end
     end

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

@@ -30,8 +30,9 @@ module RuboCop
       #   class Foo
       #     extend Qox, Bar
       #   end
-      class MixinGrouping < Cop
+      class MixinGrouping < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MIXIN_METHODS = %i[extend include prepend].freeze
         MSG = 'Put `%<mixin>s` mixins in %<suffix>s.'
@@ -47,32 +48,14 @@ module RuboCop
 
         alias on_module on_class
 
-        def autocorrect(node)
-          range = node.loc.expression
-          if separated_style?
-            correction = separate_mixins(node)
-          else
-            mixins = sibling_mixins(node)
-            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) }
-        end
-
         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)
+          between = prev_mixin.loc.expression.end.join(range.begin)
           # if separated from previous mixin with only whitespace?
-          if between.source !~ /\S/
+          unless /\S/.match?(between.source)
             range = range.join(between) # then remove that too
           end
           range
@@ -89,29 +72,39 @@ module RuboCop
         def check_grouped_style(send_node)
           return if sibling_mixins(send_node).size == 1
 
-          add_offense(send_node)
+          message = format(MSG, mixin: send_node.method_name, suffix: 'a single statement')
+
+          add_offense(send_node, message: message) do |corrector|
+            range = send_node.loc.expression
+            mixins = sibling_mixins(send_node)
+            if send_node == mixins.first
+              correction = group_mixins(send_node, mixins)
+            else
+              range = range_to_remove_for_subsequent_mixin(mixins, send_node)
+              correction = ''
+            end
+
+            corrector.replace(range, correction)
+          end
         end
 
         def check_separated_style(send_node)
           return if send_node.arguments.one?
 
-          add_offense(send_node)
-        end
+          message = format(MSG, mixin: send_node.method_name, suffix: 'separate statements')
 
-        def sibling_mixins(send_node)
-          siblings = send_node.parent.each_child_node(:send)
-                              .select(&:macro?)
+          add_offense(send_node, message: message) do |corrector|
+            range = send_node.loc.expression
+            correction = separate_mixins(send_node)
 
-          siblings.select do |sibling_node|
-            sibling_node.method?(send_node.method_name)
+            corrector.replace(range, correction)
           end
         end
 
-        def message(send_node)
-          suffix =
-            separated_style? ? 'separate statements' : 'a single statement'
+        def sibling_mixins(send_node)
+          siblings = send_node.parent.each_child_node(:send).select(&:macro?)
 
-          format(MSG, mixin: send_node.method_name, suffix: suffix)
+          siblings.select { |sibling_node| sibling_node.method?(send_node.method_name) }
         end
 
         def grouped_style?
@@ -132,16 +125,10 @@ module RuboCop
         end
 
         def group_mixins(node, mixins)
-          mixin_names = mixins.reverse.flat_map do |mixin|
-            mixin.arguments.map(&:source)
-          end
+          mixin_names = mixins.reverse.flat_map { |mixin| mixin.arguments.map(&:source) }
 
           "#{node.method_name} #{mixin_names.join(', ')}"
         end
-
-        def indent(node)
-          ' ' * node.loc.column
-        end
       end
     end
   end

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

@@ -40,50 +40,32 @@ module RuboCop
       #   class C
       #     prepend M
       #   end
-      class MixinUsage < Cop
-        MSG = '`%<statement>s` is used at the top level. Use inside `class` ' \
-              'or `module`.'
+      class MixinUsage < Base
+        MSG = '`%<statement>s` is used at the top level. Use inside `class` or `module`.'
+        RESTRICT_ON_SEND = %i[include extend prepend].freeze
 
+        # @!method include_statement(node)
         def_node_matcher :include_statement, <<~PATTERN
           (send nil? ${:include :extend :prepend}
             const)
         PATTERN
 
-        def_node_matcher :wrapped_macro_scope?, <<~PATTERN
-          {({sclass class module block} ... ({begin if} ...))}
+        # @!method in_top_level_scope?(node)
+        def_node_matcher :in_top_level_scope?, <<~PATTERN
+          {
+            root?                        # either at the top level
+            ^[  {kwbegin begin if def}   # or wrapped within one of these
+                #in_top_level_scope? ]   # that is in top level scope
+          }
         PATTERN
 
         def on_send(node)
           include_statement(node) do |statement|
-            return if node.argument? ||
-                      accepted_include?(node) ||
-                      belongs_to_class_or_module?(node)
+            return unless in_top_level_scope?(node)
 
             add_offense(node, message: format(MSG, statement: statement))
           end
         end
-
-        private
-
-        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
-            return true if node.parent.class_type? || node.parent.module_type?
-
-            belongs_to_class_or_module?(node.parent)
-          end
-        end
       end
     end
   end

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

@@ -6,7 +6,7 @@ module RuboCop
       # 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 EnforcedStyle: module_function (default)
       #   # bad
@@ -46,56 +46,101 @@ module RuboCop
       #     # ...
       #   end
       #
+      # The option `forbidden` prohibits the usage of both styles.
+      #
+      # @example EnforcedStyle: forbidden
+      #   # bad
+      #   module Test
+      #     module_function
+      #     # ...
+      #   end
+      #
+      #   # 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
+      class ModuleFunction < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
-        MODULE_FUNCTION_MSG =
-          'Use `module_function` instead of `extend self`.'
-        EXTEND_SELF_MSG =
-          'Use `extend self` instead of `module_function`.'
+        MODULE_FUNCTION_MSG = 'Use `module_function` instead of `extend self`.'
+        EXTEND_SELF_MSG = 'Use `extend self` instead of `module_function`.'
+        FORBIDDEN_MSG = 'Do not use `module_function` or `extend self`.'
 
+        # @!method module_function_node?(node)
         def_node_matcher :module_function_node?, '(send nil? :module_function)'
+
+        # @!method extend_self_node?(node)
         def_node_matcher :extend_self_node?, '(send nil? :extend self)'
+
+        # @!method private_directive?(node)
         def_node_matcher :private_directive?, '(send nil? :private ...)'
 
         def on_module(node)
           return unless node.body&.begin_type?
 
           each_wrong_style(node.body.children) do |child_node|
-            add_offense(child_node)
-          end
-        end
+            add_offense(child_node) do |corrector|
+              next if style == :forbidden
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if extend_self_node?(node)
-              corrector.replace(node.source_range, 'module_function')
-            else
-              corrector.replace(node.source_range, 'extend self')
+              if extend_self_node?(child_node)
+                corrector.replace(child_node, 'module_function')
+              else
+                corrector.replace(child_node, 'extend self')
+              end
             end
           end
         end
 
         private
 
-        def each_wrong_style(nodes)
+        def each_wrong_style(nodes, &block)
           case style
           when :module_function
-            private_directive = nodes.any? { |node| private_directive?(node) }
-
-            nodes.each do |node|
-              yield node if extend_self_node?(node) && !private_directive
-            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 message(_node)
+        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(_range)
+          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,12 +8,21 @@ 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
-      class MultilineBlockChain < Cop
+      #
+      #   # good
+      #   alive_threads = Thread.list.select do |t|
+      #     t.alive?
+      #   end
+      #   alive_threads.map do |t|
+      #     t.object_id
+      #   end
+      class MultilineBlockChain < Base
         include RangeHelp
 
         MSG = 'Avoid multi-line chains of blocks.'
@@ -24,10 +33,9 @@ module RuboCop
 
             next unless receiver&.block_type? && receiver&.multiline?
 
-            range = range_between(receiver.loc.end.begin_pos,
-                                  node.send_node.source_range.end_pos)
+            range = range_between(receiver.loc.end.begin_pos, node.send_node.source_range.end_pos)
 
-            add_offense(nil, location: range)
+            add_offense(range)
 
             # Done. If there are more blocks in the chain, they will be
             # found by subsequent calls to on_block.

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

@@ -14,9 +14,10 @@ module RuboCop
       #
       #   # good
       #   { result: 'ok' } if cond
-      class MultilineIfModifier < Cop
+      class MultilineIfModifier < Base
         include StatementModifier
         include Alignment
+        extend AutoCorrector
 
         MSG = 'Favor a normal %<keyword>s-statement over a modifier' \
               ' clause in a multiline statement.'
@@ -24,21 +25,13 @@ module RuboCop
         def on_if(node)
           return unless node.modifier_form? && node.body.multiline?
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, to_normal_if(node))
+          add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|
+            corrector.replace(node, to_normal_if(node))
           end
         end
 
         private
 
-        def message(node)
-          format(MSG, keyword: node.keyword)
-        end
-
         def to_normal_if(node)
           indented_body = indented_body(node.body, node)
           condition = "#{node.keyword} #{node.condition.source}"