rubocop 1.31.0 → 1.32.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,50 +78,79 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless node.parent&.if_type?
+          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 ignored with `IgnoredMethods`. By default,
+      # there are no methods to ignored.
       #
       # @safety
       #   Autocorrection is unsafe because it is not guaranteed that the
@@ -45,6 +46,11 @@ module RuboCop
       #   foo.try { |i| Float(i) }
       #   bar.send { |i| Complex(i) }
       #
+      # @example IgnoredMethods: [] (default)
+      #
+      #   # bad
+      #   10.minutes.to_i
+      #
       # @example IgnoredMethods: [minutes]
       #
       #   # good

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/block_length.rb

@@ -15,6 +15,7 @@ module RuboCop
       #
       # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
       # for backwards compatibility. Please use `IgnoredMethods` instead.
+      # By default, there are no methods to ignored.
       #
       # @example CountAsOne: ['array', 'heredoc']
       #

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

@@ -13,6 +13,7 @@ module RuboCop
       #
       # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
       # for backwards compatibility. Please use `IgnoredMethods` instead.
+      # By default, there are no methods to ignored.
       #
       # @example CountAsOne: ['array', 'heredoc']
       #

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/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/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,11 +47,12 @@ 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)
-        if pair && key_and_value_begin_on_same_line?(pair) && pair.right_sibling
+        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]
         end
 
@@ -62,23 +63,20 @@ 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)
         same_line?(pair.key, pair.value)
       end
 
+      def right_sibling_begins_on_subsequent_line?(pair)
+        pair.right_sibling && (pair.last_line < pair.right_sibling.first_line)
+      end
+
       def detected_styles(actual_column, offset, left_parenthesis, left_brace)
         base_column = actual_column - configured_indentation_width - offset
         detected_styles_for_column(base_column, left_parenthesis, left_brace)

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

@@ -44,13 +44,26 @@ module RuboCop
         no_acceptable_style! if brackets_required
 
         bracketed_array = build_bracketed_array(node)
-        message = format(self.class::ARRAY_MSG, prefer: bracketed_array)
+        message = build_message_for_bracketed_array(bracketed_array)
 
         add_offense(node, message: message) do |corrector|
           corrector.replace(node, bracketed_array)
         end
       end
 
+      # @param [String] preferred_array_code
+      # @return [String]
+      def build_message_for_bracketed_array(preferred_array_code)
+        format(
+          self.class::ARRAY_MSG,
+          prefer: if preferred_array_code.include?("\n")
+                    'an array literal `[...]`'
+                  else
+                    "`#{preferred_array_code}`"
+                  end
+        )
+      end
+
       def check_bracketed_array(node, literal_prefix)
         return if allowed_bracket_array?(node)
 
@@ -63,6 +76,52 @@ module RuboCop
           percent_literal_corrector.correct(corrector, node, literal_prefix)
         end
       end
+
+      # @param [RuboCop::AST::ArrayNode] node
+      # @param [Array<String>] elements
+      # @return [String]
+      def build_bracketed_array_with_appropriate_whitespace(elements:, node:)
+        [
+          '[',
+          whitespace_leading(node),
+          elements.join(",#{whitespace_between(node)}"),
+          whitespace_trailing(node),
+          ']'
+        ].join
+      end
+
+      # Provides whitespace between elements for building a bracketed array.
+      #   %w[  a   b   c    ]
+      #         ^^^
+      # @param [RuboCop::AST::ArrayNode] node
+      # @return [String]
+      def whitespace_between(node)
+        if node.children.length >= 2
+          node.source[
+            node.children[0].loc.expression.end_pos...node.children[1].loc.expression.begin_pos
+          ]
+        else
+          ' '
+        end
+      end
+
+      # Provides leading whitespace for building a bracketed array.
+      #   %w[  a   b   c    ]
+      #      ^^
+      # @param [RuboCop::AST::ArrayNode] node
+      # @return [String]
+      def whitespace_leading(node)
+        node.source[node.loc.begin.end_pos...node.children[0].loc.expression.begin_pos]
+      end
+
+      # Provides trailing whitespace for building a bracketed array.
+      #   %w[  a   b   c    ]
+      #                 ^^^^
+      # @param [RuboCop::AST::ArrayNode] node
+      # @return [String]
+      def whitespace_trailing(node)
+        node.source[node.children[-1].loc.expression.end_pos...node.loc.end.begin_pos]
+      end
     end
   end
 end

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

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     module Naming
       # Makes sure that predicates are named properly.
+      # `is_a?` method is allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @example
       #   # bad
@@ -27,6 +29,12 @@ module RuboCop
       #   # good
       #   def value?
       #   end
+      #
+      # @example AllowedMethods: ['is_a?'] (default)
+      #   # good
+      #   def is_a?(value)
+      #   end
+      #
       class PredicateName < Base
         include AllowedMethods
 

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

@@ -5,6 +5,8 @@ module RuboCop
     module Style
       # Enforces the use of `Object#instance_of?` instead of class comparison
       # for equality.
+      # `==`, `equal?`, and `eql?` methods are ignored by default.
+      # These are customizable with `IgnoredMethods` option.
       #
       # @example
       #   # bad
@@ -16,6 +18,26 @@ module RuboCop
       #   # good
       #   var.instance_of?(Date)
       #
+      # @example IgnoreMethods: [] (default)
+      #   # good
+      #   var.instance_of?(Date)
+      #
+      #   # bad
+      #   var.class == Date
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #   var.class.name == 'Date'
+      #
+      # @example IgnoreMethods: [`==`]
+      #   # good
+      #   var.instance_of?(Date)
+      #   var.class == Date
+      #   var.class.name == 'Date'
+      #
+      #   # bad
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #
       class ClassEqualityComparison < Base
         include RangeHelp
         include IgnoredMethods

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

@@ -89,6 +89,41 @@ module RuboCop
       #   if condition
       #     statement
       #   end
+      #
+      # @example AllowComments: false (default)
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #     # something comment
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #     # something comment
+      #   end
+      #
+      # @example AllowComments: true
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     # something comment
+      #     nil
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     # something comment
+      #   end
+      #
       class EmptyElse < Base
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
@@ -108,6 +143,8 @@ module RuboCop
         private
 
         def check(node)
+          return if cop_config['AllowComments'] && comment_in_else?(node.loc)
+
           empty_check(node) if empty_style?
           nil_check(node) if nil_style?
         end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for using empty heredoc to reduce redundancy.
+      #
+      # @example
+      #
+      #   # bad
+      #   <<~EOS
+      #   EOS
+      #
+      #   <<-EOS
+      #   EOS
+      #
+      #   <<EOS
+      #   EOS
+      #
+      #   # good
+      #   ''
+      #
+      #   # bad
+      #   do_something(<<~EOS)
+      #   EOS
+      #
+      #   do_something(<<-EOS)
+      #   EOS
+      #
+      #   do_something(<<EOS)
+      #   EOS
+      #
+      #   # good
+      #   do_something('')
+      #
+      class EmptyHeredoc < Base
+        include Heredoc
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use an empty string literal instead of heredoc.'
+
+        def on_heredoc(node)
+          heredoc_body = node.loc.heredoc_body
+
+          return unless heredoc_body.source.empty?
+
+          add_offense(node) do |corrector|
+            heredoc_end = node.loc.heredoc_end
+
+            corrector.replace(node, "''")
+            corrector.remove(range_by_whole_lines(heredoc_body, include_final_newline: true))
+            corrector.remove(range_by_whole_lines(heredoc_end, include_final_newline: true))
+          end
+        end
+      end
+    end
+  end
+end