Let RSpec/SpecFilePathFormat leverage ActiveSupport inflections when defined and configured

Fix #740

Author: bquorning

CHANGELOG.md

@@ -8,12 +8,12 @@
 - Fix a false positive for `RSpec/ReceiveNever` cop when `allow(...).to receive(...).never`. ([@ydah])
 - Fix detection of nameless doubles with methods in `RSpec/VerifiedDoubles`. ([@ushi-as])
 - Improve an offense message for `RSpec/RepeatedExample` cop. ([@ydah])
+- Let `RSpec/SpecFilePathFormat` leverage ActiveSupport inflections when configured. ([@corsonknowles])
 
 ## 3.7.0 (2025-09-01)
 
 - Mark `RSpec/IncludeExamples` as `SafeAutoCorrect: false`. ([@yujideveloper])
 - Fix a false positive for `RSpec/LeakyConstantDeclaration` when defining constants in explicit namespaces. ([@naveg])
-- Let `RSpec/SpecFilePathFormat` leverage ActiveSupport inflections when configured. ([@corsonknowles])
 - Add support for error matchers (`raise_exception` and `raise_error`) to `RSpec/Dialect`. ([@lovro-bikic])
 - Don't register offenses for `RSpec/DescribedClass` within `Data.define` blocks. ([@lovro-bikic])
 - Add autocorrection support for `RSpec/IteratedExpectation` for single expectations. ([@lovro-bikic])

config/default.yml

@@ -940,8 +940,12 @@ RSpec/SpecFilePathFormat:
   IgnoreMetadata:
     type: routing
   InflectorPath: "./config/initializers/inflections.rb"
-  UseActiveSupportInflections: false
+  SupportedInflectors:
+    - default
+    - active_support
+  EnforcedInflector: default
   VersionAdded: '2.24'
+  VersionChanged: "<<next>>"
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SpecFilePathFormat
 
 RSpec/SpecFilePathSuffix:

lib/rubocop/cop/rspec/spec_file_path_format.rb

@@ -32,10 +32,10 @@ module RSpec
       #   # good
       #   whatever_spec.rb         # describe MyClass, type: :routing do; end
       #
-      # @example `UseActiveSupportInflections: true`
+      # @example `EnforcedInflector: active_support`
       #   # Enable to use ActiveSupport's inflector for custom acronyms
-      #   # like HTTP, etc. Set to false by default.
-      #   # The InflectorPath provides the path to the inflector file.
+      #   # like HTTP, etc. Set to "default" by default.
+      #   # Configure `InflectorPath` with the path to the inflector file.
       #   # The default is ./config/initializers/inflections.rb.
       #
       class SpecFilePathFormat < Base
@@ -63,11 +63,6 @@ def on_top_level_example_group(node)
           end
         end
 
-        # For testing and debugging
-        def self.reset_activesupport_cache!
-          ActiveSupportInflector.reset_cache!
-        end
-
         private
 
         # Inflector module that uses ActiveSupport for advanced inflection rules
@@ -76,33 +71,20 @@ def self.call(string)
             ActiveSupport::Inflector.underscore(string)
           end
 
-          def self.available?(cop_config)
-            return @available unless @available.nil?
+          def self.prepare_availability(config)
+            return if @prepared
 
-            unless cop_config.fetch('UseActiveSupportInflections', false)
-              return @available = false
-            end
+            @prepared = true
 
-            unless File.exist?(inflector_path(cop_config))
-              return @available = false
-            end
+            inflector_path = config.fetch('InflectorPath')
 
-            @available = begin
-              require 'active_support/inflector'
-              require inflector_path(cop_config)
-              true
-            rescue LoadError, StandardError
-              false
+            unless File.exist?(inflector_path)
+              raise "The configured `InflectorPath` #{inflector_path} does " \
+                    'not exist.'
             end
-          end
-
-          def self.inflector_path(cop_config)
-            cop_config.fetch('InflectorPath',
-                             './config/initializers/inflections.rb')
-          end
 
-          def self.reset_cache!
-            @available = nil
+            require 'active_support/inflector'
+            require inflector_path
           end
         end
 
@@ -117,11 +99,16 @@ def self.call(string)
         end
 
         def inflector
-          @inflector ||= if ActiveSupportInflector.available?(cop_config)
-                           ActiveSupportInflector
-                         else
-                           DefaultInflector
-                         end
+          case cop_config.fetch('EnforcedInflector')
+          when 'active_support'
+            ActiveSupportInflector.prepare_availability(cop_config)
+            ActiveSupportInflector
+          when 'default'
+            DefaultInflector
+          else
+            raise 'Unknown value for `EnforcedInflector`: ' \
+                  "#{cop_config.fetch('EnforcedInflector')}"
+          end
         end
 
         def ensure_correct_file_path(send_node, class_name, arguments)

