rubocop 0.93.1 → 1.79.2

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

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-# rubocop:disable Style/AsciiComments
-
 module RuboCop
   module Cop
     module Naming
-      # This cop checks for non-ascii characters in identifier and constant names.
+      # Checks for non-ascii characters in identifier and constant names.
       # Identifiers are always checked and whether constants are checked
       # can be controlled using AsciiConstants config.
       #
@@ -59,7 +57,7 @@ module RuboCop
         CONSTANT_MSG   = 'Use only ascii symbols in constants.'
 
         def on_new_investigation
-          processed_source.each_token do |token|
+          processed_source.tokens.each do |token|
             next if !should_check?(token) || token.text.ascii_only?
 
             message = token.type == :tIDENTIFIER ? IDENTIFIER_MSG : CONSTANT_MSG
@@ -70,16 +68,14 @@ module RuboCop
         private
 
         def should_check?(token)
-          token.type == :tIDENTIFIER ||
-            (token.type == :tCONSTANT && cop_config['AsciiConstants'])
+          token.type == :tIDENTIFIER || (token.type == :tCONSTANT && cop_config['AsciiConstants'])
         end
 
         def first_offense_range(identifier)
           expression    = identifier.pos
           first_offense = first_non_ascii_chars(identifier.text)
 
-          start_position = expression.begin_pos +
-                           identifier.text.index(first_offense)
+          start_position = expression.begin_pos + identifier.text.index(first_offense)
           end_position   = start_position + first_offense.length
 
           range_between(start_position, end_position)
@@ -92,4 +88,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Style/AsciiComments

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop makes sure that certain binary operator methods have their
+      # Makes sure that certain binary operator methods have their
       # sole  parameter named `other`.
       #
       # @example
@@ -14,19 +14,29 @@ module RuboCop
       #   # good
       #   def +(other); end
       class BinaryOperatorParameterName < Base
-        MSG = 'When defining the `%<opr>s` operator, ' \
-              'name its argument `other`.'
+        extend AutoCorrector
+
+        MSG = 'When defining the `%<opr>s` operator, name its argument `other`.'
 
         OP_LIKE_METHODS = %i[eql? equal?].freeze
-        EXCLUDED = %i[+@ -@ [] []= << === `].freeze
+        EXCLUDED = %i[+@ -@ [] []= << === ` =~].freeze
 
