rubocop 1.88.0 → 1.88.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 672884fb2ea66b13be308094ffcec44f915943867fac5542b82ceaba3ecf32e9
-  data.tar.gz: f489cbc9ae6385c18d4d97140e4589503ac28a82a4288c5bac915679471ea683
+  metadata.gz: 04f5790c0be94705978732f52d462bd3afe919498e1e6be410fcfece0faaf4cd
+  data.tar.gz: 87c79acdf7db812d889bc2464a61d9921db70daf4e6c11117be879d7d9b64991
 SHA512:
-  metadata.gz: 8d2cb39bc17b788f176096a12ddf766dbdcfafe8a6fcd09e830544053665b3b42f204b0b7fe01a61d2be94d64fe859f6783710f01df71f136e28d9e46ec1ebf6
-  data.tar.gz: 18067fc7914382cf8c13a07a34b9774647bd85ea34e85eac8a705da85af7039f31befae4e850b23989ddb91918f4cf10bccd4d578dc79a65de5422db86b51ad2
+  metadata.gz: c8491483d605d97e0c746f171fdebf6b5b009a0e1e01392764a9fbf12208dad6a7fe8e8529f32d3a2b1ae37e39f150b689638cd7dbc901040f27b6cdf1981ab5
+  data.tar.gz: 7aa878cbe87d967607a65f37a1b3eafd47507d7a9c54c3bede0398f689527254fa4d65460d3af11d233244eb53eb7058bd5b69326588d7b3d3ed0fbb864afef8

data/config/default.yml

@@ -2844,7 +2844,7 @@ Metrics/PerceivedComplexity:
   Description: 'Checks that the perceived complexity of methods is not higher than the configured maximum.'
   Enabled: true
   VersionAdded: '0.25'
-  VersionChanged: '0.81'
+  VersionChanged: '1.88'
   AllowedMethods: []
   AllowedPatterns: []
   Max: 8
@@ -4658,7 +4658,9 @@ Style/MagicCommentFormat:
 Style/MapCompactWithConditionalBlock:
   Description: 'Prefer `select` or `reject` over `map { ... }.compact`.'
   Enabled: pending
+  SafeAutoCorrect: false
   VersionAdded: '1.30'
+  VersionChanged: '1.88'
 
 Style/MapIntoArray:
   Description: 'Checks for usages of `each` with `<<`, `push`, or `append` which can be replaced by `map`.'

data/lib/rubocop/cop/bundler/gem_comment.rb

@@ -163,7 +163,9 @@ module RuboCop
         def gem_options(node)
           return [] unless node.last_argument&.hash_type?
 
-          node.last_argument.keys.map(&:value)
+          # Only literal keys carry an option name to check; a non-literal key
+          # (e.g. a variable or method call) has no `value` and must be skipped.
+          node.last_argument.keys.filter_map { |key| key.value if key.type?(:sym, :str) }
         end
       end
     end

data/lib/rubocop/cop/correctors/each_to_for_corrector.rb

@@ -27,7 +27,7 @@ module RuboCop
         if block_node.arguments?
           format(CORRECTION_WITH_ARGUMENTS,
                  collection: collection_node.source,
-                 variables: argument_node.children.first.source)
+                 variables: argument_node.children.map(&:source).join(', '))
         else
           format(CORRECTION_WITHOUT_ARGUMENTS, enumerable: collection_node.source)
         end

data/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb

@@ -86,7 +86,13 @@ module RuboCop
       end
 
       def lambda_arg_string
-        arguments.children.map(&:source).join(', ')
+        # Block-local (shadow) arguments are separated from regular arguments by a
+        # `;`; joining everything with `,` would turn them into extra parameters
+        # and change the lambda's arity.
+        regular, shadow = arguments.children.partition { |arg| !arg.shadowarg_type? }
+        arg_string = regular.map(&:source).join(', ')
+        arg_string += "; #{shadow.map(&:source).join(', ')}" unless shadow.empty?
+        arg_string
       end
 
       def needs_separating_space?

data/lib/rubocop/cop/correctors/ordered_gem_corrector.rb

