rubocop 0.67.2 → 0.68.0

data/lib/rubocop/config_loader_resolver.rb

@@ -71,9 +71,8 @@ module RuboCop
         config = handle_disabled_by_default(config, default_configuration)
       end
 
-      Config.new(merge(default_configuration, config,
-                       inherit_mode: config['inherit_mode'] || {}),
-                 config_file)
+      opts = { inherit_mode: config['inherit_mode'] || {}, unset_nil: true }
+      Config.new(merge(default_configuration, config, opts), config_file)
     end
 
     # Return a recursive merge of two hashes. That is, a normal hash merge,
@@ -85,7 +84,9 @@ module RuboCop
       result = base_hash.merge(derived_hash)
       keys_appearing_in_both = base_hash.keys & derived_hash.keys
       keys_appearing_in_both.each do |key|
-        if base_hash[key].is_a?(Hash)
+        if opts[:unset_nil] && derived_hash[key].nil?
+          result.delete(key)
+        elsif base_hash[key].is_a?(Hash)
           result[key] = merge(base_hash[key], derived_hash[key], **opts)
         elsif should_union?(base_hash, key, opts[:inherit_mode])
           result[key] = base_hash[key] | derived_hash[key]

data/lib/rubocop/cop/commissioner.rb

@@ -44,6 +44,7 @@ module RuboCop
         invoke_custom_processing(@cops, processed_source)
         invoke_custom_processing(@forces, processed_source)
         walk(processed_source.ast) unless processed_source.blank?
+        invoke_custom_post_walk_processing(@cops, processed_source)
         @cops.flat_map(&:offenses)
       end
 
@@ -89,6 +90,10 @@ module RuboCop
       # If they define the #investigate method, all input parameters passed
       # to the commissioner will be passed to the cop too in order to do
       # its own processing.
+      #
+      # These custom processors are invoked before the AST traversal,
+      # so they can build initial state that is later used by callbacks
+      # during the AST traversal.
       def invoke_custom_processing(cops_or_forces, processed_source)
         cops_or_forces.each do |cop|
           next unless cop.respond_to?(:investigate)
@@ -99,6 +104,25 @@ module RuboCop
         end
       end
 
+      # There are cops that require their own custom processing **after**
+      # the AST traversal. By performing the walk before invoking these
+      # custom processors, we allow these cops to build their own
+      # state during the primary AST traversal instead of performing their
+      # own AST traversals. Minimizing the number of walks is more efficient.
+      #
+      # If they define the #investigate_post_walk method, all input parameters
+      # passed to the commissioner will be passed to the cop too in order to do
+      # its own processing.
+      def invoke_custom_post_walk_processing(cops, processed_source)
+        cops.each do |cop|
+          next unless cop.respond_to?(:investigate_post_walk)
+
+          with_cop_error_handling(cop) do
+            cop.investigate_post_walk(processed_source)
+          end
+        end
+      end
+
       # Allow blind rescues here, since we're absorbing and packaging or
       # re-raising exceptions that can be raised from within the individual
       # cops' `#investigate` methods.

data/lib/rubocop/cop/correctors/unused_arg_corrector.rb

@@ -15,14 +15,26 @@ module RuboCop
           @processed_source = processed_source
 
           if node.blockarg_type?
+            correct_for_blockarg_type(node)
+          else
             lambda do |corrector|
-              range = range_with_surrounding_space(range: node.source_range,
-                                                   side: :left)
-              range = range_with_surrounding_comma(range, :left)
-              corrector.remove(range)
+              variable_name = if node.optarg_type?
+                                node.node_parts[0]
+                              else
+                                # Extract only a var name without splat (`*`)
+                                node.source.gsub(/\A\*+/, '')
+                              end
+              corrector.replace(node.loc.name, "_#{variable_name}")
             end
-          else
-            ->(corrector) { corrector.insert_before(node.loc.name, '_') }
+          end
+        end
+
+        def correct_for_blockarg_type(node)
+          lambda do |corrector|
+            range = range_with_surrounding_space(range: node.source_range,
+                                                 side: :left)
+            range = range_with_surrounding_comma(range, :left)
+            corrector.remove(range)
           end
         end
       end

data/lib/rubocop/cop/internal_affairs/node_destructuring.rb

@@ -3,34 +3,32 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # Checks that node destructuring is done either using the node
-      # extensions or using a splat.
+      # Checks that node destructuring is using the node extensions.
       #
       # @example Using splat expansion
       #
       #   # bad
