rubocop 1.41.0 → 1.42.0

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of `max` or `min` instead of comparison for greater or less.
+      #
+      # NOTE: It can be used if you want to present limit or threshold in Ruby 2.7+.
+      # That it is slow though. So autocorrection will apply generic `max` or `min`:
+      #
+      # [source,ruby]
+      # ----
+      # a.clamp(b..) # Same as `[a, b].max`
+      # a.clamp(..b) # Same as `[a, b].min`
+      # ----
+      #
+      # @safety
+      #   This cop is unsafe because even if a value has `<` or `>` method,
+      #   it is not necessarily `Comparable`.
+      #
+      # @example
+      #
+      #   # bad
+      #   a > b ? a : b
+      #   a >= b ? a : b
+      #
+      #   # good
+      #   [a, b].max
+      #
+      #   # bad
+      #   a < b ? a : b
+      #   a <= b ? a : b
+      #
+      #   # good
+      #   [a, b].min
+      #
+      class MinMaxComparison < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead.'
+        GRATER_OPERATORS = %i[> >=].freeze
+        LESS_OPERATORS = %i[< <=].freeze
+        COMPARISON_OPERATORS = GRATER_OPERATORS + LESS_OPERATORS
+
+        def on_if(node)
+          lhs, operator, rhs = *node.condition
+          return unless COMPARISON_OPERATORS.include?(operator)
+
+          if_branch = node.if_branch
+          else_branch = node.else_branch
+          preferred_method = preferred_method(operator, lhs, rhs, if_branch, else_branch)
+          return unless preferred_method
+
+          replacement = "[#{lhs.source}, #{rhs.source}].#{preferred_method}"
+
+          add_offense(node, message: format(MSG, prefer: replacement)) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        private
+
+        def preferred_method(operator, lhs, rhs, if_branch, else_branch)
+          if lhs == if_branch && rhs == else_branch
+            GRATER_OPERATORS.include?(operator) ? 'max' : 'min'
+          elsif lhs == else_branch && rhs == if_branch
+            LESS_OPERATORS.include?(operator) ? 'max' : 'min'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -58,7 +58,7 @@ module RuboCop
         private
 
         def message(range)
-          format(MSG, char: range.source.chars.last)
+          format(MSG, char: range.source[-1])
         end
 
         def str_contents_range(node)
@@ -76,6 +76,7 @@ module RuboCop
           node.loc.to_hash.key?(:begin) && !node.loc.begin.nil?
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def allowed_escape?(node, range)
           escaped = range.source[(1..-1)]
 
@@ -88,13 +89,14 @@ module RuboCop
           # with different versions of Ruby so that e.g. /\d/ != /d/
           return true if /[\n\\[[:alnum:]]]/.match?(escaped[0])
 
-          return true if escaped[0] == ' ' && percent_array_literal?(node)
+          return true if escaped[0] == ' ' && (percent_array_literal?(node) || node.heredoc?)
 
           return true if disabling_interpolation?(range)
           return true if delimiter?(node, escaped[0])
 
           false
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def interpolation_not_enabled?(node)
           single_quoted?(node) ||
