rubocop 1.38.0 → 1.40.0

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Sort `require` and `require_relative` in alphabetical order.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it will obviously change the execution order.
+      #
+      # @example
+      #   # bad
+      #   require 'b'
+      #   require 'a'
+      #
+      #   # good
+      #   require 'a'
+      #   require 'b'
+      #
+      #   # bad
+      #   require_relative 'b'
+      #   require_relative 'a'
+      #
+      #   # good
+      #   require_relative 'a'
+      #   require_relative 'b'
+      #
+      #   # good (sorted within each section separated by a blank line)
+      #   require 'a'
+      #   require 'd'
+      #
+      #   require 'b'
+      #   require 'c'
+      #
+      #   # good
+      #   require 'b'
+      #   require_relative 'c'
+      #   require 'a'
+      class RequireOrder < Base
+        extend AutoCorrector
+
+        include RangeHelp
+
+        RESTRICT_ON_SEND = %i[require require_relative].freeze
+
+        def on_send(node)
+          previous_older_sibling = find_previous_older_sibling(node)
+          return unless previous_older_sibling
+
+          add_offense(
+            node,
+            message: "Sort `#{node.method_name}` in alphabetical order."
+          ) do |corrector|
+            swap(
+              range_with_comments_and_lines(previous_older_sibling),
+              range_with_comments_and_lines(node),
+              corrector: corrector
+            )
+          end
+        end
+
+        private
+
+        def find_previous_older_sibling(node)
+          node.left_siblings.reverse.find do |sibling|
+            break unless sibling.send_type?
+            break unless sibling.method?(node.method_name)
+            break unless in_same_section?(sibling, node)
+
+            node.first_argument.source < sibling.first_argument.source
+          end
+        end
+
+        def in_same_section?(node1, node2)
+          !node1.location.expression.with(
+            end_pos: node2.location.expression.end_pos
+          ).source.include?("\n\n")
+        end
+
+        def swap(range1, range2, corrector:)
+          inserted = range2.source
+          corrector.insert_before(range1, inserted)
+          corrector.remove(range2)
+        end
+      end
+    end
+  end
+end

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

@@ -50,6 +50,11 @@ module RuboCop
       #   foo && foo.bar { |e| e.something }
       #   foo && foo.bar(param) { |e| e.something }
       #
+      #   foo ? foo.bar : nil
+      #   foo.nil? ? nil : foo.bar
+      #   !foo.nil? ? foo.bar : nil
+      #   !foo ? nil : foo.bar
+      #
       #   # good
       #   foo&.bar
       #   foo&.bar&.baz
@@ -105,6 +110,17 @@ module RuboCop
           }
         PATTERN
 
+        # @!method ternary_safe_navigation_candidate(node)
+        def_node_matcher :ternary_safe_navigation_candidate, <<~PATTERN
+          {
+            (if (send $_ {:nil? :!}) nil $_)
+
+            (if (send (send $_ :nil?) :!) $_ nil)
+
+            (if $_ $_ nil)
+          }
+        PATTERN
+
         # @!method not_nil_check?(node)
         def_node_matcher :not_nil_check?, '(send (send $_ :nil?) :!)'
 
@@ -118,9 +134,11 @@ module RuboCop
           check_node(node)
         end
 
+        private
+
         def check_node(node)
           checked_variable, receiver, method_chain, method = extract_parts(node)
-          return unless receiver == checked_variable
+          return if receiver != checked_variable || receiver.nil?
           return if use_var_only_in_unless_modifier?(node, checked_variable)
           return if chain_length(method_chain, method) > max_chain_length
           return if unsafe_method_used?(method_chain, method)
@@ -133,10 +151,8 @@ module RuboCop
           node.if_type? && node.unless? && !method_called?(variable)
         end
 
-        private
-
         def autocorrect(corrector, node)
-          body = node.node_parts[1]
+          body = extract_body(node)
           method_call = method_call(node)
 
           corrector.remove(begin_range(node, body))
