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,8 @@ RSpec/SpecFilePathFormat:
   IgnoreMethods: false
   IgnoreMetadata:
     type: routing
+  Inflector: './config/initializers/inflections.rb'
+  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,49 @@ 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 inflector_path
+          cop_config.fetch('InflectorPath',
+                           './config/initializers/inflections.rb')
+        end
+
+        def activesupport_inflections_available?
+          return false unless use_activesupport_inflections?
+
+          self.class.activesupport_inflections_available?(inflector_path)
+        end
+
+        def self.activesupport_inflections_available?(inflector_path = './config/initializers/inflections.rb')
+          return @@activesupport_available unless @@activesupport_available.nil?
+
+          @@activesupport_available = begin
+            return false unless File.exist?(inflector_path)
+
+            require 'active_support/inflector'
+            require inflector_path
+
+            true
+          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,268 @@ class Foo
       RUBY
     end
   end
+
+  context 'when ActiveSupport inflections are available' do
+    let(:cop_config) { { 'UseActiveSupportInflections' => true } }
+
+    before do
+      # Stub File.exist? to return true for the default inflector path
+      allow(File).to receive(:exist?).with('./config/initializers/inflections.rb').and_return(true)
+
+      allow(described_class).to receive(:require).with('active_support/inflector').and_return(true)
+      allow(described_class).to receive(:require).with('./config/initializers/inflections.rb').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 ActiveSupport inflections are not available' do
+    let(:cop_config) { { 'UseActiveSupportInflections' => true } }
+
+    before do
+      # Stub File.exist? to return true, but ActiveSupport loading fails
+      allow(File).to receive(:exist?).with('./config/initializers/inflections.rb').and_return(true)
+      allow(described_class).to receive(:require).with('active_support/inflector').and_raise(LoadError)
+    end
+
+    around do |example|
+      described_class.reset_activesupport_cache!
+      example.run
+      described_class.reset_activesupport_cache!
+    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
+      # Stub File.exist? to return true, but ActiveSupport loading raises an error
+      allow(File).to receive(:exist?).with('./config/initializers/inflections.rb').and_return(true)
+      allow(described_class).to receive(:require).with('active_support/inflector').and_raise(
+        StandardError, 'Something went wrong'
+      )
+    end
+
+    around do |example|
+      described_class.reset_activesupport_cache!
+      example.run
+      described_class.reset_activesupport_cache!
+    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
+
+  context 'when configured with custom InflectorPath' do
+    let(:cop_config) do
+      {
+        'UseActiveSupportInflections' => true,
+        'InflectorPath' => './config/custom_inflections.rb'
+      }
+    end
+
+    around do |example|
+      described_class.reset_activesupport_cache!
+      example.run
+      described_class.reset_activesupport_cache!
+    end
+
+    context 'when inflector file exists' do
+      before do
+        # Stub ActiveSupport availability
+        allow(described_class).to receive(:require).with('active_support/inflector').and_return(true)
+        stub_const('ActiveSupport::Inflector',
+                   double('ActiveSupport::Inflector'))
+
+        # Stub File.exist? to return true for our custom path
+        allow(File).to receive(:exist?).with('./config/custom_inflections.rb').and_return(true)
+
+        # Stub the require call for the inflector file
+        allow(described_class).to receive(:require).with('./config/custom_inflections.rb').and_return(true)
+
+        # Mock the inflector behavior with custom acronyms
+        allow(ActiveSupport::Inflector).to receive(:underscore).with('HTTPSClient').and_return('https_client')
+        allow(ActiveSupport::Inflector).to receive(:underscore).with('XMLParser').and_return('xml_parser')
+      end
+
+      it 'loads the custom inflector file when it exists' do
+        expect(File).to receive(:exist?).with('./config/custom_inflections.rb').and_return(true)
+        expect(described_class).to receive(:require).with('./config/custom_inflections.rb')
+
+        expect_no_offenses(<<~RUBY, 'https_client_spec.rb')
+          describe HTTPSClient do; end
+        RUBY
+      end
+
+      it 'uses custom inflections from the inflector file' do
+        expect_no_offenses(<<~RUBY, 'https_client_spec.rb')
+          describe HTTPSClient do; end
+        RUBY
+      end
+
+      it 'does not register with nested namespaces using custom inflections' do
+        allow(ActiveSupport::Inflector).to receive(:underscore).with('API').and_return('api')
+
+        expect_no_offenses(<<~RUBY, 'api/https_client_spec.rb')
+          describe API::HTTPSClient do; end
+        RUBY
+      end
+
+      it 'registers offense when path does not match custom inflections' do
+        expect_offense(<<~RUBY, 'http_s_client_spec.rb')
+          describe HTTPSClient do; end
+          ^^^^^^^^^^^^^^^^^^^^ Spec path should end with `https_client*_spec.rb`.
+        RUBY
+      end
+    end
+
+    context 'when inflector file does not exist' do
+      before do
+        # Stub File.exist? to return false for our custom path
+        allow(File).to receive(:exist?).with('./config/custom_inflections.rb').and_return(false)
+      end
+
+      it 'does not try to require the inflector file when it does not exist' do
+        expect(File).to receive(:exist?).with('./config/custom_inflections.rb').and_return(false)
+        expect(described_class).not_to receive(:require).with('./config/custom_inflections.rb')
+        expect(described_class).not_to receive(:require).with('active_support/inflector')
+
+        # Should use default regex-based conversion: HTTPSClient -> https_client
+        expect_no_offenses(<<~RUBY, 'https_client_spec.rb')
+          describe HTTPSClient do; end
+        RUBY
+      end
+
+      it 'falls back to default camel_to_snake_case conversion without ActiveSupport' do
+        # Should use default regex-based conversion: HTTPSClient -> httpclient -> https_client
+        expect_no_offenses(<<~RUBY, 'https_client_spec.rb')
+          describe HTTPSClient do; end
+        RUBY
+      end
+    end
+
+    context 'when inflector file loading fails' do
+      before do
+        # Stub ActiveSupport availability
+        allow(described_class).to receive(:require).with('active_support/inflector').and_return(true)
+        stub_const('ActiveSupport::Inflector',
+                   double('ActiveSupport::Inflector'))
+
+        # Stub File.exist? to return true but require to fail
+        allow(File).to receive(:exist?).with('./config/custom_inflections.rb').and_return(true)
+        allow(described_class).to receive(:require).with('./config/custom_inflections.rb').and_raise(
+          LoadError, 'Cannot load file'
+        )
+
+        # Set up fallback behavior
+        allow(ActiveSupport::Inflector).to receive(:underscore).with('HTTPSClient').and_return('https_client')
+      end
+
+      it 'gracefully handles inflector file loading errors' do
+        expect(File).to receive(:exist?).with('./config/custom_inflections.rb').and_return(true)
+        expect(described_class).to receive(:require).with('./config/custom_inflections.rb').and_raise(LoadError)
+
+        # Should still work with basic ActiveSupport functionality
+        expect_no_offenses(<<~RUBY, 'https_client_spec.rb')
+          describe HTTPSClient do; end
+        RUBY
+      end
+    end
+  end
+
+  context 'when UseActiveSupportInflections is enabled with default inflector path' do
+    let(:cop_config) { { 'UseActiveSupportInflections' => true } }
+
+    around do |example|
+      described_class.reset_activesupport_cache!
+      example.run
+      described_class.reset_activesupport_cache!
+    end
+
+    before do
+      # Stub ActiveSupport availability
+      allow(described_class).to receive(:require).with('active_support/inflector').and_return(true)
+      stub_const('ActiveSupport::Inflector', double('ActiveSupport::Inflector'))
+    end
+
+    it 'uses default inflector path when not configured' do
+      allow(File).to receive(:exist?).with('./config/initializers/inflections.rb').and_return(true)
+      allow(described_class).to receive(:require).with('./config/initializers/inflections.rb').and_return(true)
+      allow(ActiveSupport::Inflector).to receive(:underscore).with('HTTPClient').and_return('http_client')
+
+      expect(File).to receive(:exist?).with('./config/initializers/inflections.rb')
+
+      expect_no_offenses(<<~RUBY, 'http_client_spec.rb')
+        describe HTTPClient do; end
+      RUBY
+    end
+
+    it 'does not require default inflector file when it does not exist' do
+      allow(File).to receive(:exist?).with('./config/initializers/inflections.rb').and_return(false)
+      allow(ActiveSupport::Inflector).to receive(:underscore).with('HTTPClient').and_return('http_client')
+
+      expect(File).to receive(:exist?).with('./config/initializers/inflections.rb').and_return(false)
+      expect(described_class).not_to receive(:require).with('./config/initializers/inflections.rb')
+
+      expect_no_offenses(<<~RUBY, 'http_client_spec.rb')
+        describe HTTPClient do; end
+      RUBY
+    end
+  end
 end