spec/rubocop/cop/rspec/spec_file_path_format_spec.rb

@@ -286,38 +286,35 @@ class Foo
   # rubocop:disable RSpec/NestedGroups
   context 'when using ActiveSupport integration' do
     around do |example|
-      described_class.reset_activesupport_cache!
+      reset_activesupport_cache!
       example.run
-      described_class.reset_activesupport_cache!
+      reset_activesupport_cache!
     end
 
-    before do
-      # We cannot verify this double because it's not a Rubocop dependency
-      # rubocop:disable RSpec/RSpec/VerifiedDoubles
-      inflector = double('ActiveSupport::Inflector')
-      # rubocop:enable RSpec/RSpec/VerifiedDoubles
-      stub_const('ActiveSupport::Inflector', inflector)
-
-      allow(File).to receive(:exist?)
-        .with(cop_config['InflectorPath']).and_return(file_exists)
+    def reset_activesupport_cache!
+      described_class::ActiveSupportInflector.instance_variable_set(
+        :@prepared, nil
+      )
     end
 
-    let(:file_exists) { true }
     let(:cop_config) do
       {
-        'UseActiveSupportInflections' => true,
+        'EnforcedInflector' => 'active_support',
         'InflectorPath' => './config/initializers/inflections.rb'
       }
     end
 
     context 'when ActiveSupport inflections are available' do
       before do
-        allow(described_class::ActiveSupportInflector)
-          .to receive(:available?)
-          .and_return(true)
-        allow(described_class).to receive(:require)
-          .with('./config/initializers/inflections.rb').and_return(true)
+        allow(File).to receive(:exist?)
+          .with(cop_config['InflectorPath']).and_return(true)
 
+        allow(described_class::ActiveSupportInflector).to receive(:require)
+          .with('active_support/inflector')
+        stub_const('ActiveSupport::Inflector', Module.new)
+
+        allow(described_class::ActiveSupportInflector).to receive(:require)
+          .with('./config/initializers/inflections.rb')
         allow(ActiveSupport::Inflector).to receive(:underscore)
           .with('PvPClass').and_return('pvp_class')
         allow(ActiveSupport::Inflector).to receive(:underscore)
@@ -355,184 +352,69 @@ class Foo
       end
     end
 
-    context 'when ActiveSupport loading raises an error' do
-      let(:cop_config) do
-        {
-          'UseActiveSupportInflections' => true,
-          'InflectorPath' => './config/initializers/inflections.rb'
-        }
-      end
-
-      it 'returns false from available? when ActiveSupport cannot be loaded' do
-        result = described_class::ActiveSupportInflector.available?(cop_config)
-        expect(result).to be false
-      end
-
-      it 'gracefully falls back to default behavior' do
-        expect_no_offenses(<<~RUBY, 'pv_p_class_spec.rb')
-          describe PvPClass do; end
-        RUBY
-
-        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 configured with custom InflectorPath' do
-      let(:cop_config) do
-        {
-          'UseActiveSupportInflections' => true,
-          'InflectorPath' => './config/custom_inflections.rb'
-        }
-      end
-
-      context 'when inflector file exists' do
-        before do
-          allow(TOPLEVEL_BINDING.receiver).to receive(:require)
-            .and_call_original
-          allow(TOPLEVEL_BINDING.receiver).to receive(:require)
-            .with('active_support/inflector').and_return(true)
-          allow(TOPLEVEL_BINDING.receiver).to receive(:require)
-            .with(cop_config['InflectorPath']).and_return(true)
-        end
-
-        it 'loads the custom inflector file when it exists' 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
-          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 loading fails' do
-        before do
-          # Stub the global require method
-          allow(TOPLEVEL_BINDING.receiver).to receive(:require)
-            .and_call_original
-          allow(TOPLEVEL_BINDING.receiver).to receive(:require)
-            .with('./config/custom_inflections.rb')
-            .and_raise(LoadError, 'Cannot load file')
-        end
-
-        it 'gracefully falls back and handles inflector file loading errors' do
-          expect_no_offenses(<<~RUBY, 'https_client_spec.rb')
-            describe HTTPSClient do; end
-          RUBY
-        end
-      end
-
-      context 'when inflector file does not exist' do
-        let(:file_exists) { false }
-
-        it 'falls back to camel_to_snake_case conversion ' \
-           'without ActiveSupport' do
-          expect_no_offenses(<<~RUBY, 'https_client_spec.rb')
-            describe HTTPSClient do; end
-          RUBY
-        end
-      end
-    end
-
-    context 'when using default inflector path' do
-      before do
-        allow(described_class::ActiveSupportInflector)
-          .to receive(:available?)
-          .and_return(true)
-      end
-
-      it 'uses default inflector path when not configured' do
-        allow(described_class::ActiveSupportInflector).to receive(:available?)
-          .and_call_original
-
-        expect_no_offenses(<<~RUBY, 'http_client_spec.rb')
-          describe HTTPClient do; end
-        RUBY
+    describe 'errors during preparation' do
+      it 'shows an error when the configured inflector file does not exist' do
+        allow(File).to receive(:exist?)
+          .with(cop_config['InflectorPath']).and_return(false)
 
