rubocop 0.67.2 → 0.68.0

data/lib/rubocop/cop/mixin/{array_hash_indentation.rb → multiline_element_indentation.rb}

@@ -2,8 +2,9 @@
 
 module RuboCop
   module Cop
-    # Common code for indenting literal arrays and hashes.
-    module ArrayHashIndentation
+    # Common code for indenting the first elements in multiline
+    # array literals, hash literals, and method definitions.
+    module MultilineElementIndentation
       private
 
       def each_argument_node(node, type)

data/lib/rubocop/cop/mixin/too_many_lines.rb

@@ -24,15 +24,11 @@ module RuboCop
 
       def extract_body(node)
         case node.type
-        when :block, :def
-          _receiver_or_method, _args, body = *node
-        when :defs
-          _self, _method, _args, body = *node
+        when :block, :def, :defs
+          node.body
         else
-          body = node
+          node
         end
-
-        body
       end
     end
   end

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -24,6 +24,13 @@ module RuboCop
       #     # do something
       #   end
       #
+      #   # good
+      #   begin
+      #     # do something
+      #   rescue MyException => _e
+      #     # do something
+      #   end
+      #
       # @example PreferredName: exception
       #   # bad
       #   begin
@@ -39,6 +46,13 @@ module RuboCop
       #     # do something
       #   end
       #
+      #   # good
+      #   begin
+      #     # do something
+      #   rescue MyException => _exception
+      #     # do something
+      #   end
+      #
       class RescuedExceptionsVariableName < Cop
         MSG = 'Use `%<preferred>s` instead of `%<bad>s`.'.freeze
 
@@ -50,21 +64,36 @@ module RuboCop
           return if @exception_name.const_type? ||
                     variable_name == preferred_name
 
-          add_offense(node, location: location)
+          add_offense(node, location: offense_range(node))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(offense_range(node), preferred_name)
+          end
         end
 
         private
 
+        def offense_range(resbody)
+          variable = resbody.exception_variable
+          variable.loc.expression
+        end
+
         def preferred_name
-          @preferred_name ||= cop_config.fetch('PreferredName', 'e')
+          @preferred_name ||= begin
+            name = cop_config.fetch('PreferredName', 'e')
+            name = "_#{name}" if variable_name.to_s.start_with?('_')
+            name
+          end
         end
 
         def variable_name
-          @variable_name ||= location.source
+          location.source
         end
 
         def location
-          @location ||= @exception_name.loc.expression
+          @exception_name.loc.expression
         end
 
         def message(_node = nil)

data/lib/rubocop/cop/rails/active_record_override.rb

@@ -29,25 +29,26 @@ module RuboCop
           'Use %<prefer>s callbacks instead of overriding the Active Record ' \
           'method `%<bad>s`.'.freeze
         BAD_METHODS = %i[create destroy save update].freeze
+        ACTIVE_RECORD_CLASSES = %w[ApplicationRecord ActiveModel::Base
+                                   ActiveRecord::Base].freeze
 
         def on_def(node)
-          method_name = node.method_name
           return unless BAD_METHODS.include?(node.method_name)
 
-          parent_parts = node.parent.node_parts
-          parent_class = parent_parts.take_while do |part|
-            !part.nil? && part.const_type?
-          end.last
-          return unless %w[ApplicationRecord ActiveModel::Base]
-                        .include?(parent_class.const_name)
+          parent_class_name = find_parent_class_name(node)
+          return unless active_model?(parent_class_name)
 
           return unless node.descendants.any?(&:zsuper_type?)
 
-          add_offense(node, message: message(method_name))
+          add_offense(node, message: message(node.method_name))
         end
 
         private
 
+        def active_model?(parent_class_name)
+          ACTIVE_RECORD_CLASSES.include?(parent_class_name)
+        end
+
         def callback_names(method_name)
           names = %w[before_ around_ after_].map do |prefix|
             "`#{prefix}#{method_name}`"
@@ -61,6 +62,20 @@ module RuboCop
         def message(method_name)
           format(MSG, prefer: callback_names(method_name), bad: method_name)
         end