@@ -18,7 +18,14 @@ module RuboCop
           current_range = declaration_with_comment(node)
           previous_range = declaration_with_comment(previous_declaration)
 
-          ->(corrector) { corrector.swap(current_range, previous_range) }
+          lambda do |corrector|
+            if current_range.source.end_with?("\n")
+              corrector.swap(current_range, previous_range)
+            else
+              corrector.insert_before(previous_range, "#{current_range.source}\n")
+              corrector.remove(current_range)
+            end
+          end
         end
 
         private

data/lib/rubocop/cop/gemspec/development_dependencies.rb

@@ -95,7 +95,7 @@ module RuboCop
         private
 
         def forbidden_gem?(gem_name)
-          !cop_config['AllowedGems'].include?(gem_name)
+          !Array(cop_config['AllowedGems']).include?(gem_name)
         end
 
         def message(_range)

data/lib/rubocop/cop/gemspec/require_mfa.rb

@@ -143,7 +143,10 @@ module RuboCop
             #{block_var}.metadata['rubygems_mfa_required'] = 'true'
           RUBY
 
-          if (last_assignment = metadata_assignment(processed_source.ast).to_a.last)
+          # Scope the search to the current spec block. Searching the whole file
+          # would, for a second `Gem::Specification.new` block, insert the directive
+          # into the first block, leaving this block uncorrected and looping forever.
+          if (last_assignment = metadata_assignment(node).to_a.last)
             corrector.insert_after(last_assignment, "\n#{require_mfa_directive}")
           else
             corrector.insert_before(node.loc.end, "#{require_mfa_directive}\n")

data/lib/rubocop/cop/layout/block_alignment.rb

@@ -281,15 +281,32 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/AbcSize
         def do_line_begins_inside_argument?(node, do_loc)
           line_begin_pos = do_loc.begin_pos - do_loc.column
           first_char_pos = line_begin_pos + (do_loc.source_line =~ /\S/)
+          return false unless inside_parentheses?(node, first_char_pos)
 
           (node.send_node.arguments + node.arguments).any? do |argument|
             argument.source_range.begin_pos <= first_char_pos &&
               first_char_pos < argument.source_range.end_pos
           end
         end
+        # rubocop:enable Metrics/AbcSize
+
+        # The continuation line indentation is only an unmeaningful alignment target when
+        # it is dictated by an opening delimiter, i.e. the line begins inside `(` or `[`.
+        # For a bare argument list without parentheses the indentation is the author's
+        # deliberate alignment, so the anchor must not move to the method dispatch line.
+        def inside_parentheses?(node, pos)
+          preceding_tokens = processed_source.tokens.select do |token|
+            token.begin_pos >= node.source_range.begin_pos && token.begin_pos < pos
+          end
+          opens = preceding_tokens.count { |token| token.left_parens? || token.left_bracket? }
+          closes = preceding_tokens.count { |token| token.right_parens? || token.right_bracket? }
+
+          opens > closes
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/class_structure.rb

@@ -278,10 +278,14 @@ module RuboCop
 
           return [] unless class_def
 
-          if class_def.type?(:def, :send)
-            [class_def]
-          else
+          # Only a multi-statement body (`begin`/`kwbegin`) wraps several elements; any
+          # single statement (`def`, `send`, `csend`, `if`, ...) is itself the sole element.
+          # Exploding such a node into its children would yield non-node values (e.g. a
+          # method-name `Symbol` from a `csend`) and crash later checks.
+          if class_def.type?(:begin, :kwbegin)
             class_def.children.compact
+          else
+            [class_def]
           end
         end
 

data/lib/rubocop/cop/layout/condition_position.rb

@@ -44,16 +44,26 @@ module RuboCop
           message = message(condition)
 
           add_offense(condition, message: message) do |corrector|
-            range = range_by_whole_lines(condition.source_range, include_final_newline: true)
-
             corrector.insert_after(condition.parent.loc.keyword, " #{condition.source}")
-            corrector.remove(range)
+            corrector.remove(removal_range(node, condition))
           end
         end
 
         def message(condition)
           format(MSG, keyword: condition.parent.keyword)
         end
