rubocop 1.23.0 → 1.24.0

data/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -135,7 +135,7 @@ module RuboCop
 
           def extract_body(node)
             case node.type
-            when :class, :module, :block, :def, :defs
+            when :class, :module, :block, :numblock, :def, :defs
               node.body
             when :casgn
               _scope, _name, value = *node

data/lib/rubocop/cop/mixin/enforce_superclass.rb

@@ -13,6 +13,11 @@ module RuboCop
     # @api private
     module EnforceSuperclass
       def self.included(base)
+        warn Rainbow(
+          '`RuboCop::Cop::EnforceSuperclass` is deprecated and will be removed in RuboCop 2.0. ' \
+          'Please upgrade to RuboCop Rails 2.9 or newer to continue.'
+        ).yellow
+
         # @!method class_definition(node)
         base.def_node_matcher :class_definition, <<~PATTERN
           (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)

data/lib/rubocop/cop/mixin/hash_alignment_styles.rb

@@ -43,7 +43,7 @@ module RuboCop
         end
 
         def value_delta(pair)
-          return 0 if pair.value_on_new_line?
+          return 0 if pair.value_on_new_line? || pair.value_omission?
 
           correct_value_column = pair.loc.operator.end.column + 1
           actual_value_column = pair.value.loc.column
@@ -111,7 +111,8 @@ module RuboCop
           correct_value_column = first_pair.key.loc.column +
                                  current_pair.delimiter(true).length +
                                  max_key_width
-          correct_value_column - current_pair.value.loc.column
+
+          current_pair.value_omission? ? 0 : correct_value_column - current_pair.value.loc.column
         end
       end
 
@@ -134,7 +135,7 @@ module RuboCop
         end
 
         def value_delta(first_pair, current_pair)
-          first_pair.value_delta(current_pair)
+          current_pair.value_omission? ? 0 : first_pair.value_delta(current_pair)
         end
       end
 

data/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module checks for Ruby 3.1's hash value omission syntax.
+    module HashShorthandSyntax
+      OMIT_HASH_VALUE_MSG = 'Omit the hash value.'
+      EXPLICIT_HASH_VALUE_MSG = 'Explicit the hash value.'
+
+      def on_pair(node)
+        return if target_ruby_version <= 3.0
+
+        hash_key_source = node.key.source
+
+        if enforced_shorthand_syntax == 'always'
+          return if node.value_omission? || require_hash_value?(hash_key_source, node)
+
+          message = OMIT_HASH_VALUE_MSG
+          replacement = "#{hash_key_source}:"
+        else
+          return unless node.value_omission?
+
+          message = EXPLICIT_HASH_VALUE_MSG
+          replacement = "#{hash_key_source}: #{hash_key_source}"
+        end
+
+        add_offense(node.value, message: message) do |corrector|
+          corrector.replace(node, replacement)
+        end
+      end
+
+      private
+
+      def enforced_shorthand_syntax
+        cop_config.fetch('EnforcedShorthandSyntax', 'always')
+      end
+
+      def require_hash_value?(hash_key_source, node)
+        return true if without_parentheses_call_expr_follows?(node)
+
+        hash_value = node.value
+        return true unless hash_value.send_type? || hash_value.lvar_type?
+
+        hash_key_source != hash_value.source || hash_key_source.end_with?('!', '?')
+      end
+
+      def without_parentheses_call_expr_follows?(node)
+        return false unless (ancestor = node.parent.parent)
+        return false unless (right_sibling = ancestor.right_sibling)
+
+        ancestor.respond_to?(:parenthesized?) && !ancestor.parenthesized? &&
+          right_sibling.respond_to?(:parenthesized?) && !right_sibling.parenthesized?
+      end
+    end
+  end
+end