@@ -147,6 +163,14 @@ module RuboCop
           add_safe_nav_to_all_methods_in_chain(corrector, method_call, body)
         end
 
+        def extract_body(node)
+          if node.if_type? && node.ternary?
+            node.branches.find { |branch| !branch.nil_type? }
+          else
+            node.node_parts[1]
+          end
+        end
+
         def handle_comments(corrector, node, method_call)
           comments = comments(node)
           return if comments.empty?
@@ -174,7 +198,7 @@ module RuboCop
         end
 
         def allowed_if_condition?(node)
-          node.else? || node.elsif? || node.ternary?
+          node.else? || node.elsif?
         end
 
         def method_call(node)
@@ -192,7 +216,12 @@ module RuboCop
         end
 
         def extract_parts_from_if(node)
-          variable, receiver = modifier_if_safe_navigation_candidate(node)
+          variable, receiver =
+            if node.ternary?
+              ternary_safe_navigation_candidate(node)
+            else
+              modifier_if_safe_navigation_candidate(node)
+            end
 
           checked_variable, matching_receiver, method = extract_common_parts(receiver, variable)
 

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

@@ -49,7 +49,8 @@ module RuboCop
         MSG = 'Prefer `%<replacement>s` to `%<original_method>s` with a regexp match.'
         RESTRICT_ON_SEND = %i[select find_all reject].freeze
         REPLACEMENTS = { select: 'grep', find_all: 'grep', reject: 'grep_v' }.freeze
-        REGEXP_METHODS = %i[match? =~].to_set.freeze
+        OPPOSITE_REPLACEMENTS = { select: 'grep_v', find_all: 'grep_v', reject: 'grep' }.freeze
+        REGEXP_METHODS = %i[match? =~ !~].to_set.freeze
 
         # @!method regexp_match?(node)
         def_node_matcher :regexp_match?, <<~PATTERN
@@ -90,8 +91,10 @@ module RuboCop
           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?(:!~)
           regexp = find_regexp(regexp_method_send_node, block_node)
-          register_offense(node, block_node, regexp)
+
+          register_offense(node, block_node, regexp, opposite)
         end
 
         private
@@ -102,8 +105,9 @@ module RuboCop
           node.hash_type? || creates_hash?(node) || env_const?(node)
         end
 
-        def register_offense(node, block_node, regexp)
-          replacement = REPLACEMENTS[node.method_name.to_sym]
+        def register_offense(node, block_node, regexp, opposite)
+          method_name = node.method_name.to_sym
+          replacement = opposite ? OPPOSITE_REPLACEMENTS[method_name] : REPLACEMENTS[method_name]
           message = format(MSG, replacement: replacement, original_method: node.method_name)
 
           add_offense(block_node, message: message) do |corrector|

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

@@ -95,11 +95,7 @@ module RuboCop
         end
 
         def offense?(node)
-          # If it's a string within an interpolation, then it's not an offense
-          # for this cop.
-          return false if inside_interpolation?(node)
-
-          wrong_quotes?(node)
+          wrong_quotes?(node) && !inside_interpolation?(node)
         end
 
         def consistent_multiline?

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

@@ -7,7 +7,7 @@ module RuboCop
       #
       # If you prefer a style that allows block for method with arguments,
       # please set `true` to `AllowMethodsWithArguments`.
-      # respond_to , and `define_method?` methods are allowed by default.
+      # `define_method?` methods are allowed by default.
       # These are customizable with `AllowedMethods` option.
       #
       # @safety
@@ -72,12 +72,10 @@ module RuboCop
       #     # some comment
       #   end
       #
-      # @example AllowedMethods: [respond_to, define_method] (default)
+      # @example AllowedMethods: [define_method] (default)
       #   # good
-      #   respond_to { |foo| foo.bar }
       #   define_method(:foo) { |foo| foo.bar }
       #
