rubocop 1.23.0 → 1.24.1

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Favor `File.(bin)write` convenience methods.
+      #
+      # @example
+      #   ## text mode
+      #   # bad
+      #   File.open(filename, 'w').write(content)
+      #   File.open(filename, 'w') do |f|
+      #     f.write(content)
+      #   end
+      #
+      #   # good
+      #   File.write(filename, content)
+      #
+      # @example
+      #   ## binary mode
+      #   # bad
+      #   File.open(filename, 'wb').write(content)
+      #   File.open(filename, 'wb') do |f|
+      #     f.write(content)
+      #   end
+      #
+      #   # good
+      #   File.binwrite(filename, content)
+      #
+      class FileWrite < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `File.%<write_method>s`.'
+
+        RESTRICT_ON_SEND = %i[open].to_set.freeze
+
+        TRUNCATING_WRITE_MODES = %w[w wt wb w+ w+t w+b].to_set.freeze
+
+        # @!method file_open?(node)
+        def_node_matcher :file_open?, <<~PATTERN
+          (send
+            (const {nil? cbase} :File)
+            :open
+            $_
+            (str $%TRUNCATING_WRITE_MODES)
+            (block-pass (sym :write))?
+          )
+        PATTERN
+
+        # @!method send_write?(node)
+        def_node_matcher :send_write?, <<~PATTERN
+          (send _ :write $_)
+        PATTERN
+
+        # @!method block_write?(node)
+        def_node_matcher :block_write?, <<~PATTERN
+          (block _ (args (arg $_)) (send (lvar $_) :write $_))
+        PATTERN
+
+        def on_send(node)
+          evidence(node) do |filename, mode, content, write_node|
+            message = format(MSG, write_method: write_method(mode))
+
+            add_offense(write_node, message: message) do |corrector|
+              range = range_between(node.loc.selector.begin_pos, write_node.loc.expression.end_pos)
+              replacement = replacement(mode, filename, content, write_node)
+
+              corrector.replace(range, replacement)
+            end
+          end
+        end
+
+        def evidence(node)
+          file_open?(node) do |filename, mode|
+            file_open_write?(node.parent) do |content|
+              yield(filename, mode, content, node.parent)
+            end
+          end
+        end
+
+        private
+
+        def file_open_write?(node)
+          content = send_write?(node) || block_write?(node) do |block_arg, lvar, write_arg|
+            write_arg if block_arg == lvar
+          end
+
+          yield(content) if content
+        end
+
+        def write_method(mode)
+          mode.end_with?('b') ? :binwrite : :write
+        end
+
+        def replacement(mode, filename, content, write_node)
+          replacement = "#{write_method(mode)}(#{filename.source}, #{content.source})"
+
+          if heredoc?(write_node)
+            first_argument = write_node.body.first_argument
+
+            <<~REPLACEMENT.chomp
+              #{replacement}
+              #{heredoc_range(first_argument).source}
+            REPLACEMENT
+          else
+            replacement
+          end
+        end
+
+        def heredoc?(write_node)
+          write_node.block_type? && (first_argument = write_node.body.first_argument) &&
+            first_argument.respond_to?(:heredoc?) && first_argument.heredoc?
+        end
+
+        def heredoc_range(first_argument)
+          range_between(
+            first_argument.loc.heredoc_body.begin_pos, first_argument.loc.heredoc_end.end_pos
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -101,7 +101,8 @@ module RuboCop
         end
 
         def requires_parens?(node)
-          node.call_type? && node.arguments.any? && !node.parenthesized?
+          (node.call_type? && node.arguments.any? && !node.parenthesized?) ||
+            node.or_type? || node.and_type?
         end
 
         def multi_argument(node)

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

@@ -19,6 +19,10 @@ module RuboCop
       # * ruby19_no_mixed_keys - forces use of ruby 1.9 syntax and forbids mixed
       # syntax hashes
       #
+      # This cop has `EnforcedShorthandSyntax` option.
+      # It can enforce either the use of the explicit hash value syntax or
+      # the use of Ruby 3.1's hash value shorthand syntax.
+      #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad
       #   {:a => 2}
@@ -54,8 +58,26 @@ module RuboCop
       #   # good
       #   {a: 1, b: 2}
       #   {:c => 3, 'd' => 4}
+      #
+      # @example EnforcedShorthandSyntax: always (default)
+      #
+      #   # bad
+      #   {foo: foo, bar: bar}
+      #
+      #   # good
+      #   {foo:, bar:}
+      #
+      # @example EnforcedShorthandSyntax: never
+      #
+      #   # bad
+      #   {foo:, bar:}
+      #
+      #   # good
+      #   {foo: foo, bar: bar}
+      #
       class HashSyntax < Base
         include ConfigurableEnforcedStyle
+        include HashShorthandSyntax
         include RangeHelp
         extend AutoCorrector
 

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

@@ -30,13 +30,13 @@ module RuboCop
         # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            ({send csend} !#array_receiver? :each_with_object (hash))
+            (call !#array_receiver? :each_with_object (hash))
             (args
               (mlhs
                 (arg $_)
                 (arg _val))
               (arg _memo))
-            ({send csend} (lvar _memo) :[]= $!`_memo $(lvar _val)))
+            (call (lvar _memo) :[]= $!`_memo $(lvar _val)))
         PATTERN
 
         # @!method on_bad_hash_brackets_map(node)
@@ -45,7 +45,7 @@ module RuboCop
             (const _ :Hash)
             :[]
             (block
-              ({send csend} !#array_receiver? {:map :collect})
+              (call !#array_receiver? {:map :collect})
               (args
                 (arg $_)
                 (arg _val))
@@ -54,9 +54,9 @@ module RuboCop
 
         # @!method on_bad_map_to_h(node)
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
-          ({send csend}
+          (call
             (block
-              ({send csend} !#array_receiver? {:map :collect})
+              (call !#array_receiver? {:map :collect})
               (args
                 (arg $_)
                 (arg _val))
@@ -67,7 +67,7 @@ module RuboCop
         # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            ({send csend} !#array_receiver? :to_h)
+            (call !#array_receiver? :to_h)
             (args
               (arg $_)
               (arg _val))

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

@@ -30,13 +30,13 @@ module RuboCop
         # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            ({send csend} !#array_receiver? :each_with_object (hash))
+            (call !#array_receiver? :each_with_object (hash))
             (args
               (mlhs
                 (arg _key)
                 (arg $_))
               (arg _memo))
-            ({send csend} (lvar _memo) :[]= $(lvar _key) $!`_memo))
+            (call (lvar _memo) :[]= $(lvar _key) $!`_memo))
         PATTERN
 
         # @!method on_bad_hash_brackets_map(node)
@@ -45,7 +45,7 @@ module RuboCop
             (const _ :Hash)
             :[]
             (block
-              ({send csend} !#array_receiver? {:map :collect})
+              (call !#array_receiver? {:map :collect})
               (args
                 (arg _key)
                 (arg $_))
@@ -54,9 +54,9 @@ module RuboCop
 
         # @!method on_bad_map_to_h(node)
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
-          ({send csend}
+          (call
             (block
-              ({send csend} !#array_receiver? {:map :collect})
+              (call !#array_receiver? {:map :collect})
               (args
                 (arg _key)
                 (arg $_))
@@ -67,7 +67,7 @@ module RuboCop
         # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            ({send csend} !#array_receiver? :to_h)
+            (call !#array_receiver? :to_h)
             (args
               (arg _key)
               (arg $_))

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

@@ -80,11 +80,19 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
+          if then?(node)
+            # If the nested `if` is a then node, correct it first,
+            # then the next pass will use `correct_to_elsif_from_if_inside_else_form`
+            IfThenCorrector.new(node, indentation: 0).call(corrector)
+            return
+          end
+
           if node.modifier_form?
             correct_to_elsif_from_modifier_form(corrector, node)
           else
             correct_to_elsif_from_if_inside_else_form(corrector, node, node.condition)
           end
+
           corrector.remove(range_by_whole_lines(find_end_range(node), include_final_newline: true))
           return unless (if_branch = node.if_branch)
 
@@ -102,15 +110,22 @@ module RuboCop
 
         def correct_to_elsif_from_if_inside_else_form(corrector, node, condition)
           corrector.replace(node.parent.loc.else, "elsif #{condition.source}")
+
           if_condition_range = if_condition_range(node, condition)
+
           if (if_branch = node.if_branch)
             corrector.replace(if_condition_range, if_branch.source)
           else
             corrector.remove(range_by_whole_lines(if_condition_range, include_final_newline: true))
           end
+
           corrector.remove(condition)
         end
 
+        def then?(node)
+          node.loc.begin&.source == 'then'
+        end
+
         def find_end_range(node)
           end_range = node.loc.end
           return end_range if end_range

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,16 @@ module RuboCop
             node.each_ancestor(:def, :defs).any?(&:endless?) && node.arguments.any?
           end
 
+          # Require hash value omission be enclosed in parentheses to prevent the following issue:
+          # https://bugs.ruby-lang.org/issues/18396.
+          def require_parentheses_for_hash_value_omission?(node)
+            return unless (last_argument = node.last_argument)
+
+            return false unless (right_sibling = node.right_sibling)
+
+            last_argument.hash_type? && last_argument.pairs.last&.value_omission? && 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 the 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_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