+        # @!method op_method_candidate?(node)
         def_node_matcher :op_method_candidate?, <<~PATTERN
           (def [#op_method? $_] (args $(arg [!:other !:_other])) _)
         PATTERN
 
         def on_def(node)
           op_method_candidate?(node) do |name, arg|
-            add_offense(arg, message: format(MSG, opr: name))
+            add_offense(arg, message: format(MSG, opr: name)) do |corrector|
+              corrector.replace(arg, 'other')
+              node.each_descendant(:lvar, :lvasgn) do |lvar|
+                lvar_location = lvar.loc.name
+                next unless lvar_location.source == arg.source
+
+                corrector.replace(lvar_location, 'other')
+              end
+            end
           end
         end
 

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

@@ -0,0 +1,156 @@
+# 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.
+      # You can specify the block variable name for autocorrection with `BlockForwardingName`.
+      # The default variable name is `block`. If the name is already in use, it will not be
+      # autocorrected.
+      #
+      # [NOTE]
+      # ====
+      # Because of a bug in Ruby 3.3.0, when a block is referenced inside of another block,
+      # no offense will be registered until Ruby 3.4:
+      #
+      # [source,ruby]
+      # ----
+      # def foo(&block)
+      #   # Using an anonymous block would be a syntax error on Ruby 3.3.0
+      #   block_method { bar(&block) }
+      # end
+      # ----
+      # ====
+      #
+      # @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
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 3.1
+
+        MSG = 'Use %<style>s block forwarding.'
+
+        def self.autocorrect_incompatible_with
+          [Lint::AmbiguousOperator, Style::ArgumentsForwarding, Style::ExplicitBlockArgument]
+        end
+
+        def on_def(node)
+          return if node.arguments.empty?
+
+          last_argument = node.last_argument
+          return if expected_block_forwarding_style?(node, last_argument)
+
+          forwarded_args = node.each_descendant(:block_pass).with_object([]) do |block_pass, result|
+            return nil if invalidates_syntax?(block_pass)
+            next unless block_argument_name_matched?(block_pass, last_argument)
+
+            result << block_pass
+          end
+
+          forwarded_args.each do |forwarded_arg|
+            register_offense(forwarded_arg, node)
+          end
+
+          register_offense(last_argument, node)
+        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.source[1..])
+          else
+            !anonymous_block_argument?(last_argument)
+          end
+        end
+
+        def block_argument_name_matched?(block_pass_node, last_argument)
+          return false if block_pass_node.children.first&.sym_type?
+
+          last_argument.source == block_pass_node.source
+        end
+
+        # Ruby 3.3.0 had a bug where accessing an anonymous block argument inside of a block
+        # was a syntax error in unambiguous cases: https://bugs.ruby-lang.org/issues/20090
+        # We disallow this also for earlier Ruby versions so that code is forwards compatible.
+        def invalidates_syntax?(block_pass_node)
+          target_ruby_version <= 3.3 && block_pass_node.each_ancestor(:any_block).any?
+        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 register_offense(block_argument, node)
+          add_offense(block_argument, message: format(MSG, style: style)) do |corrector|
+            if style == :anonymous
+              corrector.replace(block_argument, '&')
+
+              arguments = block_argument.parent
+
+              add_parentheses(arguments, corrector) unless arguments.parenthesized_call?
+            else
+              unless use_block_argument_as_local_variable?(node, block_forwarding_name)
+                corrector.replace(block_argument, "&#{block_forwarding_name}")
+              end
+            end
+          end
+        end
+
+        def use_block_argument_as_local_variable?(node, last_argument)
+          return false if node.body.nil?
+
+          node.body.each_node(:lvar, :lvasgn).any? do |lvar|
+            !lvar.parent.block_pass_type? && lvar.node_parts[0].to_s == last_argument
+          end
+        end
+
+        def block_forwarding_name
+          cop_config.fetch('BlockForwardingName', 'block')
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop checks block parameter names for how descriptive they
+      # Checks block parameter names for how descriptive they
       # are. It is highly configurable.
       #
       # The `MinNameLength` config option takes an integer. It represents
@@ -24,7 +24,7 @@ module RuboCop
       #   # With `AllowNamesEndingInNumbers` set to false
       #   foo { |num1, num2| num1 * num2 }
       #
-      #   # With `MinParamNameLength` set to number greater than 1
+      #   # With `MinNameLength` set to number greater than 1
       #   baz { |a, b, c| do_stuff(a, b, c) }
       #
       #   # good
@@ -38,7 +38,7 @@ module RuboCop
       class BlockParameterName < Base
         include UncommunicativeName
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless node.arguments?
 
           check(node, node.arguments)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop checks for class and module names with
+      # Checks for class and module names with
       # an underscore in them.
       #
       # `AllowedNames` config takes an array of permitted names.
@@ -30,9 +30,11 @@ module RuboCop
         MSG = 'Use CamelCase for classes and modules.'
 
         def on_class(node)
+          return unless node.loc.name.source.include?('_')
+
           allowed = /#{cop_config['AllowedNames'].join('|')}/
           name = node.loc.name.source.gsub(allowed, '')
-          return unless /_/.match?(name)
+          return unless name.include?('_')
 
           add_offense(node.loc.name)
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop checks whether constant names are written using
+      # Checks whether constant names are written using
       # SCREAMING_SNAKE_CASE.
       #
       # To avoid false positives, it ignores cases in which we cannot know
@@ -23,6 +23,7 @@ module RuboCop
         # than just standard ASCII characters
         SNAKE_CASE = /^[[:digit:][:upper:]_]+$/.freeze
 
+        # @!method class_or_struct_return_method?(node)
         def_node_matcher :class_or_struct_return_method?, <<~PATTERN
           (send
             (const _ {:Class :Struct}) :new
@@ -30,12 +31,11 @@ module RuboCop
         PATTERN
 
         def on_casgn(node)
-          if node.parent&.or_asgn_type?
-            lhs, value = *node.parent
-            _scope, const_name = *lhs
-          else
-            _scope, const_name, value = *node
-          end
+          value = if node.parent&.or_asgn_type?
+                    node.parent.expression
+                  else
+                    node.expression
+                  end
 
           # We cannot know the result of method calls like
           # NewClass = something_that_returns_a_class
@@ -45,7 +45,7 @@ module RuboCop
           # SomeClass = Class.new(...)
           # SomeClass = Struct.new(...)
           return if allowed_assignment?(value)
-          return if SNAKE_CASE.match?(const_name)
+          return if SNAKE_CASE.match?(node.name)
 
           add_offense(node.loc.name)
         end
@@ -53,28 +53,28 @@ module RuboCop
         private
 
         def allowed_assignment?(value)
-          value && %i[block const casgn].include?(value.type) ||
+          (value && %i[block const casgn].include?(value.type)) ||
             allowed_method_call_on_rhs?(value) ||
             class_or_struct_return_method?(value) ||
             allowed_conditional_expression_on_rhs?(value)
         end
 
         def allowed_method_call_on_rhs?(node)
-          node&.send_type? &&
-            (node.receiver.nil? || !literal_receiver?(node))
+          node&.send_type? && (node.receiver.nil? || !literal_receiver?(node))
         end
 
+        # @!method literal_receiver?(node)
         def_node_matcher :literal_receiver?, <<~PATTERN
           {(send literal? ...)
            (send (begin literal?) ...)}
         PATTERN
 
         def allowed_conditional_expression_on_rhs?(node)
-          node&.if_type? && contains_contant?(node)
+          node&.if_type? && contains_constant?(node)
         end
 
-        def contains_contant?(node)
-          node.branches.any?(&:const_type?)
+        def contains_constant?(node)
+          node.branches.compact.any?(&:const_type?)
         end
       end
     end

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

@@ -5,7 +5,7 @@ require 'pathname'
 module RuboCop
   module Cop
     module Naming
-      # This cop makes sure that Ruby source files have snake_case
+      # Makes sure that Ruby source files have snake_case
       # names. Ruby scripts (i.e. source files with a shebang in the
       # first line) are ignored.
       #
@@ -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
@@ -25,24 +37,25 @@ module RuboCop
       #
       #   anything/using_snake_case.rake
       class FileName < Base
-        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_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_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)
+          return if config.file_to_exclude?(file_path) || config.allowed_camel_case_file?(file_path)
 
-          for_bad_filename(file_path) do |range, msg|
-            add_offense(range, message: msg)
-          end
+          for_bad_filename(file_path)
         end
 
         private
@@ -56,14 +69,13 @@ module RuboCop
             msg = other_message(basename) unless bad_filename_allowed?
           end
 
-          yield source_range(processed_source.buffer, 1, 0), msg if msg
+          add_global_offense(msg) if msg
         end
 
         def perform_class_and_module_naming_checks(file_path, basename)
           return unless expect_matching_definition?
 
-          if check_definition_path_hierarchy? &&
-             !matching_definition?(file_path)
+          if check_definition_path_hierarchy? && !matching_definition?(file_path)
             msg = no_definition_message(basename, file_path)
           elsif !matching_class?(basename)
             msg = no_definition_message(basename, basename)
@@ -109,6 +121,10 @@ module RuboCop
           cop_config['CheckDefinitionPathHierarchy']
         end
 
+        def definition_path_hierarchy_roots
+          cop_config['CheckDefinitionPathHierarchyRoots'] || []
+        end
+
         def regex
           cop_config['Regex']
         end
@@ -118,7 +134,7 @@ module RuboCop
         end
 
         def filename_good?(basename)
-          basename = basename.sub(/^\./, '')
+          basename = basename.delete_prefix('.')
           basename = basename.sub(/\.[^.]+$/, '')
           # special handling for Action Pack Variants file names like
           # some_file.xlsx+mobile.axlsx
@@ -132,12 +148,11 @@ 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)
-            next unless namespace.empty? ||
-                        match_namespace(child, const_namespace, namespace)
+            next unless namespace.empty? || namespace_matches?(child, const_namespace, namespace)
 
             return node
           end