+
+        def find_parent_class_name(node)
+          return nil unless node
+
+          if node.class_type?
+            parent_class_name = node.node_parts[1]
+
+            return nil if parent_class_name.nil?
+
+            return parent_class_name.source
+          end
+
+          find_parent_class_name(node.parent)
+        end
       end
     end
   end

data/lib/rubocop/cop/rails/delegate.rb

@@ -68,11 +68,10 @@ module RuboCop
         end
 
         def autocorrect(node)
-          method_name, _args, body = *node
-          delegation = ["delegate :#{body.method_name}",
-                        "to: :#{body.receiver.method_name}"]
+          delegation = ["delegate :#{node.body.method_name}",
+                        "to: :#{node.body.receiver.method_name}"]
 
-          if method_name == prefixed_method_name(body)
+          if node.method_name == prefixed_method_name(node.body)
             delegation << ['prefix: true']
           end
 
@@ -84,11 +83,9 @@ module RuboCop
         private
 
         def trivial_delegate?(def_node)
-          method_name, args, body = *def_node
-
           delegate?(def_node) &&
-            method_name_matches?(method_name, body) &&
-            arguments_match?(args, body)
+            method_name_matches?(def_node.method_name, def_node.body) &&
+            arguments_match?(def_node.arguments, def_node.body)
         end
 
         def arguments_match?(arg_array, body)

data/lib/rubocop/cop/rails/environment_comparison.rb

@@ -56,10 +56,12 @@ module RuboCop
         private
 
         def replacement(node)
-          receiver, _, compared = *node
-          environment, = *compared
-          "#{receiver.source}.#{environment}?"
+          "#{node.receiver.source}.#{content(node.first_argument)}?"
         end
+
+        def_node_matcher :content, <<-PATTERN
+          ({str sym} $_)
+        PATTERN
       end
     end
   end

data/lib/rubocop/cop/rails/find_each.rb

@@ -39,7 +39,7 @@ module RuboCop
         private
 
         def method_chain(node)
-          [*node.descendants.select(&:send_type?), node].map(&:method_name)
+          node.each_node(:send).map(&:method_name)
         end
 
         def ignored_by_find_each?(relation_method)

data/lib/rubocop/cop/rails/redundant_allow_nil.rb

@@ -79,10 +79,10 @@ module RuboCop
           node.each_descendant do |descendant|
             next unless descendant.pair_type?
 
-            key = descendant.children.first.value
+            key = descendant.children.first.source
 
-            allow_nil = descendant if key == :allow_nil
-            allow_blank = descendant if key == :allow_blank
+            allow_nil = descendant if key == 'allow_nil'
+            allow_blank = descendant if key == 'allow_blank'
 
             break if allow_nil && allow_blank
           end

data/lib/rubocop/cop/rails/reflection_class_name.rb

@@ -21,7 +21,7 @@ module RuboCop
         PATTERN
 
         def_node_search :reflection_class_name, <<-PATTERN
-          (pair (sym :class_name) [!str !sym])
+          (pair (sym :class_name) [!dstr !str !sym])
         PATTERN
 
         def on_send(node)

data/lib/rubocop/cop/rails/skips_model_validations.rb

@@ -56,13 +56,7 @@ module RuboCop
         def on_send(node)
           return if whitelist.include?(node.method_name.to_s)
           return unless blacklist.include?(node.method_name.to_s)
-
-          _receiver, method_name, *args = *node
-
-          if METHODS_WITH_ARGUMENTS.include?(method_name.to_s) && args.empty?
-            return
-          end
-
+          return if allowed_method?(node)
           return if good_touch?(node)
 
           add_offense(node, location: :selector)
@@ -75,6 +69,11 @@ module RuboCop
           format(MSG, method: node.method_name)
         end
 
+        def allowed_method?(node)
+          METHODS_WITH_ARGUMENTS.include?(node.method_name.to_s) &&
+            !node.arguments?
+        end
+
         def blacklist
           cop_config['Blacklist'] || []
         end

