rubocop 1.31.2 → 1.34.0

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

@@ -57,8 +57,8 @@ module RuboCop
         def allowed_expression?(node)
           allowed_ancestor?(node) ||
             allowed_method_call?(node) ||
-            allowed_array_or_hash_element?(node) ||
-            allowed_multiple_expression?(node)
+            allowed_multiple_expression?(node) ||
+            allowed_ternary?(node)
         end
 
         def allowed_ancestor?(node)
@@ -80,6 +80,19 @@ module RuboCop
           !ancestor.begin_type? && !ancestor.def_type? && !ancestor.block_type?
         end
 
+        def allowed_ternary?(node)
+          return unless node&.parent&.if_type?
+
+          node.parent.ternary? && ternary_parentheses_required?
+        end
+
+        def ternary_parentheses_required?
+          config = @config.for_cop('Style/TernaryParentheses')
+          allowed_styles = %w[require_parentheses require_parentheses_when_complex]
+
+          config.fetch('Enabled') && allowed_styles.include?(config['EnforcedStyle'])
+        end
+
         def like_method_argument_parentheses?(node)
           node.send_type? && node.arguments.one? &&
             !node.arithmetic_operation? && node.first_argument.begin_type?
@@ -153,26 +166,6 @@ module RuboCop
           node.parent&.keyword?
         end
 
-        def allowed_array_or_hash_element?(node)
-          # Don't flag
-          # ```
-          # { a: (1
-          #      ), }
-          # ```
-          hash_or_array_element?(node) && only_closing_paren_before_comma?(node)
-        end
-
-        def hash_or_array_element?(node)
-          node.each_ancestor(:array, :hash).any?
-        end
-
-        def only_closing_paren_before_comma?(node)
-          source_buffer = node.source_range.source_buffer
-          line_range = source_buffer.line_range(node.loc.end.line)
-
-          /^\s*\)\s*,/.match?(line_range.source)
-        end
-
         def disallowed_literal?(begin_node, node)
           node.literal? && !node.range_type? && !raised_to_power_negative_numeric?(begin_node, node)
         end

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

@@ -123,13 +123,8 @@ module RuboCop
 
         def register_offense(node, sort_node, sorter, accessor)
           message = message(node, sorter, accessor)
-
           add_offense(offense_range(sort_node, node), message: message) do |corrector|
-            # Remove accessor, e.g. `first` or `[-1]`.
-            corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))
-
-            # Replace "sort" or "sort_by" with the appropriate min/max method.
-            corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
+            autocorrect(corrector, node, sort_node, sorter, accessor)
           end
         end
 
@@ -149,6 +144,20 @@ module RuboCop
                  accessor_source: accessor_source)
         end
 
+        def autocorrect(corrector, node, sort_node, sorter, accessor)
+          # Remove accessor, e.g. `first` or `[-1]`.
+          corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))
+          # Replace "sort" or "sort_by" with the appropriate min/max method.
+          corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
+          # Replace to avoid syntax errors when followed by a logical operator.
+          replace_with_logical_operator(corrector, node) if with_logical_operator?(node)
+        end
+
+        def replace_with_logical_operator(corrector, node)
+          corrector.insert_after(node.child_nodes.first, " #{node.parent.loc.operator.source}")
+          corrector.remove(node.parent.loc.operator)
+        end
+
         def suggestion(sorter, accessor, arg)
           base(accessor, arg) + suffix(sorter)
         end
@@ -187,6 +196,12 @@ module RuboCop
             node.loc.selector.begin_pos
           end
         end
+
+        def with_logical_operator?(node)
+          return unless (parent = node.parent)
+
+          parent.or_type? || parent.and_type?
+        end
       end
     end
   end

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

@@ -64,12 +64,14 @@ module RuboCop
           # Make the obvious check first
           return unless processed_source.raw_source.include?(';')
 
-          each_semicolon { |line, column| register_semicolon(line, column, false) }
+          each_semicolon do |line, column, token_before_semicolon|
+            register_semicolon(line, column, false, token_before_semicolon)
+          end
         end
 
         def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            yield line, tokens.last.column if tokens.last.semicolon?
+            yield line, tokens.last.column, tokens[-2] if tokens.last.semicolon?
             yield line, tokens.first.column if tokens.first.semicolon?
           end
         end
@@ -78,13 +80,21 @@ module RuboCop
           processed_source.tokens.group_by(&:line)
         end
 
