Revise style

railties/lib/rails/autoloaders.rb

@@ -2,41 +2,43 @@
 
 require "zeitwerk"
 
-module Rails::Autoloaders # :nodoc:
+module Rails
-  require_relative "autoloaders/inflector"
+  module Autoloaders # :nodoc:
+    require_relative "autoloaders/inflector"
 
-  class << self
+    class << self
-    include Enumerable
+      include Enumerable
 
-    def main
+      def main
-      @main ||= Zeitwerk::Loader.new.tap do |loader|
+        @main ||= Zeitwerk::Loader.new.tap do |loader|
-        loader.tag = "rails.main"
+          loader.tag = "rails.main"
-        loader.inflector = Inflector
+          loader.inflector = Inflector
+        end
       end
-    end
 
-    def once
+      def once
-      @once ||= Zeitwerk::Loader.new.tap do |loader|
+        @once ||= Zeitwerk::Loader.new.tap do |loader|
-        loader.tag = "rails.once"
+          loader.tag = "rails.once"
-        loader.inflector = Inflector
+          loader.inflector = Inflector
+        end
       end
-    end
 
-    def each
+      def each
-      yield main
+        yield main
-      yield once
+        yield once
-    end
+      end
 
-    def logger=(logger)
+      def logger=(logger)
-      each { |loader| loader.logger = logger }
+        each { |loader| loader.logger = logger }
-    end
+      end
 
-    def log!
+      def log!
-      each(&:log!)
+        each(&:log!)
-    end
+      end
 
-    def zeitwerk_enabled?
+      def zeitwerk_enabled?
-      true
+        true
+      end
     end
   end
 end

railties/lib/rails/autoloaders/inflector.rb

@@ -2,16 +2,20 @@
 
 require "active_support/inflector"
 
-module Rails::Autoloaders::Inflector # :nodoc:
+module Rails
-  # Concurrent::Map is not needed. This is a private class, and overrides
+  module Autoloaders
-  # must be defined while the application boots.
+    module Inflector # :nodoc:
-  @overrides = {}
+      # Concurrent::Map is not needed. This is a private class, and overrides
+      # must be defined while the application boots.
+      @overrides = {}
 
-  def self.camelize(basename, _abspath)
+      def self.camelize(basename, _abspath)
-    @overrides[basename] || basename.camelize
+        @overrides[basename] || basename.camelize
-  end
+      end
 
-  def self.inflect(overrides)
+      def self.inflect(overrides)
-    @overrides.merge!(overrides)
+        @overrides.merge!(overrides)
+      end
+    end
   end
 end