@@ -169,9 +171,10 @@ module RuboCop
           # Allow \#{foo}, \#$foo, \#@foo, and \#@@foo
           # for escaping local, global, instance and class variable interpolations
           return true if range.source.match?(/\A\\#[{$@]/)
-
           # Also allow #\{foo}, #\$foo, #\@foo and #\@@foo
           return true if range.adjust(begin_pos: -2).source.match?(/\A[^\\]#\\[{$@]/)
+          # For `\#\{foo} allow `\#` and warn `\{`
+          return true if range.adjust(end_pos: 1).source == '\\#\\{'
 
           false
         end

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

@@ -81,7 +81,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless node.arguments?
+          return unless node.parent && node.arguments?
           return if not_modifier_form?(node.parent)
 
           previous_older_sibling = find_previous_older_sibling(node)
@@ -102,8 +102,10 @@ module RuboCop
           node.if_type? && !node.modifier_form?
         end
 
-        def find_previous_older_sibling(node) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+        def find_previous_older_sibling(node) # rubocop:disable Metrics
           search_node(node).left_siblings.reverse.find do |sibling|
+            next unless sibling.is_a?(AST::Node)
+
             sibling = sibling_node(sibling)
             break unless sibling&.send_type? && sibling&.method?(node.method_name)
             break unless sibling.arguments? && !sibling.receiver

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

@@ -86,12 +86,12 @@ module RuboCop
 
         def on_send(node)
           return unless (block_node = node.block_node)
-          return if block_node.body.begin_type?
+          return if block_node.body&.begin_type?
           return if receiver_allowed?(block_node.receiver)
           return unless (regexp_method_send_node = extract_send_node(block_node))
           return if match_predicate_without_receiver?(regexp_method_send_node)
 
-          opposite = regexp_method_send_node.send_type? && regexp_method_send_node.method?(:!~)
+          opposite = opposite?(regexp_method_send_node)
           regexp = find_regexp(regexp_method_send_node, block_node)
 
           register_offense(node, block_node, regexp, opposite)
@@ -128,6 +128,10 @@ module RuboCop
           regexp_method_send_node
         end
 
+        def opposite?(regexp_method_send_node)
+          regexp_method_send_node.send_type? && regexp_method_send_node.method?(:!~)
+        end
+
         def find_regexp(node, block)
           return node.child_nodes.first if node.match_with_lvasgn_type?
 

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

@@ -119,11 +119,6 @@ module RuboCop
         # @!method custom_fail_methods(node)
         def_node_search :custom_fail_methods, '{(def :fail ...) (defs _ :fail ...)}'
 
-        def on_new_investigation
-          ast = processed_source.ast
-          @custom_fail_defined = ast && custom_fail_methods(ast).any?
-        end
-
         def on_rescue(node)
           return unless style == :semantic
 
@@ -141,7 +136,7 @@ module RuboCop
           when :semantic
             check_send(:raise, node) unless ignored_node?(node)
           when :only_raise
-            return if @custom_fail_defined
+            return if custom_fail_defined?
 
             check_send(:fail, node)
           when :only_fail
@@ -151,6 +146,13 @@ module RuboCop
 
         private
 
+        def custom_fail_defined?
+          return @custom_fail_defined if defined?(@custom_fail_defined)
+
+          ast = processed_source.ast
+          @custom_fail_defined = ast && custom_fail_methods(ast).any?
+        end
+
         def message(method_name)
           case style
           when :semantic

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

@@ -88,6 +88,10 @@ module RuboCop
         include TrailingComma
         extend AutoCorrector
 
+        def self.autocorrect_incompatible_with
+          [Layout::HeredocArgumentClosingParenthesis]
+        end
+
         def on_send(node)
           return unless node.arguments? && node.parenthesized?
 
@@ -96,10 +100,6 @@ module RuboCop
                 node.source_range.end_pos)
         end
         alias on_csend on_send
-
-        def self.autocorrect_incompatible_with
-          [Layout::HeredocArgumentClosingParenthesis]
-        end
       end
     end
   end

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

@@ -27,6 +27,25 @@ module RuboCop
       #   # bad (contains spaces)
       #   %w[foo\ bar baz\ quux]
       #
+      #   # bad
+      #   [
+      #     ['one', 'One'],
+      #     ['two', 'Two']
+      #   ]
+      #
+      #   # good
+      #   [
+      #     %w[one One],
+      #     %w[two Two]
+      #   ]
+      #
+      #   # good (2d array containing spaces)
+      #   [
+      #     ['one', 'One'],
+      #     ['two', 'Two'],
+      #     ['forty two', 'Forty Two']
+      #   ]
+      #
       # @example EnforcedStyle: brackets
       #   # good
       #   ['foo', 'bar', 'baz']
@@ -36,6 +55,19 @@ module RuboCop
       #
       #   # good (contains spaces)
       #   ['foo bar', 'baz quux']
+      #
+      #   # good
+      #   [
+      #     ['one', 'One'],
+      #     ['two', 'Two']
+      #   ]
+      #
+      #   # bad
+      #   [
+      #     %w[one One],
+      #     %w[two Two]
+      #   ]
+      #
       class WordArray < Base
         include ArrayMinSize
         include ArraySyntax
@@ -53,6 +85,7 @@ module RuboCop
         def on_array(node)
           if bracketed_array_of?(:str, node)
             return if complex_content?(node.values)
+            return if within_2d_array_of_complex_content?(node)
 
             check_bracketed_array(node, 'w')
           elsif node.percent_literal?(:string)
@@ -62,6 +95,14 @@ module RuboCop
 
         private
 
+        def within_2d_array_of_complex_content?(node)
+          return false unless (parent = node.parent)
+
+          parent.array_type? &&
+            parent.values.all?(&:array_type?) &&
+            parent.values.any? { |subarray| complex_content?(subarray.values) }
+        end
+
         def complex_content?(strings, complex_regex: word_regex)
           strings.any? do |s|
             next unless s.str_content

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Forbids Yoda expressions, i.e. binary operations (using `*`, `+`, `&`, `|`,
+      # and `^` operators) where the order of expression is reversed, eg. `1 + x`.
+      # This cop complements `Style/YodaCondition` cop, which has a similar purpose.
+      #
+      # @safety
+      #   This cop is unsafe because binary operators can be defined
+      #   differently on different classes, and are not guaranteed to
+      #   have the same result if reversed.
+      #
+      # @example SupportedOperators: ['*', '+', '&'']
+      #   # bad
+      #   1 + x
+      #   10 * y
+      #   1 & z
+      #
+      #   # good
+      #   60 * 24
+      #   x + 1
+      #   y * 10
+      #   z & 1
+      #
+      #   # good
+      #   1 | x
+      #
+      class YodaExpression < Base
+        extend AutoCorrector
+
+        MSG = 'Non-literal operand (`%<source>s`) should be first.'
+
+        RESTRICT_ON_SEND = %i[* + & | ^].freeze
+
+        def on_new_investigation
+          @offended_nodes = nil
+        end
+
+        def on_send(node)
+          return unless supported_operators.include?(node.method_name.to_s)
+
+          lhs = node.receiver
+          rhs = node.first_argument
+          return if !lhs.numeric_type? || rhs.numeric_type?
+
+          return if offended_ancestor?(node)
+
+          message = format(MSG, source: rhs.source)
+          add_offense(node, message: message) do |corrector|
+            corrector.swap(lhs, rhs)
+          end
+
+          offended_nodes.add(node)
+        end
+
+        private
+
+        def supported_operators
+          Array(cop_config['SupportedOperators'])
+        end
+
+        def offended_ancestor?(node)
+          node.each_ancestor(:send).any? { |ancestor| @offended_nodes&.include?(ancestor) }
+        end
+
+        def offended_nodes
+          @offended_nodes ||= Set.new.compare_by_identity
+        end
+      end
+    end
+  end
+end

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

@@ -34,43 +34,55 @@ module RuboCop
       class ZeroLengthPredicate < Base
         extend AutoCorrector
 
-        ZERO_MSG = 'Use `empty?` instead of `%<lhs>s %<opr>s %<rhs>s`.'
-        NONZERO_MSG = 'Use `!empty?` instead of `%<lhs>s %<opr>s %<rhs>s`.'
+        ZERO_MSG = 'Use `empty?` instead of `%<current>s`.'
+        NONZERO_MSG = 'Use `!empty?` instead of `%<current>s`.'
 
         RESTRICT_ON_SEND = %i[size length].freeze
 
         def on_send(node)
           check_zero_length_predicate(node)
-          check_nonzero_length_predicate(node)
+          check_zero_length_comparison(node)
+          check_nonzero_length_comparison(node)
         end
 
         private
 
         def check_zero_length_predicate(node)
-          zero_length_predicate = zero_length_predicate(node.parent)
-          return unless zero_length_predicate
+          return unless (length_method = zero_length_predicate(node.parent))
 
-          lhs, opr, rhs = zero_length_predicate
+          offense = node.loc.selector.join(node.parent.source_range.end)
+          message = format(ZERO_MSG, current: "#{length_method}.zero?")
+
+          add_offense(offense, message: message) do |corrector|
+            corrector.replace(offense, 'empty?')
+          end
+        end
+
+        def check_zero_length_comparison(node)
+          zero_length_comparison = zero_length_comparison(node.parent)
+          return unless zero_length_comparison
+
+          lhs, opr, rhs = zero_length_comparison
 
           return if non_polymorphic_collection?(node.parent)
 
           add_offense(
-            node.parent, message: format(ZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
+            node.parent, message: format(ZERO_MSG, current: "#{lhs} #{opr} #{rhs}")
           ) do |corrector|
             corrector.replace(node.parent, replacement(node.parent))
           end
         end
 
-        def check_nonzero_length_predicate(node)
-          nonzero_length_predicate = nonzero_length_predicate(node.parent)
-          return unless nonzero_length_predicate
+        def check_nonzero_length_comparison(node)
+          nonzero_length_comparison = nonzero_length_comparison(node.parent)
+          return unless nonzero_length_comparison
 
-          lhs, opr, rhs = nonzero_length_predicate
+          lhs, opr, rhs = nonzero_length_comparison
 
           return if non_polymorphic_collection?(node.parent)
 
           add_offense(
-            node.parent, message: format(NONZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
+            node.parent, message: format(NONZERO_MSG, current: "#{lhs} #{opr} #{rhs}")
           ) do |corrector|
             corrector.replace(node.parent, replacement(node.parent))
           end
@@ -78,14 +90,19 @@ module RuboCop
 
         # @!method zero_length_predicate(node)
         def_node_matcher :zero_length_predicate, <<~PATTERN
+          (send (send (...) ${:length :size}) :zero?)
+        PATTERN
+
+        # @!method zero_length_comparison(node)
+        def_node_matcher :zero_length_comparison, <<~PATTERN
           {(send (send (...) ${:length :size}) $:== (int $0))
            (send (int $0) $:== (send (...) ${:length :size}))
            (send (send (...) ${:length :size}) $:<  (int $1))
            (send (int $1) $:> (send (...) ${:length :size}))}
         PATTERN
 
-        # @!method nonzero_length_predicate(node)
-        def_node_matcher :nonzero_length_predicate, <<~PATTERN
+        # @!method nonzero_length_comparison(node)
+        def_node_matcher :nonzero_length_comparison, <<~PATTERN
           {(send (send (...) ${:length :size}) ${:> :!=} (int $0))
            (send (int $0) ${:< :!=} (send (...) ${:length :size}))}
         PATTERN

data/lib/rubocop/cop/team.rb

@@ -10,20 +10,6 @@ module RuboCop
     # first the ones needed for autocorrection (if any), then the rest
     # (unless autocorrections happened).
     class Team
-      attr_reader :errors, :warnings, :updated_source_file, :cops
-
-      alias updated_source_file? updated_source_file
-
-      def initialize(cops, config = nil, options = {})
-        @cops = cops
-        @config = config
-        @options = options
-        reset
-        @ready = true
-
-        validate_config
-      end
-
       # @return [Team]
       def self.new(cop_or_classes, config, options = {})
         # Support v0 api:
@@ -47,6 +33,35 @@ module RuboCop
         end
       end
 
+      # @return [Array<Force>] needed for the given cops
+      def self.forces_for(cops)
+        needed = Hash.new { |h, k| h[k] = [] }
+        cops.each do |cop|
+          forces = cop.class.joining_forces
+          if forces.is_a?(Array)
+            forces.each { |force| needed[force] << cop }
+          elsif forces
+            needed[forces] << cop
+          end
+        end
+
+        needed.map { |force_class, joining_cops| force_class.new(joining_cops) }
+      end
+
+      attr_reader :errors, :warnings, :updated_source_file, :cops
+
+      alias updated_source_file? updated_source_file
+
+      def initialize(cops, config = nil, options = {})
+        @cops = cops
+        @config = config
+        @options = options
+        reset
+        @ready = true
+
+        validate_config
+      end
+
       def autocorrect?
         @options[:autocorrect]
       end
@@ -94,21 +109,6 @@ module RuboCop
         @forces ||= self.class.forces_for(cops)
       end
 
-      # @return [Array<Force>] needed for the given cops
-      def self.forces_for(cops)
-        needed = Hash.new { |h, k| h[k] = [] }
-        cops.each do |cop|
-          forces = cop.class.joining_forces
-          if forces.is_a?(Array)
-            forces.each { |force| needed[force] << cop }
-          elsif forces
-            needed[forces] << cop
-          end
-        end
-
-        needed.map { |force_class, joining_cops| force_class.new(joining_cops) }
-      end
-
       def external_dependency_checksum
         keys = cops.map(&:external_dependency_checksum).compact
         Digest::SHA1.hexdigest(keys.join)

data/lib/rubocop/cop/variable_force.rb

@@ -108,7 +108,6 @@ module RuboCop
         :skip_children
       end
 
-      # rubocop:disable Layout/ClassStructure
       NODE_HANDLER_METHOD_NAMES = [
         [VARIABLE_ASSIGNMENT_TYPE, :process_variable_assignment],
         [REGEXP_NAMED_CAPTURE_TYPE, :process_regexp_named_captures],
@@ -123,8 +122,6 @@ module RuboCop
         *SCOPE_TYPES.product([:process_scope])
       ].to_h.freeze
       private_constant :NODE_HANDLER_METHOD_NAMES
-      # rubocop:enable Layout/ClassStructure
-
       def node_handler_method_name(node)
         NODE_HANDLER_METHOD_NAMES[node.type]
       end

data/lib/rubocop/cops_documentation_generator.rb

@@ -33,7 +33,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     cops.with_department(department).sort!
   end
 
-  def cops_body(cop, description, examples_objects, safety_objects, pars) # rubocop:disable Metrics/AbcSize
+  def cops_body(cop, description, examples_objects, safety_objects, see_objects, pars) # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists
     check_examples_to_have_the_default_enforced_style!(examples_objects, cop)
 
     content = h2(cop.cop_name)
@@ -43,7 +43,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     content << safety_object(safety_objects) if safety_objects.any? { |s| !s.text.blank? }
     content << examples(examples_objects) if examples_objects.any?
     content << configurations(cop.department, pars)
-    content << references(cop)
+    content << references(cop, see_objects)
     content
   end
 
@@ -224,14 +224,16 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     end
   end
 
-  def references(cop)
+  def references(cop, see_objects) # rubocop:disable Metrics/AbcSize
     cop_config = config.for_cop(cop)
     urls = RuboCop::Cop::MessageAnnotator.new(config, cop.name, cop_config, {}).urls
-    return '' if urls.empty?
+    return '' if urls.empty? && see_objects.empty?
 
     content = h3('References')
     content << urls.map { |url| "* #{url}" }.join("\n")
-    content << "\n"
+    content << "\n" unless urls.empty?
+    content << see_objects.map { |see| "* #{see.name}" }.join("\n")
+    content << "\n" unless see_objects.empty?
     content
   end
 
@@ -257,7 +259,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     end
   end
 
-  def print_cop_with_doc(cop)
+  def print_cop_with_doc(cop) # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
     cop_config = config.for_cop(cop)
     non_display_keys = %w[
       Description Enabled StyleGuide Reference Safe SafeAutoCorrect VersionAdded
@@ -265,13 +267,14 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     ]
     pars = cop_config.reject { |k| non_display_keys.include? k }
     description = 'No documentation'
-    examples_object = safety_object = []
+    examples_object = safety_object = see_object = []
     cop_code(cop) do |code_object|
       description = code_object.docstring unless code_object.docstring.blank?
       examples_object = code_object.tags('example')
       safety_object = code_object.tags('safety')
+      see_object = code_object.tags('see')
     end
-    cops_body(cop, description, examples_object, safety_object, pars)
+    cops_body(cop, description, examples_object, safety_object, see_object, pars)
   end
 
   def cop_code(cop)

data/lib/rubocop/formatter.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module RuboCop
+  # The bootstrap module for formatter.
+  # @api private
   module Formatter
     require_relative 'formatter/text_util'
 

data/lib/rubocop/path_util.rb

@@ -46,7 +46,7 @@ module RuboCop
         matches =
           if pattern == path
             true
-          elsif pattern.match?(/[*{\[?]/)
+          elsif glob?(pattern)
             File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
           end
 
@@ -68,6 +68,11 @@ module RuboCop
       %r{\A([A-Z]:)?/}i.match?(path)
     end
 
+    # Returns true for a glob
+    def glob?(path)
+      path.match?(/[*{\[?]/)
+    end
+
     def hidden_file_in_not_hidden_dir?(pattern, path)
       hidden_file?(path) &&
         File.fnmatch?(

data/lib/rubocop/result_cache.rb

@@ -53,7 +53,7 @@ module RuboCop
       def remove_oldest_files(files, dirs, cache_root, verbose)
         # Add 1 to half the number of files, so that we remove the file if
         # there's only 1 left.
-        remove_count = 1 + (files.length / 2)
+        remove_count = (files.length / 2) + 1
         puts "Removing the #{remove_count} oldest files from #{cache_root}" if verbose
         sorted = files.sort_by { |path| File.mtime(path) }
         remove_files(sorted, dirs, remove_count)