actionpack-minimizer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6097ac817e3819beabfa9fc7952395e2d796429505b56654beb9120140535b0a
+  data.tar.gz: d2c992a82c0691212eb47b262dd016baa46f44cdf1a38b64aaea69c08586fa0b
+SHA512:
+  metadata.gz: 443211ad950bbdc1fadc55098abd58c7359e99aed1854dfa6b0949cf1147f7a70fb0816721679036dd2d0ab3a98b4d621e37c25369c80df86d4116939f7b37d2
+  data.tar.gz: a0ad267400fd14780acbc991eed72ccc1cf70f1aabe4c0ddf75e6f25b9007eba5b2e1415a8d9b04fc605833d8793ed8d6d670b3389f180cb8a1c9752f9992397

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 0.1.0 (2026-10-18)
+
+First release.
+
+- Named route helpers as interpolation over cached URL parts, with Rails' own escaping.
+- Templates: `render` of partials and records, and `link_to` (with literal or computed options, and block form), compiled to direct calls.

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,129 @@
+# actionpack-minimizer
+
+Precompiles named route helpers and the common view helpers. Part of
+[rails-minify](../rails-minify); controller callbacks are in
+activesupport-minimizer.
+
+```ruby
+# config/environments/production.rb
+config.ap_minimizer.route_helpers = true
+config.ap_minimizer.views = true
+```
+
+## Route helpers
+
+Rails builds every URL from scratch. Its "optimized" path still merges
+hashes and runs the Journey formatter; with `default_url_options` set (most
+apps with a locale in their URLs), every helper takes the full `url_for`
+path with recall, defaults and route matching. Here the original helper
+runs once with placeholder arguments, and what surrounds the placeholders is
+reused:
+
+```ruby
+trip_url("Zq9ArmSentinel0Zq9")  # => "https://example.com/ja/trips/Zq9ArmSentinel0Zq9"
+# later calls:
+"https://example.com/ja/trips/#{escape_segment(trip.to_param)}"
+```
+
+The cache key is everything else that goes into the URL: url_options except
+the request's path parameters (host, script name, default_url_options such
+as the locale), whether Rails would optimize, the helper and argument count
+(which decide the segment each argument fills), and the request's path
+parameters only for route parts nothing else provides (usually none; Rails
+fills those from the request). Arguments are escaped with Rails' own
+`escape_segment` (skipped for ids and slugs with nothing to escape).
+
+Options hashes, nil or empty `to_param`, more than four arguments, glob
+routes, constrained segments filled by arguments, and arguments that would
+land in the query string or anchor use the original helper.
+
+## Views
+
+Each template's compiled Ruby is rewritten when ActionView compiles it:
+
+```ruby
+render "comments/comment", comment: c      # -> __ap_render_partial(...)
+render partial: "comments/comment", locals: { comment: c }
+link_to post.title, post_path(post)        # -> __ap_link_to(...)
+link_to "Edit", edit_path, class: "btn"    # -> __ap_link_to_attrs(..., " class=\"btn\"")
+link_to trip_path(trip), class: "card" do  # -> __ap_link_to_block(..., " class=\"card\"", 3) do
+render @comment                            # -> __ap_render_object(@comment)
+```
+
+`render @comment` (and `render @comment, extra: 1`) works out the partial
+path and local name with Rails' own ObjectRenderer once per
+`to_partial_path` and controller prefix (so namespaced controllers still get
+`admin/comments/_comment`), then does what ObjectRenderer does after that.
+Collections (`render @comments`) and components (`render_in`) are told
+apart at runtime and keep Rails' render: the collection renderer is already
+the faster one, instrumenting once per collection.
+
+For `link_to` with html options, Rails' `tag_options` renders each pair on
+its own and concatenates them, so literal pairs (strings, symbols, numbers,
+booleans, nil, arrays and `data:`/`aria:` hashes of those) are rendered once,
+by `tag_options`, when the template compiles, and computed values per call
+(plain Strings and Symbols inline with Rails' escaping, anything else through
+`tag_options` for that one pair); `href` goes after them, as `link_to` puts
+it. Option values are evaluated once, in order. Computed keys, `**splats`,
+`method:`, `remote:` and `href:` keep `link_to`. Block-form `link_to` keeps its block
+(and the rewrites inside it) and renders it with `capture`, as `content_tag`
+does. Name and url are evaluated once each, in order; a url that isn't a
+String goes to `link_to` with the original options.
+
+A template whose rewrite doesn't parse is left as written; the census lists it.
+
+`__ap_render_partial` caches the template per path, local names and lookup
+details, then does what PartialRenderer does after its lookup (the
+`render_partial.action_view` event with the same payload, `template.render`),
+without the renderer object and option hashes. `__ap_link_to` builds the `<a>`
+with link_to's escaping when the URL is a String, and calls `link_to`
+otherwise. Partials named without a directory are looked up under the
+controller's prefixes, which are part of the cache key. Collections, `as:`/`object:`, blocks and views overriding
+`render`/`link_to`/`url_for`/`content_tag` keep the stock path.
+
+## Numbers
+
+Ruby 4.0, Rails 8.1.
+
+Without `default_url_options` (Rails' optimized path), YJIT:
+
+| route helper            | stock   | compiled |
+|-------------------------|--------:|---------:|
+| `root_path`             | 767 ns  | 167 ns   |
+| `post_path(post)`       | 1532 ns | 494 ns   |
+| `post_url(post)`        | 2971 ns | 495 ns   |
+
+With `default_url_options` returning the locale and a `scope "(:locale)"`
+(Rails' full path), YJIT:
+
+| route helper            | stock   | compiled |
+|-------------------------|--------:|---------:|
+| `trip_path(1)`          | 7979 ns | 582 ns   |
+| `trips_path`            | 5547 ns | 167 ns   |
+
+Each helper is a small body calling one shared method. A version with
+specialized branches per helper was 40% faster per call, but with golf-buddy's
+~1,100 helpers it cost 19 MB and made whole pages 3% slower under YJIT
+(more code to compile and keep in cache), so it's gone.
+
+In golf-buddy's controller and integration tests, 34,646 of 34,873 helper
+calls (99.3%) took the compiled path.
+
+A page rendering 50 partials with two `link_to` each (`bench/views.rb`):
+830 → 385 µs per page, 423 → 218 µs with YJIT.
+
+`link_to` with literal html options (`bench/links.rb`, 50 per page): 7.6 → 2.0 µs
+per link, 4.4 → 1.1 µs with YJIT. With a computed class: 7.3 → 2.5 µs,
+4.3 → 1.5 µs. Block form with options: 9.3 → 3.4 µs, 5.4 → 1.8 µs with YJIT.
+
+Single-record `render @comment`: 4.9 → 2.6 µs, 10.3 → 5.0 µs without YJIT.
+
+golf-buddy: 999 of 1,080 `render`/`link_to` call sites compile (233 partial
+renders, 149 record renders, of which collections and components take Rails'
+path at runtime, 375 `link_to`, 242 block-form `link_to`: all of them).
+
+golf-buddy's test suite (4317 runs) gives the same results with both on.
+
+Note: with eager loading, Rails frees each route's AST once routes are
+finalized, so `Route#glob?` raises afterwards; glob status is recorded when
+helpers are defined.

data/lib/actionpack-minimizer.rb

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

data/lib/ap_minimizer/census.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ApMinimizer
+  # What the route helper and view compilers cover in an app, and why the
+  # rest takes Rails' path.
+  module Census
+    Result = Data.define(:routes, :views) do
+      def lines(verbose: false)
+        out = []
+        compiled, skipped = routes.partition { |_, why| why.nil? }
+        out << "route helpers: #{compiled.size}/#{routes.size} #{Routes.enabled? ? "compiled" : "compilable (config.ap_minimizer.route_helpers is off)"}"
+        skipped.group_by(&:last).sort_by { -it[1].size }.each do |why, list|
+          out << "  #{list.size} through Rails: #{why}"
+          list.first(verbose ? list.size : 3).each { |name, _| out << "    #{name}" }
+        end
+        compiled = ["render partial", "render record", "link_to", "link_to with a block"]
+        done = views.select { |k, _| compiled.include?(k) }.sum(&:last)
+        out << "view call sites: #{done}/#{views.values.sum} compiled (#{views["render partial"]} render, #{views["render record"].to_i} render record (collections and components keep Rails' render at runtime), " \
+          "#{views["link_to"]} link_to, #{views["link_to with a block"].to_i} link_to with a block)"
+        views.reject { |k, _| compiled.include?(k) }.sort_by { -it[1] }.each { |k, n| out << "  #{n} #{k}" }
+        out
+      end
+    end
+
+    class << self
+      def report(route_set, view_paths)
+        Result.new(routes(route_set), views(view_paths))
+      end
+
+      # [[helper name, nil or why not compiled], ...]
+      def routes(route_set)
+        route_set.named_routes.names.sort.map do |name|
+          route = route_set.named_routes.get(name)
+          # Positional arguments fill the required segments; constraints there
+          # (id: /\d+/) keep Rails' helper. Constraints on optional segments
+          # filled from url_options, like (:locale), don't.
+          constrained = route.required_parts & route.path.requirements.keys
+          why =
+            if Routes.glob?(route) then "a glob segment (or unknown: AST already freed)"
+            elsif constrained.any? then "constraints on segments arguments fill (#{constrained.join(", ")})"
+            end
+          ["#{name}_path", why]
+        end
+      end
+
+      # Counts over every ERB template under the paths, rewritten or not.
+      def views(view_paths)
+        stats = Hash.new(0)
+        Array(view_paths).flat_map { Dir.glob(File.join(it.to_s, "**", "*.erb")) }.each do |file|
+          ruby = ActionView::Template::Handlers::ERB::Erubi.new(File.read(file)).src
+          Views.rewrite_with_stats(ruby).last.each { |k, n| stats[k] += n }
+        rescue StandardError
+          stats["templates that didn't compile for the census"] += 1
+        end
+        stats["render partial"] += 0
+        stats["link_to"] += 0
+        stats.to_h
+      end
+    end
+  end
+end

data/lib/ap_minimizer/railtie.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ApMinimizer
+  class Railtie < Rails::Railtie
+    config.ap_minimizer = ActiveSupport::OrderedOptions.new
+
+    # In config/environments/production.rb:
+    #
+    #   config.ap_minimizer.route_helpers = true  # post_path(post) as string interpolation
+    #   config.ap_minimizer.views = true          # literal partial renders and tag helpers precompiled
+    #
+    # Before routes are drawn, so every helper gets defined through the hook.
+    initializer "ap_minimizer", before: :set_routes_reloader_hook do |app|
+      options = app.config.ap_minimizer
+      ApMinimizer::Routes.install! if options.route_helpers
+      ActiveSupport.on_load(:action_view) { ApMinimizer::Views.install! } if options.views
+    end
+  end
+end

data/lib/ap_minimizer/routes.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module ApMinimizer
+  # Named route helpers (post_path, post_url, ...) as string interpolation.
+  #
+  # Rails builds every URL from scratch: the "optimized" path merges hashes
+  # and runs the Journey formatter (~1.5 µs); with default_url_options set,
+  # as in most apps with a locale in their URLs, every helper takes the full
+  # url_for path with recall, defaults and route matching (~6-8 µs).
+  #
+  # Here the original helper runs once with placeholder arguments,
+  #
+  #   trip_path("Zq9ArmSentinel0Zq9")  # => "/ja/trips/Zq9ArmSentinel0Zq9"
+  #
+  # and what surrounds the placeholders is reused:
+  #
+  #   "/ja/trips/#{escape_segment(trip.to_param)}"
+  #
+  # That holds for as long as everything else that goes into the URL is the
+  # same, so the result is cached by:
+  #
+  #   - url_options, except the current request's path parameters (_recall):
+  #     host, protocol, script name, default_url_options (the locale), ...
+  #   - whether Rails would take its optimized path here;
+  #   - the helper and the number of arguments, which decide the segment
+  #     each argument fills;
+  #   - the values of the request's path parameters for the route parts that
+  #     neither the arguments nor url_options provide (usually none), since
+  #     Rails fills those from the request.
+  #
+  # The original helper runs instead for an options hash, a nil or empty
+  # to_param, more than four arguments, glob routes, arguments filling a
+  # constrained segment, and when an argument would land in the query string
+  # or anchor, where escaping differs.
+  module Routes
+    SENTINEL = "Zq9ArmSentinel%dZq9"
+    SENTINEL_RE = /Zq9ArmSentinel(\d+)Zq9/
+    MAX_ARGS = 4
+    MAX_ENTRIES = 4096
+
+    # Unreserved characters are never escaped: most ids and slugs skip the encoder.
+    UNRESERVED = /\A[a-zA-Z0-9\-._~]*\z/
+    ESCAPE = ->(value) { UNRESERVED.match?(value) ? value : ActionDispatch::Journey::Router::Utils.escape_segment(value) }
+
+    HELPERS = {} # [helpers module, helper name] => UrlHelper
+    # Journey route => glob?, recorded when helpers are defined: with eager
+    # loading Rails frees each route's AST once routes are finalized, and
+    # Route#glob? reads it.
+    GLOBS = {}.compare_by_identity
+    BASES = {}   # [routes object_id, optimized?, url_options without _recall] => Integer
+    META = {}    # [base, helper name, argument count] => recall keys, or false
+    PARTS = {}   # [base, helper name, argument count, recall values] => frozen literal parts, or false
+    MUTEX = Mutex.new
+
+    class << self
+      def install!
+        @enabled = true
+        @next_base = 0
+        collection = ActionDispatch::Routing::RouteSet::NamedRouteCollection
+        collection.prepend(Collection) unless collection < Collection
+      end
+
+      def enabled? = @enabled == true
+
+      # The url_options part of the cache key, as a small Integer. Computed
+      # once per url_options object (Rails memoizes it per request).
+      def base_for(context, options)
+        key = [context._routes.object_id, context.send(:optimize_routes_generation?), options.except(:_recall)]
+        BASES[key] || MUTEX.synchronize do
+          reset! if BASES.size >= MAX_ENTRIES
+          BASES[key] ||= (@next_base += 1)
+        end
+      end
+
+      # Literal parts around each argument, or false to always use the original helper.
+      def parts_for(context, name, count, base, options)
+        meta_key = [base, name, count]
+        recall_keys = META.fetch(meta_key) { store(META, meta_key, recall_keys_for(context, name, count, options)) }
+        return false unless recall_keys
+
+        recall = options[:_recall] || {}
+        key = [base, name, count, recall_keys.map { recall[it] }]
+        PARTS.fetch(key) { store(PARTS, key, literal_parts(context, name, count)) }
+      end
+
+      # The URL for args, or nil to let the original helper decide (it raises
+      # or builds something else for nil, empty or non-String to_param values).
+      def fill(parts, args)
+        return parts[0].dup if args.empty?
+
+        out = +parts[0]
+        args.each_with_index do |arg, i|
+          value = arg.to_param
+          return nil unless ::String === value && !value.empty?
+
+          out << ESCAPE.(value) << parts[i + 1]
+        end
+        out
+      end
+
+      # True when unknown (the AST is already gone): such routes keep Rails' helper.
+      def glob?(route)
+        GLOBS.fetch(route) { route.path.ast ? route.glob? : true }
+      end
+
+      def define(mod, name, helper)
+        HELPERS[[mod, name]] = helper
+        route = helper.instance_variable_get(:@route)
+        GLOBS[route] = route.path.ast ? route.glob? : true
+        mod.alias_method(:"__ap_original_#{name}", name)
+        mod.send(:private, :"__ap_original_#{name}")
+        mod.module_eval(<<~RUBY, "route helper: #{name}", 1)
+          def #{name}(*args)
+            ::ApMinimizer::Routes.url_for_args(self, :#{name}, args) || __ap_original_#{name}(*args)
+          end
+        RUBY
+        define_parts_lookup(mod)
+      end
+
+      # Shared by every helper: the URL, or nil for the original helper.
+      #
+      # One small body per helper and the work here, rather than a
+      # specialized body per helper: those were 40% faster per call but, with
+      # ~1,100 helpers, cost 19 MB and made whole pages slower under YJIT.
+      def url_for_args(context, name, args)
+        last = args[-1]
+        return if args.size > MAX_ARGS || ::Hash === last || ::ActionController::Parameters === last
+
+        parts = context.__send__(:__ap_route_parts, name, args.size) or return
+        fill(parts, args)
+      end
+
+      private
+
+      def store(table, key, value)
+        MUTEX.synchronize do
+          reset! if table.size >= MAX_ENTRIES
+          table[key] = value
+        end
+      end
+
+      def reset!
+        [BASES, META, PARTS].each(&:clear)
+      end
+
+      # Route parts Rails would fill from the current request: those neither
+      # the arguments nor url_options and the route's defaults provide. false
+      # when the helper can't be compiled for this argument count.
+      def recall_keys_for(context, name, count, options)
+        owner = context.class.instance_method(:"__ap_original_#{name}").owner
+        helper = HELPERS[[owner, name]] or return false
+        route = helper.instance_variable_get(:@route)
+        return false if glob?(route)
+
+        optimized = helper.is_a?(ActionDispatch::Routing::RouteSet::NamedRouteCollection::UrlHelper::OptimizedUrlHelper) &&
+          count == helper.arg_size && context.send(:optimize_routes_generation?)
+        return [].freeze if optimized # Rails' optimized path uses neither recall nor defaults
+
+        sentinels = Array.new(count) { format(SENTINEL, it) }
+        defaults = options.merge(helper.instance_variable_get(:@options))
+        mapped = helper.handle_positional_args(options, {}, sentinels, defaults, route.segment_keys.uniq)
+        filled = mapped.select { |_, v| ::String === v && SENTINEL_RE.match?(v) }.keys
+        return false unless filled.size == count # an argument with no segment to go to
+        return false if filled.any? { route.path.requirements.key?(it) }
+
+        (route.parts - mapped.keys).freeze
+      rescue StandardError
+        false
+      end
+
+      def literal_parts(context, name, count)
+        sentinels = Array.new(count) { format(SENTINEL, it) }
+        url = context.__send__(:"__ap_original_#{name}", *sentinels)
+        return false unless url.scan(SENTINEL_RE).flatten == Array.new(count) { it.to_s }
+
+        # Query strings and anchors escape differently from path segments.
+        cut = url.index(/[?#]/)
+        return false if cut && count.positive? && url.index(SENTINEL_RE, cut)
+
+        url.split(SENTINEL_RE, -1).values_at(*(0..count).map { it * 2 }).map(&:freeze).freeze
+      rescue StandardError
+        false
+      end
+
+      # In each helper context (controller, view, mailer): the parts for each
+      # helper and argument count, for the current url_options object.
+      def define_parts_lookup(mod)
+        return if mod.private_method_defined?(:__ap_route_parts)
+
+        mod.module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          private def __ap_route_parts(name, count)
+            options = url_options
+            memo = @__ap_route_parts
+            unless memo && memo[0].equal?(options)
+              memo = @__ap_route_parts = [options, ::ApMinimizer::Routes.base_for(self, options), {}]
+            end
+            by_count = (memo[2][name] ||= [])
+            parts = by_count[count]
+            parts.nil? ? (by_count[count] = ::ApMinimizer::Routes.parts_for(self, name, count, memo[1], options)) : parts
+          rescue ::FrozenError
+            nil
+          end
+        RUBY
+      end
+    end
+
+    module Collection
+      private
+
+      def define_url_helper(mod, name, helper, url_strategy)
+        super
+        Routes.define(mod, name, helper) if Routes.enabled?
+      end
+    end
+  end
+end

data/lib/ap_minimizer/version.rb

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

data/lib/ap_minimizer/views.rb

@@ -0,0 +1,498 @@
+# frozen_string_literal: true
+
+require "prism"
+require "bigdecimal"
+require "json"
+
+module ApMinimizer
+  # Rewrites each template's compiled Ruby as ActionView compiles it:
+  #
+  #   render "comments/comment", comment: c   ->  __ap_render_partial("comments/comment", { comment: c })
+  #   render partial: "comments/comment", locals: { comment: c }   (same)
+  #   link_to post.title, post_path(post)     ->  __ap_link_to(post.title, post_path(post))
+  #   link_to "Edit", edit_path, class: "btn" ->  the attributes string, built once by Rails'
+  #                                              tag_options when the template compiles
+  #
+  # __ap_render_partial looks the partial up once per path, local names and
+  # lookup details (formats, locale, variants, handlers), then does what
+  # PartialRenderer does after its lookup: the render_partial.action_view
+  # event with the same payload, and template.render. It skips building the
+  # renderer and the options hashes. Partials named without a directory
+  # are looked up under the controller's prefixes, which are part of the cache key.
+  #
+  # __ap_link_to builds `<a href="...">...</a>` directly when the URL is a
+  # String, with link_to's escaping; anything else calls link_to.
+  #
+  # Both call the stock helper instead in a view class that overrides render,
+  # link_to, url_for or content_tag.
+  module Views
+    STOCK_OWNERS = {
+      render: ["ActionView::Helpers::RenderingHelper"],
+      link_to: ["ActionView::Helpers::UrlHelper"],
+      url_for: ["ActionView::Helpers::UrlHelper", "ActionView::RoutingUrlFor"],
+      content_tag: ["ActionView::Helpers::TagHelper"],
+    }.freeze
+
+    NO_PREFIXES = [].freeze
+
+    # Literal html options of block-form link_to sites, for the fallback.
+    LINK_OPTIONS = []
+    LINK_OPTIONS_MUTEX = Mutex.new
+
+    class << self
+      def register_link_options(options)
+        LINK_OPTIONS_MUTEX.synchronize { (LINK_OPTIONS << options.freeze).size - 1 }
+      end
+
+      def install!
+        @enabled = true
+        @stock = {}
+        @templates = {}
+        @objects = {}
+        @mutex = Mutex.new
+        ActionView::Template.prepend(TemplateHook) unless ActionView::Template < TemplateHook
+        ActionView::Base.include(Helpers) unless ActionView::Base < Helpers
+      end
+
+      def disable! = @enabled = false
+
+      def enabled? = @enabled == true
+
+      # True when render/link_to/url_for/content_tag are ActionView's own in this view class.
+      def stock?(klass)
+        @stock.fetch(klass) do
+          @stock[klass] = STOCK_OWNERS.all? { |name, owners| owners.include?(klass.instance_method(name).owner.name) }
+        end
+      end
+
+      # As PartialRenderer#find_template: a name without a directory is
+      # looked up under the controller's prefixes, so they're in the key.
+      def template_for(view, path, locals, keys = locals.keys)
+        lookup = view.lookup_context
+        prefixes = path.include?("/") ? NO_PREFIXES : lookup.prefixes
+        key = [lookup.details_key, path, keys, prefixes]
+        @templates.fetch(key) do
+          template = lookup.find_template(path, prefixes, true, keys, {})
+          @mutex.synchronize { @templates[key.dup.tap { it[3] = prefixes.dup.freeze }] = template }
+        end
+      end
+
+      # For render(record): [partial path, local name, [local name]], worked
+      # out by Rails' ObjectRenderer once per to_partial_path and controller
+      # prefix; false when Rails would raise or look in the controller's
+      # directory (no "/" in the path), so the stock render runs.
+      def object_partial(view, object, partial_path)
+        lookup = view.lookup_context
+        prefixed = view.prefix_partial_path_with_controller_namespace
+        prefix = lookup.prefixes.first
+        key = [prefixed, prefix, partial_path]
+        @objects.fetch(key) do
+          info =
+            begin
+              renderer = ActionView::ObjectRenderer.new(lookup, {})
+              path = renderer.send(:partial_path, object, view)
+              local = renderer.send(:local_variable, path)
+              path.include?("/") ? [path.freeze, local, [local].freeze].freeze : false
+            rescue StandardError
+              false
+            end
+          @mutex.synchronize { @objects[key] = info }
+        end
+      end
+
+      def rewrite(source) = Rewriter.new(source).rewrite
+
+      # What link_to's html options become in the tag, from Rails itself.
+      def static_attributes(options)
+        @tag_builder ||= ActionView::Helpers::TagHelper::TagBuilder.new(ActionView::Base.empty)
+        @tag_builder.tag_options(options.transform_keys(&:to_s)) || ""
+      end
+
+      # [rewritten source, stats] for the census.
+      def rewrite_with_stats(source)
+        rewriter = Rewriter.new(source)
+        [rewriter.rewrite, rewriter.stats]
+      end
+    end
+
+    module TemplateHook
+      private
+
+      def compiled_source
+        source = super
+        Views.enabled? ? Views.rewrite(source) : source
+      end
+    end
+
+    module Helpers
+      private
+
+      def __ap_render_partial(path, locals = {})
+        return render(path, locals) unless Views.enabled? && ::Hash === locals && Views.stock?(self.class)
+
+        template = Views.template_for(self, path, locals)
+        ActiveSupport::Notifications.instrument("render_partial.action_view",
+          identifier: template.identifier, layout: nil, locals: locals) do |payload|
+          content = template.render(self, locals, add_to_stack: true) { |*name| _layout_for(*name) }
+          payload[:cache_hit] = view_renderer.cache_hits[template.virtual_path]
+          content
+        end
+      end
+
+      def __ap_fast_links? = Views.enabled? && Views.stock?(self.class)
+
+      # link_to(name, url, literal options): attrs is Rails' rendering of the
+      # options; link_to appends href after them.
+      def __ap_link_to_attrs(name, url, attrs)
+        href = ERB::Util.unwrapped_html_escape(url)
+        href = href.gsub('"', "&quot;") if href.include?('"')
+        content = name || url
+        content = ERB::Util.unwrapped_html_escape(content) if content.present?
+        "<a#{attrs} href=\"#{href}\">#{content}</a>".html_safe
+      end
+
+      # link_to(url[, literal options]) do ... end. Content as content_tag
+      # makes it: capture(&block).
+      def __ap_link_to_block(url, attrs, options_index, &block)
+        unless Views.enabled? && ::String === url && Views.stock?(self.class)
+          return link_to(url, &block) unless options_index
+
+          return link_to(url, LINK_OPTIONS[options_index].dup, &block)
+        end
+
+        href = ERB::Util.unwrapped_html_escape(url)
+        href = href.gsub('"', "&quot;") if href.include?('"')
+        content = capture(&block)
+        content = ERB::Util.unwrapped_html_escape(content) if content.present?
+        "<a#{attrs} href=\"#{href}\">#{content}</a>".html_safe
+      end
+
+      # render(record) / render(record, locals): what ObjectRenderer does
+      # after working out the partial: the object goes into the locals under
+      # the partial's name, then the same event and template.render.
+      def __ap_render_object(object, locals = nil)
+        unless Views.enabled? && Views.stock?(self.class) && (locals.nil? || ::Hash === locals) &&
+            !(::String === object) && !(::Hash === object) && !object.respond_to?(:render_in) && !object.respond_to?(:to_ary)
+          return locals.nil? ? render(object) : render(object, locals)
+        end
+
+        model = object.respond_to?(:to_model) ? object.to_model : object
+        info = model.respond_to?(:to_partial_path) && Views.object_partial(self, object, model.to_partial_path)
+        return (locals.nil? ? render(object) : render(object, locals)) unless info
+
+        path, local, keys = info
+        if locals
+          keys = locals.keys << local
+        else
+          locals = {}
+        end
+        template = Views.template_for(self, path, locals, keys)
+        locals[local] = object
+        ActiveSupport::Notifications.instrument("render_partial.action_view",
+          identifier: template.identifier, layout: nil, locals: locals) do |payload|
+          content = template.render(self, locals, add_to_stack: true) { |*name| _layout_for(*name) }
+          payload[:cache_hit] = view_renderer.cache_hits[template.virtual_path]
+          content
+        end
+      end
+
+      # One html option with a value known only at runtime, as Rails'
+      # tag_options renders it (it renders each pair on its own). Plain
+      # Strings and Symbols under an ordinary key take the short way.
+      def __ap_attr(key, escaped_key, plain, value)
+        if plain && (::String === value || ::Symbol === value)
+          v = ERB::Util.unwrapped_html_escape(value)
+          v = v.gsub('"', "&quot;") if v.include?('"')
+          " #{escaped_key}=\"#{v}\""
+        else
+          tag_builder.tag_options({ key => value }) || ""
+        end
+      end
+
+      # Block-form link_to with options not all literal: the fallback gets them as a Hash.
+      def __ap_link_to_block_dyn(url, attrs, options, &block)
+        return link_to(url, options, &block) unless Views.enabled? && ::String === url && Views.stock?(self.class)
+
+        href = ERB::Util.unwrapped_html_escape(url)
+        href = href.gsub('"', "&quot;") if href.include?('"')
+        content = capture(&block)
+        content = ERB::Util.unwrapped_html_escape(content) if content.present?
+        "<a#{attrs} href=\"#{href}\">#{content}</a>".html_safe
+      end
+
+      def __ap_link_to(name, url)
+        return link_to(name, url) unless Views.enabled? && ::String === url && Views.stock?(self.class)
+
+        href = ERB::Util.unwrapped_html_escape(url)
+        href = href.gsub('"', "&quot;") if href.include?('"')
+        content = name || url
+        content = ERB::Util.unwrapped_html_escape(content) if content.present?
+        "<a href=\"#{href}\">#{content}</a>".html_safe
+      end
+    end
+
+    class Rewriter
+      # { "render partial" => n, "link_to" => n, "render: <why not>" => n, ... }
+      attr_reader :stats
+
+      NotLiteral = Class.new(StandardError)
+      SPECIAL_LINK_OPTIONS = %w[method remote href].freeze
+
+      def initialize(source)
+        @source = source
+        @edits = []
+        @stats = Hash.new(0)
+        @temps = 0
+      end
+
+      def rewrite
+        result = Prism.parse(@source)
+        return @source unless result.success?
+
+        visit(result.value)
+        return @source if @edits.empty?
+
+        out = @source.b
+        @edits.sort_by { -it[0] }.each { |start, stop, text| out[start...stop] = text.b }
+        out.force_encoding(@source.encoding)
+        return out if Prism.parse(out).success?
+
+        # A bug here must not break the template: keep it as written, and say so in the census.
+        @stats = Hash.new(0).merge("templates left as written (their rewrite didn't parse)" => 1)
+        @source
+      end
+
+      private
+
+      def visit(node)
+        return unless node
+
+        if node.is_a?(Prism::CallNode) && node.receiver.nil? && node.name == :link_to && node.block.is_a?(Prism::BlockNode) &&
+            (head = link_to_block_head(node))
+          @stats["link_to with a block"] += 1
+          @edits << [node.location.start_offset, node.block.location.start_offset, head]
+          visit(node.block) # its body keeps its own rewrites
+          return
+        end
+
+        if node.is_a?(Prism::CallNode) && node.receiver.nil? && %i[render link_to].include?(node.name)
+          if node.block
+            @stats["#{node.name}: with a block#{" (#{@reason})" if @reason && node.name == :link_to}"] += 1
+          elsif (text = replacement(node))
+            @stats[node.name == :render ? "render partial" : "link_to"] += 1 unless @counted
+            @counted = false
+            @edits << [node.location.start_offset, node.location.end_offset, text]
+            return # arguments keep their source; nested calls in them stay as written
+          else
+            @stats["#{node.name}: #{@reason || "other arguments"}"] += 1
+          end
+          @reason = nil
+        end
+        node.compact_child_nodes.each { visit(it) }
+      end
+
+      def replacement(node)
+        args = node.arguments&.arguments || []
+        case node.name
+        when :render then render_replacement(args)
+        when :link_to then link_to_replacement(args)
+        end
+      end
+
+      # render "dir/name" | render "dir/name", locals | render "dir/name", k: v
+      # render partial: "dir/name" [, locals: {...}]
+      def render_replacement(args)
+        if (text = render_object_replacement(args))
+          @stats["render record"] += 1
+          @counted = true
+          return text
+        end
+        @reason = render_reason(args)
+        if args.size.between?(1, 2) && (path = partial_path(args[0]))
+          return "__ap_render_partial(#{path.inspect})" if args.size == 1
+
+          locals = args[1]
+          return if locals.is_a?(Prism::BlockArgumentNode) || locals.is_a?(Prism::SplatNode)
+
+          text = locals.is_a?(Prism::KeywordHashNode) ? "{ #{slice(locals)} }" : "(#{slice(locals)})"
+          return "__ap_render_partial(#{path.inspect}, #{text})"
+        end
+        hash = args[0] if args.size == 1
+        return unless hash.is_a?(Prism::KeywordHashNode) || hash.is_a?(Prism::HashNode)
+
+        pairs = hash.elements.to_h do |el|
+          return nil unless el.is_a?(Prism::AssocNode) && el.key.is_a?(Prism::SymbolNode)
+
+          [el.key.unescaped.to_sym, el.value]
+        end
+        return unless pairs.keys.include?(:partial) && (pairs.keys - %i[partial locals]).empty?
+        return unless (path = partial_path(pairs[:partial]))
+
+        pairs[:locals] ? "__ap_render_partial(#{path.inspect}, (#{slice(pairs[:locals])}))" : "__ap_render_partial(#{path.inspect})"
+      end
+
+      # render @comment, render comment, render(comment, extra: 1): anything
+      # that isn't a partial name or an options hash. Collections and
+      # components are told apart at runtime and keep the stock render.
+      NOT_OBJECTS = [Prism::StringNode, Prism::InterpolatedStringNode, Prism::HashNode, Prism::KeywordHashNode,
+                     Prism::SymbolNode, Prism::NilNode, Prism::SplatNode, Prism::BlockArgumentNode, Prism::ArrayNode].freeze
+
+      def render_object_replacement(args)
+        object, locals = args
+        return unless args.size.between?(1, 2) && NOT_OBJECTS.none? { object.is_a?(it) }
+        return "__ap_render_object((#{slice(object)}))" if args.size == 1
+        return unless locals.is_a?(Prism::KeywordHashNode) || locals.is_a?(Prism::HashNode)
+
+        text = locals.is_a?(Prism::KeywordHashNode) ? "{ #{slice(locals)} }" : slice(locals)
+        "__ap_render_object((#{slice(object)}), #{text})"
+      end
+
+      def render_reason(args)
+        first = args[0]
+        case first
+        when Prism::StringNode
+          return "a partial name with unusual characters"
+        when Prism::KeywordHashNode, Prism::HashNode
+          keys = first.elements.filter_map { it.key.unescaped.to_sym if it.is_a?(Prism::AssocNode) && it.key.is_a?(Prism::SymbolNode) }
+          return "collection:/object:/as:/layout: options" if (keys - %i[partial locals]).any?
+        when Prism::InterpolatedStringNode then return "an interpolated partial name"
+        when nil then return "no arguments"
+        else return "a record, collection or component (render @x)"
+        end
+        "other arguments"
+      end
+
+      def partial_path(node)
+        return unless node.is_a?(Prism::StringNode) && !node.opening_loc&.slice&.start_with?("<<")
+
+        path = node.unescaped
+        path if path.match?(%r{\A[\w/\-.]+\z})
+      end
+
+      def link_to_replacement(args)
+        return link_to_with_options(args) if args.size == 3
+        @reason = args.size == 2 ? "an options hash or splat" : "#{args.size} arguments (name only, or url options)"
+        return unless args.size == 2
+        return if args.any? { it.is_a?(Prism::KeywordHashNode) || it.is_a?(Prism::HashNode) || it.is_a?(Prism::BlockArgumentNode) || it.is_a?(Prism::SplatNode) }
+
+        "__ap_link_to((#{slice(args[0])}), (#{slice(args[1])}))"
+      end
+
+      OPTIONS_REASON = "html options with computed keys, **splats, or method:/remote:/href:"
+
+      # link_to(name, url, class: "btn", data: { ... }). Name, url and option
+      # values are evaluated once, in order; a url that isn't a String at
+      # runtime goes to link_to with the same options.
+      def link_to_with_options(args)
+        name, url, options = args
+        @reason = OPTIONS_REASON
+        return unless options.is_a?(Prism::KeywordHashNode) || options.is_a?(Prism::HashNode)
+        return if [name, url].any? { it.is_a?(Prism::KeywordHashNode) || it.is_a?(Prism::HashNode) || it.is_a?(Prism::SplatNode) || it.is_a?(Prism::BlockArgumentNode) }
+        return unless (pairs = option_pairs(options))
+
+        n = "__apn#{@temps += 1}"
+        u = "__apu#{@temps}"
+        assigns = pairs.filter_map { |pair| "#{pair[:temp]} = (#{slice(pair[:node])}); " if pair[:temp] }.join
+        "(#{n} = (#{slice(name)}); #{u} = (#{slice(url)}); #{assigns}__ap_fast_links? && ::String === #{u} ? " \
+          "__ap_link_to_attrs(#{n}, #{u}, #{attributes_expression(pairs)}) : link_to(#{n}, #{u}, #{rebuilt_options(pairs)}))"
+      end
+
+      # link_to(url[, options]) do ... end: the call up to the block, as a
+      # call to __ap_link_to_block (literal options) or __ap_link_to_block_dyn.
+      def link_to_block_head(node)
+        @reason = nil
+        args = node.arguments&.arguments || []
+        url, options = args
+        @reason =
+          if node.block.parameters then "block parameters"
+          elsif !args.size.between?(1, 2) then "#{args.size} arguments"
+          elsif [Prism::KeywordHashNode, Prism::HashNode, Prism::SplatNode, Prism::BlockArgumentNode].any? { url.is_a?(it) }
+            "a hash or splat as the url"
+          elsif options && !(options.is_a?(Prism::KeywordHashNode) || options.is_a?(Prism::HashNode))
+            OPTIONS_REASON
+          end
+        return if @reason
+        return "__ap_link_to_block((#{slice(url)}), \"\", nil) " unless options
+        return unless (pairs = option_pairs(options))
+
+        if pairs.none? { it[:temp] }
+          hash = pairs.to_h { [it[:key], it[:value]] }
+          return "__ap_link_to_block((#{slice(url)}), #{Views.static_attributes(hash).inspect}, #{Views.register_link_options(hash)}) "
+        end
+
+        assigns = pairs.filter_map { |pair| "#{pair[:temp]} = (#{slice(pair[:node])}); " if pair[:temp] }.join
+        "__ap_link_to_block_dyn((#{slice(url)}), (#{assigns}#{attributes_expression(pairs)}), #{rebuilt_options(pairs)}) "
+      end
+
+      # [{ key:, value: } for literal values, { key:, node:, temp: } for the rest],
+      # or nil (and @reason) for keys link_to treats specially or that aren't literal.
+      def option_pairs(options)
+        options.elements.map do |el|
+          unless el.is_a?(Prism::AssocNode) && (el.key.is_a?(Prism::SymbolNode) || el.key.is_a?(Prism::StringNode))
+            @reason = OPTIONS_REASON
+            return nil
+          end
+          key = literal(el.key)
+          if SPECIAL_LINK_OPTIONS.include?(key.to_s) || key.to_s.empty?
+            @reason = OPTIONS_REASON
+            return nil
+          end
+          begin
+            { key: key, value: literal(el.value), value_node: el.value }
+          rescue NotLiteral
+            { key: key, node: el.value, temp: "__apa#{@temps += 1}" }
+          end
+        end
+      rescue NotLiteral
+        @reason = OPTIONS_REASON
+        nil
+      end
+
+      # Ruby for the attributes string: Rails' rendering of each literal pair,
+      # __ap_attr for each computed one, in the options' order.
+      def attributes_expression(pairs)
+        pieces = pairs.map do |pair|
+          key = pair[:key].to_s
+          if pair[:temp]
+            plain = ActionView::Helpers::TagHelper::TAG_TYPES[key].nil?
+            "__ap_attr(#{key.inspect}, #{ERB::Util.xml_name_escape(key).inspect}, #{plain}, #{pair[:temp]})"
+          else
+            Views.static_attributes({ key => pair[:value] }).inspect
+          end
+        end
+        return pieces.first if pieces.size == 1 && !pairs.first[:temp]
+
+        %("#{pieces.map { "\#{#{it}}" }.join}")
+      end
+
+      # The options as link_to gets them in the fallback: computed values from their temps.
+      def rebuilt_options(pairs)
+        "{ #{pairs.map { |pair| "#{pair[:key].inspect} => #{pair[:temp] || slice(pair[:value_node])}" }.join(", ")} }"
+      end
+
+      def literal(node)
+        case node
+        when Prism::StringNode
+          raise NotLiteral if node.opening_loc&.slice&.start_with?("<<")
+
+          node.unescaped
+        when Prism::SymbolNode then node.unescaped.to_sym
+        when Prism::IntegerNode, Prism::FloatNode then node.value
+        when Prism::TrueNode then true
+        when Prism::FalseNode then false
+        when Prism::NilNode then nil
+        when Prism::ArrayNode then node.elements.map { literal(it) }
+        when Prism::HashNode, Prism::KeywordHashNode
+          node.elements.to_h do |el|
+            raise NotLiteral unless el.is_a?(Prism::AssocNode) && (el.key.is_a?(Prism::SymbolNode) || el.key.is_a?(Prism::StringNode))
+
+            [literal(el.key), literal(el.value)]
+          end
+        else raise NotLiteral
+        end
+      end
+
+      def slice(node) = @source.byteslice(node.location.start_offset, node.location.length)
+    end
+  end
+end

data/lib/ap_minimizer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "action_controller"
+require "ap_minimizer/version"
+
+# Precompiles parts of Action Pack / Action View: named route helpers
+# (ApMinimizer::Routes) and template rendering (ApMinimizer::Views).
+# Controller callbacks are unrolled by activesupport-minimizer.
+module ApMinimizer
+  autoload :Routes, "ap_minimizer/routes"
+  autoload :Views, "ap_minimizer/views"
+  autoload :Census, "ap_minimizer/census"
+end
+
+require "ap_minimizer/railtie" if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: actionpack-minimizer
+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: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.3'
+description: Turns named route helpers into string interpolation over cached URL parts,
+  and compiles render and link_to calls in templates to direct calls without their
+  option-hash machinery.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/actionpack-minimizer.rb
+- lib/ap_minimizer.rb
+- lib/ap_minimizer/census.rb
+- lib/ap_minimizer/railtie.rb
+- lib/ap_minimizer/routes.rb
+- lib/ap_minimizer/version.rb
+- lib/ap_minimizer/views.rb
+homepage: https://github.com/sampokuokkanen/rails-minify/tree/main/actionpack-minimizer
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/sampokuokkanen/rails-minify/tree/main/actionpack-minimizer
+  changelog_uri: https://github.com/sampokuokkanen/rails-minify/blob/main/actionpack-minimizer/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 named route helpers and template rendering
+test_files: []