data/lib/rubocop/cop/naming/block_forwarding.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # In Ruby 3.1, anonymous block forwarding has been added.
+      #
+      # This cop identifies places where `do_something(&block)` can be replaced
+      # by `do_something(&)`.
+      #
+      # It also supports the opposite style by alternative `explicit` option.
+      #
+      # @example EnforcedStyle: anonymous (default)
+      #
+      #   # bad
+      #   def foo(&block)
+      #     bar(&block)
+      #   end
+      #
+      #   # good
+      #   def foo(&)
+      #     bar(&)
+      #   end
+      #
+      # @example EnforcedStyle: explicit
+      #
+      #   # bad
+      #   def foo(&)
+      #     bar(&)
+      #   end
+      #
+      #   # good
+      #   def foo(&block)
+      #     bar(&block)
+      #   end
+      #
+      class BlockForwarding < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 3.1
+
+        MSG = 'Use %<style>s block forwarding.'
+
+        def on_def(node)
+          return if node.arguments.empty?
+
+          last_argument = node.arguments.last
+          return if expected_block_forwarding_style?(node, last_argument)
+
+          register_offense(last_argument)
+
+          node.each_descendant(:block_pass) do |block_pass_node|
+            next if block_pass_node.children.first&.sym_type?
+
+            register_offense(block_pass_node)
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        def expected_block_forwarding_style?(node, last_argument)
+          if style == :anonymous
+            !explicit_block_argument?(last_argument) ||
+              use_kwarg_in_method_definition?(node) ||
+              use_block_argument_as_local_variable?(node, last_argument)
+          else
+            !anonymous_block_argument?(last_argument)
+          end
+        end
+
+        def use_kwarg_in_method_definition?(node)
+          node.arguments.each_descendant(:kwarg, :kwoptarg).any?
+        end
+
+        def anonymous_block_argument?(node)
+          node.blockarg_type? && node.name.nil?
+        end
+
+        def explicit_block_argument?(node)
+          node.blockarg_type? && !node.name.nil?
+        end
+
+        def use_block_argument_as_local_variable?(node, last_argument)
+          return if node.body.nil?
+
+          node.body.each_descendant(:lvar).any? do |lvar|
+            !lvar.parent.block_pass_type? && lvar.source == last_argument.source[1..-1]
+          end
+        end
+
+        def register_offense(block_argument)
+          add_offense(block_argument, message: format(MSG, style: style)) do |corrector|
+            corrector.replace(block_argument, '&')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/security/open.rb

@@ -3,7 +3,8 @@
 module RuboCop
   module Cop
     module Security
-      # This cop checks for the use of `Kernel#open` and `URI.open`.
+      # This cop checks for the use of `Kernel#open` and `URI.open` with dynamic
+      # data.
       #
       # `Kernel#open` and `URI.open` enable not only file access but also process
       # invocation by prefixing a pipe symbol (e.g., `open("| ls")`).
@@ -11,6 +12,9 @@ module RuboCop
       # the argument of `Kernel#open` and `URI.open`. It would be better to use
       # `File.open`, `IO.popen` or `URI.parse#open` explicitly.
       #
+      # NOTE: `open` and `URI.open` with literal strings are not flagged by this
+      # cop.
+      #
       # @safety
       #   This cop could register false positives if `open` is redefined
       #   in a class and then used without a receiver in that class.
@@ -18,12 +22,18 @@ module RuboCop
       # @example
       #   # bad
       #   open(something)
+      #   open("| #{something}")
       #   URI.open(something)
       #
       #   # good
       #   File.open(something)
       #   IO.popen(something)
       #   URI.parse(something).open
+      #
+      #   # good (literal strings)
+      #   open("foo.text")
+      #   open("| foo")
+      #   URI.open("http://example.com")
       class Open < Base
         MSG = 'The use of `%<receiver>sopen` is a serious security risk.'
         RESTRICT_ON_SEND = %i[open].freeze

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

@@ -4,6 +4,12 @@ module RuboCop
   module Cop
     module Style
       # Checks for uses of the character literal ?x.
+      # Starting with Ruby 1.9 character literals are
+      # essentially one-character strings, so this syntax
+      # is mostly redundant at this point.
+      #
+      # ? character literal can be used to express meta and control character.
+      # That's a good use case of ? literal so it doesn't count it as an offense.
       #
       # @example
       #   # bad
@@ -12,8 +18,9 @@ module RuboCop
       #   # good
       #   'x'
       #
-      #   # good
+      #   # good - control & meta escapes
       #   ?\C-\M-d
+      #   "\C-\M-d" # same as above
       class CharacterLiteral < Base
         include StringHelp
         extend AutoCorrector

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 _ {:reject :reject!}
+            (block_pass
+              (sym :nil?)))
+        PATTERN
+
         # @!method reject_method?(node)
         def_node_matcher :reject_method?, <<~PATTERN
           (block
             (send
-              _ ${:reject :reject!})
+              _ {:reject :reject!})
             $(args ...)
             (send
               $(lvar _) :nil?))
@@ -51,7 +60,7 @@ module RuboCop
         def_node_matcher :select_method?, <<~PATTERN
           (block
             (send
-              _ ${:select :select!})
+              _ {: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/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/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,98 @@
+# 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 = "#{write_method(mode)}(#{filename.source}, #{content.source})"
+
+              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
+      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