-      #
       # @example AllowedPatterns: [] (default)
       #   # bad
       #   something.map { |s| s.upcase }

data/lib/rubocop/cop/team.rb

@@ -38,7 +38,7 @@ module RuboCop
         new(cops, config, options)
       end
 
-      # @return [Array<Cop::Cop>]
+      # @return [Array<Cop::Base>]
       def self.mobilize_cops(cop_classes, config, options = {})
         cop_classes = Registry.new(cop_classes.to_a, options) unless cop_classes.is_a?(Registry)
 

data/lib/rubocop/cop/util.rb

@@ -122,7 +122,7 @@ module RuboCop
           string.inspect
         else
           # In a single-quoted strings, double quotes don't need to be escaped
-          "'#{string.gsub('\"', '"').gsub('\\') { '\\\\' }}'"
+          "'#{string.gsub('\\') { '\\\\' }.gsub('\"', '"')}'"
         end
       end
 
@@ -159,7 +159,7 @@ module RuboCop
       private
 
       def compatible_external_encoding_for?(src)
-        src = src.dup if RUBY_VERSION < '2.3' || RUBY_ENGINE == 'jruby'
+        src = src.dup if RUBY_ENGINE == 'jruby'
         src.force_encoding(Encoding.default_external).valid_encoding?
       end
     end

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -83,7 +83,7 @@ module RuboCop
         end
 
         def multiple_assignment_node
-          grandparent_node = node.parent ? node.parent.parent : nil
+          grandparent_node = node.parent&.parent
           return nil unless grandparent_node
           return nil unless grandparent_node.type == MULTIPLE_ASSIGNMENT_TYPE
           return nil unless node.parent.type == MULTIPLE_LEFT_HAND_SIDE_TYPE

data/lib/rubocop/cop/variable_force.rb

@@ -108,34 +108,26 @@ module RuboCop
         :skip_children
       end
 
-      # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+      # rubocop:disable Layout/ClassStructure
+      NODE_HANDLER_METHOD_NAMES = [
+        [VARIABLE_ASSIGNMENT_TYPE, :process_variable_assignment],
+        [REGEXP_NAMED_CAPTURE_TYPE, :process_regexp_named_captures],
+        [MULTIPLE_ASSIGNMENT_TYPE, :process_variable_multiple_assignment],
+        [VARIABLE_REFERENCE_TYPE, :process_variable_referencing],
+        [RESCUE_TYPE, :process_rescue],
+        [ZERO_ARITY_SUPER_TYPE, :process_zero_arity_super],
+        [SEND_TYPE, :process_send],
+        *ARGUMENT_DECLARATION_TYPES.product([:process_variable_declaration]),
+        *OPERATOR_ASSIGNMENT_TYPES.product([:process_variable_operator_assignment]),
+        *LOOP_TYPES.product([:process_loop]),
+        *SCOPE_TYPES.product([:process_scope])
+      ].to_h.freeze
+      private_constant :NODE_HANDLER_METHOD_NAMES
+      # rubocop:enable Layout/ClassStructure
+
       def node_handler_method_name(node)
-        case node.type
-        when VARIABLE_ASSIGNMENT_TYPE
-          :process_variable_assignment
-        when REGEXP_NAMED_CAPTURE_TYPE
-          :process_regexp_named_captures
-        when MULTIPLE_ASSIGNMENT_TYPE
-          :process_variable_multiple_assignment
-        when VARIABLE_REFERENCE_TYPE
-          :process_variable_referencing
-        when RESCUE_TYPE
-          :process_rescue
-        when ZERO_ARITY_SUPER_TYPE
-          :process_zero_arity_super
-        when SEND_TYPE
-          :process_send
-        when *ARGUMENT_DECLARATION_TYPES
-          :process_variable_declaration
-        when *OPERATOR_ASSIGNMENT_TYPES
-          :process_variable_operator_assignment
-        when *LOOP_TYPES
-          :process_loop
-        when *SCOPE_TYPES
-          :process_scope
-        end
+        NODE_HANDLER_METHOD_NAMES[node.type]
       end