-      #   receiver, method_name, arguments = send_node.children
-      #
-      #   # good
-      #   receiver, method_name, arguments = *send_node
-      #
-      # @example Using node extensions
+      #   _receiver, method_name, _arguments = send_node.children
       #
       #   # bad
-      #   _receiver, method_name, _arguments = send_node.children
+      #   _receiver, method_name, _arguments = *send_node
       #
       #   # good
       #   method_name = send_node.method_name
       class NodeDestructuring < Cop
-        MSG = 'Use the methods provided with the node extensions or ' \
-              'destructure the node using `*`.'.freeze
+        MSG = 'Use the methods provided with the node extensions instead ' \
+              'of manually destructuring nodes.'.freeze
+
+        def_node_matcher :node_variable?, <<-PATTERN
+          {(lvar [#node_suffix? _]) (send nil? [#node_suffix? _])}
+        PATTERN
 
-        def_node_matcher :node_children_destructuring?, <<-PATTERN
-          (masgn (mlhs ...) (send (send nil? [#node_suffix? _]) :children))
+        def_node_matcher :node_destructuring?, <<-PATTERN
+          {(masgn (mlhs ...) {(send #node_variable? :children) (array (splat #node_variable?))})}
         PATTERN
 
         def on_masgn(node)
-          node_children_destructuring?(node) do
+          node_destructuring?(node) do
             add_offense(node)
           end
         end

data/lib/rubocop/cop/layout/access_modifier_indentation.rb

@@ -3,8 +3,9 @@
 module RuboCop
   module Cop
     module Layout
-      # Modifiers should be indented as deep as method definitions, or as deep
-      # as the class/module keyword, depending on configuration.
+      # Bare access modifiers (those not applying to specific methods) should be
+      # indented as deep as method definitions, or as deep as the class/module
+      # keyword, depending on configuration.
       #
       # @example EnforcedStyle: indent (default)
       #   # bad
@@ -39,23 +40,13 @@ module RuboCop
         MSG = '%<style>s access modifiers like `%<node>s`.'.freeze
 
         def on_class(node)
-          _name, _base_class, body = *node
-          check_body(body, node)
-        end
-
-        def on_sclass(node)
-          _name, body = *node
-          check_body(body, node)
-        end
+          return unless node.body && node.body.begin_type?
 
-        def on_module(node)
-          _name, body = *node
-          check_body(body, node)
-        end
-
-        def on_block(node)
           check_body(node.body, node)
         end
+        alias on_sclass on_class
+        alias on_module on_class
+        alias on_block  on_class
 
         def autocorrect(node)
           AlignmentCorrector.correct(processed_source, node, @column_delta)
@@ -64,10 +55,8 @@ module RuboCop
         private
 
         def check_body(body, node)
-          return if body.nil? # Empty class etc.
-          return unless body.begin_type?
-
-          modifiers = body.each_child_node(:send).select(&:access_modifier?)
+          modifiers = body.each_child_node(:send)
+                          .select(&:bare_access_modifier?)
           end_range = node.loc.end
 
           modifiers.each { |modifier| check_modifier(modifier, end_range) }

data/lib/rubocop/cop/layout/align_arguments.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Here we check if the arguments on a multi-line method
+      # definition are aligned.
+      #
+      # @example EnforcedStyle: with_first_argument (default)
+      #   # good
+      #
+      #   foo :bar,
+      #       :baz
+      #
+      #   foo(
+      #     :bar,
+      #     :baz
+      #   )
+      #
+      #   # bad
+      #
+      #   foo :bar,
+      #     :baz
+      #
+      #   foo(
+      #     :bar,
+      #       :baz
+      #   )
+      #
+      # @example EnforcedStyle: with_fixed_indentation
+      #   # good
+      #
+      #   foo :bar,
+      #     :baz
+      #
+      #   # bad
+      #
+      #   foo :bar,
+      #       :baz
+      class AlignArguments < Cop
+        include Alignment
+
+        ALIGN_PARAMS_MSG = 'Align the arguments of a method call if ' \
+          'they span more than one line.'.freeze
+
+        FIXED_INDENT_MSG = 'Use one level of indentation for arguments ' \
+          'following the first line of a multi-line method call.'.freeze
+
+        def on_send(node)
+          return if node.arguments.size < 2 ||
+                    node.send_type? && node.method?(:[]=)
+
+          check_alignment(node.arguments, base_column(node, node.arguments))
+        end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, column_delta)
+        end
+
+        private
+
+        def message(_node)
+          fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
+        end
+
+        def fixed_indentation?
+          cop_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def base_column(node, args)
+          if fixed_indentation?
+            lineno = target_method_lineno(node)
+            line = node.source_range.source_buffer.source_line(lineno)
+            indentation_of_line = /\S.*/.match(line).begin(0)
+            indentation_of_line + configured_indentation_width
+          else
+            display_column(args.first.source_range)
+          end
+        end
+
+        def target_method_lineno(node)
+          if node.loc.selector
+            node.loc.selector.line
+          else
+            # l.(1) has no selector, so we use the opening parenthesis instead
+            node.loc.begin.line
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/align_parameters.rb

@@ -6,45 +6,83 @@ module RuboCop
       # Here we check if the parameters on a multi-line method call or
       # definition are aligned.
       #
+      # To set the alignment of the first argument, use the cop
+      # FirstParameterIndentation.
+      #
       # @example EnforcedStyle: with_first_parameter (default)
       #   # good
       #
-      #   foo :bar,
-      #       :baz
+      #   def foo(bar,
+      #           baz)
+      #     123
+      #   end
+      #
+      #   def foo(
+      #     bar,
+      #     baz
+      #   )
+      #     123
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo(bar,
+      #        baz)
+      #     123
+      #   end
       #
       #   # bad
       #
-      #   foo :bar,
-      #     :baz
+      #   def foo(
+      #     bar,
+      #        baz)
+      #     123
+      #   end
       #
       # @example EnforcedStyle: with_fixed_indentation
       #   # good
       #
-      #   foo :bar,
-      #     :baz
+      #   def foo(bar,
+      #     baz)
+      #     123
+      #   end
+      #
+      #   def foo(
+      #     bar,
+      #     baz
+      #   )
+      #     123
+      #   end
       #
       #   # bad
       #
-      #   foo :bar,
-      #       :baz
+      #   def foo(bar,
+      #           baz)
+      #     123
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo(
+      #     bar,
+      #        baz)
+      #     123
+      #   end
       class AlignParameters < Cop
         include Alignment
 
-        ALIGN_PARAMS_MSG = 'Align the parameters of a method %<type>s if ' \
+        ALIGN_PARAMS_MSG = 'Align the parameters of a method definition if ' \
           'they span more than one line.'.freeze
 
         FIXED_INDENT_MSG = 'Use one level of indentation for parameters ' \
-          'following the first line of a multi-line method %<type>s.'.freeze
+          'following the first line of a multi-line method definition.'.freeze
 
-        def on_send(node)
-          return if node.arguments.size < 2 ||
-                    node.send_type? && node.method?(:[]=)
+        def on_def(node)
+          return if node.arguments.size < 2
 
           check_alignment(node.arguments, base_column(node, node.arguments))
         end
-        alias on_csend on_send
-        alias on_def  on_send
-        alias on_defs on_send
+        alias on_defs on_def
 
         def autocorrect(node)
           AlignmentCorrector.correct(processed_source, node, column_delta)
@@ -52,15 +90,8 @@ module RuboCop
 
         private
 
-        def message(node)
-          type = if node && (node.parent.send_type? || node.parent.csend_type?)
-                   'call'
-                 else
-                   'definition'
-                 end
-          msg = fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
-
-          format(msg, type: type)
+        def message(_node)
+          fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
         end
 
         def fixed_indentation?
@@ -79,14 +110,7 @@ module RuboCop
         end
 
         def target_method_lineno(node)
-          if node.def_type? || node.defs_type?
-            node.loc.keyword.line
-          elsif node.loc.selector
-            node.loc.selector.line
-          else
-            # l.(1) has no selector, so we use the opening parenthesis instead
-            node.loc.begin.line
-          end
+          node.loc.keyword.line
         end
       end
     end

data/lib/rubocop/cop/layout/class_structure.rb

@@ -223,7 +223,8 @@ module RuboCop
         end
 
         def class_elements(class_node)
-          *, class_def = class_node.children
+          class_def = class_node.body
+
           return [] unless class_def
 
           if class_def.def_type? || class_def.send_type?
@@ -240,8 +241,8 @@ module RuboCop
         end
 
         def node_visibility(node)
-          _, method_name, = *find_visibility_start(node)
-          method_name || :public
+          scope = find_visibility_start(node)
+          scope && scope.method_name || :public
         end
 
         def find_visibility_start(node)
@@ -272,9 +273,8 @@ module RuboCop
         end
 
         def humanize_node(node)
-          method_name, = *node
           if node.def_type?
-            return :initializer if method_name == :initialize
+            return :initializer if node.method?(:initialize)
 
             return "#{node_visibility(node)}_methods"
           end