rubocop 1.23.0 → 1.25.1

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for uses of `map.to_h` or `collect.to_h` that could be
+      # written with just `to_h` in Ruby >= 2.6.
+      #
+      # NOTE: `Style/HashTransformKeys` and `Style/HashTransformValues` will
+      # also change this pattern if only hash keys or hash values are being
+      # transformed.
+      #
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if the receiver
+      #   is not an `Enumerable`.
+      #
+      # @example
+      #   # bad
+      #   something.map { |v| [v, v * 2] }.to_h
+      #
+      #   # good
+      #   something.to_h { |v| [v, v * 2] }
+      #
+      #   # bad
+      #   {foo: bar}.collect { |k, v| [k.to_s, v.do_something] }.to_h
+      #
+      #   # good
+      #   {foo: bar}.to_h { |k, v| [k.to_s, v.do_something] }
+      #
+      class MapToHash < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+        include RangeHelp
+
+        minimum_target_ruby_version 2.6
+
+        MSG = 'Pass a block to `to_h` instead of calling `%<method>s.to_h`.'
+        RESTRICT_ON_SEND = %i[to_h].freeze
+
+        # @!method map_to_h?(node)
+        def_node_matcher :map_to_h?, <<~PATTERN
+          $(send (block $(send _ {:map :collect}) ...) :to_h)
+        PATTERN
+
+        def on_send(node)
+          return unless (to_h_node, map_node = map_to_h?(node))
+
+          message = format(MSG, method: map_node.loc.selector.source)
+          add_offense(map_node.loc.selector, message: message) do |corrector|
+            # If the `to_h` call already has a block, do not auto-correct.
+            next if to_h_node.block_node
+
+            autocorrect(corrector, to_h_node, map_node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, to_h, map)
+          removal_range = range_between(to_h.loc.dot.begin_pos, to_h.loc.selector.end_pos)
+
+          corrector.remove(range_with_surrounding_space(range: removal_range, side: :left))
+          corrector.replace(map.loc.selector, 'to_h')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -13,9 +13,11 @@ module RuboCop
 
           private
 
+          # rubocop:disable Metrics/PerceivedComplexity
           def omit_parentheses(node)
             return unless node.parenthesized?
             return if inside_endless_method_def?(node)
+            return if require_parentheses_for_hash_value_omission?(node)
             return if syntax_like_method_call?(node)
             return if super_call_without_arguments?(node)
             return if allowed_camel_case_method_call?(node)
@@ -26,6 +28,7 @@ module RuboCop
               auto_correct(corrector, node)
             end
           end
+          # rubocop:enable Metrics/PerceivedComplexity
 
           def auto_correct(corrector, node)
             if parentheses_at_the_end_of_multiline_call?(node)
@@ -45,6 +48,23 @@ module RuboCop
             node.each_ancestor(:def, :defs).any?(&:endless?) && node.arguments.any?
           end
 
+          def require_parentheses_for_hash_value_omission?(node)
+            return false unless (last_argument = node.last_argument)
+            return false if !last_argument.hash_type? || !last_argument.pairs.last&.value_omission?
+
+            modifier_form?(node) || exist_next_line_expression?(node)
+          end
+
+          def modifier_form?(node)
+            node.parent.respond_to?(:modifier_form?) && node.parent.modifier_form?
+          end
+
+          # Require hash value omission be enclosed in parentheses to prevent the following issue:
+          # https://bugs.ruby-lang.org/issues/18396.
+          def exist_next_line_expression?(node)
+            node.parent&.assignment? ? node.parent.right_sibling : node.right_sibling
+          end
+
           def syntax_like_method_call?(node)
             node.implicit_call? || node.operator_method?
           end

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

@@ -43,9 +43,11 @@ module RuboCop
       # NOTE: Parentheses are still allowed in cases where omitting them
       # results in ambiguous or syntactically incorrect code. For example,
       # parentheses are required around a method with arguments when inside an
-      # endless method definition introduced in Ruby 3.0.  Parentheses are also
+      # endless method definition introduced in Ruby 3.0. Parentheses are also
       # allowed when forwarding arguments with the triple-dot syntax introduced
       # in Ruby 2.7 as omitting them starts an endless range.
+      # And Ruby 3.1's hash omission syntax has a case that requires parentheses
+      # because of the following issue: https://bugs.ruby-lang.org/issues/18396.
       #
       # @example EnforcedStyle: require_parentheses (default)
       #

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

