rubocop 1.32.0 → 1.37.0

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

@@ -141,7 +141,7 @@ module RuboCop
 
           corrector.remove(begin_range(node, body))
           corrector.remove(end_range(node, body))
-          corrector.insert_before(method_call.loc.dot, '&')
+          corrector.insert_before(method_call.loc.dot, '&') unless method_call.safe_navigation?
           handle_comments(corrector, node, method_call)
 
           add_safe_nav_to_all_methods_in_chain(corrector, method_call, body)
@@ -250,7 +250,9 @@ module RuboCop
         end
 
         def unsafe_method?(send_node)
-          negated?(send_node) || send_node.assignment? || !send_node.dot?
+          negated?(send_node) ||
+            send_node.assignment? ||
+            (!send_node.dot? && !send_node.safe_navigation?)
         end
 
         def negated?(send_node)

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

@@ -33,7 +33,7 @@ module RuboCop
 
         MSG = 'Name `%<method>s` block params `|%<params>s|`.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless node.single_line?
 
           return unless eligible_method?(node)

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)
@@ -162,8 +173,6 @@ module RuboCop
         end
 
         def correct_for_comment(corrector, node, if_branch)
-          return if config.for_cop('Style/IfUnlessModifier')['Enabled']
-
           comments = processed_source.ast_with_comments[if_branch]
           comment_text = comments.map(&:text).join("\n") << "\n"
 
@@ -207,7 +216,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 +228,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/static_class.rb

@@ -44,18 +44,49 @@ module RuboCop
       #   end
       #
       class StaticClass < Base
+        include RangeHelp
         include VisibilityHelp
+        extend AutoCorrector
 
         MSG = 'Prefer modules to classes with only class methods.'
 
         def on_class(class_node)
           return if class_node.parent_class
+          return unless class_convertible_to_module?(class_node)
 
-          add_offense(class_node) if class_convertible_to_module?(class_node)
+          add_offense(class_node) do |corrector|
+            autocorrect(corrector, class_node)
+          end
         end
 
         private
 
+        def autocorrect(corrector, class_node)
+          corrector.replace(class_node.loc.keyword, 'module')
+          corrector.insert_after(class_node.loc.name, "\nmodule_function\n")
+
+          class_elements(class_node).each do |node|
+            if node.defs_type?
+              autocorrect_def(corrector, node)
+            elsif node.sclass_type?
+              autocorrect_sclass(corrector, node)
+            end
+          end
+        end
+
+        def autocorrect_def(corrector, node)
+          corrector.remove(
+            range_between(node.receiver.source_range.begin_pos, node.loc.name.begin_pos)
+          )
+        end
+
+        def autocorrect_sclass(corrector, node)
+          corrector.remove(
+            range_between(node.loc.keyword.begin_pos, node.identifier.source_range.end_pos)
+          )
+          corrector.remove(node.loc.end)
+        end
+
         def class_convertible_to_module?(class_node)
           nodes = class_elements(class_node)
           return false if nodes.empty?

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

@@ -65,11 +65,13 @@ module RuboCop
         end
 
         def build_bracketed_array(node)
+          return '[]' if node.children.empty?
+
           syms = node.children.map do |c|
             if c.dsym_type?
               string_literal = to_string_literal(c.source)
 
-              ":#{trim_string_interporation_escape_character(string_literal)}"
+              ":#{trim_string_interpolation_escape_character(string_literal)}"
             else
               to_symbol_literal(c.value.to_s)
             end

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

@@ -7,14 +7,15 @@ 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 ignored by default.
-      # These are customizable with `IgnoredMethods` option.
+      # 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
-      #   an `ArgumentError`.
+      #   This cop is unsafe because there is a difference that a `Proc`
+      #   generated from `Symbol#to_proc` behaves as a lambda, while
+      #   a `Proc` generated from a block does not.
+      #   For example, a lambda will raise an `ArgumentError` if the
+      #   number of arguments is wrong, but a non-lambda `Proc` will not.
       #
       #   For example:
       #
@@ -71,15 +72,25 @@ module RuboCop
       #     # some comment
       #   end
       #
-      # @example IgnoredMethods: [respond_to, define_method] (default)
+      # @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.'
@@ -103,15 +114,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)
@@ -119,7 +132,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)
@@ -128,6 +141,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

@@ -63,6 +63,8 @@ module RuboCop
           add_offense(node)
         end
 
+        alias on_numblock on_block
+
         private
 
         def top_level_method_definition?(node)
@@ -75,7 +77,7 @@ module RuboCop
 
         # @!method define_method_block?(node)
         def_node_matcher :define_method_block?, <<~PATTERN
-          (block (send _ {:define_method} _) ...)
+          ({block numblock} (send _ {:define_method} _) ...)
         PATTERN
       end
     end

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

@@ -64,7 +64,7 @@ module RuboCop
 
         MSG = 'Useless trailing comma present in block arguments.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           # lambda literal (`->`) never has block arguments.
           return if node.send_node.lambda_literal?
           return unless useless_trailing_comma?(node)

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

@@ -83,11 +83,13 @@ module RuboCop
         end
 
         def build_bracketed_array(node)
+          return '[]' if node.children.empty?
+
           words = node.children.map do |word|
             if word.dstr_type?
               string_literal = to_string_literal(word.source)
 
