rubocop 1.31.1 → 1.33.0

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

@@ -25,30 +25,37 @@ module RuboCop
       #   to be strictly equivalent to that before the replacement.
       #
       # @example
-      #   # bad
-      #   unless FileTest.exist?(path)
-      #     FileUtils.makedirs(path)
+      #   # bad - race condition with another process may result in an error in `mkdir`
+      #   unless Dir.exist?(path)
+      #     FileUtils.mkdir(path)
       #   end
       #
-      #   if FileTest.exist?(path)
+      #   # good - atomic and idempotent creation
+      #   FileUtils.mkdir_p(path)
+      #
+      #   # bad - race condition with another process may result in an error in `remove`
+      #   if File.exist?(path)
       #     FileUtils.remove(path)
       #   end
       #
-      #   # good
-      #   FileUtils.mkdir_p(path)
-      #
-      #   FileUtils.rm_rf(path)
+      #   # good - atomic and idempotent removal
+      #   FileUtils.rm_f(path)
       #
       class NonAtomicFileOperation < Base
         extend AutoCorrector
         include Alignment
         include RangeHelp
 
-        MSG = 'Remove unnecessary existence checks `%<receiver>s.%<method_name>s`.'
-        MAKE_METHODS = %i[makedirs mkdir mkdir_p mkpath].freeze
-        REMOVE_METHODS = %i[remove remove_dir remove_entry remove_entry_secure delete unlink
-                            remove_file rm rm_f rm_r rm_rf rmdir rmtree safe_unlink].freeze
-        RESTRICT_ON_SEND = (MAKE_METHODS + REMOVE_METHODS).freeze
+        MSG_REMOVE_FILE_EXIST_CHECK = 'Remove unnecessary existence check ' \
+                                      '`%<receiver>s.%<method_name>s`.'
+        MSG_CHANGE_FORCE_METHOD = 'Use atomic file operation method `FileUtils.%<method_name>s`.'
+        MAKE_FORCE_METHODS = %i[makedirs mkdir_p mkpath].freeze
+        MAKE_METHODS = %i[mkdir].freeze
+        REMOVE_FORCE_METHODS = %i[rm_f rm_rf].freeze
+        REMOVE_METHODS = %i[remove remove_dir remove_entry remove_entry_secure
+                            delete unlink remove_file rm rmdir safe_unlink].freeze
+        RESTRICT_ON_SEND = (MAKE_METHODS + MAKE_FORCE_METHODS + REMOVE_METHODS +
+          REMOVE_FORCE_METHODS).freeze
 
         # @!method send_exist_node(node)
         def_node_search :send_exist_node, <<-PATTERN
@@ -71,51 +78,79 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless node.parent&.if_type?
-          return if node.parent.else_branch
+          return unless if_node_child?(node)
           return if explicit_not_force?(node)
           return unless (exist_node = send_exist_node(node.parent).first)
           return unless exist_node.first_argument == node.first_argument
 
-          offense(node, exist_node)
+          register_offense(node, exist_node)
         end
 
         private
 
-        def offense(node, exist_node)
+        def if_node_child?(node)
+          return false unless (parent = node.parent)
+
+          parent.if_type? && !allowable_use_with_if?(parent)
+        end
+
+        def allowable_use_with_if?(if_node)
+          if_node.condition.and_type? || if_node.condition.or_type? || if_node.else_branch
+        end
+
+        def register_offense(node, exist_node)
+          unless force_method?(node)
+            add_offense(node,
+                        message: format(MSG_CHANGE_FORCE_METHOD,
+                                        method_name: replacement_method(node)))
+          end
+
           range = range_between(node.parent.loc.keyword.begin_pos,
                                 exist_node.loc.expression.end_pos)
-
-          add_offense(range, message: message(exist_node)) do |corrector|
+          add_offense(range, message: message_remove_file_exist_check(exist_node)) do |corrector|
             autocorrect(corrector, node, range)
           end
         end
 
-        def message(node)
+        def message_remove_file_exist_check(node)
           receiver, method_name = receiver_and_method_name(node)