@@ -6,8 +6,13 @@ module RuboCop
       # This cop checks for parentheses around the arguments in method
       # definitions. Both instance and class/singleton methods are checked.
       #
-      # This cop does not consider endless methods, since parentheses are
-      # always required for them.
+      # Regardless of style, parentheses are necessary for:
+      #
+      # 1. Endless methods
+      # 2. Argument lists containing a `forward-arg` (`...`)
+      # 3. Argument lists containing an anonymous block forwarding (`&`)
+      #
+      # Removing the parens would be a syntax error here.
       #
       # @example EnforcedStyle: require_parentheses (default)
       #   # The `require_parentheses` style requires method definitions
@@ -121,21 +126,13 @@ module RuboCop
           corrector.remove(arg_node.loc.end)
         end
 
-        def correct_definition(def_node, corrector)
-          arguments_range = def_node.arguments.source_range
-          args_with_space = range_with_surrounding_space(range: arguments_range, side: :left)
-          leading_space = range_between(args_with_space.begin_pos, arguments_range.begin_pos)
-          corrector.replace(leading_space, '(')
-          corrector.insert_after(arguments_range, ')')
-        end
-
         def forced_parentheses?(node)
           # Regardless of style, parentheses are necessary for:
           # 1. Endless methods
           # 2. Argument lists containing a `forward-arg` (`...`)
+          # 3. Argument lists containing an anonymous block forwarding (`&`)
           # Removing the parens would be a syntax error here.
-
-          node.endless? || node.arguments.any?(&:forward_arg_type?)
+          node.endless? || node.arguments.any?(&:forward_arg_type?) || anonymous_block_arg?(node)
         end
 
         def require_parentheses?(args)
@@ -151,7 +148,8 @@ module RuboCop
           location = node.arguments.source_range
 
           add_offense(location, message: MSG_MISSING) do |corrector|
-            correct_definition(node, corrector)
+            add_parentheses(node.arguments, corrector)
+
             unexpected_style_detected 'require_no_parentheses'
           end
         end
@@ -163,6 +161,12 @@ module RuboCop
             unexpected_style_detected 'require_parentheses'
           end
         end
+
+        def anonymous_block_arg?(node)
+          return false unless (last_argument = node.arguments.last)
+
+          last_argument.blockarg_type? && last_argument.name.nil?
+        end
       end
     end
   end

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

@@ -27,6 +27,11 @@ module RuboCop
       #   # bad
       #   10_000_00 # typical representation of $10,000 in cents
       #
+      # @example AllowedNumbers: [3000]
+      #
+      #   # good
+      #   3000 # You can specify allowed numbers. (e.g. port number)
+      #
       class NumericLiterals < Base
         include IntegerNode
         extend AutoCorrector
@@ -51,9 +56,9 @@ module RuboCop
 
         def check(node)
           int = integer_part(node)
-
           # TODO: handle non-decimal literals as well
           return if int.start_with?('0')
+          return if allowed_numbers.include?(int)
           return unless int.size >= min_digits
 
           case int
@@ -99,6 +104,10 @@ module RuboCop
         def min_digits
           cop_config['MinDigits']
         end
+
+        def allowed_numbers
+          cop_config.fetch('AllowedNumbers', []).map(&:to_s)
+        end
       end
     end
   end

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

@@ -45,7 +45,7 @@ module RuboCop
 
           message = message(node)
           add_offense(node, message: message) do |corrector|
-            corrector.replace(node, replacement(node))
+            autocorrect(corrector, node)
           end
         end
 
@@ -55,55 +55,30 @@ module RuboCop
           format(MSG, keyword: node.keyword)
         end
 
-        def replacement(node)
+        def autocorrect(corrector, node)
           if always_multiline? || cannot_replace_to_ternary?(node)
-            multiline_replacement(node)
+            IfThenCorrector.new(node, indentation: indentation_width).call(corrector)
           else
-            replaced_node = ternary_replacement(node)
-            return replaced_node unless node.parent
-            return "(#{replaced_node})" if %i[and or].include?(node.parent.type)
-            return "(#{replaced_node})" if node.parent.send_type? && node.parent.operator_method?
-
-            replaced_node
+            corrector.replace(node, ternary_correction(node))
           end
         end
 
-        def always_multiline?
-          @config.for_cop('Style/OneLineConditional')['AlwaysCorrectToMultiline']
-        end
+        def ternary_correction(node)
+          replaced_node = ternary_replacement(node)
 