-        def register_semicolon(line, column, after_expression)
+        def register_semicolon(line, column, after_expression, token_before_semicolon = nil)
           range = source_range(processed_source.buffer, line, column)
 
           add_offense(range) do |corrector|
             if after_expression
               corrector.replace(range, "\n")
             else
+              # Prevents becoming one range instance with subsequent line when endless range
+              # without parentheses.
+              # See: https://github.com/rubocop/rubocop/issues/10791
+              if token_before_semicolon&.regexp_dots?
+                range_node = find_range_node(token_before_semicolon)
+                corrector.wrap(range_node, '(', ')') if range_node
+              end
+
               corrector.remove(range)
             end
           end
@@ -103,6 +113,20 @@ module RuboCop
             yield Regexp.last_match.begin(0)
           end
         end
+
+        def find_range_node(token_before_semicolon)
+          range_nodes.detect do |range_node|
+            range_node.source_range.contains?(token_before_semicolon.pos)
+          end
+        end
+
+        def range_nodes
+          return @range_nodes if instance_variable_defined?(:@range_nodes)
+
+          ast = processed_source.ast
+          @range_nodes = ast.range_type? ? [ast] : []
+          @range_nodes.concat(ast.each_descendant(:irange, :erange).to_a)
+        end
       end
     end
   end

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

@@ -148,7 +148,18 @@ module RuboCop
           )
           corrector.replace(range, and_operator)
           corrector.remove(range_by_whole_lines(node.loc.end, include_final_newline: true))
-          corrector.wrap(if_branch.condition, '(', ')') if wrap_condition?(if_branch.condition)
+
+          wrap_condition(corrector, if_branch.condition)
+        end
+
+        def wrap_condition(corrector, condition)
+          # Handle `send` and `block` nodes that need to be wrapped in parens
+          # FIXME: autocorrection prevents syntax errors by wrapping the entire node in parens,
+          #        but wrapping the argument list would be a more ergonomic correction.
+          node_to_check = condition&.block_type? ? condition.send_node : condition
+          return unless wrap_condition?(node_to_check)
+
+          corrector.wrap(condition, '(', ')')
         end
 
         def correct_for_outer_condition_modify_form_style(corrector, node, if_branch)
@@ -207,7 +218,7 @@ module RuboCop
         end
 
         def require_parentheses?(condition)
-          condition.send_type? && !condition.arguments.empty? && !condition.parenthesized? &&
+          condition.call_type? && !condition.arguments.empty? && !condition.parenthesized? &&
             !condition.comparison_method?
         end
 
@@ -219,7 +230,7 @@ module RuboCop
 
         def wrap_condition?(node)
           node.and_type? || node.or_type? ||
-            (node.send_type? && node.arguments.any? && !node.parenthesized?)
+            (node.call_type? && node.arguments.any? && !node.parenthesized?)
         end
 
         def replace_condition(condition)

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

@@ -39,7 +39,7 @@ module RuboCop
         minimum_target_ruby_version 2.0
 
         PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'
-        ARRAY_MSG = 'Use `%<prefer>s` for an array of symbols.'
+        ARRAY_MSG = 'Use %<prefer>s for an array of symbols.'
 
         class << self
           attr_accessor :largest_brackets
@@ -74,8 +74,7 @@ module RuboCop
               to_symbol_literal(c.value.to_s)
             end
           end
-
-          "[#{syms.join(', ')}]"
+          build_bracketed_array_with_appropriate_whitespace(elements: syms, node: node)
         end
 
         def to_symbol_literal(string)

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

@@ -7,11 +7,13 @@ 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.
+      # These are customizable with `AllowedMethods` option.
       #
       # @safety
       #   This cop is unsafe because `proc`s and blocks work differently
       #   when additional arguments are passed in. A block will silently
-      #   ignore additional arguments, but a `proc` will raise
+      #   allow additional arguments, but a `proc` will raise
       #   an `ArgumentError`.
       #
       #   For example:
@@ -68,10 +70,26 @@ module RuboCop
       #     s.upcase # some comment
       #     # some comment
       #   end
