rubocop 1.22.1 → 1.24.0

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/naming/file_name.rb

@@ -14,6 +14,18 @@ module RuboCop
       # (i.e. `bundler-console` becomes `Bundler::Console`). As such, the
       # gemspec is supposed to be named `bundler-console.gemspec`.
       #
+      # When `ExpectMatchingDefinition` (default: `false`) is `true`, the cop requires
+      # each file to have a class, module or `Struct` defined in it that matches
+      # the filename. This can be further configured using
+      # `CheckDefinitionPathHierarchy` (default: `true`) to determine whether the
+      # path should match the namespace of the above definition.
+      #
+      # When `IgnoreExecutableScripts` (default: `true`) is `true`, files that start
+      # with a shebang line are not considered by the cop.
+      #
+      # When `Regex` is set, the cop will flag any filename that does not match
+      # the regular expression.
+      #
       # @example
       #   # bad
       #   lib/layoutManager.rb
@@ -28,11 +40,19 @@ module RuboCop
         include RangeHelp
 
         MSG_SNAKE_CASE = 'The name of this source file (`%<basename>s`) should use snake_case.'
-        MSG_NO_DEFINITION = '%<basename>s should define a class or module called `%<namespace>s`.'
+        MSG_NO_DEFINITION = '`%<basename>s` should define a class or module called `%<namespace>s`.'
         MSG_REGEX = '`%<basename>s` should match `%<regex>s`.'
 
         SNAKE_CASE = /^[\d[[:lower:]]_.?!]+$/.freeze
 
+        # @!method struct_definition(node)
+        def_node_matcher :struct_definition, <<~PATTERN
+          {
+            (casgn $_ $_        (send (const {nil? cbase} :Struct) :new ...))
+            (casgn $_ $_ (block (send (const {nil? cbase} :Struct) :new ...) ...))
+          }
+        PATTERN
+
         def on_new_investigation
           file_path = processed_source.file_path
           return if config.file_to_exclude?(file_path) || config.allowed_camel_case_file?(file_path)
@@ -103,6 +123,10 @@ module RuboCop
           cop_config['CheckDefinitionPathHierarchy']
         end
 
+        def definition_path_hierarchy_roots
+          cop_config['CheckDefinitionPathHierarchyRoots'] || []
+        end
+
         def regex
           cop_config['Regex']
         end
@@ -126,7 +150,7 @@ module RuboCop
           name = namespace.pop
 
           on_node(%i[class module casgn], node) do |child|
-            next unless (const = child.defined_module)
+            next unless (const = find_definition(child))
 
             const_namespace, const_name = *const
             next if name != const_name && !match_acronym?(name, const_name)
@@ -138,6 +162,15 @@ module RuboCop
           nil
         end
 
+        def find_definition(node)
+          node.defined_module || defined_struct(node)
+        end
+
+        def defined_struct(node)
+          namespace, name = *struct_definition(node)
+          s(:const, namespace, name) if name
+        end
+
         def match_namespace(node, namespace, expected)
           match_partial = partial_matcher!(expected)
 
@@ -177,13 +210,13 @@ module RuboCop
           allowed_acronyms.any? { |acronym| expected.gsub(acronym.capitalize, acronym) == name }
         end
 
-        def to_namespace(path)
+        def to_namespace(path) # rubocop:disable Metrics/AbcSize
           components = Pathname(path).each_filename.to_a
           # To convert a pathname to a Ruby namespace, we need a starting point
           # But RC can be run from any working directory, and can check any path
           # We can't assume that the working directory, or any other, is the
           # "starting point" to build a namespace.
-          start = %w[lib spec test src]
+          start = definition_path_hierarchy_roots
           start_index = nil
 
           # To find the closest namespace root take the path components, and

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

@@ -7,7 +7,7 @@ module RuboCop
       # security issues.
       #
       # @safety
-      #   Autocorrect is disabled by default because it's potentially dangerous.
+      #   This cop's autocorrection is unsafe because it's potentially dangerous.
       #   If using a stream, like `JSON.load(open('file'))`, it will need to call
       #   `#read` manually, like `JSON.parse(open('file').read)`.
       #   If reading single values (rather than proper JSON objects), like

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

@@ -52,9 +52,11 @@ module RuboCop
         ALLOWED_COMMENTS = %w[:nodoc: :yields: rubocop:disable rubocop:todo].freeze
         ALLOWED_COMMENT_REGEXES = ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ }.freeze
 
+        REGEXP = /(?<keyword>\S+).*#/.freeze
+
         def on_new_investigation
           processed_source.comments.each do |comment|
-            next unless offensive?(comment) && (match = line(comment).match(/(?<keyword>\S+).*#/))
+            next unless offensive?(comment) && (match = source_line(comment).match(REGEXP))
 
             register_offense(comment, match[:keyword])
           end
@@ -76,12 +78,12 @@ module RuboCop
         end
 
         def offensive?(comment)
-          line = line(comment)
+          line = source_line(comment)
           KEYWORD_REGEXES.any? { |r| r.match?(line) } &&
             ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
         end
 
-        def line(comment)
+        def source_line(comment)
           comment.location.expression.source_line
         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,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/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)