rails-minify 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32a43a0b86ec6d79152580e59ed32f5468ddd3d1a4e0865716f404bd542b566c
-  data.tar.gz: fa640778b9324a8737ff1e809af7a101ff2e10b910677611de081b033678c983
+  metadata.gz: bf98d2d12a8005e5ef2755cd6bba97a32122a7dd2514518e9a749d1ba367af00
+  data.tar.gz: 878a2fab37d90963eb4b4d5924d7b3437847672741471d84ea6cefc686cb7ca1
 SHA512:
-  metadata.gz: d078aaa82950d4407b91e82fcde444264496d72551db08177d629cdb61d5928ff23381462f23388cbf5db91c138cca78d1f79a870f0eeca794d178b0e8427af9
-  data.tar.gz: e6ee0e7f39335eaba0d2adf4718a89dbdf52e8d1a8b993539ddfa3081631714bac16c5fc899b6f8dea5fd3cf12d667875843a1d73ccc524ecc72735c9e42834d
+  metadata.gz: 2baf13ba8db10c35cfaccfaf86b6c966b11555b9b232c1710da044a37dad166f96dee80cdc2380db98321a845c612e80f3a3648dbc515b31f9402a54bc393599
+  data.tar.gz: b26a83ac5f86fc456c18444e7eba578cb095fa897ee4bac9a508a10047a9164fc8d22197dc0ae6f7f2c7193ca32a437fe1b8fc35c7c9ab873d9091c936be57a0

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.1.2 (2026-10-18)
+
+- `minify:check` also fails on callback chains longer than `callback_limit` (default 5, `ApplicationController`'s callbacks excluded) and on model callbacks that save their own record again; `callback_limit_mode` and `callback_loops` set either to `:warn`. Works without the rest of rails-minify turned on; the manifest check runs only when there is a manifest.
+- Requires activesupport-minimizer 0.1.1.
+
+## 0.1.1 (2026-10-18)
+
+- `:omniauth` isn't installed when OmniAuth already skips requests that can't be the strategy's (a public `Strategy#passthrough?`, as in the version proposed upstream); its own helper no longer shares that name.
+
 ## 0.1.0 (2026-10-18)
 
 First release.

data/README.md

@@ -14,6 +14,19 @@ config.rails_minify.enabled = true
 (`config.ar_minimizer.enums = false`, `config.rails_minify.patches = [:omniauth]`).
 Ruby 3.4+, Rails 8.0, 8.1 and main.
 
+Turn it on in tests too, so a call to a method strict mode removed fails in CI
+rather than in production. In development, strict mode alone is enough: the
+same errors show up while you work, and the compiling parts, which don't
+follow code reloads, stay off.
+
+```ruby
+# config/environments/test.rb
+config.rails_minify.enabled = true
+
+# config/environments/development.rb
+config.ar_minimizer.slim = true # strict mode, without the rest
+```
+
 ## Strict by default
 
 Active Record defines, for every column, a reader, a writer and 19 more
@@ -57,7 +70,7 @@ For parts of Rails and common gems that redo work on every request.
   Attachments that are Active Storage blobs, remote images or inline content
   are cached too: a blob without a caption contributes its filename, which a
   hit checks in one query (renamed or deleted: computed again). Other
-  attachables aren't cached. In golf-buddy, 13% of all allocations on its
+  attachables aren't cached. In [Japan Voyage](https://japanvoyage.jp), 13% of all allocations on its
   pages came from it, and guides with images another 4.5%.
 * `:request_host`: `ActionDispatch::Request#host` runs a regexp substitution
   on every call, port or not, and Rails reads it several times per request.
@@ -67,11 +80,13 @@ For parts of Rails and common gems that redo work on every request.
   options on every request before looking at the path. Requests that can't
   be OmniAuth's go straight to the app. Only when that's certain up front:
   a session is present, not in test mode, no `other_phase` or callable
-  paths, and the strategy doesn't override how paths are matched.
+  paths, and the strategy doesn't override how paths are matched. Not
+  installed when OmniAuth already does this itself (it then has a public
+  `Strategy#passthrough?`, as in the version proposed upstream).
 
 ## Numbers
 
-golf-buddy, 132 production pages, with everything on (strict mode after
+Japan Voyage, 132 production pages, with everything on (strict mode after
 rubocop-minify's rewrites, all patches): identical HTML, and
 1,561,283 → 1,224,141 allocations per pass (−21.6%). The machine was too
 loaded for wall-clock times to mean much.
@@ -79,7 +94,26 @@ loaded for wall-clock times to mean much.
 ## Checks
 
 * `bin/rails minify:census`: how much of the app runs compiled, and why the rest doesn't.
-* `bin/rails minify:check`: callbacks naming methods that don't exist (for CI).
+* `bin/rails minify:check` (for CI; works whether or not the rest of
+  rails-minify is on) fails on:
+  * callbacks naming methods that don't exist;
+  * callback chains with more than `callback_limit` (default 5) of the app's
+    own callbacks (Rails' and gems' don't count; controllers per action).
+    Callbacks inherited from `callback_limit_exclude` (default
+    `["ApplicationController"]`: time zone, locale, current user, the
+    per-request basics) don't count either. A base class over the limit is
+    reported once, with the classes that inherit it;
+  * model callbacks that call `save`, `update`, `touch`, ... on the record
+    they run for, which runs the chain again;
+  * an out-of-date manifest.
+
+  ```ruby
+  config.rails_minify.callback_limit = 8
+  config.rails_minify.callback_limit_exclude = ["ApplicationController", "Admin::BaseController"] # [] counts everything
+  config.rails_minify.callback_limit_mode = :warn # report, don't fail
+  config.rails_minify.callback_loops = :warn
+  config.rails_minify.allow_callback_loops = ["Trip#recalculate"] # guarded on purpose
+  ```
 
 ## Things found that are app config, not patches
 

data/lib/rails_minify/patches/action_text_plain_text.rb

@@ -4,9 +4,9 @@ module RailsMinify
   module Patches
     # ActionText::Content#to_plain_text walks the whole HTML tree with
     # Nokogiri on every call, and looks up the record behind every attachment:
-    # in golf-buddy, 13% of all allocations on its pages came from it
-    # (excerpts, meta descriptions, cards). The text is computed once per
-    # distinct HTML and kept, up to MAX_BYTES of HTML.
+    # on Japan Voyage (japanvoyage.jp), 13% of all allocations on its pages
+    # came from it (excerpts, meta descriptions, cards). The text is computed
+    # once per distinct HTML and kept, up to MAX_BYTES of HTML.
     #
     # Without attachments the text depends on the HTML alone. An attachment
     # adds its record's text: for Active Storage blobs "[caption]" (from the

data/lib/rails_minify/patches/omniauth_passthrough.rb

@@ -3,20 +3,29 @@
 module RailsMinify
   module Patches
     # Every OmniAuth strategy is a middleware that, on every request, dups
-    # itself (and its Hashie::Mash options) before looking at the path: in
-    # golf-buddy about 35k allocations per pass over its pages, none of them
-    # on a login path. Requests that can't be OmniAuth's go straight to the
-    # app; anything that might be (or that the strategy decides at runtime:
-    # callable paths, other_phase, overridden path methods, test mode, a
-    # missing session, which OmniAuth reports) runs OmniAuth as before.
+    # itself (and its Hashie::Mash options) before looking at the path: on
+    # Japan Voyage (japanvoyage.jp) about 35k allocations per pass over its
+    # pages, none of them on a login path. Requests that can't be OmniAuth's
+    # go straight to the app; anything that might be (or that the strategy
+    # decides at runtime: callable paths, other_phase, overridden path
+    # methods, test mode, a missing session, which OmniAuth reports) runs
+    # OmniAuth as before.
     module OmniAuthPassthrough
       # What decides whether a request is the strategy's. A strategy that
       # overrides any of these decides for itself: always run it.
       PATH_METHODS = %i[call! on_auth_path? on_request_path? on_callback_path? on_path? request_path
                         callback_path current_path path_prefix script_name].freeze
 
-      def self.install!
-        OmniAuth::Strategy.prepend(self) unless OmniAuth::Strategy < self
+      def self.install!(strategy = OmniAuth::Strategy)
+        return if upstream?(strategy) # OmniAuth does this itself
+
+        strategy.prepend(self) unless strategy < self
+      end
+
+      # The same check in OmniAuth (sampokuokkanen/omniauth@skip-dup-off-auth-paths,
+      # proposed upstream) defines a public Strategy#passthrough?.
+      def self.upstream?(strategy = OmniAuth::Strategy)
+        strategy.public_method_defined?(:passthrough?) && !(strategy < self)
       end
 
       # Per strategy class: are all of PATH_METHODS OmniAuth's own?
@@ -28,14 +37,14 @@ module RailsMinify
       end
 
       def call(env)
-        return super unless passthrough?(env)
+        return super unless minify_passthrough?(env)
 
         @app.call(env)
       end
 
       private
 
-      def passthrough?(env)
+      def minify_passthrough?(env)
         return false if OmniAuth.config.test_mode || !env["rack.session"] || respond_to?(:other_phase)
         return false unless OmniAuthPassthrough.standard_paths?(self.class)
 

data/lib/rails_minify/railtie.rb

@@ -69,15 +69,39 @@ module RailsMinify
           end
         end
 
-        desc "Fail on what would break at runtime or compile stale: missing callback targets, an out-of-date manifest"
+        desc "Fail on callback problems (missing targets, chains longer than callback_limit, " \
+             "callbacks that save their own record) and an out-of-date manifest"
         task check: :environment do
           app = prepare.call
-          problems = AsMinimizer::Check.callback_targets(routed: AsMinimizer::Check.routed_actions(app.routes))
-          missing = problems.select { it.status == :missing }
-          missing.each { puts "  #{it}" }
-          manifest = ArMinimizer::Census.manifest_state(app.root, ArMinimizer::Index.from_models)
-          puts "callback targets: #{missing.size} missing; manifest: #{manifest}"
-          abort if missing.any? || manifest.start_with?("out of date")
+          options = app.config.rails_minify
+          routed = AsMinimizer::Check.routed_actions(app.routes)
+          failed = false
+          report = lambda do |title, items, mode|
+            next puts("#{title}: none") if items.empty?
+
+            puts "#{title}: #{items.size}#{" (warning)" if mode == :warn}"
+            items.each { puts "  #{it}" }
+            failed ||= mode != :warn
+          end
+
+          missing = AsMinimizer::Check.callback_targets(routed: routed).select { it.status == :missing }
+          report.("callback targets naming no method", missing, :fail)
+
+          limit = options.callback_limit || 5
+          report.("callback chains with more than #{limit} of the app's callbacks",
+            AsMinimizer::Check.long_chains(limit: limit, root: app.root.to_s, routed: routed,
+              exclude: options.callback_limit_exclude.nil? ? ["ApplicationController"] : Array(options.callback_limit_exclude)),
+            (options.callback_limit_mode || :fail).to_sym)
+
+          report.("callbacks saving their own record",
+            AsMinimizer::Check.callback_loops(root: app.root.to_s, allow: Array(options.allow_callback_loops)), (options.callback_loops || :fail).to_sym)
+
+          if defined?(ArMinimizer::Census) && app.root.join("config/ar_minimizer.json").exist?
+            manifest = ArMinimizer::Census.manifest_state(app.root, ArMinimizer::Index.from_models)
+            puts "manifest: #{manifest}"
+            failed ||= manifest.start_with?("out of date")
+          end
+          abort if failed
         end
       end
     end

data/lib/rails_minify/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsMinify
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-minify
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Sampo Kuokkanen
@@ -44,6 +44,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -51,6 +54,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
 description: Turns on activerecord-, activesupport- and actionpack-minimizer, and
   patches parts of Rails and common gems that redo work on every request (Action Text
   plain text, Request#host, OmniAuth strategies).