a-nti_manner_kick_course 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4dc6a3d6c4947ef0ed61f061101a08fbce40cb114e6a8e27f10445d3c3d77ba9
+  data.tar.gz: ad23ea7057ba5e40f4a4830c363aab4b73c18678292e83dd06894c049c803da1
+SHA512:
+  metadata.gz: 5e43b59506830ae8320db2ea37c5a87d28967f43399982492196b14bc4fc10b51aa23058875c04b269769a9d96048071ef2d6d79d86c43904234256d12e8662b
+  data.tar.gz: aa4d12b64c793bf21480abd45364f54ad2d2c881846cd4493ca23d2617f35f84844a8109b8d78d95980c3d5746025bedeba7493dc0c2e0df0b47134e098dc02d

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Shinichi Maeshima
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,121 @@
+# A::NtiMannerKickCourse
+
+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.
+
+For example, consider the following scenario:
+
+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
+###
+# Do not treat an `ActionController::Parameters` instance
+# as equal to an equivalent `Hash` by default.
+#++
+Rails.application.config.action_controller.allow_deprecated_parameters_hash_equality = false
+````
+
+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.
+
+In this case, the value of `Rails.application.config.action_controller.allow_deprecated_parameters_hash_equality` is assigned to `ActionController::Parameters.allow_deprecated_parameters_hash_equality` during initialization, as seen in the following code:
+
+```ruby
+ActionController::Parameters.allow_deprecated_parameters_hash_equality = Rails.application.config.action_controller.allow_deprecated_parameters_hash_equality
+```
+
+Source: https://github.com/rails/rails/blob/36c1591bcb5e0ee3084759c7f42a706fe5bb7ca7/actionpack/lib/action_controller/railtie.rb#L51-L52
+
+This assignment is wrapped in an `ActiveSupport.on_load(:action_controller, run_once: true) do ... end` block, ensuring that it runs only when ActionController::Base is loaded:
+
+```ruby
+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:
+
+```ruby
+module AddSomeFunctionToController
+# snip
+end
+
+ActionController::Base.include(AddSomeFunctionToController)
+```
+
+Since all gems listed in the Gemfile are required in config/application.rb, the above code causes ActionController::Base to be loaded during Rails initialization. The order of initialization typically looks like this:
+
+1.	config/application.rb
+2.	Component configuration logic (e.g., applying settings)
+3.	Initializer files in config/initializers/*.rb
+
+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
+
+To solve this, modify the gem code as follows:
+
+```ruby
+module AddSomeFunctionToController
+# snip
+end
+
+ActiveSupport.on_load(:action_controller) do
+  ActionController::Base.include(AddSomeFunctionToController)
+end
+```
+
+This ensures that ActionController::Base is loaded lazily, delaying the execution of the configuration logic to the correct timing. The updated order of initialization becomes:
+
+1.	config/application.rb
+2.	Initializer files in config/initializers/*.rb
+3.	Component configuration logic
+
+This resolves the issue, as the setting in config/initializers/new_framework_defaults_7_1.rb is now applied correctly.
+
+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 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
+
+Add this line **at the top of your Gemfile**.
+
+```ruby
+gem "a-nti_manner_kick_course"
+```
+
+> [!IMPORTANT]
+> To detect gems that fail to defer execution, you need to add this gem at the top of your Gemfile.
+
+And then execute:
+```bash
+$ bundle
+```
+
+## Usage
+
+Start your Rails application with the ANTI_MANNER environment variable as follows.
+
+```bash
+$ ANTI_MANNER=1 rails boot
+```
+
+If you are using Rails 7.1 or below, start the application as follows.
+
+```bash
+$ 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.  
+
+For more details about ActiveSupport.on_load, check [the official Rails documentation]((https://api.rubyonrails.org/classes/ActiveSupport/LazyLoadHooks.html).
+
+If the ANTI_MANNER environment variable is not set, this gem does nothing.
+
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"

data/lib/a/nti_manner_kick_course/railtie.rb

@@ -0,0 +1,16 @@
+require "rails"
+
+module A
+  module NtiMannerKickCourse
+    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
+        end
+      end
+    end
+  end
+end

data/lib/a/nti_manner_kick_course/version.rb

@@ -0,0 +1,5 @@
+module A
+  module NtiMannerKickCourse
+    VERSION = "0.1.0"
+  end
+end

data/lib/a/nti_manner_kick_course.rb

@@ -0,0 +1,92 @@
+require "a/nti_manner_kick_course/version"
+require "a/nti_manner_kick_course/railtie"
+
+module A
+  module NtiMannerKickCourse
+    MONITORED_HOOKS =  %i[
+      action_controller action_controller_base action_controller_api action_controller_test_case action_dispatch_response action_dispatch_integration_test
+      message_pack active_model active_model_translation active_job active_job_test_case active_record_fixtures
+      action_cable_connection action_cable_connection_test_case action_cable action_cable_channel action_cable_channel_test_case
+      action_text_encrypted_rich_text action_text_record action_text_rich_text action_text_content active_record active_record_fixture_set
+      active_record_sqlite3adapter active_record_mysql2adapter active_record_trilogyadapter active_record_postgresqladapter active_record_encryption
+      action_view action_view_test_case action_mailer action_mailer_test_case active_storage_blog active_storage_record active_storage_variant_record
+      active_storage_attachment action_mailbox_inbound_email action_mailbox_record action_mailbox action_mailbox_test_case
+     ].freeze
+
+    class << self
+      def enabled?
+        ENV["ANTI_MANNER"]
+      end
+
+      def debug?
+        ENV["ANTI_MANNER_DEBUG"]
+      end
+
+      def monitor
+        require "active_support/lazy_load_hooks"
+
+        start_monitoring
+
+        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.
+
+                  #{suspect}
+
+                  If you want to check the entire stack trace, set the ANTI_MANNER_DEBUG environment variable.
+                MESSAGE
+              end
+
+              abort(message)
+            end
+          end
+        end
+      end
+
+      def monitoring?
+        @monitoring
+      end
+
+      def finish_monitoring
+        @monitoring = false
+      end
+
+      # TODO: We need to make this list more comprehensive.
+      def filtering
+        %r{<internal:|/bundled_gems.rb|/(activesupport|actionpack|activerecord|bootsnap|bundler|zeitwerk)-[0-9a-z\.]+/}
+      end
+
+      def already_checked?
+        @already_checked
+      end
+
+      def already_checked
+        @already_checked = true
+      end
+
+      private
+
+      def start_monitoring
+        @monitoring = true
+      end
+    end
+
+    monitor if enabled?
+  end
+end

data/lib/tasks/a/nti_manner_kick_course_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :a_nti_manner_kick_course do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: a-nti_manner_kick_course
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shinichi Maeshima
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-01-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+description: This library detects code or gems that violate lazy loading conventions
+  during Rails initialization.
+email:
+- netwillnet@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/a/nti_manner_kick_course.rb
+- lib/a/nti_manner_kick_course/railtie.rb
+- lib/a/nti_manner_kick_course/version.rb
+- lib/tasks/a/nti_manner_kick_course_tasks.rake
+homepage: https://github.com/willnet/a-nti_manner_kick_course
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/willnet/a-nti_manner_kick_course
+  source_code_uri: https://github.com/willnet/a-nti_manner_kick_course
+  changelog_uri: https://github.com/willnet/a-nti_manner_kick_course/releases
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: This library detects code or gems that violate lazy loading conventions during
+  Rails initialization.
+test_files: []