-          format(MSG, receiver: receiver, method_name: method_name)
+          format(MSG_REMOVE_FILE_EXIST_CHECK, receiver: receiver, method_name: method_name)
         end
 
         def autocorrect(corrector, node, range)
           corrector.remove(range)
+          autocorrect_replace_method(corrector, node)
+          corrector.remove(node.parent.loc.end) if node.parent.multiline?
+        end
+
+        def autocorrect_replace_method(corrector, node)
+          return if force_method?(node)
+
           corrector.replace(node.child_nodes.first.loc.name, 'FileUtils')
           corrector.replace(node.loc.selector, replacement_method(node))
-          corrector.remove(node.parent.loc.end) if node.parent.multiline?
         end
 
         def replacement_method(node)
-          return node.method_name if force_option?(node)
-
           if MAKE_METHODS.include?(node.method_name)
             'mkdir_p'
           elsif REMOVE_METHODS.include?(node.method_name)
-            'rm_rf'
+            'rm_f'
+          else
+            node.method_name
           end
         end
 
+        def force_method?(node)
+          force_method_name?(node) || force_option?(node)
+        end
+
         def force_option?(node)
           node.arguments.any? { |arg| force?(arg) }
         end
+
+        def force_method_name?(node)
+          (MAKE_FORCE_METHODS + REMOVE_FORCE_METHODS).include?(node.method_name)
+        end
       end
     end
   end

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

@@ -16,7 +16,8 @@ module RuboCop
       # NOTE: Some values cannot be converted properly using one of the `Kernel`
       # method (for instance, `Time` and `DateTime` values are allowed by this
       # cop by default). Similarly, Rails' duration methods do not work well
-      # with `Integer()` and can be ignored with `IgnoredMethods`.
+      # with `Integer()` and can be allowed with `AllowedMethods`. By default,
+      # there are no methods to allowed.
       #
       # @safety
       #   Autocorrection is unsafe because it is not guaranteed that the
@@ -45,7 +46,22 @@ module RuboCop
       #   foo.try { |i| Float(i) }
       #   bar.send { |i| Complex(i) }
       #
-      # @example IgnoredMethods: [minutes]
+      # @example AllowedMethods: [] (default)
+      #
+      #   # bad
+      #   10.minutes.to_i
+      #
+      # @example AllowedMethods: [minutes]
+      #
+      #   # good
+      #   10.minutes.to_i
+      #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   10.minutes.to_i
+      #
+      # @example AllowedPatterns: [/min*/]
       #
       #   # good
       #   10.minutes.to_i
