rails-minify 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 32a43a0b86ec6d79152580e59ed32f5468ddd3d1a4e0865716f404bd542b566c
+  data.tar.gz: fa640778b9324a8737ff1e809af7a101ff2e10b910677611de081b033678c983
+SHA512:
+  metadata.gz: d078aaa82950d4407b91e82fcde444264496d72551db08177d629cdb61d5928ff23381462f23388cbf5db91c138cca78d1f79a870f0eeca794d178b0e8427af9
+  data.tar.gz: e6ee0e7f39335eaba0d2adf4718a89dbdf52e8d1a8b993539ddfa3081631714bac16c5fc899b6f8dea5fd3cf12d667875843a1d73ccc524ecc72735c9e42834d

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## 0.1.0 (2026-10-18)
+
+First release.
+
+- `config.rails_minify.enabled` turns on activerecord-, activesupport- and actionpack-minimizer.
+- Patches: `:action_text_plain_text` (cached plain text, including blob attachments), `:request_host` (rails/rails#59104 for Rails 8.0/8.1), `:omniauth` (strategies skip requests that can't be theirs).
+- `minify:census` and `minify:check` tasks.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sampo Kuokkanen
+
+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,89 @@
+# rails-minify
+
+Cuts what Rails (and common gems) build or redo on every request.
+
+```ruby
+# Gemfile
+gem "rails-minify"
+
+# config/environments/production.rb
+config.rails_minify.enabled = true
+```
+
+`enabled` turns on every part below; each can still be set on its own
+(`config.ar_minimizer.enums = false`, `config.rails_minify.patches = [:omniauth]`).
+Ruby 3.4+, Rails 8.0, 8.1 and main.
+
+## Strict by default
+
+Active Record defines, for every column, a reader, a writer and 19 more
+methods (`name?`, `name_changed?`, `saved_change_to_name?`, ...). With
+rails-minify they're gone: only readers and writers are generated, which
+on a 191-model app is 42,210 → ~4,500 methods, ~10 MB less memory and ~150
+ms less boot. Calling a removed method raises NoMethodError naming its
+replacement:
+
+```
+name_changed? was removed by activerecord-minimizer's strict mode; use attribute_changed?(:name, ...)
+```
+
+rubocop-minify rewrites those calls in your code. For calls in gems
+(Devise's `will_save_change_to_email?`, ...), list them in
+`config/ar_minimizer_keep.txt`; `bin/rails ar_minimizer:profile` finds them.
+`config.ar_minimizer.strict = false` keeps the removed methods working
+instead, generated the first time each is called.
+
+## What's in it
+
+| part | does | gem |
+|---|---|---|
+| attribute methods | readers and writers only (strict) | activerecord-minimizer |
+| enums | predicates/bang methods as plain methods (1.3-1.6x) | activerecord-minimizer |
+| small records | no Hashes for records that never fill them (-22% per record) | activerecord-minimizer |
+| callbacks | chains as generated methods (`valid?` -33..45%) | activesupport-minimizer |
+| route helpers | `post_path(post)` as interpolation (3-14x) | actionpack-minimizer |
+| views | `render`/`link_to` without their machinery (2x per page of partials) | actionpack-minimizer |
+| patches | below | rails-minify |
+| rewrites | removed-method calls in Ruby and ERB, as RuboCop autocorrections | rubocop-minify (development) |
+
+## Patches
+
+For parts of Rails and common gems that redo work on every request.
+`config.rails_minify.patches = [...]` picks them; all by default.
+
+* `:action_text_plain_text`: `ActionText::Content#to_plain_text` parses the
+  HTML with Nokogiri, and looks up every attachment's record, on every call.
+  It's computed once per distinct HTML (cache capped at 8 MB of HTML).
+  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
+  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.
+  rails/rails#59104 (Rails 8.2) for 8.1: no substitution without a port, and
+  the host kept while the raw host is the same String. Not installed on 8.2.
+* `:omniauth`: every OmniAuth strategy middleware dups itself and its
+  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.
+
+## Numbers
+
+golf-buddy, 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.
+
+## 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).
+
+## Things found that are app config, not patches
+
+* sentry-rails' `breadcrumbs_logger = [:active_support_logger]` subscribes to
+  every notification (each SQL query, render, instantiation) and takes
+  `Time.now` twice per event, Sentry enabled or not. `:monotonic_active_support_logger`
+  avoids the clock calls; dropping it avoids the rest.

data/lib/rails-minify.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "rails_minify"

data/lib/rails_minify/patches/action_text_plain_text.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+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.
+    #
+    # Without attachments the text depends on the HTML alone. An attachment
+    # adds its record's text: for Active Storage blobs "[caption]" (from the
+    # HTML) or, without a caption, "[filename]". So content whose attachments
+    # are all blobs, remote images or inline content is cached too, with the
+    # filenames it used: a hit with caption-less blobs checks them in one
+    # query (renamed or deleted: computed again). Attachments of other
+    # records (an app's own attachables, whose text can be anything) aren't
+    # cached.
+    module ActionTextPlainText
+      MAX_BYTES = 8 * 1024 * 1024
+      ATTACHMENT = /<action-text-attachment|data-trix-attachment/
+
+      @cache = {}   # [html, canonicalize] => text, or [text, { blob id => filename }] with attachments
+      @bytes = 0
+      @mutex = Mutex.new
+
+      class << self
+        def install!
+          ActionText::Content.prepend(Content) unless ActionText::Content < Content
+        end
+
+        def fetch(key)
+          @cache.fetch(key) { store(key, yield.freeze) }
+        end
+
+        # The text, from the cache when the blobs it named are unchanged.
+        def fetch_with_attachments(key, content)
+          if (entry = @cache[key]) && filenames_unchanged?(entry[1])
+            return entry[0]
+          end
+
+          text = yield.freeze
+          filenames = blob_filenames(content)
+          store(key, [text, filenames]) if filenames
+          text
+        end
+
+        def clear! = @mutex.synchronize { @cache = {}; @bytes = 0 }
+
+        private
+
+        def store(key, value)
+          @mutex.synchronize do
+            if @bytes + key[0].bytesize > MAX_BYTES
+              @cache = {}
+              @bytes = 0
+            end
+            @bytes += key[0].bytesize unless @cache.key?(key)
+            @cache[key] = value
+          end
+          value
+        end
+
+        # { blob id => filename } for the caption-less blobs, or nil when an
+        # attachment's text could depend on more than that.
+        def blob_filenames(content)
+          content.attachments.each_with_object({}) do |attachment, filenames|
+            case attachable = attachment.attachable
+            when ActiveStorage::Blob
+              filenames[attachable.id] = attachable[:filename] unless attachment.caption
+            when ActionText::Attachables::RemoteImage, ActionText::Attachables::ContentAttachment
+              # the text comes from the HTML
+            else
+              return nil
+            end
+          end
+        end
+
+        def filenames_unchanged?(filenames)
+          filenames.empty? || ActiveStorage::Blob.where(id: filenames.keys).pluck(:id, :filename).to_h == filenames
+        end
+      end
+
+      module Content
+        def initialize(content = nil, options = {})
+          super
+          return unless content.is_a?(String)
+
+          @plain_text_key = [content.frozen? ? content : content.dup.freeze, options.fetch(:canonicalize, true)]
+          @plain_text_attachments = content.match?(ATTACHMENT)
+        end
+
+        def to_plain_text
+          return super unless @plain_text_key
+          return ActionTextPlainText.fetch(@plain_text_key) { super }.dup unless @plain_text_attachments
+
+          ActionTextPlainText.fetch_with_attachments(@plain_text_key, self) { super }.dup
+        end
+      end
+    end
+  end
+end

data/lib/rails_minify/patches/omniauth_passthrough.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+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.
+    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
+      end
+
+      # Per strategy class: are all of PATH_METHODS OmniAuth's own?
+      def self.standard_paths?(klass)
+        @standard ||= {}.compare_by_identity
+        @standard.fetch(klass) do
+          @standard[klass] = PATH_METHODS.all? { |name| [OmniAuth::Strategy, self].include?(klass.instance_method(name).owner) }
+        end
+      end
+
+      def call(env)
+        return super unless passthrough?(env)
+
+        @app.call(env)
+      end
+
+      private
+
+      def passthrough?(env)
+        return false if OmniAuth.config.test_mode || !env["rack.session"] || respond_to?(:other_phase)
+        return false unless OmniAuthPassthrough.standard_paths?(self.class)
+
+        request_path = options[:request_path]
+        callback_path = options[:callback_path]
+        return false if request_path.respond_to?(:call) || callback_path.respond_to?(:call)
+
+        path_info = env["PATH_INFO"].to_s.downcase
+        full_path = "#{env["SCRIPT_NAME"]}#{path_info}".downcase
+        prefixes = [options[:path_prefix] || OmniAuth.config.path_prefix, request_path, callback_path]
+        prefixes.none? { |prefix| prefix.is_a?(String) && (path_info.start_with?(prefix.downcase) || full_path.start_with?(prefix.downcase)) }
+      end
+    end
+  end
+end

data/lib/rails_minify/patches/request_host.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RailsMinify
+  module Patches
+    # ActionDispatch::Request#host runs a regexp substitution on every call,
+    # allocating a String and a MatchData even when the host has no port
+    # (behind a proxy, the usual case), and Rails reads it several times per
+    # request: url_options, routes constrained by host, cookies, redirects.
+    #
+    # The same change as rails/rails#59104 (Rails 8.2) for earlier versions:
+    # no substitution without a colon, and the host kept for as long as the
+    # raw host is the same String (the env's HTTP_HOST; a test's host= or
+    # X-Forwarded-Host make a new one, so nothing goes stale).
+    module RequestHost
+      PORT = /:\d+$/
+
+      def self.install!
+        return if ActionPack.gem_version >= Gem::Version.new("8.2.0.alpha") # upstream already
+
+        ActionDispatch::Request.prepend(self) unless ActionDispatch::Request < self
+      end
+
+      def host
+        raw = raw_host_with_port
+        return @__rm_host if @__rm_host_raw.equal?(raw)
+
+        @__rm_host_raw = raw
+        @__rm_host = raw.include?(":") ? raw.sub(PORT, "") : raw
+      end
+    end
+  end
+end

data/lib/rails_minify/railtie.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RailsMinify
+  class Railtie < Rails::Railtie
+    config.rails_minify = ActiveSupport::OrderedOptions.new
+
+    # After config/environments/*.rb, before any initializer reads the
+    # minimizers' options.
+    config.before_initialize do |app|
+      next unless app.config.rails_minify.enabled
+
+      ar = app.config.ar_minimizer
+      ar.slim = true if ar.slim.nil?
+      ar.views = true if ar.views.nil?
+      ar.enums = true if ar.enums.nil?
+      ar.small_records = true if ar.small_records.nil?
+      ar.load_time = app.root.join("config/ar_minimizer.json").exist? if ar.load_time.nil?
+      as = app.config.as_minimizer
+      as.unroll_callbacks = true if as.unroll_callbacks.nil?
+      ap = app.config.ap_minimizer
+      ap.route_helpers = true if ap.route_helpers.nil?
+      ap.views = true if ap.views.nil?
+    end
+
+    PATCHES = {
+      action_text_plain_text: ["ActionText::Content", :action_text_content, -> { Patches::ActionTextPlainText.install! }],
+      omniauth: ["OmniAuth::Strategy", nil, -> { Patches::OmniAuthPassthrough.install! }],
+      request_host: ["ActionDispatch::Request", nil, -> { Patches::RequestHost.install! }],
+    }.freeze
+
+    initializer "rails_minify.patches" do |app|
+      options = app.config.rails_minify
+      next unless options.enabled || options.patches
+
+      Array(options.patches || PATCHES.keys).each do |name|
+        constant, hook, install = PATCHES.fetch(name.to_sym)
+        if hook
+          ActiveSupport.on_load(hook) { install.call }
+        else
+          config.after_initialize { install.call if Object.const_defined?(constant) }
+        end
+      end
+    end
+
+    rake_tasks do
+      namespace :minify do
+        prepare = lambda do
+          app = Rails.application
+          app.eager_load!
+          # Routes define methods too (Devise's authenticate_user!); Rails 8 loads them lazily.
+          app.respond_to?(:reload_routes_unless_loaded) ? app.reload_routes_unless_loaded : app.reload_routes!
+          app
+        end
+
+        desc "How much of the app runs compiled, and why the rest doesn't (VERBOSE=1 for every item)"
+        task census: :environment do
+          app = prepare.call
+          verbose = ENV["VERBOSE"] == "1"
+          routed = AsMinimizer::Check.routed_actions(app.routes)
+          sections = {
+            "Active Record (activerecord-minimizer)" => ArMinimizer::Census.report(root: app.root),
+            "Callbacks (activesupport-minimizer)" => AsMinimizer::Census.report(routed: routed),
+            "Routes and views (actionpack-minimizer)" => ApMinimizer::Census.report(app.routes, app.paths["app/views"].existent),
+          }
+          sections.each do |title, result|
+            puts title
+            result.lines(verbose: verbose).each { puts "  #{it}" }
+            puts
+          end
+        end
+
+        desc "Fail on what would break at runtime or compile stale: missing callback targets, 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")
+        end
+      end
+    end
+  end
+end

data/lib/rails_minify/version.rb

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

data/lib/rails_minify.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "rails_minify/version"
+require "as_minimizer"
+require "ar_minimizer"
+require "ap_minimizer"
+
+# One switch for the minimizers:
+#
+#   # config/environments/production.rb
+#   config.rails_minify.enabled = true
+#
+# turns on, unless set otherwise on their own:
+#   config.ar_minimizer.slim, .views, .load_time (load_time only with config/ar_minimizer.json)
+#   config.as_minimizer.unroll_callbacks
+#   config.ap_minimizer.route_helpers, .views
+#
+# and these patches, for parts of Rails and common gems that redo work on
+# every request (config.rails_minify.patches = [...] to choose):
+#   :action_text_plain_text  ActionText::Content#to_plain_text, once per distinct HTML
+#   :omniauth                OmniAuth strategies skip their per-request dup off their paths
+module RailsMinify
+  module Patches
+    autoload :ActionTextPlainText, "rails_minify/patches/action_text_plain_text"
+    autoload :OmniAuthPassthrough, "rails_minify/patches/omniauth_passthrough"
+    autoload :RequestHost, "rails_minify/patches/request_host"
+  end
+end
+
+require "rails_minify/railtie" if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: rails-minify
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sampo Kuokkanen
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord-minimizer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: actionpack-minimizer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport-minimizer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.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).
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/rails-minify.rb
+- lib/rails_minify.rb
+- lib/rails_minify/patches/action_text_plain_text.rb
+- lib/rails_minify/patches/omniauth_passthrough.rb
+- lib/rails_minify/patches/request_host.rb
+- lib/rails_minify/railtie.rb
+- lib/rails_minify/version.rb
+homepage: https://github.com/sampokuokkanen/rails-minify/tree/main/rails-minify
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/sampokuokkanen/rails-minify/tree/main/rails-minify
+  changelog_uri: https://github.com/sampokuokkanen/rails-minify/blob/main/rails-minify/CHANGELOG.md
+  bug_tracker_uri: https://github.com/sampokuokkanen/rails-minify/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: 'Precompile what Rails works out at runtime: attribute methods, callback
+  chains'
+test_files: []