+      #
+      # @example AllowedMethods: [respond_to, define_method] (default)
+      #   # good
+      #   respond_to { |foo| foo.bar }
+      #   define_method(:foo) { |foo| foo.bar }
+      #
+      #
+      # @example AllowedPatterns: [] (default)
+      #   # bad
+      #   something.map { |s| s.upcase }
+      #
+      # @example AllowedPatterns: [/map/] (default)
+      #   # good
+      #   something.map { |s| s.upcase }
+      #
       class SymbolProc < Base
         include CommentsHelp
         include RangeHelp
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
         extend AutoCorrector
 
         MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` instead of a block.'
@@ -81,7 +99,7 @@ module RuboCop
         def_node_matcher :proc_node?, '(send (const {nil? cbase} :Proc) :new)'
 
         # @!method symbol_proc_receiver?(node)
-        def_node_matcher :symbol_proc_receiver?, '{(send ...) (super ...) zsuper}'
+        def_node_matcher :symbol_proc_receiver?, '{(call ...) (super ...) zsuper}'
 
         # @!method symbol_proc?(node)
         def_node_matcher :symbol_proc?, <<~PATTERN
@@ -95,15 +113,17 @@ module RuboCop
           [Layout::SpaceBeforeBlockBraces]
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_block(node)
           symbol_proc?(node) do |dispatch_node, arguments_node, method_name|
             # TODO: Rails-specific handling that we should probably make
             # configurable - https://github.com/rubocop/rubocop/issues/1485
-            # we should ignore lambdas & procs
+            # we should allow lambdas & procs
             return if proc_node?(dispatch_node)
+            return if unsafe_hash_usage?(dispatch_node)
+            return if unsafe_array_usage?(dispatch_node)
             return if %i[lambda proc].include?(dispatch_node.method_name)
-            return if ignored_method?(dispatch_node.method_name)
+            return if allowed_method_name?(dispatch_node.method_name)
             return if allow_if_method_has_argument?(node.send_node)
             return if node.block_type? && destructuring_block_argument?(arguments_node)
             return if allow_comments? && contains_comments?(node)
@@ -111,7 +131,7 @@ module RuboCop
             register_offense(node, method_name, dispatch_node.method_name)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         alias on_numblock on_block
 
         def destructuring_block_argument?(argument_node)
@@ -120,6 +140,19 @@ module RuboCop
 
         private
 
+        # See: https://github.com/rubocop/rubocop/issues/10864
+        def unsafe_hash_usage?(node)
+          node.receiver&.hash_type? && %i[reject select].include?(node.method_name)
+        end
+
+        def unsafe_array_usage?(node)
+          node.receiver&.array_type? && %i[min max].include?(node.method_name)
+        end
+
+        def allowed_method_name?(name)
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
         def register_offense(node, method_name, block_method_name)
           block_start = node.loc.begin.begin_pos
           block_end = node.loc.end.end_pos

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

@@ -71,7 +71,7 @@ module RuboCop
 
           return if only_closing_parenthesis_is_last_line?(condition)
           return if condition_as_parenthesized_one_line_pattern_matching?(condition)
-          return unless node.ternary? && !infinite_loop? && offense?(node)
+          return unless node.ternary? && offense?(node)
 
           message = message(node)
 
@@ -166,22 +166,10 @@ module RuboCop
           style == :require_parentheses_when_complex
         end
 
-        def redundant_parentheses_enabled?
-          @config.for_cop('Style/RedundantParentheses').fetch('Enabled')
-        end
-
         def parenthesized?(node)
           node.begin_type?
         end
 
-        # When this cop is configured to enforce parentheses and the
-        # `RedundantParentheses` cop is enabled, it will cause an infinite loop
-        # as they compete to add and remove the parentheses respectively.
-        def infinite_loop?
-          (require_parentheses? || require_parentheses_when_complex?) &&
-            redundant_parentheses_enabled?
-        end
-
         def unsafe_autocorrect?(condition)
           condition.children.any? do |child|
             unparenthesized_method_call?(child) || below_ternary_precedence?(child)

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

@@ -47,6 +47,8 @@ module RuboCop
       class TopLevelMethodDefinition < Base
         MSG = 'Do not define methods at the top-level.'
 
+        RESTRICT_ON_SEND = %i[define_method].freeze
+
         def on_def(node)
           return unless top_level_method_definition?(node)
 

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

@@ -5,6 +5,9 @@ module RuboCop
     module Style
       # Looks for trivial reader/writer methods, that could
       # have been created with the attr_* family of functions automatically.
+      # `to_ary`, `to_a`, `to_c`, `to_enum`, `to_h`, `to_hash`, `to_i`, `to_int`, `to_io`,
+      # `to_open`, `to_path`, `to_proc`, `to_r`, `to_regexp`, `to_str`, `to_s`, and `to_sym` methods
+      # are allowed by default. These are customizable with `AllowedMethods` option.
       #
       # @example
       #   # bad

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

@@ -44,7 +44,7 @@ module RuboCop
         extend AutoCorrector
 
         PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'
-        ARRAY_MSG = 'Use `%<prefer>s` for an array of words.'
+        ARRAY_MSG = 'Use %<prefer>s for an array of words.'
 
         class << self
           attr_accessor :largest_brackets
@@ -92,8 +92,7 @@ module RuboCop
               to_string_literal(word.children[0])
             end
           end
-
-          "[#{words.join(', ')}]"
+          build_bracketed_array_with_appropriate_whitespace(elements: words, node: node)
         end
       end
     end

data/lib/rubocop/ext/range.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Ext
+    # Extensions to Parser::Source::Range
+    module Range
+      # Adds `Range#single_line?` to parallel `Node#single_line?`
+      def single_line?
+        first_line == last_line
+      end
+    end
+  end
+end
+
+Parser::Source::Range.include RuboCop::Ext::Range