data/lib/rubocop/cop/rails/time_zone.rb

@@ -128,17 +128,12 @@ module RuboCop
         def extract_method_chain(node)
           chain = []
           while !node.nil? && node.send_type?
-            chain << extract_method(node) if method_from_time_class?(node)
+            chain << node.method_name if method_from_time_class?(node)
             node = node.parent
           end
           chain
         end
 
-        def extract_method(node)
-          _receiver, method_name, *_args = *node
-          method_name
-        end
-
         # Only add the method to the chain if the method being
         # called is part of the time class.
         def method_from_time_class?(node)
@@ -155,9 +150,7 @@ module RuboCop
         def method_send?(node)
           return false unless node.parent && node.parent.send_type?
 
-          receiver, _method_name, *_args = *node.parent
-
-          receiver == node
+          node.parent.receiver == node
         end
 
         def safe_method(method_name, node)
@@ -174,7 +167,7 @@ module RuboCop
           selector_node = node
 
           while node && node.send_type?
-            break if extract_method(node) == :localtime
+            break if node.method_name == :localtime
 
             node = node.parent
           end

data/lib/rubocop/cop/rails/validation.rb

@@ -15,6 +15,7 @@ module RuboCop
       #   validates_length_of :foo
       #   validates_numericality_of :foo
       #   validates_presence_of :foo
+      #   validates_absence_of :foo
       #   validates_size_of :foo
       #   validates_uniqueness_of :foo
       #
@@ -27,6 +28,7 @@ module RuboCop
       #   validates :foo, length: true
       #   validates :foo, numericality: true
       #   validates :foo, presence: true
+      #   validates :foo, absence: true
       #   validates :foo, size: true
       #   validates :foo, uniqueness: true
       #
@@ -43,6 +45,7 @@ module RuboCop
           length
           numericality
           presence
+          absence
           size
           uniqueness
         ].freeze

data/lib/rubocop/cop/registry.rb

@@ -65,17 +65,17 @@ module RuboCop
       #
       #   cops = RuboCop::Cop::Cop.all
       #   cops.
-      #     qualified_cop_name('Layout/IndentArray') # => 'Layout/IndentArray'
+      #     qualified_cop_name('Layout/EndOfLine') # => 'Layout/EndOfLine'
       #
       # @example fixes incorrect namespaces
       #
       #   cops = RuboCop::Cop::Cop.all
-      #   cops.qualified_cop_name('Lint/IndentArray') # => 'Layout/IndentArray'
+      #   cops.qualified_cop_name('Lint/EndOfLine') # => 'Layout/EndOfLine'
       #
       # @example namespaces bare cop identifiers
       #
       #   cops = RuboCop::Cop::Cop.all
-      #   cops.qualified_cop_name('IndentArray') # => 'Layout/IndentArray'
+      #   cops.qualified_cop_name('EndOfLine') # => 'Layout/EndOfLine'
       #
       # @example passes back unrecognized cop names
       #

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

@@ -114,27 +114,33 @@ module RuboCop
         def correct_alias_method_to_alias(send_node)
           lambda do |corrector|
             new, old = *send_node.arguments
-            replacement = "alias #{new.children.first} #{old.children.first}"
+            replacement = "alias #{identifier(new)} #{identifier(old)}"
             corrector.replace(send_node.source_range, replacement)
           end
         end
 
         def correct_alias_to_alias_method(node)
           lambda do |corrector|
-            new, old = *node
-            replacement = "alias_method :#{new.children.first}, " \
-                          ":#{old.children.first}"
+            replacement =
+              'alias_method ' \
+              ":#{identifier(node.new_identifier)}, " \
+              ":#{identifier(node.old_identifier)}"
             corrector.replace(node.source_range, replacement)
           end
         end
 
         def correct_alias_with_symbol_args(node)
           lambda do |corrector|
-            new, old = *node
-            corrector.replace(new.source_range, new.children.first.to_s)
-            corrector.replace(old.source_range, old.children.first.to_s)
+            corrector.replace(node.new_identifier.source_range,
+                              node.new_identifier.source[1..-1])
+            corrector.replace(node.old_identifier.source_range,
+                              node.old_identifier.source[1..-1])
           end
         end
