Let RSpec/SpecFilePathFormat leverage ActiveSupport inflections, if defined.

Fix #740

Author: corsonknowles

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Master (Unreleased)
 
+- Let `RSpec/SpecFilePathFormat` leverage ActiveSupport inflections, if defined. ([@corsonknowles])
+
 ## 3.6.0 (2025-04-18)
 
 - Fix false positive in `RSpec/Pending`, where it would mark the default block `it` as an offense. ([@bquorning])

config/default.yml

@@ -924,6 +924,7 @@ RSpec/SpecFilePathFormat:
   IgnoreMethods: false
   IgnoreMetadata:
     type: routing
+  UseActiveSupportInflections: false
   VersionAdded: '2.24'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SpecFilePathFormat
 

lib/rubocop/cop/rspec/spec_file_path_format.rb

@@ -32,13 +32,20 @@ module RSpec
       #   # good
       #   whatever_spec.rb         # describe MyClass, type: :routing do; end
       #
+      # @example `UseActiveSupportInflections: true`
+      #   # When enabled, uses ActiveSupport's inflector for handling custom acronyms
+      #   # like PvP, HTTP, etc. Set to false by default.
+      #
       class SpecFilePathFormat < Base
         include TopLevelGroup
         include Namespace
         include FileHelp
 
         MSG = 'Spec path should end with `%<suffix>s`.'
 