-        def cannot_replace_to_ternary?(node)
-          node.elsif_conditional?
-        end
+          return replaced_node unless node.parent
+          return "(#{replaced_node})" if %i[and or].include?(node.parent.type)
+          return "(#{replaced_node})" if node.parent.send_type? && node.parent.operator_method?
 
-        def multiline_replacement(node, indentation = nil)
-          indentation = ' ' * node.source_range.column if indentation.nil?
-          if_branch_source = node.if_branch&.source || 'nil'
-          elsif_indentation = indentation if node.respond_to?(:elsif?) && node.elsif?
-          if_branch = <<~RUBY
-            #{elsif_indentation}#{node.keyword} #{node.condition.source}
-            #{indentation}#{branch_body_indentation}#{if_branch_source}
-          RUBY
-          else_branch = else_branch_to_multiline(node.else_branch, indentation)
-          if_branch + else_branch
+          replaced_node
         end
 
-        def else_branch_to_multiline(else_branch, indentation)
-          if else_branch.nil?
-            'end'
-          elsif else_branch.if_type? && else_branch.elsif?
-            multiline_replacement(else_branch, indentation)
-          else
-            <<~RUBY.chomp
-              #{indentation}else
-              #{indentation}#{branch_body_indentation}#{else_branch.source}
-              #{indentation}end
-            RUBY
-          end
+        def always_multiline?
+          @config.for_cop('Style/OneLineConditional')['AlwaysCorrectToMultiline']
         end
 
-        def branch_body_indentation
-          ' ' * (@config.for_cop('Layout/IndentationWidth')['Width'] || 2)
+        def cannot_replace_to_ternary?(node)
+          node.elsif_conditional?
         end
 
         def ternary_replacement(node)
@@ -141,6 +116,10 @@ module RuboCop
 
           node.respond_to?(:arguments?) && node.arguments? && !node.parenthesized_call?
         end
+
+        def indentation_width
+          @config.for_cop('Layout/IndentationWidth')['Width']
+        end
       end
     end
   end

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

@@ -97,7 +97,7 @@ module RuboCop
           offense_range = node.loc.begin
 
           add_offense(offense_range) do |corrector|
-            if any_ancestor_assignment_node?(node)
+            if node.parent&.assignment?
               replace_begin_with_statement(corrector, offense_range, node)
             else
               corrector.remove(offense_range)
@@ -170,11 +170,7 @@ module RuboCop
         end
 
         def valid_begin_assignment?(node)
-          any_ancestor_assignment_node?(node) && !node.children.one?
-        end
-
-        def any_ancestor_assignment_node?(node)
-          node.each_ancestor.any?(&:assignment?)
+          node.parent&.assignment? && !node.children.one?
         end
       end
     end

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

@@ -82,10 +82,20 @@ module RuboCop
         end
 
         def autocorrect_single_variable_interpolation(corrector, embedded_node, node)
-          variable_loc = embedded_node.children.first.loc
-          replacement = "#{variable_loc.expression.source}.to_s"
+          embedded_var = embedded_node.children.first
 
-          corrector.replace(node, replacement)
+          source = if require_parentheses?(embedded_var)
+                     receiver = range_between(
+                       embedded_var.loc.expression.begin_pos, embedded_var.loc.selector.end_pos
+                     )
+                     arguments = embedded_var.arguments.map(&:source).join(', ')
+
+                     "#{receiver.source}(#{arguments})"
+                   else
+                     embedded_var.source
+                   end
+
+          corrector.replace(node, "#{source}.to_s")
         end
 
         def autocorrect_other(corrector, embedded_node, node)
@@ -97,6 +107,10 @@ module RuboCop
           corrector.replace(embedded_loc.begin, '(')
           corrector.replace(embedded_loc.end, ').to_s')
         end
+
+        def require_parentheses?(node)
+          node.send_type? && !node.arguments.count.zero? && !node.parenthesized_call?
+        end
       end
     end
   end

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

@@ -80,7 +80,11 @@ module RuboCop
         end
 
         def without_character_class(loc)
-          loc.source[1..-2]
+          without_character_class = loc.source[1..-2]
+
+          # Adds `\` to prevent auto-correction that changes to an interpolated string when `[#]`.
+          # e.g. From `/[#]{0}/` to `/#{0}/`
+          loc.source == '[#]' ? "\\#{without_character_class}" : without_character_class
         end
 
         def whitespace_in_free_space_mode?(node, elem)

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