@@ -145,7 +160,16 @@ module RuboCop
           nil
         end
 
-        def match_namespace(node, namespace, expected)
+        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 namespace_matches?(node, namespace, expected)
           match_partial = partial_matcher!(expected)
 
           match_partial.call(namespace)
@@ -181,18 +205,16 @@ module RuboCop
           expected = expected.to_s
           name = name.to_s
 
-          allowed_acronyms.any? do |acronym|
-            expected.gsub(acronym.capitalize, acronym) == name
-          end
+          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
@@ -209,7 +231,7 @@ module RuboCop
           if start_index.nil?
             [to_module_name(components.last)]
           else
-            components[start_index..-1].map { |c| to_module_name(c) }
+            components[start_index..].map { |c| to_module_name(c) }
           end
         end
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop checks that your heredocs are using the configured case.
+      # Checks that your heredocs are using the configured case.
       # By default it is configured to enforce uppercase heredocs.
       #
       # @example EnforcedStyle: uppercase (default)
@@ -30,13 +30,19 @@ module RuboCop
       class HeredocDelimiterCase < Base
         include Heredoc
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Use %<style>s heredoc delimiters.'
 
         def on_heredoc(node)
           return if correct_case_delimiters?(node)
 
-          add_offense(node.loc.heredoc_end)
+          add_offense(node.loc.heredoc_end) do |corrector|
+            expr = node.source_range
+
+            corrector.replace(expr, correct_delimiters(expr.source))
+            corrector.replace(node.loc.heredoc_end, correct_delimiters(delimiter_string(expr)))
+          end
         end
 
         private
@@ -46,14 +52,14 @@ module RuboCop
         end
 
         def correct_case_delimiters?(node)
-          delimiter_string(node) == correct_delimiters(node)
+          delimiter_string(node) == correct_delimiters(delimiter_string(node))
         end
 
-        def correct_delimiters(node)
+        def correct_delimiters(source)
           if style == :uppercase
-            delimiter_string(node).upcase
+            source.upcase
           else
-            delimiter_string(node).downcase
+            source.downcase
           end
         end
       end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop checks that your heredocs are using meaningful delimiters.
+      # Checks that your heredocs are using meaningful delimiters.
       # By default it disallows `END` and `EO*`, and can be configured through
       # forbidden listing additional delimiters.
       #
@@ -31,7 +31,9 @@ module RuboCop
         def on_heredoc(node)
           return if meaningful_delimiters?(node)
 
-          add_offense(node.loc.heredoc_end)
+          range = node.children.empty? ? node : node.loc.heredoc_end
+
+          add_offense(range)
         end
 
         private