+        # Class variable to cache ActiveSupport availability for performance
+        @@activesupport_available = nil
+
         # @!method example_group_arguments(node)
         def_node_matcher :example_group_arguments, <<~PATTERN
           (block $(send #rspec? #ExampleGroups.all $_ $...) ...)
@@ -106,10 +113,40 @@ def expected_path(constant)
         end
 
         def camel_to_snake_case(string)
-          string
-            .gsub(/([^A-Z])([A-Z]+)/, '\1_\2')
-            .gsub(/([A-Z])([A-Z][^A-Z\d]+)/, '\1_\2')
-            .downcase
+          if use_activesupport_inflections? && activesupport_inflections_available?
+            ActiveSupport::Inflector.underscore(string)
+          else
+            string
+              .gsub(/([^A-Z])([A-Z]+)/, '\1_\2')
+              .gsub(/([A-Z])([A-Z][^A-Z\d]+)/, '\1_\2')
+              .downcase
+          end
+        end
+
+        def use_activesupport_inflections?
+          cop_config.fetch('UseActiveSupportInflections', false)
+        end
+
+        def activesupport_inflections_available?
+          self.class.activesupport_inflections_available?
+        end
+
+        def self.activesupport_inflections_available?
+          return @@activesupport_available unless @@activesupport_available.nil?
+
+          @@activesupport_available = begin
+            require 'active_support/inflector'
+            # Since the require is the heavy lifting here, we can use a more robust check
+            # that actually calls the method to ensure it works
+            ActiveSupport::Inflector.underscore('TestClass') == 'test_class'
+          rescue LoadError, NameError, StandardError
+            false
+          end
+        end
+
+        # For testing and debugging
+        def self.reset_activesupport_cache!
+          @@activesupport_available = nil
         end
 
         def custom_transform

spec/rubocop/cop/rspec/spec_file_path_format_spec.rb

@@ -281,4 +281,121 @@ class Foo
       RUBY
     end
   end
+
+  context 'when ActiveSupport inflections are available' do
+    let(:cop_config) { { 'UseActiveSupportInflections' => true } }
+
+    before do
+      allow(described_class).to receive(:require).with('active_support/inflector').and_return(true)
+      stub_const('ActiveSupport::Inflector', double('ActiveSupport::Inflector'))
+      allow(ActiveSupport::Inflector).to receive(:underscore).with('TestClass').and_return('test_class')
+    end
+
+    around do |example|
+      described_class.reset_activesupport_cache!
+      example.run
+      described_class.reset_activesupport_cache!
+    end
+
+    it 'uses ActiveSupport inflections for custom acronyms' do
+      allow(ActiveSupport::Inflector).to receive(:underscore).with('PvPClass').and_return('pvp_class')
+
+      expect_no_offenses(<<~RUBY, 'pvp_class_spec.rb')
+        describe PvPClass do; end
+      RUBY
+    end
+
+    it 'registers an offense when ActiveSupport inflections suggest different path' do
+      allow(ActiveSupport::Inflector).to receive(:underscore).with('PvPClass').and_return('pvp_class')
+
+      expect_offense(<<~RUBY, 'pv_p_class_spec.rb')
+        describe PvPClass do; end
+        ^^^^^^^^^^^^^^^^^ Spec path should end with `pvp_class*_spec.rb`.
+      RUBY
+    end
+
+    it 'does not register complex acronyms with method names' do
+      allow(ActiveSupport::Inflector).to receive(:underscore).with('PvPClass').and_return('pvp_class')
+
+      expect_no_offenses(<<~RUBY, 'pvp_class_foo_spec.rb')
+        describe PvPClass, 'foo' do; end
+      RUBY
+    end
+
+    it 'does not register nested namespaces with custom acronyms' do
+      allow(ActiveSupport::Inflector).to receive(:underscore).with('API').and_return('api')
+      allow(ActiveSupport::Inflector).to receive(:underscore).with('HTTPClient').and_return('http_client')
+
+      expect_no_offenses(<<~RUBY, 'api/http_client_spec.rb')
+        describe API::HTTPClient do; end
+      RUBY
+    end
+  end
+
+  context 'when UseActiveSupportInflections is disabled' do
+    let(:cop_config) { { 'UseActiveSupportInflections' => false } }
+
+    before do
+      # Even if ActiveSupport is available, it should not be used when disabled
+      allow(described_class).to receive(:require).with('active_support/inflector').and_return(true)
+      stub_const('ActiveSupport::Inflector', double('ActiveSupport::Inflector'))
+      allow(ActiveSupport::Inflector).to receive(:underscore).with('TestClass').and_return('test_class')
+    end
+
+    around do |example|
+      described_class.reset_activesupport_cache!
+      example.run
+      described_class.reset_activesupport_cache!
+    end
+
+    it 'uses default inflection instead of ActiveSupport' do
+      expect_no_offenses(<<~RUBY, 'pv_p_class_spec.rb')
+        describe PvPClass do; end
+      RUBY
+    end
+
+    it 'registers offense when default inflection does not match ActiveSupport result' do
+      expect_offense(<<~RUBY, 'pvp_class_spec.rb')
+        describe PvPClass do; end
+        ^^^^^^^^^^^^^^^^^ Spec path should end with `pv_p_class*_spec.rb`.
+      RUBY
+    end
+  end
+
+  context 'when ActiveSupport inflections are not available' do
+    let(:cop_config) { { 'UseActiveSupportInflections' => true } }
+
+    before do
+      allow(described_class).to receive(:require).with('active_support/inflector').and_raise(LoadError)
+    end
+
+    it 'falls back to default inflection behavior' do
+      expect_no_offenses(<<~RUBY, 'pv_p_class_spec.rb')
+        describe PvPClass do; end
+      RUBY
+    end
+
+    it 'registers offense when default inflection does not match' do
+      expect_offense(<<~RUBY, 'pvp_class_spec.rb')
+        describe PvPClass do; end
+        ^^^^^^^^^^^^^^^^^ Spec path should end with `pv_p_class*_spec.rb`.
+      RUBY
+    end
+  end
+
+  context 'when ActiveSupport loading raises an error' do
+    let(:cop_config) { { 'UseActiveSupportInflections' => true } }
+
+    before do
+      allow(described_class).to receive(:require).with('active_support/inflector').and_raise(
+        StandardError, 'Something went wrong'
+      )
+    end
+
+    it 'gracefully falls back to default behavior' do
+      expect_no_offenses(<<~RUBY, 'pv_p_class_spec.rb')
+        describe PvPClass do; end
+      RUBY
+    end
+  end
 end