data/lib/rubocop/feature_loader.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # This class handles loading files (a.k.a. features in Ruby) specified
+  # by `--require` command line option and `require` directive in the config.
+  #
+  # Normally, the given string is directly passed to `require`. If a string
+  # beginning with `.` is given, it is assumed to be relative to the given
+  # directory.
+  #
+  # If a string containing `-` is given, it will be used as is, but if we
+  # cannot find the file to load, we will replace `-` with `/` and try it
+  # again as when Bundler loads gems.
+  #
+  # @api private
+  class FeatureLoader
+    class << self
+      # @param [String] config_directory_path
+      # @param [String] feature
+      def load(config_directory_path:, feature:)
+        new(config_directory_path: config_directory_path, feature: feature).load
+      end
+    end
+
+    # @param [String] config_directory_path
+    # @param [String] feature
+    def initialize(config_directory_path:, feature:)
+      @config_directory_path = config_directory_path
+      @feature = feature
+    end
+
+    def load
+      ::Kernel.require(target)
+    rescue ::LoadError => e
+      raise if e.path != target
+
+      begin
+        ::Kernel.require(namespaced_target)
+      rescue ::LoadError => error_for_namespaced_target
+        raise e if error_for_namespaced_target.path == namespaced_target
+
+        raise error_for_namespaced_target
+      end
+    end
+
+    private
+
+    # @return [String]
+    def namespaced_feature
+      @feature.tr('-', '/')
+    end
+
+    # @return [String]
+    def namespaced_target
+      if relative?
+        relative(namespaced_feature)
+      else
+        namespaced_feature
+      end
+    end
+
+    # @param [String]
+    # @return [String]
+    def relative(feature)
+      ::File.join(@config_directory_path, feature)
+    end
+
+    # @return [Boolean]
+    def relative?
+      @feature.start_with?('.')
+    end
+
+    # @param [LoadError] error
+    # @return [Boolean]
+    def seems_cannot_load_such_file_error?(error)
+      error.path == target
+    end
+
+    # @return [String]
+    def target
+      if relative?
+        relative(@feature)
+      else
+        @feature
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/clang_style_formatter.rb

@@ -41,7 +41,7 @@ module RuboCop
       def report_line(location)
         source_line = location.source_line
 
-        if location.first_line == location.last_line
+        if location.single_line?
           output.puts(source_line)
         else
           output.puts("#{source_line} #{yellow(ELLIPSES)}")

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -161,7 +161,7 @@ module RuboCop
           next unless value.is_a?(Array)
           next if value.empty?
 
-          output_buffer.puts "# #{param}: #{value.join(', ')}"
+          output_buffer.puts "# #{param}: #{value.uniq.join(', ')}"
         end
       end
 

data/lib/rubocop/formatter/html_formatter.rb

@@ -115,7 +115,7 @@ module RuboCop
         end
 
         def possible_ellipses(location)
-          location.first_line == location.last_line ? '' : " #{ELLIPSES}"
+          location.single_line? ? '' : " #{ELLIPSES}"
         end
 
         def escape(string)

data/lib/rubocop/formatter/markdown_formatter.rb

@@ -71,7 +71,7 @@ module RuboCop
       end
 
       def possible_ellipses(location)