-      # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
       def process_variable_declaration(node)
         variable_name = node.children.first
@@ -358,13 +350,12 @@ module RuboCop
         end
       end
 
-      # Use Node#equal? for accurate check.
       def scanned_node?(node)
-        scanned_nodes.any? { |scanned_node| scanned_node.equal?(node) }
+        scanned_nodes.include?(node)
       end
 
       def scanned_nodes
-        @scanned_nodes ||= []
+        @scanned_nodes ||= Set.new.compare_by_identity
       end
 
       # Hooks invoked by VariableTable.

data/lib/rubocop/cops_documentation_generator.rb

@@ -183,11 +183,10 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   # rubocop:enable Metrics/CyclomaticComplexity,Metrics/MethodLength
 
   def to_table(header, content)
-    # Specify `[separator=¦]` to prevent the regexp `|` is not used as a table separator.
-    # See: https://docs.asciidoctor.org/asciidoc/latest/tables/data-format/#escape-the-cell-separator
-    table = ['[separator=¦]', '|===', "| #{header.join(' | ')}\n\n"].join("\n")
+    table = ['|===', "| #{header.join(' | ')}\n\n"].join("\n")
     marked_contents = content.map do |plain_content|
-      plain_content.map { |c| "¦ #{c}" }.join("\n")
+      # Escape `|` with backslash to prevent the regexp `|` is not used as a table separator.
+      plain_content.map { |c| "| #{c.gsub(/\|/, '\|')}" }.join("\n")
     end
     table << marked_contents.join("\n\n")
     table << "\n|===\n"

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -65,6 +65,10 @@ module RuboCop
         @options.fetch(:offense_counts, true)
       end
 
+      def auto_gen_enforced_style?
+        @options.fetch(:auto_gen_enforced_style, true)
+      end
+
       def command
         command = 'rubocop --auto-gen-config'
 
@@ -79,6 +83,8 @@ module RuboCop
 
         command += ' --no-auto-gen-timestamp' unless show_timestamp?
 
+        command += ' --no-auto-gen-enforced-style' unless auto_gen_enforced_style?
+
         command
       end
 
@@ -172,17 +178,22 @@ module RuboCop
       end
 
       def output_cop_config(output_buffer, cfg, cop_name)
-        # 'Enabled' option will be put into file only if exclude
-        # limit is exceeded.
-        cfg_without_enabled = cfg.reject { |key| key == 'Enabled' }
-
+        filtered_cfg = filtered_config(cfg)
         output_buffer.puts "#{cop_name}:"
-        cfg_without_enabled.each do |key, value|
+        filtered_cfg.each do |key, value|
           value = value[0] if value.is_a?(Array)
           output_buffer.puts "  #{key}: #{value}"
         end
 
-        output_offending_files(output_buffer, cfg_without_enabled, cop_name)
+        output_offending_files(output_buffer, filtered_cfg, cop_name)
+      end
+
+      def filtered_config(cfg)
+        # 'Enabled' option will be put into file only if exclude
+        # limit is exceeded.
+        rejected_keys = ['Enabled']
+        rejected_keys << 'EnforcedStyle' unless auto_gen_enforced_style?
+        cfg.reject { |key| rejected_keys.include?(key) }
       end
 
       def output_offending_files(output_buffer, cfg, cop_name)

data/lib/rubocop/formatter/html_formatter.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
+require 'base64'
 require 'cgi'
 require 'erb'
 require 'ostruct'
-require 'base64'
 
 module RuboCop
   module Formatter

data/lib/rubocop/formatter.rb

@@ -6,6 +6,7 @@ module RuboCop
 
     require_relative 'formatter/base_formatter'
     require_relative 'formatter/simple_text_formatter'
