rubocop 0.65.0 → 0.66.0

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

@@ -36,11 +36,19 @@ module RuboCop
           check_each_arg(arguments)
         end
 
-        def autocorrect(range)
+        # @param target [RuboCop::AST::Node,Parser::Source::Range]
+        def autocorrect(target)
           lambda do |corrector|
-            case range.source
-            when /^\s+$/ then corrector.remove(range)
-            else              corrector.insert_after(range, ' ')
+            if target.is_a?(RuboCop::AST::Node)
+              if target.parent.children.first == target
+                corrector.insert_before(target.source_range, ' ')
+              else
+                corrector.insert_after(target.source_range, ' ')
+              end
+            elsif target.source =~ /^\s+$/
+              corrector.remove(target)
+            else
+              corrector.insert_after(target, ' ')
             end
           end
         end
@@ -97,11 +105,12 @@ module RuboCop
         end
 
         def check_opening_pipe_space(args, opening_pipe)
-          first = args.first.source_range
+          first_arg = args.first
+          range = first_arg.source_range
 
-          check_space(opening_pipe.end_pos, first.begin_pos, first,
-                      'before first block parameter')
-          check_no_space(opening_pipe.end_pos, first.begin_pos - 1,
+          check_space(opening_pipe.end_pos, range.begin_pos, range,
+                      'before first block parameter', first_arg)
+          check_no_space(opening_pipe.end_pos, range.begin_pos - 1,
                          'Extra space before first')
         end
 
@@ -120,20 +129,27 @@ module RuboCop
         end
 
         def check_each_arg(args)
-          args.children.butfirst.each do |arg|
-            expr = arg.source_range
-            check_no_space(
-              range_with_surrounding_space(range: expr, side: :left).begin_pos,
-              expr.begin_pos - 1,
-              'Extra space before'
-            )
+          args.children.each do |arg|
+            check_arg(arg)
           end
         end
 
-        def check_space(space_begin_pos, space_end_pos, range, msg)
+        def check_arg(arg)
+          arg.children.each { |a| check_arg(a) } if arg.mlhs_type?
+
+          expr = arg.source_range
+          check_no_space(
+            range_with_surrounding_space(range: expr, side: :left).begin_pos,
+            expr.begin_pos - 1,
+            'Extra space before'
+          )
+        end
+
+        def check_space(space_begin_pos, space_end_pos, range, msg, node = nil)
           return if space_begin_pos != space_end_pos
 
-          add_offense(range, location: range, message: "Space #{msg} missing.")
+          target = node || range
+          add_offense(target, location: range, message: "Space #{msg} missing.")
         end
 
         def check_no_space(space_begin_pos, space_end_pos, msg)

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

@@ -10,12 +10,16 @@ module RuboCop
       #   # bad
       #
       #   File.exists?(some_path)
+      #   Dir.exists?(some_path)
+      #   iterator?
       #
       # @example
       #
       #   # good
       #
       #   File.exist?(some_path)
+      #   Dir.exist?(some_path)
+      #   block_given?
       class DeprecatedClassMethods < Cop
         # Inner class to DeprecatedClassMethods.
         # This class exists to add abstraction and clean naming to the
@@ -25,24 +29,35 @@ module RuboCop
 
           attr_reader :class_constant, :deprecated_method, :replacement_method
 
-          def initialize(class_constant, deprecated_method, replacement_method)
+          def initialize(deprecated:, replacement:, class_constant: nil)
+            @deprecated_method = deprecated
+            @replacement_method = replacement
             @class_constant = class_constant
-            @deprecated_method = deprecated_method
-            @replacement_method = replacement_method
           end
 
           def class_nodes
-            @class_nodes ||= [
-              s(:const, nil, class_constant),
-              s(:const, s(:cbase), class_constant)
-            ]
+            @class_nodes ||=
+              if class_constant
+                [
+                  s(:const, nil, class_constant),
+                  s(:const, s(:cbase), class_constant)
+                ]
+              else
+                [nil]
+              end
           end
         end
 
         MSG = '`%<current>s` is deprecated in favor of `%<prefer>s`.'.freeze
         DEPRECATED_METHODS_OBJECT = [
-          DeprecatedClassMethod.new(:File, :exists?, :exist?),
-          DeprecatedClassMethod.new(:Dir, :exists?, :exist?)
+          DeprecatedClassMethod.new(deprecated: :exists?,
+                                    replacement: :exist?,
+                                    class_constant: :File),
+          DeprecatedClassMethod.new(deprecated: :exists?,
+                                    replacement: :exist?,
+                                    class_constant: :Dir),
+          DeprecatedClassMethod.new(deprecated: :iterator?,
+                                    replacement: :block_given?)
         ].freeze
 
         def on_send(node)
@@ -83,8 +98,12 @@ module RuboCop
         end
 
         def method_call(class_constant, method)
-          format('%<constant>s.%<method>s', constant: class_constant,
-                                            method: method)
+          if class_constant
+            format('%<constant>s.%<method>s', constant: class_constant,
+                                              method: method)
+          else
+            format('%<method>s', method: method)
+          end
         end
       end
     end

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

@@ -55,6 +55,7 @@ module RuboCop
 
           first_else = else_branch.children.first
 
+          return unless first_else
           return unless first_else.source_range.line == node.loc.else.line
 
           add_offense(first_else)

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

@@ -87,7 +87,7 @@ module RuboCop
         def splat_args?(node)
           return false if percent?(node)
 
-          node.arguments.butfirst.any?(&:splat_type?)
+          node.arguments.drop(1).any?(&:splat_type?)
         end
 
         def heredoc?(node)

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks to make sure safe navigation isn't used with `empty?` in
+      # a conditional.
+      #
+      # While the safe navigation operator is generally a good idea, when
+      # checking `foo&.empty?` in a conditional, `foo` being `nil` will actually
+      # do the opposite of what the author intends.
+      #
+      # @example
+      #   # bad
+      #   return if foo&.empty?
+      #   return unless foo&.empty?
+      #
+      #   # good
+      #   return if foo && foo.empty?
+      #   return unless foo && foo.empty?
+      #
+      class SafeNavigationWithEmpty < Cop
+        MSG = 'Avoid calling `empty?` with the safe navigation operator ' \
+          'in conditionals.'.freeze
+
+        def_node_matcher :safe_navigation_empty_in_conditional?, <<-PATTERN
+          (if (csend (send ...) :empty?) ...)
+        PATTERN
+
+        def on_if(node)
+          return unless safe_navigation_empty_in_conditional?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -107,12 +107,25 @@ module RuboCop
           error && error.ancestors[1] == SystemCallError
         end
 
+        def silence_warnings
+          # Replaces Kernel::silence_warnings since it hides any warnings,
+          # including the RuboCop ones
+          old_verbose = $VERBOSE
+          $VERBOSE = nil
+          yield
+        ensure
+          $VERBOSE = old_verbose
+        end
+
         def evaluate_exceptions(rescue_group)
           if rescue_group
             rescued_exceptions = rescued_exceptions(rescue_group)
             rescued_exceptions.each_with_object([]) do |exception, converted|
               begin
-                converted << Kernel.const_get(exception)
+                silence_warnings do
+                  # Avoid printing deprecation warnings about constants
+                  converted << Kernel.const_get(exception)
+                end
               rescue NameError
                 converted << nil
               end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks to make sure `#to_json` includes an optional argument.
+      # When overriding `#to_json`, callers may invoke JSON
+      # generation via `JSON.generate(your_obj)`.  Since `JSON#generate` allows
+      # for an optional argument, your method should too.
+      #
+      # @example
+      #   # bad
+      #   def to_json
+      #   end
+      #
+      #   # good
+      #   def to_json(_opts)
+      #   end
+      #
+      class ToJSON < Cop
+        MSG = ' `#to_json` requires an optional argument to be parsable ' \
+          'via JSON.generate(obj).'.freeze
+
+        def on_def(node)
+          return unless node.method?(:to_json) && node.arguments.empty?
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.insert_after(node.loc.name, '(_opts)')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -96,7 +96,7 @@ module RuboCop
 
         def check_begin(node)
           expressions = *node
-          expressions = expressions.drop_last(1) unless in_void_context?(node)
+          expressions.pop unless in_void_context?(node)
           expressions.each do |expr|
             check_expression(expr)
           end

data/lib/rubocop/cop/message_annotator.rb

@@ -64,7 +64,7 @@ module RuboCop
       end
 
       def urls
-        [style_guide_url, reference_url].compact
+        [style_guide_url, *reference_urls].compact
       end
 
       private
@@ -89,9 +89,9 @@ module RuboCop
           !urls.empty?
       end
 
-      def reference_url
-        url = cop_config['Reference']
-        url.nil? || url.empty? ? nil : url
+      def reference_urls
+        urls = Array(cop_config['Reference'])
+        urls.nil? || urls.empty? ? nil : urls.reject(&:empty?)
       end
 
       def extra_details?

data/lib/rubocop/cop/metrics/abc_size.rb

@@ -6,6 +6,7 @@ module RuboCop
       # This cop checks that the ABC size of methods is not higher than the
       # configured maximum. The ABC size is based on assignments, branches
       # (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
+      # and https://en.wikipedia.org/wiki/ABC_Software_Metric.
       class AbcSize < Cop
         include MethodComplexity
 

data/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb

@@ -10,7 +10,7 @@ module RuboCop
         #
         # We separate the *calculator* from the *cop* so that the calculation,
         # the formula itself, is easier to test.
-        module AbcSizeCalculator
+        class AbcSizeCalculator
           # > Branch -- an explicit forward program branch out of scope -- a
           # > function call, class method call ..
           # > http://c2.com/cgi/wiki?AbcMetric
@@ -22,21 +22,43 @@ module RuboCop
           CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
 
           def self.calculate(node)
-            assignment = 0
-            branch = 0
-            condition = 0
+            new(node).calculate
+          end
+
+          def initialize(node)
+            @assignment = 0
+            @branch = 0
+            @condition = 0
+            @node = node
+          end
 
-            node.each_node do |child|
+          def calculate
+            @node.each_node do |child|
               if child.assignment?
-                assignment += 1
+                @assignment += 1
               elsif BRANCH_NODES.include?(child.type)
-                branch += 1
+                evaluate_branch_nodes(child)
               elsif CONDITION_NODES.include?(child.type)
-                condition += 1
+                @condition += 1 if node_has_else_branch?(child)
+                @condition += 1
               end
             end
 
-            Math.sqrt(assignment**2 + branch**2 + condition**2).round(2)
+            Math.sqrt(@assignment**2 + @branch**2 + @condition**2).round(2)
+          end
+
+          def evaluate_branch_nodes(node)
+            if node.comparison_method?
+              @condition += 1
+            else
+              @branch += 1
+            end
+          end
+
+          def node_has_else_branch?(node)
+            %i[case if].include?(node.type) &&
+              node.else? &&
+              node.loc.else.is?('else')
           end
         end
       end

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

@@ -30,7 +30,7 @@ module RuboCop
         #
         #   return true if ruby_version >= 3.1
         #
-        # And the above `ruby_version >= 3.1` is undecidedd whether it will be
+        # And the above `ruby_version >= 3.1` is undecided whether it will be
         # Ruby 3.1, 3.2, 4.0 or others.
         # See https://bugs.ruby-lang.org/issues/8976#note-41 for details.
         return false unless ruby_version >= 2.3

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

@@ -7,7 +7,7 @@ module RuboCop
       private
 
       def integer_part(node)
-        node.source.sub(/^[+-]/, '').split('.').first
+        node.source.sub(/^[+-]/, '').split(/[eE.]/, 2).first
       end
     end
   end

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

@@ -18,7 +18,8 @@ module RuboCop
             default = default_cop_config['PreferredMethods']
             merged = cop_config['PreferredMethods']
             overrides = merged.values - default.values
-            merged.reject { |key, _| overrides.include?(key) }.symbolize_keys
+            merged.reject { |key, _| overrides.include?(key) }
+                  .map { |k, v| [k.to_sym, v] }.to_h
           end
       end
 

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

@@ -60,9 +60,14 @@ module RuboCop
 
         def allowed_method_call_on_rhs?(node)
           node && node.send_type? &&
-            (node.receiver.nil? || !node.receiver.literal?)
+            (node.receiver.nil? || !literal_receiver?(node))
         end
 
+        def_node_matcher :literal_receiver?, <<-PATTERN
+          {(send literal? ...)
+           (send (begin literal?) ...)}
+        PATTERN
+
         def allowed_conditional_expression_on_rhs?(node)
           node && node.if_type? && contains_contant?(node)
         end

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

@@ -7,6 +7,9 @@ module RuboCop
       #
       # @example
       #   # bad
+      #   def is_even(value)
+      #   end
+      #
       #   def is_even?(value)
       #   end
       #
@@ -15,6 +18,9 @@ module RuboCop
       #   end
       #
       #   # bad
+      #   def has_value
+      #   end
+      #
       #   def has_value?
       #   end
       #