rubocop 1.22.3 → 1.25.0

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

@@ -16,6 +16,7 @@ module RuboCop
       #
       # @example
       #   # bad
+      #   array.reject(&:nil?)
       #   array.reject { |e| e.nil? }
       #   array.select { |e| !e.nil? }
       #
@@ -23,6 +24,7 @@ module RuboCop
       #   array.compact
       #
       #   # bad
+      #   hash.reject!(&:nil?)
       #   hash.reject! { |k, v| v.nil? }
       #   hash.select! { |k, v| !v.nil? }
       #
@@ -37,11 +39,18 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[reject reject! select select!].freeze
 
+        # @!method reject_method_with_block_pass?(node)
+        def_node_matcher :reject_method_with_block_pass?, <<~PATTERN
+          (send !nil? {:reject :reject!}
+            (block_pass
+              (sym :nil?)))
+        PATTERN
+
         # @!method reject_method?(node)
         def_node_matcher :reject_method?, <<~PATTERN
           (block
             (send
-              _ ${:reject :reject!})
+              !nil? {:reject :reject!})
             $(args ...)
             (send
               $(lvar _) :nil?))
@@ -51,7 +60,7 @@ module RuboCop
         def_node_matcher :select_method?, <<~PATTERN
           (block
             (send
-              _ ${:select :select!})
+              !nil? {:select :select!})
             $(args ...)
             (send
               (send
@@ -59,16 +68,9 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          block_node = node.parent
-          return unless block_node&.block_type?
-
-          return unless (method_name, args, receiver =
-                           reject_method?(block_node) || select_method?(block_node))
+          return unless (range = offense_range(node))
 
-          return unless args.last.source == receiver.source
-
-          range = offense_range(node, block_node)
-          good = good_method_name(method_name)
+          good = good_method_name(node.method_name)
           message = format(MSG, good: good, bad: range.source)
 
           add_offense(range, message: message) { |corrector| corrector.replace(range, good) }
@@ -76,6 +78,22 @@ module RuboCop
 
         private
 
+        def offense_range(node)
+          if reject_method_with_block_pass?(node)
+            range(node, node)
+          else
+            block_node = node.parent
+
+            return unless block_node&.block_type?
+            unless (args, receiver = reject_method?(block_node) || select_method?(block_node))
+              return
+            end
+            return unless args.last.source == receiver.source
+
+            range(node, block_node)
+          end
+        end
+
         def good_method_name(method_name)
           if method_name.to_s.end_with?('!')
             'compact!'
@@ -84,8 +102,8 @@ module RuboCop
           end
         end
 
-        def offense_range(send_node, block_node)
-          range_between(send_node.loc.selector.begin_pos, block_node.loc.end.end_pos)
+        def range(begin_pos_node, end_pos_node)
+          range_between(begin_pos_node.loc.selector.begin_pos, end_pos_node.loc.end.end_pos)
         end
       end
     end

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

@@ -77,14 +77,14 @@ module RuboCop
 
         def collection_looping_method?(node)
           # TODO: Remove `Symbol#to_s` after supporting only Ruby >= 2.7.
-          method_name = node.send_node.method_name.to_s
+          method_name = node.method_name.to_s
           method_name.start_with?('each') || method_name.end_with?('_each')
         end
 
         def same_collection_looping?(node, sibling)
           sibling&.block_type? &&
             sibling.send_node.method?(node.method_name) &&
-            sibling.send_node.receiver == node.send_node.receiver &&
+            sibling.receiver == node.receiver &&
             sibling.send_node.arguments == node.send_node.arguments
         end
       end

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

@@ -176,7 +176,7 @@ module RuboCop
         end
 
         def qualify_const(node)
-          return if node.nil?
+          return if node.nil? || node.cbase_type?
 
           [qualify_const(node.namespace), node.short_name].compact
         end

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

@@ -79,6 +79,8 @@ module RuboCop
           when_nodes.each do |when_node|
             conditions = when_node.conditions
 
+            replace_then_with_line_break(corrector, conditions, when_node)
+
             next unless conditions.size > 1
 
             range = range_between(conditions.first.source_range.begin_pos,
@@ -97,6 +99,14 @@ module RuboCop
           line_beginning = case_range.adjust(begin_pos: -case_range.column)
           corrector.insert_before(line_beginning, comments)
         end
+
+        def replace_then_with_line_break(corrector, conditions, when_node)
+          return unless when_node.parent.parent && when_node.then?
+
+          range = range_between(conditions.last.source_range.end_pos, when_node.loc.begin.end_pos)
+
+          corrector.replace(range, "\n")
+        end
       end
     end
   end

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

@@ -9,7 +9,7 @@ module RuboCop
       # to go on its own line (expanded style).
       #
       # NOTE: A method definition is not considered empty if it contains
-      #       comments.
+      # comments.
       #
       # @example EnforcedStyle: compact (default)
       #   # bad

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Favor `File.(bin)read` convenience methods.
+      #
+      # @example
+      #   ## text mode
+      #   # bad
+      #   File.open(filename).read
+      #   File.open(filename, &:read)
+      #   File.open(filename) { |f| f.read }
+      #   File.open(filename) do |f|
+      #     f.read
+      #   end
+      #   File.open(filename, 'r').read
+      #   File.open(filename, 'r', &:read)
+      #   File.open(filename, 'r') do |f|
+      #     f.read
+      #   end
+      #
+      #   # good
+      #   File.read(filename)
+      #
+      # @example
+      #   ## binary mode
+      #   # bad
+      #   File.open(filename, 'rb').read
+      #   File.open(filename, 'rb', &:read)
+      #   File.open(filename, 'rb') do |f|
+      #     f.read
+      #   end
+      #
+      #   # good
+      #   File.binread(filename)
+      #
+      class FileRead < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `File.%<read_method>s`.'
+
+        RESTRICT_ON_SEND = %i[open].freeze
+
+        READ_FILE_START_TO_FINISH_MODES = %w[r rt rb r+ r+t r+b].to_set.freeze
+
+        # @!method file_open?(node)
+        def_node_matcher :file_open?, <<~PATTERN
+          (send
+            (const {nil? cbase} :File)
+            :open
+            $_
+            (str $%READ_FILE_START_TO_FINISH_MODES)?
+            $(block-pass (sym :read))?
+          )
+        PATTERN
+
+        # @!method send_read?(node)
+        def_node_matcher :send_read?, <<~PATTERN
+          (send _ :read)
+        PATTERN
+
+        # @!method block_read?(node)
+        def_node_matcher :block_read?, <<~PATTERN
+          (block _ (args (arg $_)) (send (lvar $_) :read))
+        PATTERN
+
+        def on_send(node)
+          evidence(node) do |filename, mode, read_node|
+            message = format(MSG, read_method: read_method(mode))
+
+            add_offense(read_node, message: message) do |corrector|
+              range = range_between(node.loc.selector.begin_pos, read_node.loc.expression.end_pos)
+              replacement = "#{read_method(mode)}(#{filename.source})"
+
+              corrector.replace(range, replacement)
+            end
+          end
+        end
+
+        private
+
+        def evidence(node)
+          file_open?(node) do |filename, mode_array, block_pass|
+            read_node?(node, block_pass) do |read_node|
+              yield(filename, mode_array.first || 'r', read_node)
+            end
+          end
+        end
+
+        def read_node?(node, block_pass)
+          if block_pass.any?
+            yield(node)
+          elsif file_open_read?(node.parent)
+            yield(node.parent)
+          end
+        end
+
+        def file_open_read?(node)
+          return true if send_read?(node)
+
+          block_read?(node) { |block_arg, read_lvar| block_arg == read_lvar }
+        end
+
+        def read_method(mode)
+          mode.end_with?('b') ? :binread : :read
+        end
+      end
+    end
+  end
+end

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/format_string_token.rb

@@ -102,7 +102,8 @@ module RuboCop
         end
 
         def use_ignored_method?(node)
-          (parent = node.parent) && parent.send_type? && ignored_method?(parent.method_name)
+          send_parent = node.each_ancestor(:send).first
+          send_parent && ignored_method?(send_parent.method_name)
         end
 
         def unannotated_format?(node, detected_style)

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,16 @@ 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.
+      #
+      # The supported styles are:
+      #
+      # * always - forces use of the 3.1 syntax (e.g. {foo:})
+      # * never - forces use of explicit hash literal value
+      # * either - accepts both shorthand and explicit use of hash literal value
+      #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad
       #   {:a => 2}
@@ -54,8 +64,34 @@ 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}
+      #
+      # @example EnforcedShorthandSyntax: either
+      #
+      #   # good
+      #   {foo: foo, bar: bar}
+      #
+      #   # good
+      #   {foo:, 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/if_with_boolean_literal_branches.rb

@@ -36,7 +36,7 @@ module RuboCop
       #   # good (but potentially an unsafe correction)
       #   foo.do_something?
       #
-      # @example AllowedMethods: ['nonzero?']
+      # @example AllowedMethods: ['nonzero?'] (default)
       #   # good
       #   num.nonzero? ? true : false
       #

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