+
+        # When a body statement shares the condition's line (e.g. `while\n cond; body\nend`),
+        # removing the whole line would delete the body too. In that case only remove the
+        # condition and its trailing separator, preserving the body statement.
+        def removal_range(node, condition)
+          body = node.body
+          if body && body.source_range.line == condition.source_range.last_line
+            range_between(condition.source_range.begin_pos, body.source_range.begin_pos)
+          else
+            range_by_whole_lines(condition.source_range, include_final_newline: true)
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/empty_comment.rb

@@ -95,8 +95,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          previous_token = previous_token(node)
-          range = if previous_token && same_line?(node, previous_token)
+          range = if inline_comment?(node)
                     range_with_surrounding_space(node.source_range, newlines: false)
                   else
                     range_by_whole_lines(node.source_range, include_final_newline: true)
@@ -138,14 +137,13 @@ module RuboCop
           cop_config['AllowMarginComment']
         end
 
-        def current_token(comment)
-          processed_source.tokens.find { |token| token.pos == comment.source_range }
-        end
-
-        def previous_token(node)
-          current_token = current_token(node)
-          index = processed_source.tokens.index(current_token)
-          index.zero? ? nil : processed_source.tokens[index - 1]
+        # A comment is inline when code precedes it on the same line. Detecting this
+        # from the source (rather than the token stream) is required because, for a
+        # comment trailing a heredoc opener, the preceding token is the heredoc end on
+        # a later line, which would wrongly trigger whole-line removal of the opener.
+        def inline_comment?(comment)
+          preceding_source = processed_source.lines[comment.loc.line - 1][0...comment.loc.column]
+          !preceding_source.strip.empty?
         end
       end
     end

data/lib/rubocop/cop/layout/empty_line_between_defs.rb

@@ -274,7 +274,20 @@ module RuboCop
         end
 
         def end_loc(node)
-          node.source_range.end
+          end_location = node.source_range.end
+          trailing_heredoc_end(node, end_location) || end_location
+        end
+
+        # For an endless method whose body is a heredoc (e.g. `def a = <<~TEXT`), the
+        # node's source range ends at the heredoc opening line, before the heredoc body.
+        # Use the heredoc's closing delimiter so the def's real end is located after the
+        # heredoc and blank-line insertion does not land inside the heredoc body.
+        def trailing_heredoc_end(node, end_location)
+          heredocs = node.each_descendant(:any_str).select(&:heredoc?)
+          return if heredocs.empty?
+
+          heredoc_end = heredocs.map { |heredoc| heredoc.loc.heredoc_end }.max_by(&:end_pos)
+          heredoc_end if heredoc_end.end_pos > end_location.end_pos
         end
 
         def autocorrect_remove_lines(corrector, newline_pos, count)

data/lib/rubocop/cop/layout/first_hash_element_indentation.rb

@@ -28,10 +28,10 @@ module RuboCop
       #   # bad
       #   hash = {
       #     key: :value
-      #   }
-      #   and_in_a_method_call({
-      #     no: :difference
-      #                        })
+      #          }
+      #   in_a_method_call({
+      #     foo: :bar
+      #   })
       #   takes_multi_pairs_hash(x: {
       #     a: 1,
       #     b: 2
@@ -42,13 +42,12 @@ module RuboCop
       #                          })
       #
       #   # good
-      #   special_inside_parentheses
       #   hash = {
       #     key: :value
       #   }
-      #   but_in_a_method_call({
-      #                          its_like: :this
-      #                        })
+      #   in_a_method_call({
+      #                      foo: :bar
+      #                    })
       #   takes_multi_pairs_hash(x: {
       #                            a: 1,
       #                            b: 2
@@ -67,17 +66,17 @@ module RuboCop
       #   # bad
       #   hash = {
       #     key: :value
-      #   }
-      #   but_in_a_method_call({
-      #                          its_like: :this
-      #                         })
+      #          }
+      #   in_a_method_call({
+      #                     foo: :bar
+      #                   })
       #
       #   # good
       #   hash = {
       #     key: :value
       #   }