+
     # relies on simple text
     require_relative 'formatter/clang_style_formatter'
     require_relative 'formatter/disabled_config_formatter'
@@ -18,11 +19,12 @@ module RuboCop
     require_relative 'formatter/junit_formatter'
     require_relative 'formatter/markdown_formatter'
     require_relative 'formatter/offense_count_formatter'
+    require_relative 'formatter/pacman_formatter'
     require_relative 'formatter/progress_formatter'
     require_relative 'formatter/quiet_formatter'
     require_relative 'formatter/tap_formatter'
     require_relative 'formatter/worst_offenders_formatter'
-    require_relative 'formatter/pacman_formatter'
+
     # relies on progress formatter
     require_relative 'formatter/auto_gen_config_formatter'
 

data/lib/rubocop/optimized_patterns.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # @api private
+  module OptimizedPatterns
+    # A wrapper around patterns array to perform optimized search.
+    # @api private
+    class PatternsSet
+      def initialize(patterns)
+        @strings = Set.new
+        @patterns = []
+        partition_patterns(patterns)
+      end
+
+      def match?(path)
+        @strings.include?(path) || @patterns.any? { |pattern| PathUtil.match_path?(pattern, path) }
+      end
+
+      private
+
+      def partition_patterns(patterns)
+        patterns.each do |pattern|
+          if pattern.is_a?(String) && !pattern.match?(/[*{\[?]/)
+            @strings << pattern
+          else
+            @patterns << pattern
+          end
+        end
+      end
+    end
+
+    @cache = {}.compare_by_identity
+
+    def self.from(patterns)
+      @cache[patterns] ||= PatternsSet.new(patterns)
+    end
+  end
+end

data/lib/rubocop/options.rb

@@ -167,6 +167,7 @@ module RuboCop
         option(opts, '--[no-]offense-counts')
         option(opts, '--[no-]auto-gen-only-exclude')
         option(opts, '--[no-]auto-gen-timestamp')
+        option(opts, '--[no-]auto-gen-enforced-style')
       end
     end
 
@@ -464,7 +465,7 @@ module RuboCop
 
   # This module contains help texts for command line options.
   # @api private
-  module OptionsHelp
+  module OptionsHelp # rubocop:disable Metrics/ModuleLength
     MAX_EXCL = RuboCop::Options::DEFAULT_MAXIMUM_EXCLUSION_ITEMS.to_s
     FORMATTER_OPTION_LIST = RuboCop::Formatter::FormatterSet::BUILTIN_FORMATTERS_FOR_KEYS.keys
 
@@ -486,6 +487,13 @@ module RuboCop
       auto_gen_timestamp:
                                         ['Include the date and time when the --auto-gen-config',
                                          'was run in the file it generates. Default is true.'],
+      auto_gen_enforced_style:
+                                        ['Add a setting to the TODO configuration file to enforce',
+                                         'the style used, rather than a per-file exclusion',
+                                         'if one style is used in all files for cop with',
+                                         'EnforcedStyle as a configurable option',
+                                         'when the --auto-gen-config was run',
+                                         'in the file it generates. Default is true.'],
       auto_gen_only_exclude:
                                         ['Generate only Exclude parameters and not Max',
                                          'when running --auto-gen-config, except if the',

data/lib/rubocop/path_util.rb

@@ -33,11 +33,18 @@ module RuboCop
       end
     end
 
+    # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
     def match_path?(pattern, path)
       case pattern
       when String
-        File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB) ||
-          hidden_file_in_not_hidden_dir?(pattern, path)
+        matches =
+          if pattern == path
+            true
+          elsif pattern.match?(/[*{\[?]/)
+            File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+          end
+
+        matches || hidden_file_in_not_hidden_dir?(pattern, path)
       when Regexp
         begin
           pattern.match?(path)
@@ -48,6 +55,7 @@ module RuboCop
         end
       end
     end
+    # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
     # Returns true for an absolute Unix or Windows path.
     def absolute?(path)
@@ -67,8 +75,12 @@ module RuboCop
       maybe_hidden_file?(path) && File.basename(path).start_with?('.')
     end
 
+    HIDDEN_FILE_PATTERN = "#{File::SEPARATOR}."
+
     # Loose check to reduce memory allocations
     def maybe_hidden_file?(path)
+      return false unless path.include?(HIDDEN_FILE_PATTERN)
+
       separator_index = path.rindex(File::SEPARATOR)
       return false unless separator_index
 

data/lib/rubocop/result_cache.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require 'digest/sha1'
-require 'find'
 require 'etc'
+require 'find'
 require 'zlib'
 require_relative 'cache_config'
 

data/lib/rubocop/rspec/cop_helper.rb

@@ -44,7 +44,10 @@ module CopHelper
 
   def registry
     @registry ||= begin
-      cops = configuration.keys.map { |cop| RuboCop::Cop::Registry.global.find_by_cop_name(cop) }
+      keys = configuration.keys
+      cops =
+        keys.map { |directive| RuboCop::Cop::Registry.global.find_cops_by_directive(directive) }
+            .flatten
       cops << cop_class if defined?(cop_class) && !cops.include?(cop_class)
       cops.compact!
       RuboCop::Cop::Registry.new(cops)

data/lib/rubocop/rspec/support.rb

@@ -3,10 +3,10 @@
 # Require this file to load code that supports testing using RSpec.
 
 require_relative 'cop_helper'
-require_relative 'host_environment_simulation_helper'
-require_relative 'shared_contexts'
 require_relative 'expect_offense'
+require_relative 'host_environment_simulation_helper'
 require_relative 'parallel_formatter'
+require_relative 'shared_contexts'
 
 RSpec.configure do |config|
   config.include CopHelper

data/lib/rubocop/server/core.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'socket'
 require 'securerandom'
+require 'socket'
 
 #
 # This code is based on https://github.com/fohte/rubocop-daemon.
@@ -17,6 +17,8 @@ module RuboCop
     # The core of server process. It starts TCP server and perform socket communication.
     # @api private
     class Core
+      JSON_FORMATS = %w[json j].freeze
+
       def self.token
         @token ||= SecureRandom.hex(4)
       end
@@ -57,6 +59,10 @@ module RuboCop
       def start_server(host, port)
         @server = TCPServer.open(host, port)
 
+        # JSON format does not expected output message when IDE integration with server mode.
+        # See: https://github.com/rubocop/rubocop/issues/11164
+        return if use_json_format?
+
         output_stream = ARGV.include?('--stderr') ? $stderr : $stdout
         output_stream.puts "RuboCop server starting on #{@server.addr[3]}:#{@server.addr[1]}."
       end
@@ -76,6 +82,15 @@ module RuboCop
       ensure
         socket.close
       end
+
+      def use_json_format?
+        return true if ARGV.include?('--format=json') || ARGV.include?('--format=j')
+        return false unless (index = ARGV.index('--format'))
+
+        format = ARGV[index + 1]
+
+        JSON_FORMATS.include?(format)
+      end
     end
   end
 end

data/lib/rubocop/target_ruby.rb

@@ -84,7 +84,7 @@ module RuboCop
     # @api private
     class ToolVersionsFile < RubyVersionFile
       TOOL_VERSIONS_FILENAME = '.tool-versions'
-      TOOL_VERSIONS_PATTERN = /\Aruby (?:ruby-)?(?<version>\d+\.\d+)/.freeze
+      TOOL_VERSIONS_PATTERN = /^(?:ruby )(?<version>\d+\.\d+)/.freeze
 
       def name
         "`#{TOOL_VERSIONS_FILENAME}`"

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.38.0'
+    STRING = '1.40.0'
 
     MSG = '%<version>s (using Parser %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \