a-nti_manner_kick_course 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68267188f3995d0cf7a60c081677f7b86ebc4dba7e29a5b075b32d1edd98b411
-  data.tar.gz: 037e96608abbb2fbef919095be48ea7dc48d171e7446292b52dc4f53be69fc60
+  metadata.gz: 9ff98ea010b2a18d649f9d61a592063abe42f27311ede7c647f30b8a50cb49a8
+  data.tar.gz: 978697243153cb4439afd3988c65799b90b00523a32ba46a199bbe5dcb8fd5a6
 SHA512:
-  metadata.gz: 9cb5109a6b9524bc12ca8209a309bab3a46c938eb4ccbd66f1642f3c8d23b3b44fd65d9013bbbbf5eb7e5b94c23fc3460cc9b6eb786ead28c59353c57e1f37fd
-  data.tar.gz: 5b4836b815b3cc14c7d009f1b61132cb58df8619f7e213b587f25e0eb5a67c8944d0891e75ce9d63dd73ebc3c02b7ace5cb37f9a99844e1db93b995b5e355833
+  metadata.gz: ee5c1bb87b979434b0cbb5cce467adc13dc7cfab3a194aef87fee9f6901f61b627a634ecf194f924f76f60bbccd75660fd8db9aabcd5decc377f076b2535806f
+  data.tar.gz: 3eda7e4a5837d9d14bd3981080f36d2622db09b051c4c5cc50d8e603b1fdc95faced616a6d8edf43bbcc8ef364470a40accb118a8b5d4c49f782e440939cbd64

data/README.md

@@ -1,9 +1,14 @@
 # A::NtiMannerKickCourse
 
+## Introduction
 Rails speeds up the startup process by lazily loading classes for components like ActiveRecord::Base and ActionController::Base. Additionally, the behavior of lazy loading is essential for applying configuration settings to these components. Without lazy loading, some configurations might not be applied as expected.
 
+### Why Lazy Loading Matters
+Without lazy loading, certain settings might not be applied in time.
+
 For example, consider the following scenario:
 
+### Example: Upgrading from Rails 7.0 to 7.1
 When upgrading from Rails 7.0 to Rails 7.1, running rails app:upgrade generates a file named `config/initializers/new_framework_defaults_7_1.rb`. This file helps incrementally enable new default settings for Rails 7.1. Initially, all settings in this file are commented out. Uncommenting the following setting will enable it:
 
 ```ruby
@@ -12,8 +17,9 @@ When upgrading from Rails 7.0 to Rails 7.1, running rails app:upgrade generates
 # as equal to an equivalent `Hash` by default.
 #++
 Rails.application.config.action_controller.allow_deprecated_parameters_hash_equality = false
-````
+```
 
+### Configuration Details and Pitfalls
 As the comment suggests, this setting ensures that ActionController::Parameters instances are no longer treated as equivalent to Hash. However, if ActionController::Base is eager-loaded, this configuration will not behave as expected. Why does this happen?
 
 Configuration settings like `Rails.application.config.action_controller.allow_deprecated_parameters_hash_equality` are not automatically effective. These settings are applied to components like ActionController only during the Rails initialization process.
@@ -32,7 +38,7 @@ This assignment is wrapped in an `ActiveSupport.on_load(:action_controller, run_
 ActiveSupport.on_load(:action_controller, run_once: true) do
   # Configuration assignment logic
 end
-````
+```
 
 Now, consider a gem "add_some_function_to_controller" with the following code:
 
@@ -52,8 +58,7 @@ Since all gems listed in the Gemfile are required in config/application.rb, the
 
 As a result, the configuration logic for ActionController is executed before the initializer file `config/initializers/new_framework_defaults_7_1.rb`. This means that the setting `Rails.application.config.action_controller.allow_deprecated_parameters_hash_equality = false` is not applied in time.
 
-Fixing the Issue
-
+### Fixing the Issue
 To solve this, modify the gem code as follows:
 
 ```ruby
@@ -76,6 +81,7 @@ This resolves the issue, as the setting in config/initializers/new_framework_def
 
 While this specific case is likely a common issue, other problems may also arise from changes to the initialization order. To ensure reliable behavior, it is critical to keep all component loading deferred during Rails initialization. However, manually checking for potential issues with lazy loading is impractical.
 
+### Using a-nti_manner_kick_course
 Using a-nti_manner_kick_course can help detect libraries or application code (like add_some_function_to_controller) that interfere with lazy loading, allowing you to maintain proper initialization behavior.
 
 ## Installation
@@ -94,7 +100,7 @@ And then execute:
 $ bundle
 ```
 
-## Usage
+## Usage for rails application developers
 
 Start your Rails application with the ANTI_MANNER environment variable as follows.
 
@@ -110,7 +116,7 @@ $ ANTI_MANNER=1 rails runner 1
 
 If any code fails to lazy loading, the process will exit with status code 1. This command suggests which lines are eager loading Rails code. It is a good idea to regularly check in CI if lazy loading is working correctly.
 
-You can fix the issue by wrapping the relevant code in an `ActiveSupport.on_load` block.  
+You can fix the issue by wrapping the relevant code in an `ActiveSupport.on_load` block.
 
 For more details about ActiveSupport.on_load, check [the official Rails documentation](https://api.rubyonrails.org/classes/ActiveSupport/LazyLoadHooks.html).
 
@@ -119,5 +125,17 @@ If the ANTI_MANNER environment variable is not set, this gem does nothing.
 > [!CAUTION]
 > If you are using Spring, this gem will not work correctly. In that case, add DISABLE_SPRING=1 to your command before running it.
 
+## Usage for gem developers
+
+`A::NtiMannerKickcourse.monitor { require 'your_gem' }` allows you to run the specified code in a new process and exit with status code 1 if lazy loading is not properly deferred.
+
+Execute `require 'your_gem'` within the `A::NtiMannerKickcourse.monitor` block as follows:
+
+```ruby
+A::NtiMannerKickcourse.monitor { require 'your_gem' }
+```
+
+When this code runs, if `your_gem` interferes with lazy loading, an error message will be displayed and the process will exit with status code 1. This helps you quickly identify and fix lazy loading issues.
+
 ## License
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/a/nti_manner_kick_course/railtie.rb

@@ -5,10 +5,7 @@ module A
     class Railtie < ::Rails::Railtie
       initializer "anti_manner", before: :eager_load! do
         if A::NtiMannerKickCourse.enabled?
-          A::NtiMannerKickCourse.finish_monitoring
-
-          puts "Congratulations! No code was found that fails to defer execution!"
-          exit
+          A::NtiMannerKickCourse.wrapup!
         end
       end
     end

data/lib/a/nti_manner_kick_course/version.rb

@@ -1,5 +1,5 @@
 module A
   module NtiMannerKickCourse
-    VERSION = "0.1.3"
+    VERSION = "0.2.0"
   end
 end

data/lib/a/nti_manner_kick_course.rb

@@ -22,41 +22,25 @@ module A
         ENV["ANTI_MANNER_DEBUG"]
       end
 
-      def monitor
-        require "active_support/lazy_load_hooks"
-
+      def monitor_rails_startup
         start_monitoring
+        add_hooks
+      end
 
-        MONITORED_HOOKS.each do |framework|
-          ActiveSupport.on_load(framework) do
-            if A::NtiMannerKickCourse.monitoring? && !A::NtiMannerKickCourse.already_checked?
-              A::NtiMannerKickCourse.already_checked
-              message = if A::NtiMannerKickCourse.debug?
-                <<~"MESSAGE"
-                  During Rails startup, the block inside ActiveSupport.on_load(:#{framework}) was executed.
-                  There is code that is not being deferred as expected.
-
-                  Currently, debug mode is enabled, so the full stack trace is being displayed.
-                  To show only the suspicious code line, remove the ANTI_MANNER_DEBUG environment variable and rerun.
-
-                  #{caller}
-                MESSAGE
-              else
-                suspect = caller.find { |c| !A::NtiMannerKickCourse.filtering.match?(c) }
-                <<~"MESSAGE"
-                  During Rails startup, the block inside ActiveSupport.on_load(:#{framework}) was executed.
-                  There is code that is not being deferred as expected. The suspicious part is here.
+      def monitor_gem
+        start_monitoring
+        add_hooks
+        yield
+        wrapup!
+      end
 
-                  #{suspect}
+      alias monitor monitor_gem
 
-                  If you want to check the entire stack trace, set the ANTI_MANNER_DEBUG environment variable.
-                MESSAGE
-              end
+      def wrapup!
+        A::NtiMannerKickCourse.finish_monitoring
 
-              abort(message)
-            end
-          end
-        end
+        puts "✅Congratulations! No code was found that fails to defer execution!"
+        exit
       end
 
       def monitoring?
@@ -80,13 +64,56 @@ module A
         @already_checked = true
       end
 
+      def error_message(framework)
+        suspect = caller.find { |c| !A::NtiMannerKickCourse.filtering.match?(c) }
+        <<~"MESSAGE"
+          ❌During Rails startup, the block inside ActiveSupport.on_load(:#{framework}) was executed.
+          There is code that is not being deferred as expected. The suspicious part is here.
+
+          #{suspect}
+
+          If you want to check the entire stack trace, set the ANTI_MANNER_DEBUG environment variable.
+        MESSAGE
+      end
+
+      def error_message_with_debug(framework)
+        <<~"MESSAGE"
+          ❌During Rails startup, the block inside ActiveSupport.on_load(:#{framework}) was executed.
+          There is code that is not being deferred as expected.
+
+          Currently, debug mode is enabled, so the full stack trace is being displayed.
+          To show only the suspicious code line, remove the ANTI_MANNER_DEBUG environment variable and rerun.
+
+          #{caller}
+        MESSAGE
+      end
+
       private
 
       def start_monitoring
         @monitoring = true
       end
+
+      def add_hooks
+        require "active_support/lazy_load_hooks"
+
+        MONITORED_HOOKS.each do |framework|
+          ActiveSupport.on_load(framework) do
+            if A::NtiMannerKickCourse.monitoring? && !A::NtiMannerKickCourse.already_checked?
+              A::NtiMannerKickCourse.already_checked
+              message = if A::NtiMannerKickCourse.debug?
+                A::NtiMannerKickCourse.error_message_with_debug(framework)
+              else
+                A::NtiMannerKickCourse.error_message(framework)
+              end
+
+              abort(message)
+            end
+          end
+        end
+      end
     end
 
-    monitor if enabled?
+    monitor_rails_startup if enabled?
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: a-nti_manner_kick_course
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Shinichi Maeshima
 bindir: bin
 cert_chain: []
-date: 2025-02-07 00:00:00.000000000 Z
+date: 2025-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -59,7 +59,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.5
 specification_version: 4
 summary: This library detects code or gems that violate lazy loading conventions during
   Rails initialization.