-        expect(File).to have_received(:exist?)
-          .with('./config/initializers/inflections.rb')
+        expect do
+          inspect_source('describe PvPClass do; end', 'pv_p_class_spec.rb')
+        end.to raise_error('The configured `InflectorPath` ./config' \
+                           '/initializers/inflections.rb does not exist.')
       end
 
-      context 'when inflector file does not exist' do
-        let(:file_exists) { false }
+      it 'lets LoadError pass all the way up when ActiveSupport loading ' \
+         'raises an error' do
+        allow(File).to receive(:exist?)
+          .with(cop_config['InflectorPath']).and_return(true)
 
-        it 'does not require default inflector file when it does not exist' do
-          allow(described_class::ActiveSupportInflector).to receive(:available?)
-            .and_call_original
+        allow(described_class::ActiveSupportInflector).to receive(:require)
+          .with('active_support/inflector').and_raise(LoadError)
 
-          expect_no_offenses(<<~RUBY, 'http_client_spec.rb')
-            describe HTTPClient do; end
-          RUBY
-        end
+        expect do
+          inspect_source('describe PvPClass do; end', 'pv_p_class_spec.rb')
+        end.to raise_error(LoadError)
       end
     end
 
     context 'when testing custom InflectorPath configuration precedence' do
       let(:cop_config) do
         {
-          'UseActiveSupportInflections' => true,
+          'EnforcedInflector' => 'active_support',
           'InflectorPath' => '/custom/path/to/inflections.rb'
         }
       end
-      let(:file_exists) { false }
 
       before do
+        allow(File).to receive(:exist?).and_call_original
         # Ensure default path is not checked when custom path is configured
         allow(File).to receive(:exist?)
           .with('./config/initializers/inflections.rb').and_return(false)
-      end
+        allow(File).to receive(:exist?)
+          .with(cop_config['InflectorPath']).and_return(true)
 
-      it 'reads the InflectorPath configuration correctly and checks ' \
-         'for file existence' do
-        expect_no_offenses(<<~RUBY, 'http_client_spec.rb')
-          describe HTTPClient do; end
-        RUBY
+        allow(described_class::ActiveSupportInflector).to receive(:require)
+          .with('active_support/inflector')
+        stub_const('ActiveSupport::Inflector', Module.new)
 
-        expect(File).to have_received(:exist?)
-          .with('/custom/path/to/inflections.rb')
+        allow(described_class::ActiveSupportInflector).to receive(:require)
+          .with(cop_config['InflectorPath'])
+        allow(ActiveSupport::Inflector).to receive(:underscore)
+          .and_return('')
       end
 
       it 'reads the InflectorPath configuration correctly and does not ' \
-         'fall back to the default inflector path' do
+         'fall back to the default inflector path', :aggregate_failures do
         expect_no_offenses(<<~RUBY, 'http_client_spec.rb')
           describe HTTPClient do; end
         RUBY
 
+        expect(File).to have_received(:exist?)
+          .with('/custom/path/to/inflections.rb')
         expect(File).not_to have_received(:exist?)
           .with('./config/initializers/inflections.rb')
       end
     end
-
-    context 'when testing ActiveSupportInflector success path' do
-      before do
-        # Stub the require calls to succeed
-        allow(described_class::ActiveSupportInflector).to receive(:require)
-          .and_call_original
-        allow(described_class::ActiveSupportInflector).to receive(:require)
-          .with('active_support/inflector').and_return(true)
-        allow(described_class::ActiveSupportInflector).to receive(:require)
-          .with('./config/initializers/inflections.rb').and_return(true)
-      end
-
-      it 'returns true when ActiveSupport is successfully loaded' do
-        result = described_class::ActiveSupportInflector.available?(cop_config)
-        expect(result).to be true
-      end
-    end
   end
   # rubocop:enable RSpec/NestedGroups
 end