-      #   and_in_a_method_call({
-      #     no: :difference
+      #   in_a_method_call({
+      #     foo: :bar
       #   })
       #
       #

data/lib/rubocop/cop/layout/indentation_width.rb

@@ -25,6 +25,17 @@ module RuboCop
       #     end
       #   end
       #
+      # @example
+      #   # bad
+      #   value = (
+      #   foo - bar
+      #   )
+      #
+      #   # good
+      #   value = (
+      #     foo - bar
+      #   )
+      #
       # @example AllowedPatterns: ['^\s*module']
       #   # bad
       #   module A
@@ -95,6 +106,16 @@ module RuboCop
           check_indentation(node.loc.end, node.children.first)
         end
 
+        def on_begin(node)
+          # Only a parenthesized grouping expression (e.g. `(\n  foo\n)`) has
+          # explicit delimiters. Indent the body one step from the line
+          # the opening parenthesis is on, but only when the closing parenthesis is
+          # first on its line (a body on the opening line is skipped downstream).
+          return unless parentheses?(node) && begins_its_line?(node.loc.end)
+
+          check_indentation(opening_line_start(node.loc.begin), node.children.first)
+        end
+
         def on_block(node)
           end_loc = node.loc.end
 
@@ -188,6 +209,13 @@ module RuboCop
           AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
         end
 
+        # Returns a range at the first non-space column of the line the opening parenthesis is on,
+        # used as the base to indent the body from.
+        def opening_line_start(begin_loc)
+          column = begin_loc.source_line =~ /\S/
+          source_range(processed_source.buffer, begin_loc.line, column)
+        end
+
         def check_members(base, members)
           check_indentation(base, select_check_member(members.first))
 

data/lib/rubocop/cop/layout/space_around_operators.rb

@@ -204,10 +204,14 @@ module RuboCop
 
         def autocorrect(corrector, range, right_operand)
           range_source = range.source
+          # Match the operator exactly, not by substring, so compound assignments
+          # like `**=` and `/=` are not mistaken for `**` and `/` (which would drop
+          # the `=` and silently change the program's behavior).
+          operator = range_source.strip
 
-          if range_source.include?('**') && !space_around_exponent_operator?
+          if operator == '**' && !space_around_exponent_operator?
             corrector.replace(range, '**')
-          elsif range_source.include?('/') && !space_around_slash_operator?(right_operand)
+          elsif operator == '/' && !space_around_slash_operator?(right_operand)
             corrector.replace(range, '/')
           elsif range_source.end_with?("\n")
             corrector.replace(range, " #{range_source.strip}\n")

data/lib/rubocop/cop/lint/assignment_in_condition.rb

@@ -78,13 +78,25 @@ module RuboCop
         end
 
         def allowed_construct?(asgn_node)
-          asgn_node.begin_type? || conditional_assignment?(asgn_node)
+          return true if asgn_node.begin_type?
+
+          conditional_assignment?(asgn_node) || discarded_assignment?(asgn_node)
         end
 
         def conditional_assignment?(asgn_node)
           !asgn_node.loc.operator
         end
 
+        # An assignment that is a statement of a multi-statement `begin`
+        # (e.g. `(foo = bar; baz)`) has its value discarded, so it is not used
+        # as the condition. Wrapping it in parentheses would only conflict with
+        # `Style/RedundantParentheses`, so it is left alone.
+        def discarded_assignment?(asgn_node)
+          parent = asgn_node.parent
+
+          parent&.begin_type? && parent.children.size > 1
+        end
+
         def skip_children?(asgn_node)
           (asgn_node.call_type? && !asgn_node.assignment_method?) ||
             empty_condition?(asgn_node) ||

data/lib/rubocop/cop/lint/to_enum_arguments.rb

@@ -109,9 +109,11 @@ module RuboCop
           when :optarg
             send_arg.source == def_arg_name.to_s
           when :kwoptarg, :kwarg
-            send_arg.hash_type? &&
+            keyword_hash_argument?(send_arg) &&
               send_arg.pairs.any? { |pair| passing_keyword_arg?(pair, def_arg_name) }
           when :kwrestarg