-              trim_string_interporation_escape_character(string_literal)
+              trim_string_interpolation_escape_character(string_literal)
             else
               to_string_literal(word.children[0])
             end

data/lib/rubocop/cop/util.rb

@@ -126,7 +126,7 @@ module RuboCop
         end
       end
 
-      def trim_string_interporation_escape_character(str)
+      def trim_string_interpolation_escape_character(str)
         str.gsub(/\\\#\{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
       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,94 @@
+# 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
+      # Don't use `::Kernel.require(target)` to prevent the following error:
+      # https://github.com/rubocop/rubocop/issues/10893
+      require(target)
+    rescue ::LoadError => e
+      raise if e.path != target
+
+      begin
+        # Don't use `::Kernel.require(target)` to prevent the following error:
+        # https://github.com/rubocop/rubocop/issues/10893
+        require(namespaced_target)
+      rescue ::LoadError => error_for_namespaced_target
+        # NOTE: This wrap is necessary due to JRuby 9.3.4.0 incompatibility:
+        # https://github.com/jruby/jruby/issues/7316
+        raise LoadError, 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

@@ -70,7 +70,9 @@ module RuboCop
 
         command += ' --auto-gen-only-exclude' if @options[:auto_gen_only_exclude]
 
-        if @exclude_limit_option
+        if no_exclude_limit?
+          command += ' --no-exclude-limit'
+        elsif @exclude_limit_option
           command += format(' --exclude-limit %<limit>d', limit: Integer(@exclude_limit_option))
         end
         command += ' --no-offense-counts' unless show_offense_counts?
@@ -161,7 +163,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
 
@@ -187,7 +189,7 @@ module RuboCop
         return unless cfg.empty?
 
         offending_files = @files_with_offenses[cop_name].sort
-        if offending_files.count > @exclude_limit
+        if !no_exclude_limit? && offending_files.count > @exclude_limit
           output_buffer.puts '  Enabled: false'
         else
           output_exclude_list(output_buffer, offending_files, cop_name)
@@ -245,6 +247,10 @@ module RuboCop
       def safe_autocorrect?(config)
         config.fetch('Safe', true) && config.fetch('SafeAutoCorrect', true)
       end
+
+      def no_exclude_limit?
+        @options[:no_exclude_limit] == false
+      end
     end
   end
 end

data/lib/rubocop/formatter/html_formatter.rb

@@ -93,12 +93,12 @@ module RuboCop
 
         def highlighted_source_line(offense)
           source_before_highlight(offense) +
-            hightlight_source_tag(offense) +
+            highlight_source_tag(offense) +
             source_after_highlight(offense) +
             possible_ellipses(offense.location)
         end
 
-        def hightlight_source_tag(offense)
+        def highlight_source_tag(offense)
           "<span class=\"highlight #{offense.severity}\">" \
             "#{escape(offense.highlighted_area.source)}" \
             '</span>'
@@ -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

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require 'optparse'
-require 'shellwords'
+require_relative 'arguments_env'
+require_relative 'arguments_file'
 
 module RuboCop
   class IncorrectCopNameError < StandardError; end
@@ -24,7 +25,10 @@ module RuboCop
     end
 
     def parse(command_line_args)
+      args_from_file = ArgumentsFile.read_as_arguments
+      args_from_env = ArgumentsEnv.read_as_arguments
       args = args_from_file.concat(args_from_env).concat(command_line_args)
+
       define_options.parse!(args)
 
       @validator.validate_compatibility
@@ -45,18 +49,6 @@ module RuboCop
 
     private
 
-    def args_from_file
-      if File.exist?('.rubocop') && !File.directory?('.rubocop')
-        File.read('.rubocop').shellsplit
-      else
-        []
-      end
-    end
-
-    def args_from_env
-      Shellwords.split(ENV.fetch('RUBOCOP_OPTS', ''))
-    end
-
     def define_options
       OptionParser.new do |opts|
         opts.banner = rainbow.wrap('Usage: rubocop [options] [file1, file2, ...]').bright
@@ -169,6 +161,7 @@ module RuboCop
         end
 
         option(opts, '--exclude-limit COUNT') { @validator.validate_exclude_limit_option }
+        option(opts, '--no-exclude-limit')
 
         option(opts, '--[no-]offense-counts')
         option(opts, '--[no-]auto-gen-only-exclude')
@@ -400,6 +393,12 @@ module RuboCop
     end
 
     def validate_autocorrect
+      if @options.key?(:safe_autocorrect) && @options.key?(:autocorrect_all)
+        message = Rainbow(<<~MESSAGE).red
+          Error: Both safe and unsafe autocorrect options are specified, use only one.
+        MESSAGE
+        raise OptionArgumentError, message
+      end
       return if @options.key?(:autocorrect)
       return unless @options.key?(:disable_uncorrectable)
 
@@ -497,6 +496,7 @@ module RuboCop
       disable_uncorrectable:            ['Used with --autocorrect to annotate any',
                                          'offenses that do not support autocorrect',
                                          'with `rubocop:todo` comments.'],
+      no_exclude_limit:                 ['Do not set the limit for how many files to exclude.'],
       force_exclusion:                  ['Any files excluded by `Exclude` in configuration',
                                          'files will be excluded, even if given explicitly',
                                          'as arguments.'],