@@ -53,7 +53,7 @@ module RuboCop
                       yield __FILE__ __LINE__ __ENCODING__].freeze
 
         def self.autocorrect_incompatible_with
-          [ColonMethodCall]
+          [ColonMethodCall, Layout::DotPosition]
         end
 
         def initialize(config = nil, options = nil)

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

@@ -218,11 +218,7 @@ module RuboCop
         def find_matching_receiver_invocation(method_chain, checked_variable)
           return nil unless method_chain
 
-          receiver = if method_chain.block_type?
-                       method_chain.send_node.receiver
-                     else
-                       method_chain.receiver
-                     end
+          receiver = method_chain.receiver
 
           return receiver if receiver == checked_variable
 

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

@@ -91,11 +91,12 @@ module RuboCop
           second.int_type? ? second.to_a.first : :unknown
         end
 
-        def range_size(range_node) # rubocop:todo Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def range_size(range_node)
           vals = range_node.to_a
-          return :unknown unless vals.all?(&:int_type?)
+          return :unknown unless vals.all? { |val| val.nil? || val.int_type? }
 
-          low, high = vals.map { |val| val.children[0] }
+          low, high = vals.map { |val| val.nil? ? 0 : val.children[0] }
           return :unknown unless low.zero? && high >= 0
 
           case range_node.type
@@ -105,6 +106,7 @@ module RuboCop
             (low..high).size
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def source_range(shuffle_node, node)
           Parser::Source::Range.new(shuffle_node.source_range.source_buffer,

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

@@ -39,7 +39,7 @@ module RuboCop
           return unless eligible_method?(node)
           return unless eligible_arguments?(node)
 
-          method_name = node.send_node.method_name
+          method_name = node.method_name
           return if args_match?(method_name, node.arguments)
 
           preferred_block_arguments = build_preferred_arguments_map(node, target_args(method_name))
@@ -81,7 +81,7 @@ module RuboCop
         end
 
         def eligible_method?(node)
-          node.send_node.receiver && method_names.include?(node.send_node.method_name)
+          node.receiver && method_names.include?(node.method_name)
         end
 
         def methods

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

@@ -82,7 +82,9 @@ module RuboCop
         end
 
         def autocorrect(corrector, node, if_branch)
-          corrector.wrap(node.condition, '(', ')') if node.condition.or_type?
+          if node.condition.or_type? || node.condition.assignment?
+            corrector.wrap(node.condition, '(', ')')
+          end
 
           correct_from_unless_to_if(corrector, node) if node.unless?
 

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

@@ -58,6 +58,8 @@ module RuboCop
         end
 
         def simple_assignment?(node)
+          return false unless node.respond_to?(:type)
+
           SIMPLE_ASSIGNMENT_TYPES.include?(node.type)
         end
 

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

@@ -67,7 +67,10 @@ module RuboCop
         MSG_COMPLEX = '%<command>s parentheses for ternary expressions with complex conditions.'
 
         def on_if(node)
-          return if only_closing_parenthesis_is_last_line?(node.condition)
+          condition = node.condition
+
+          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)
 
           message = message(node)
@@ -77,11 +80,22 @@ module RuboCop
           end
         end
 
+        private
+
         def only_closing_parenthesis_is_last_line?(condition)
           condition.source.split("\n").last == ')'
         end
 
-        private
+        def condition_as_parenthesized_one_line_pattern_matching?(condition)
+          return false unless condition.parenthesized_call?
+          return false unless (first_child = condition.children.first)
+
+          if target_ruby_version >= 3.0
+            first_child.match_pattern_p_type?
+          else
+            first_child.match_pattern_type? # For Ruby 2.7's one line pattern matching AST.
+          end
+        end
 
         def autocorrect(corrector, node)
           condition = node.condition

data/lib/rubocop/cop/team.rb

@@ -131,7 +131,7 @@ module RuboCop
           @options[:stdin] = new_source
         else
           filename = processed_source.buffer.name
-          File.open(filename, 'w') { |f| f.write(new_source) }
+          File.write(filename, new_source)
         end
         @updated_source_file = true
       end

data/lib/rubocop/cop/util.rb