+
+        def_node_matcher :identifier, <<-PATTERN
+          (sym $_)
+        PATTERN
       end
     end
   end

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

@@ -95,10 +95,24 @@ module RuboCop
       #     word.flip.flop
       #   }.join("-")
       #
+      # @example EnforcedStyle: always_braces
+      #   # bad
+      #   words.each do |word|
+      #     word.flip.flop
+      #   end
+      #
+      #   # good
+      #   words.each { |word|
+      #     word.flip.flop
+      #   }
+      #
       class BlockDelimiters < Cop
         include ConfigurableEnforcedStyle
         include IgnoredMethods
 
+        ALWAYS_BRACES_MESSAGE = 'Prefer `{...}` over `do...end` for blocks.'
+                                .freeze
+
         def on_send(node)
           return unless node.arguments?
           return if node.parenthesized? || node.operator_method?
@@ -166,6 +180,7 @@ module RuboCop
           when :line_count_based    then line_count_based_message(node)
           when :semantic            then semantic_message(node)
           when :braces_for_chaining then braces_for_chaining_message(node)
+          when :always_braces       then ALWAYS_BRACES_MESSAGE
           end
         end
 
@@ -229,6 +244,7 @@ module RuboCop
           when :line_count_based    then line_count_based_block_style?(node)
           when :semantic            then semantic_block_style?(node)
           when :braces_for_chaining then braces_for_chaining_style?(node)
+          when :always_braces       then braces_style?(node)
           end
         end
 
@@ -257,6 +273,10 @@ module RuboCop
                          end
         end
 
+        def braces_style?(node)
+          node.loc.begin.source == '{'
+        end
+
         def return_value_chaining?(node)
           node.parent && node.parent.send_type? && node.parent.dot?
         end

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

@@ -31,36 +31,30 @@ module RuboCop
                       'nested style.'.freeze
 
         def on_class(node)
-          _name, superclass, body = *node
-          return if superclass && style != :nested
+          return if node.parent_class && style != :nested
 
-          check_style(node, body)
+          check_style(node, node.body)
         end
 
         def on_module(node)
-          _name, body = *node
-          check_style(node, body)
+          check_style(node, node.body)
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            if node.class_type?
-              name, superclass, body = *node
-              return if superclass && style != :nested
-            else
-              name, body = *node
-            end
-            nest_or_compact(corrector, node, name, body)
+            return if node.class_type? && node.parent_class && style != :nested
+
+            nest_or_compact(corrector, node)
           end
         end
 
         private
 
-        def nest_or_compact(corrector, node, name, body)
+        def nest_or_compact(corrector, node)
           if style == :nested
             nest_definition(corrector, node)
           else
-            compact_definition(corrector, node, name, body)
+            compact_definition(corrector, node)
           end
         end
 
@@ -91,19 +85,23 @@ module RuboCop
           corrector.replace(node.loc.end, replacement)
         end
 
-        def compact_definition(corrector, node, name, body)
-          compact_node(corrector, node, name, body)
-          remove_end(corrector, body)
+        def compact_definition(corrector, node)
+          compact_node(corrector, node)
+          remove_end(corrector, node.body)
         end
 
-        def compact_node(corrector, node, name, body)
-          const_name = "#{name.const_name}::#{body.children.first.const_name}"
-          replacement = "#{body.type} #{const_name}"
+        def compact_node(corrector, node)
+          replacement = "#{node.body.type} #{compact_identifier_name(node)}"
           range = range_between(node.loc.keyword.begin_pos,
-                                body.loc.name.end_pos)
+                                node.body.loc.name.end_pos)
           corrector.replace(range, replacement)
         end
 
+        def compact_identifier_name(node)
+          "#{node.identifier.const_name}::" \
+            "#{node.body.children.first.const_name}"
+        end
+
         def remove_end(corrector, body)
           range = range_between(
             body.loc.end.begin_pos - leading_spaces(body).size,