@@ -56,7 +72,8 @@ module RuboCop
       #   Time.now.to_datetime.to_i
       class NumberConversion < Base
         extend AutoCorrector
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
 
         CONVERSION_METHOD_CLASS_MAPPING = {
           to_i: "#{Integer.name}(%<number_object>s, 10)",
@@ -91,7 +108,7 @@ module RuboCop
 
         def handle_conversion_method(node)
           to_method(node) do |receiver, to_method|
-            next if receiver.nil? || ignore_receiver?(receiver)
+            next if receiver.nil? || allow_receiver?(receiver)
 
             message = format(
               MSG,
@@ -135,9 +152,10 @@ module RuboCop
           corrector.remove(node.loc.end)
         end
 
-        def ignore_receiver?(receiver)
+        def allow_receiver?(receiver)
           if receiver.numeric_type? || (receiver.send_type? &&
-            (conversion_method?(receiver.method_name) || ignored_method?(receiver.method_name)))
+            (conversion_method?(receiver.method_name) ||
+            allowed_method_name?(receiver.method_name)))
             true
           elsif (receiver = top_receiver(receiver))
             receiver.const_type? && ignored_class?(receiver.const_name)
@@ -146,6 +164,10 @@ module RuboCop
           end
         end
 
+        def allowed_method_name?(name)
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
         def top_receiver(node)
           receiver = node
           receiver = receiver.receiver until receiver.receiver.nil?

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

@@ -35,6 +35,13 @@ module RuboCop
       #   # good - without `&.` this will always return `true`
       #   foo&.respond_to?(:to_a)
       #
+      # @example AllowedMethods: [foo?]
+      #   # bad
+      #   do_something if attrs&.foo?(:[])
+      #
+      #   # good
+      #   do_something if attrs&.bar?(:[])
+      #
       class RedundantSafeNavigation < Base
         include AllowedMethods
         include RangeHelp

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks that a range literal is enclosed in parentheses when the end of the range is
+      # at a line break.
+      #
+      # NOTE: The following is maybe intended for `(42..)`. But, compatible is `42..do_something`.
+      # So, this cop does not provide autocorrection because it is left to user.
+      #
+      # [source,ruby]
+      # ----
+      # case condition
+      # when 42..
+      #   do_something
+      # end
+      # ----
+      #
+      # @example
+      #
+      #   # bad - Represents `(1..42)`, not endless range.
+      #   1..
+      #   42
+      #
+      #   # good - It's incompatible, but your intentions when using endless range may be:
+      #   (1..)
+      #   42
+      #
+      #   # good
+      #   1..42
+      #
+      #   # good
+      #   (1..42)
+      #
+      #   # good
+      #   (1..
+      #   42)
+      #
+      class RequireRangeParentheses < Base
+        MSG = 'Wrap the endless range literal `%<range>s` to avoid precedence ambiguity.'
+
+        def on_irange(node)
+          return if node.parent&.begin_type?
+          return unless node.begin && node.end
+          return if same_line?(node.begin, node.end)
+
+          message = format(MSG, range: "#{node.begin.source}#{node.loc.operator.source}")
+
+          add_offense(node, message: message)
+        end
+
+        alias on_erange on_irange
+      end
+    end
+  end
+end

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

@@ -25,6 +25,7 @@ module RuboCop
       #   x&.foo || bar
       class SafeNavigationChain < Base
         include NilMethods
+        extend AutoCorrector
         extend TargetRubyVersion
 
         minimum_target_ruby_version 2.3
@@ -48,12 +49,45 @@ module RuboCop
               Parser::Source::Range.new(node.source_range.source_buffer,
                                         safe_nav.source_range.end_pos,
                                         method_chain.source_range.end_pos)
-            add_offense(location)
+            add_offense(location) do |corrector|
+              autocorrect(corrector, offense_range: location, send_node: method_chain)
+            end
           end
         end
 
         private
 
+        # @param [Parser::Source::Range] offense_range
+        # @param [RuboCop::AST::SendNode] send_node
+        # @return [String]
+        def add_safe_navigation_operator(offense_range:, send_node:)
+          source = \
+            if send_node.method?(:[]) || send_node.method?(:[]=)
+              format(
+                '%<method_name>s(%<arguments>s)',
+                arguments: send_node.arguments.map(&:source).join(', '),
+                method_name: send_node.method_name
+              )
+            else
+              offense_range.source.dup
+            end
+          source.prepend('.') unless send_node.dot?
+          source.prepend('&')
+        end
+
+        # @param [RuboCop::Cop::Corrector] corrector
+        # @param [Parser::Source::Range] offense_range
+        # @param [RuboCop::AST::SendNode] send_node
+        def autocorrect(corrector, offense_range:, send_node:)
+          corrector.replace(
+            offense_range,
+            add_safe_navigation_operator(
+              offense_range: offense_range,
+              send_node: send_node
+            )
+          )
+        end
+
         def method_chain(node)
           chain = node
           chain = chain.parent if chain.send_type? && chain.parent&.call_type?

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

@@ -33,7 +33,9 @@ module RuboCop
       #      render 'pages/search/page'
       #    end
       #
-      # This cop also takes into account `IgnoredMethods` (defaults to `[]`)
+      # This cop also takes into account `AllowedMethods` (defaults to `[]`)
+      # And `AllowedPatterns` (defaults to `[]`)
+      #
       class AbcSize < Base
         include MethodComplexity
 

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

@@ -14,7 +14,8 @@ module RuboCop
       #
       #
       # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
-      # for backwards compatibility. Please use `IgnoredMethods` instead.
+      # for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns`
+      # instead. By default, there are no methods to allowed.
       #
       # @example CountAsOne: ['array', 'heredoc']
       #
@@ -37,14 +38,13 @@ module RuboCop
       # NOTE: This cop does not apply for `Struct` definitions.
       class BlockLength < Base
         include CodeLength
-        include IgnoredMethods
-
-        ignored_methods deprecated_key: 'ExcludedMethods'
+        include AllowedMethods
+        include AllowedPattern
 
         LABEL = 'Block'
 
         def on_block(node)
-          return if ignored_method?(node.method_name)
+          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
           return if method_receiver_excluded?(node)
           return if node.class_constructor? || node.struct_constructor?
 
@@ -58,7 +58,7 @@ module RuboCop
           node_receiver = node.receiver&.source&.gsub(/\s+/, '')
           node_method = String(node.method_name)
 
-          ignored_methods.any? do |config|
+          allowed_methods.any? do |config|
             next unless config.is_a?(String)
 
             receiver, method = config.split('.')

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

@@ -4,15 +4,17 @@ module RuboCop
   module Cop
     module Metrics
       # Checks if the length of a method exceeds some maximum value.
-      # Comment lines can optionally be ignored.
+      # Comment lines can optionally be allowed.
       # The maximum allowed length is configurable.
       #
       # You can set literals you want to fold with `CountAsOne`.
       # Available are: 'array', 'hash', and 'heredoc'. Each literal
       # will be counted as one line regardless of its actual size.
       #
-      # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
-      # for backwards compatibility. Please use `IgnoredMethods` instead.
+      # NOTE: The `ExcludedMethods` and `IgnoredMethods` configuration is
+      # deprecated and only kept for backwards compatibility.
+      # Please use `AllowedMethods` and `AllowedPatterns` instead.
+      # By default, there are no methods to allowed.
       #
       # @example CountAsOne: ['array', 'heredoc']
       #
@@ -34,14 +36,13 @@ module RuboCop
       #
       class MethodLength < Base
         include CodeLength
-        include IgnoredMethods
-
-        ignored_methods deprecated_key: 'ExcludedMethods'
+        include AllowedMethods
+        include AllowedPattern
 
         LABEL = 'Method'
 
         def on_def(node)
-          return if ignored_method?(node.method_name)
+          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
 
           check_code_length(node)
         end

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

@@ -12,10 +12,24 @@ module RuboCop
         allowed_methods.include?(name.to_s)
       end
 
+      # @deprecated Use allowed_method? instead
+      alias ignored_method? allowed_method?
+
       # @api public
       def allowed_methods
-        cop_config.fetch('AllowedMethods', [])
+        deprecated_values = cop_config_deprecated_values
+        if deprecated_values.any?(Regexp)
+          cop_config.fetch('AllowedMethods', [])
+        else
+          Array(cop_config['AllowedMethods']).concat(deprecated_values)
+        end
+      end
+
+      def cop_config_deprecated_values
+        Array(cop_config['IgnoredMethods']).concat(Array(cop_config['ExcludedMethods']))
       end
     end
+    # @deprecated IgnoredMethods class has been replaced with AllowedMethods.
+    IgnoredMethods = AllowedMethods
   end
 end

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

@@ -30,7 +30,15 @@ module RuboCop
       def allowed_patterns
         # Since there could be a pattern specified in the default config, merge the two
         # arrays together.
-        Array(cop_config['AllowedPatterns']).concat(Array(cop_config['IgnoredPatterns']))
+        patterns = Array(cop_config['AllowedPatterns']).concat(Array(cop_config['IgnoredPatterns']))
+        deprecated_values = cop_config_deprecated_methods_values
+        return patterns unless deprecated_values.any?(Regexp)
+
+        Array(patterns.concat(deprecated_values))
+      end
+
+      def cop_config_deprecated_methods_values
+        Array(cop_config['IgnoredMethods']).concat(Array(cop_config['ExcludedMethods']))
       end
     end
 

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

@@ -46,6 +46,8 @@ module RuboCop
         if node.send_type?
           args = process_args(node.arguments)
           return extract_breakable_node_from_elements(node, args, max)
+        elsif node.def_type?
+          return extract_breakable_node_from_elements(node, node.arguments, max)
         elsif node.array_type? || node.hash_type?
           return extract_breakable_node_from_elements(node, node.children, max)
         end
@@ -216,6 +218,8 @@ module RuboCop
 
       # @api private
       def already_on_multiple_lines?(node)
+        return node.first_line != node.arguments.last.last_line if node.def_type?
+
         node.first_line != node.last_line
       end
     end

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

@@ -12,10 +12,14 @@ module RuboCop
       end
 
       def contains_comments?(node)
+        comments_in_range(node).any?
+      end
+
+      def comments_in_range(node)
         start_line = node.source_range.line
         end_line = find_end_line(node)
 
-        processed_source.each_comment_in_lines(start_line...end_line).any?
+        processed_source.each_comment_in_lines(start_line...end_line)
       end
 
       private

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

@@ -5,8 +5,7 @@ module RuboCop
     # Common functionality for checking def nodes.
     module DefNode
       extend NodePattern::Macros
-
-      NON_PUBLIC_MODIFIERS = %w[private protected].freeze
+      include VisibilityHelp
 
       private
 
@@ -15,11 +14,7 @@ module RuboCop
       end
 
       def preceding_non_public_modifier?(node)
-        stripped_source_upto(node.first_line).any? { |line| NON_PUBLIC_MODIFIERS.include?(line) }
-      end
-
-      def stripped_source_upto(index)
-        processed_source[0..index].map(&:strip)
+        node_visibility(node) != :public
       end
 
       # @!method non_public_modifier?(node)

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

@@ -6,21 +6,16 @@ module RuboCop
     #
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
-      include IgnoredMethods
+      include AllowedMethods
+      include AllowedPattern
       include Metrics::Utils::RepeatedCsendDiscount
       extend NodePattern::Macros
       extend ExcludeLimit
 
       exclude_limit 'Max'
 
-      # Ensure cops that include `MethodComplexity` have the config
-      # `attr_accessor`s that `ignored_method?` needs.
-      def self.included(base)
-        base.extend(IgnoredMethods::Config)
-      end
-
       def on_def(node)
-        return if ignored_method?(node.method_name)
+        return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
 
         check_complexity(node, node.method_name)
       end
@@ -28,7 +23,7 @@ module RuboCop
 
       def on_block(node)
         define_method?(node) do |name|
-          return if ignored_method?(name)
+          return if allowed_method?(name) || matches_allowed_pattern?(name)
 
           check_complexity(node, name)
         end

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

@@ -26,7 +26,7 @@ module RuboCop
       def check_first(first, left_brace, left_parenthesis, offset)
         actual_column = first.source_range.column
 
-        indent_base_column, indent_base_type = indent_base(left_brace, left_parenthesis)
+        indent_base_column, indent_base_type = indent_base(left_brace, first, left_parenthesis)
         expected_column = indent_base_column + configured_indentation_width + offset
 
         @column_delta = expected_column - actual_column
@@ -47,10 +47,10 @@ module RuboCop
         end
       end
 
-      def indent_base(left_brace, left_parenthesis)
+      def indent_base(left_brace, first, left_parenthesis)
         return [left_brace.column, :left_brace_or_bracket] if style == brace_alignment_style
 
-        pair = hash_pair_where_value_beginning_with(left_brace)
+        pair = hash_pair_where_value_beginning_with(left_brace, first)
         if pair && key_and_value_begin_on_same_line?(pair) &&
            right_sibling_begins_on_subsequent_line?(pair)
           return [pair.loc.column, :parent_hash_key]
@@ -63,17 +63,10 @@ module RuboCop
         [left_brace.source_line =~ /\S/, :start_of_line]
       end
 
-      def hash_pair_where_value_beginning_with(left_brace)
-        node = node_beginning_with(left_brace)
-        node.parent&.pair_type? ? node.parent : nil
-      end
+      def hash_pair_where_value_beginning_with(left_brace, first)
+        return unless first && first.parent.loc.begin == left_brace
 
-      def node_beginning_with(left_brace)
-        processed_source.ast.each_descendant do |node|
-          if node.loc.is_a?(Parser::Source::Map::Collection) && (node.loc.begin == left_brace)
-            break node
-          end
-        end
+        first.parent&.parent&.pair_type? ? first.parent.parent : nil
       end
 
       def key_and_value_begin_on_same_line?(pair)