+            return false unless keyword_hash_argument?(send_arg)
+
             send_arg.each_child_node(:kwsplat, :forwarded_kwrestarg).any? do |child|
               child.source == def_arg.source
             end
@@ -120,6 +122,10 @@ module RuboCop
           end
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+        def keyword_hash_argument?(send_arg)
+          send_arg.hash_type? && !send_arg.braces?
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/unescaped_bracket_in_regexp.rb

@@ -44,9 +44,7 @@ module RuboCop
 
         def on_regexp(node)
           RuboCop::Util.silence_warnings do
-            node.parsed_tree&.each_expression do |expr|
-              detect_offenses(node, expr)
-            end
+            detect_offenses_in_tree(node, node.parsed_tree)
           end
         end
 
@@ -55,19 +53,43 @@ module RuboCop
           return if node.each_descendant(:dstr).any?
 
           regexp_constructor(node) do |text|
-            parse_regexp(text.value)&.each_expression do |expr|
-              detect_offenses(text, expr)
-            end
+            detect_offenses_in_tree(text, parse_regexp(text.value))
           end
         end
 
         private
 
-        def detect_offenses(node, expr)
-          return unless expr.type?(:literal)
+        # When a character class opens with a bare `]` (e.g. `[^]]`), `regexp_parser` parses
+        # `[^]` / `[]` as an empty set and reports the closing `]` as a separate literal.
+        # Ruby treats that `]` as the end of the class, not as an unescaped bracket,
+        # so the first `]` following an empty set must be skipped.
+        def detect_offenses_in_tree(node, tree)
+          return unless tree
+
+          skip_class_closer = false
+          tree.each_expression do |expr|
+            if empty_character_set?(expr)
+              skip_class_closer = true
+            elsif expr.type?(:literal)
+              skip_class_closer = detect_offenses(node, expr, skip_class_closer)
+            end
+          end
+        end
+
+        def empty_character_set?(expr)
+          expr.type?(:set) && expr.expressions.empty?
+        end
 
+        def detect_offenses(node, expr, skip_class_closer)
           expr.text.scan(/(?<!\\)\]/) do
             pos = Regexp.last_match.begin(0)
+
+            # The first `]` following an empty `[^]` / `[]` set closes the character class.
+            if skip_class_closer
+              skip_class_closer = false
+              next
+            end
+
             # If the unescaped bracket is the first character of the regexp, Ruby does not warn.
             # `pos` is relative to the sub-expression, so add its start offset (`expr.ts`).
             next if (expr.ts + pos).zero?
@@ -78,6 +100,8 @@ module RuboCop
               corrector.replace(location, '\]')
             end
           end
+
+          skip_class_closer
         end
 
         def range_at_index(node, index, offset)

data/lib/rubocop/cop/metrics/method_length.rb

@@ -58,7 +58,7 @@ module RuboCop
           return unless node.method?(:define_method)
 
           method_name = node.send_node.first_argument
-          return if method_name.basic_literal? && allowed?(method_name.value)
+          return if method_name&.basic_literal? && allowed?(method_name.value)
 
           check_code_length(node)
         end

data/lib/rubocop/cop/metrics/perceived_complexity.rb

@@ -12,9 +12,15 @@ module RuboCop
       # nodes count. In contrast to the CyclomaticComplexity cop, this cop
       # considers `else` nodes as adding complexity.
       #
+      # A `case`/`in` branch whose pattern is a simple literal (e.g. `in 1`, `in "red"`, `in 1..10`)
+      # or a constant/type (e.g. `in Integer`) and has no guard is just as easy to read as a `when`
+      # branch, so it is discounted the same way. Branches with structural patterns (e.g. array,
+      # hash, or find patterns), bindings, alternatives, or a guard add the full complexity of
+      # a decision point.
+      #
       # @example
       #
-      #   def my_method                   # 1
+      #   def example_1                   # 1
       #     if cond                       # 1
       #       case var                    # 2 (0.8 + 4 * 0.2, rounded)
       #       when 1 then func_one
@@ -26,33 +32,58 @@ module RuboCop
       #       do_something until a && b   # 2
       #     end                           # ===
       #   end                             # 7 complexity points