@@ -30,8 +30,15 @@ module RuboCop
         node.loc.respond_to?(:end) && node.loc.end && node.loc.end.is?(')')
       end
 
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       def add_parentheses(node, corrector)
-        if !node.respond_to?(:arguments)
+        if node.args_type?
+          arguments_range = node.source_range
+          args_with_space = range_with_surrounding_space(range: arguments_range, side: :left)
+          leading_space = range_between(args_with_space.begin_pos, arguments_range.begin_pos)
+          corrector.replace(leading_space, '(')
+          corrector.insert_after(arguments_range, ')')
+        elsif !node.respond_to?(:arguments)
           corrector.wrap(node, '(', ')')
         elsif node.arguments.empty?
           corrector.insert_after(node, '()')
@@ -43,6 +50,7 @@ module RuboCop
           corrector.insert_after(args_end(node), ')')
         end
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       def args_begin(node)
         loc = node.loc

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -121,9 +121,14 @@ module RuboCop
         output_buffer.puts "# Offense count: #{offense_count}" if show_offense_counts?
 
         cop_class = Cop::Registry.global.find_by_cop_name(cop_name)
-        output_buffer.puts '# Cop supports --auto-correct.' if cop_class&.support_autocorrect?
-
         default_cfg = default_config(cop_name)
+
+        if supports_safe_auto_correct?(cop_class, default_cfg)
+          output_buffer.puts '# Cop supports --auto-correct.'
+        elsif supports_unsafe_autocorrect?(cop_class, default_cfg)
+          output_buffer.puts '# Cop supports --auto-correct-all.'
+        end
+
         return unless default_cfg
 
         params = cop_config_params(default_cfg, cfg)
@@ -132,6 +137,15 @@ module RuboCop
         output_cop_param_comments(output_buffer, params, default_cfg)
       end
 
+      def supports_safe_auto_correct?(cop_class, default_cfg)
+        cop_class&.support_autocorrect? &&
+          (default_cfg.nil? || default_cfg['Safe'] || default_cfg['Safe'].nil?)
+      end
+
+      def supports_unsafe_autocorrect?(cop_class, default_cfg)
+        cop_class&.support_autocorrect? && !default_cfg.nil? && default_cfg['Safe'] == false
+      end
+
       def cop_config_params(default_cfg, cfg)
         default_cfg.keys -
           %w[Description StyleGuide Reference Enabled Exclude Safe

data/lib/rubocop/options.rb

@@ -15,7 +15,7 @@ module RuboCop
                       'root of the project. RuboCop will use this path to determine which ' \
                       'cops are enabled (via eg. Include/Exclude), and so that certain cops ' \
                       'like Naming/FileName can be checked.'
-    EXITING_OPTIONS = %i[version verbose_version show_cops].freeze
+    EXITING_OPTIONS = %i[version verbose_version show_cops show_docs_url].freeze
     DEFAULT_MAXIMUM_EXCLUSION_ITEMS = 15
 
     def initialize
@@ -188,6 +188,9 @@ module RuboCop
         option(opts, '--show-cops [COP1,COP2,...]') do |list|
           @options[:show_cops] = list.nil? ? [] : list.split(',')
         end
+        option(opts, '--show-docs-url [COP1,COP2,...]') do |list|
+          @options[:show_docs_url] = list.nil? ? [] : list.split(',')
+        end
       end
     end
 
@@ -475,6 +478,8 @@ module RuboCop
       show_cops:                        ['Shows the given cops, or all cops by',
                                          'default, and their configurations for the',
                                          'current directory.'],
+      show_docs_url:                    ['Display url to documentation for the given',
+                                         'cops, or base url by default.'],
       fail_fast:                        ['Inspect files in order of modification',
                                          'time and stop after the first file',
                                          'containing offenses.'],

data/lib/rubocop/remote_config.rb

@@ -23,9 +23,7 @@ module RuboCop
         next if response.is_a?(Net::HTTPNotModified)
         next if response.is_a?(SocketError)
 
-        File.open cache_path, 'w' do |io|
-          io.write response.body
-        end
+        File.write(cache_path, response.body)
       end
 
       cache_path

data/lib/rubocop/result_cache.rb

@@ -179,7 +179,7 @@ module RuboCop
             .select { |path| File.file?(path) }
             .sort!
             .each do |path|
-              content = File.open(path, 'rb', &:read)
+              content = File.binread(path)
               digest << Zlib.crc32(content).to_s # mtime not reliable
             end
           digest << RuboCop::Version::STRING << RuboCop::AST::Version::STRING

data/lib/rubocop/version.rb

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