-        location.first_line == location.last_line ? '' : ' ...'
+        location.single_line? ? '' : ' ...'
       end
     end
   end

data/lib/rubocop/formatter/tap_formatter.rb

@@ -29,7 +29,7 @@ module RuboCop
       def report_line(location)
         source_line = location.source_line
 
-        if location.first_line == location.last_line
+        if location.single_line?
           output.puts("# #{source_line}")
         else
           output.puts("# #{source_line} #{yellow(ELLIPSES)}")

data/lib/rubocop/options.rb

@@ -421,12 +421,9 @@ module RuboCop
     end
 
     def invalid_arguments_for_parallel
-      [('--auto-gen-config'    if @options.key?(:auto_gen_config)),
-       ('-F/--fail-fast'       if @options.key?(:fail_fast)),
-       ('-x/--fix-layout'      if @options.key?(:fix_layout)),
-       ('-a/--autocorrect'     if @options.key?(:safe_autocorrect)),
-       ('-A/--autocorrect-all' if @options.key?(:autocorrect_all)),
-       ('--cache false'        if @options > { cache: 'false' })].compact
+      [('--auto-gen-config' if @options.key?(:auto_gen_config)),
+       ('-F/--fail-fast'    if @options.key?(:fail_fast)),
+       ('--cache false'     if @options > { cache: 'false' })].compact
     end
 
     def only_includes_redundant_disable?

data/lib/rubocop/result_cache.rb

@@ -4,6 +4,7 @@ require 'digest/sha1'
 require 'find'
 require 'etc'
 require 'zlib'
+require_relative 'cache_config'
 
 module RuboCop
   # Provides functionality for caching RuboCop runs.
@@ -13,6 +14,12 @@ module RuboCop
                       fix_layout autocorrect safe_autocorrect autocorrect_all
                       cache fail_fast stdin parallel].freeze
 
+    DL_EXTENSIONS = ::RbConfig::CONFIG
+                    .values_at('DLEXT', 'DLEXT2')
+                    .reject { |ext| !ext || ext.empty? }
+                    .map    { |ext| ".#{ext}" }
+                    .freeze
+
     # Remove old files so that the cache doesn't grow too big. When the
     # threshold MaxFilesInCache has been exceeded, the oldest 50% of all the
     # files in the cache are removed. The reason for removing so much is that
@@ -67,24 +74,9 @@ module RuboCop
     end
 
     def self.cache_root(config_store)
-      root = ENV.fetch('RUBOCOP_CACHE_ROOT', nil)
-      root ||= config_store.for_pwd.for_all_cops['CacheRootDirectory']
-      root ||= if ENV.key?('XDG_CACHE_HOME')
-                 # Include user ID in the path to make sure the user has write
-                 # access.
-                 File.join(ENV.fetch('XDG_CACHE_HOME'), Process.uid.to_s)
-               else
-                 # On FreeBSD, the /home path is a symbolic link to /usr/home
-                 # and the $HOME environment variable returns the /home path.
-                 #
-                 # As $HOME is a built-in environment variable, FreeBSD users
-                 # always get a warning message.
-                 #
-                 # To avoid raising warn log messages on FreeBSD, we retrieve
-                 # the real path of the home folder.
-                 File.join(File.realpath(Dir.home), '.cache')
-               end
-      File.join(root, 'rubocop_cache')
+      CacheConfig.root_dir do
+        config_store.for_pwd.for_all_cops['CacheRootDirectory']
+      end
     end
 
     def self.allow_symlinks_in_cache_location?(config_store)
@@ -188,14 +180,24 @@ module RuboCop
             .select { |path| File.file?(path) }
             .sort!
             .each do |path|
-              content = File.binread(path)
-              digest << Zlib.crc32(content).to_s # mtime not reliable
+              digest << digest(path)
             end
           digest << RuboCop::Version::STRING << RuboCop::AST::Version::STRING
           digest.hexdigest
         end
     end
 
+    def digest(path)
+      content = if path.end_with?(*DL_EXTENSIONS)
+                  # Shared libraries often contain timestamps of when
+                  # they were compiled and other non-stable data.
+                  File.basename(path)
+                else
+                  File.binread(path) # mtime not reliable
+                end
+      Zlib.crc32(content).to_s
+    end
+
     def rubocop_extra_features
       lib_root = File.join(File.dirname(__FILE__), '..')
       exe_root = File.join(lib_root, '..', 'exe')