+      #
+      #   def example_2                   # 1
+      #     case color                    # 1 (3 * 0.2, rounded)
+      #     in "red" then func_red
+      #     in "blue" then func_blue
+      #     in "green" then func_green
+      #     end                           # ===
+      #   end                             # 2 complexity points
       class PerceivedComplexity < CyclomaticComplexity
         MSG = 'Perceived complexity for `%<method>s` is too high. [%<complexity>d/%<max>d]'
 
-        COUNTED_NODES = (CyclomaticComplexity::COUNTED_NODES - [:when] + [:case]).freeze
+        COUNTED_NODES = (
+          CyclomaticComplexity::COUNTED_NODES - %i[when in_pattern] + %i[case case_match]
+        ).freeze
 
         private
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def complexity_score_for(node)
           case node.type
           when :case
-            # If cond is nil, that means each when has an expression that
-            # evaluates to true or false. It's just an alternative to
-            # if/elsif/elsif... so the when nodes count.
+            # If cond is nil, that means each when has an expression that evaluates to true or
+            # false. It's just an alternative to if/elsif/elsif... so the when nodes count.
             nb_branches = node.when_branches.length + (node.else_branch ? 1 : 0)
             if node.condition.nil?
               nb_branches
             else
-              # Otherwise, the case node gets 0.8 complexity points and each
-              # when gets 0.2.
+              # Otherwise, the case node gets 0.8 complexity points and each when gets 0.2.
               ((nb_branches * 0.2) + 0.8).round
             end
+          when :case_match
+            # Simple `in` branches are discounted like `when`, while structural patterns keep
+            # the full complexity of a decision point.
+            score = node.in_pattern_branches.sum { |branch| simple_in_pattern?(branch) ? 0.2 : 1 }
+            score += 0.2 if node.else_branch
+            score.round
           when :if
             node.else? && !node.elsif? ? 2 : 1
           else
             super
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+        def simple_in_pattern?(in_pattern_node)
+          # `in_pattern_node.children[1]` is the guard (`if`/`unless`), or `nil`.
+          return false unless in_pattern_node.children[1].nil?
+
+          # A scalar literal, a literal range, or a constant/type is as easy to read as a `when`.
+          pattern = in_pattern_node.pattern
+          pattern.literal? || pattern.const_type?
+        end
       end
     end
   end

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

@@ -182,10 +182,18 @@ module RuboCop
         return ":\"#{value.source}\"" if value.dsym_type?
         return "\"#{value.source}\"" if value.dstr_type?
         return ":#{value.source}" if value.sym_type?
+        # The element of a `%w` array can contain characters that are special
+        # inside a single-quoted string (e.g. a `'`), so escape them rather than
+        # wrapping the raw source.
+        return to_single_quoted(value.value) if value.str_type?
 
         "'#{value.source}'"
       end
 
+      def to_single_quoted(string)
+        "'#{string.gsub(/['\\]/) { |character| "\\#{character}" }}'"
+      end
+
       def except_key(node)
         key_arg = node.argument_list.first.source
         body, = extract_body_if_negated(node.body)

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

@@ -94,6 +94,10 @@ module RuboCop
 
         return unless captures.use_transformed_argname?
 
+        # A splat transforming expression (e.g. `[k, *v]`) can't be used as a
+        # standalone block return value, so the rewrite would produce invalid Ruby.
+        return if captures.transforming_body_expr.splat_type?
+
         message = "Prefer `#{new_method_name}` over `#{match_desc}`."
         add_offense(node, message: message) do |corrector|
           correction = prepare_correction(node)

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

@@ -203,9 +203,10 @@ module RuboCop
 
         def match_acronym?(expected, name)
           expected = expected.to_s
-          name = name.to_s
-
-          allowed_acronyms.any? { |acronym| expected.gsub(acronym.capitalize, acronym) == name }
+          name = allowed_acronyms.reduce(name.to_s) do |result, acronym|
+            result.gsub(acronym, acronym.capitalize)
+          end
+          expected == name
         end
 
         def to_namespace(path) # rubocop:disable Metrics/AbcSize