view_bind 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 45fd0d48621262e28bbfb10957903033b51390f54a54b479ba2ae97dda1c3e3c
+  data.tar.gz: 3fe098f2d09c228f374be992470d0486603aec240bcb3d20f9ca947ddbe9772c
+SHA512:
+  metadata.gz: c95cba0f1a80d9f61c08f5176be215d2a934865e370e21431bbb7da0255bd98e7c4fd50965f435fd0f8c20fbae872ab1b0019a2fe4890f559aa20be6f19d44a2
+  data.tar.gz: 66f447f82d5d74d5e5529b3c20646c7bd716a18691d7c149731d3b2d6595b4e2cc70492cebad47fd9b753a21c9f92f0ae4ed2f6d0006f69d20d396a64a67caf5

data/CHANGELOG.md

@@ -0,0 +1,45 @@
+# Changelog
+
+## Unreleased
+
+- Preserve empty and whitespace-only output in `bind_capture` and `bind_render_memo`.
+- Render non-ERB handlers through `Template#render` so raw and static HTML output is
+  preserved by every helper, including collections.
+- Reuse the caller's buffer for strict-locals ERB, and reuse the implicit-locals list
+  across collection items to avoid per-partial allocations.
+- Skip memoization for zero-valued Floats so `0.0` and `-0.0` keep their distinct output.
+
+## [0.1.0] - 2026-09-10
+
+- `bind_capture` rejects unsupported blocks instead of silently dropping their content.
+- Dummy-app smoke checks clear inherited `LOG_LEVEL` for the unset-variable case.
+- Responsive publication layout for the dummy app, with equivalent output across all routes.
+- Reproducible request benchmarks with randomized rounds, median and range reporting,
+  response validation, accurate query counts, configurable page size and raw JSON output.
+- Concurrent first-render and per-view memo isolation regression coverage.
+- Include the changelog in the built gem.
+- `bind_render`, `bind_render_memo` and `bind_render_each` raise on render's option names
+  (`locals:`, `object:`, `collection:`, `partial:`, `layout:`, …) instead of silently
+  passing them to the partial as locals.
+- `bind_render_each` accepts `as:` as a String and rejects a name that is not a valid Ruby
+  identifier, the way `render collection:` does.
+- The dependency tracker ignores interpolated paths rather than reporting a dependency
+  that resolves to nothing.
+- Releases require MFA (`rubygems_mfa_required`), and CI covers Rails 7.2.
+- `bind_render` and `bind_render_each`: render a partial through its own compiled method.
+- Dependency tracker so `cache` digests still bust when a bound partial changes.
+- Lookup cache keyed by the whole resolver context — `details_key`, view paths and prefixes —
+  so locales, variants, themed or engine view paths and relative partial names all resolve
+  correctly, and `ViewBind.clear_cache` invalidates views that already warmed.
+- `bind_render_memo` keys on HTML safety as well as value, so an `html_safe` local and an
+  equal escaped one never share an entry.
+- Dependency tracking covers every helper form, with or without parentheses.
+- Relative bound paths resolve against the template's directory for digests, so a `cache`
+  block above `bind_render "card"` busts when `card` changes.
+- Prefix strings are snapshotted, not just the array, so editing one in place is noticed.
+- The profiler measures strict-locals collections, and counts a delegated memo call at its
+  own nesting level so its time reaches the header total.
+- `rake coverage`: the suite under SimpleCov, gated at 100% line and branch coverage.
+- CI matrix over Rails 7.1, 7.2 and 8.0, plus the newest release through the default
+  `Gemfile`.
+- Templates re-resolved in development, cached in production.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Igor Kasyanchuk
+
+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,365 @@
+# view_bind
+
+Render a Rails partial by calling the method ActionView already compiled for it, instead of
+walking the whole `render` path on every call.
+
+```erb
+<%# before %>
+<%= render partial: "posts/card", collection: @posts, as: :post %>
+<%= render "shared/button", label: "Read", style: "primary" %>
+
+<%# after %>
+<%= bind_render_each "posts/card", @posts, as: :post %>
+<%= bind_render "shared/button", label: "Read", style: "primary" %>
+```
+
+Partials stay ordinary partials. Nothing is merged into the parent template, no source is
+rewritten, and every file keeps its own identity — so backtraces, `local_assigns`, strict
+locals, development reloading and fragment cache digests all keep working.
+
+## Why it is faster
+
+A normal partial render performs template lookup, creates rendering objects and buffers,
+and emits ActiveSupport notifications. For a page with many small partials, that work adds up.
+
+`bind_render` caches the resolved template by resolver context and locals shape, then calls
+the method Rails compiled for it, writing into the current output buffer.
+`bind_render_each` also resolves once and reuses view bookkeeping across the collection.
+The direct call is used for the stock ERB handler. Strict-locals templates use
+`Template#render` for Rails' argument validation while reusing the caller's buffer.
+Other handlers also use `Template#render`,
+preserving output from handlers that return a string or a new buffer.
+
+### bind_render_memo
+
+Memoization reuses a partial's markup within one view context:
+
+```erb
+<%= bind_render_memo "shared/tag", tag: "ruby" %>
+```
+
+Only String, Symbol, Numeric, true, false and nil values are memoized. Zero-valued Floats
+fall through to rendering because `0.0` and `-0.0` compare as the same hash key but render
+differently. Other objects also fall through. Keys include resolver context, locals names,
+values and HTML safety; mutable strings are snapshotted so later mutation does not corrupt
+stored keys.
+
+Use it only when repeating those inputs should produce the same markup. Instance variables,
+current-user state, time and side effects are not part of the key. Request state can change
+within a render: a shared request alone does not guarantee correctness.
+A hit skips all partial side effects, including `content_for`, `provide` and counters.
+It behaves the same with template caching enabled or disabled.
+
+Memoization can reduce allocations without improving latency. Measure the subtree you want
+to memoize; the lookup itself has a cost.
+
+## Install
+
+```ruby
+gem "view_bind"
+```
+
+Nothing to configure. The railtie adds the helpers to every view, partial, layout and mailer
+view, and registers a dependency tracker so `cache` digests still notice bound partials.
+
+## Usage
+
+Works the same in a view, in a partial, and in a layout:
+
+```erb
+<%# app/views/layouts/application.html.erb %>
+<body>
+  <%= bind_render "shared/header", user: current_user %>
+  <main><%= yield %></main>
+  <%= bind_render "shared/footer" %>
+</body>
+```
+
+```erb
+<%# app/views/posts/index.html.erb %>
+<section class="cards">
+  <%= bind_render_each "posts/card", @posts, as: :post %>
+</section>
+```
+
+`bind_render_each` provides `<as>_counter` and `<as>_iteration` exactly like
+`render collection:`, so existing collection partials keep working:
+
+```erb
+<%# app/views/posts/_card.html.erb %>
+<article class="card <%= "is-first" if post_iteration.first? %>">
+  <h3><%= post_counter + 1 %>. <%= post.title %></h3>
+</article>
+```
+
+Both helpers write into the buffer and return `nil`, so `<%= %>` appends nothing extra. When
+you need the markup **as a value** — `content_for`, a helper argument — use `bind_capture`,
+which returns a safe string, preserving empty and whitespace-only output:
+
+```erb
+<% content_for :sidebar, bind_capture("shared/widget") %>
+```
+
+Passing `bind_render` itself as a value would put the HTML in the page and store an empty
+string, so the block form of `render` is not supported either: passing a block raises
+`ArgumentError` rather than dropping it silently.
+
+## Benchmark
+
+The dummy app renders a responsive publication page with a featured article, a card grid,
+navigation, tags, author information, buttons, community statistics, ranked posts and comments.
+It uses 2,000 posts, 6,000 comments and 10 authors, with **10 SQL queries per request**.
+
+All five routes produce equivalent HTML after normalizing the footer timestamp. The baseline
+already uses Rails' collection renderer. The default is 200 cards, which deliberately exercises
+many nested partials; use `PER=20` for a smaller page.
+
+```sh
+bundle exec rake bench
+PER=20 bundle exec rake bench
+OUTPUT=tmp/benchmark.json bundle exec rake bench
+
+# Use a dedicated database: the dummy app creates/reseeds its tables.
+createdb view_bind_bench
+DB=postgres PGUSER=your_user PGDATABASE=view_bind_bench bundle exec rake bench
+
+# Synthetic notification subscribers, not a named production APM agent:
+APM=1 bundle exec rake bench
+```
+
+The runner defaults to production mode, 15 warmup requests per case and nine rounds of twenty
+requests. Case order is randomized using a reproducible seed. Override `WARMUP`, `R`, `N`,
+`SEED` or `PER` as needed; `PER` accepts 1–500. `OUTPUT` saves metadata and all raw rounds.
+Use `RAILS_ENV=development bundle exec ruby benchmarks/run.rb` for an explicit development run;
+`rake bench` always selects production.
+
+Reported times are **median batch averages**; min–max describes batch variation, not request
+latency percentiles. Each request must return HTTP 200, and output equivalence is checked
+before timing and after every batch. Allocations are averaged per request, not universal constants.
+
+The `observed` column counts template instances reported through Rails notifications, including
+collection payload counts. Bound templates still execute even though they emit fewer events.
+The default timing excludes the benchmark's inspection subscribers.
+
+See [the current measured results](benchmarks/results/README.md) and accompanying raw JSON.
+These are serial in-process measurements, not browser load times or concurrent throughput.
+Database latency, page size, GC and instrumentation affect the result; benchmark your own page.
+No leaf-level microsecond or profiler-overhead claims are inferred from this request benchmark.
+
+### Concurrent throughput, over HTTP
+
+The numbers above are serial and in-process. This is the same page behind Puma, measured with
+ApacheBench, so the socket, the router and the middleware stack are all included:
+
+```sh
+RAILS_ENV=production LOG_LEVEL=info bin/rails s -b 127.0.0.1 -p 3000
+```
+
+```sh
+ab -n 200 -c 2 'http://127.0.0.1:3000/?per=200'
+ab -n 200 -c 2 'http://127.0.0.1:3000/bind_both?per=200'
+```
+
+| | `/` (standard Rails) | `/bind_both` (view\_bind) |
+| --- | ---: | ---: |
+| Requests/sec | 79.12 | **181.20** |
+| Mean request time | 25.28 ms | **11.04 ms** |
+| Median latency | 25 ms | **11 ms** |
+| p95 latency | 30 ms | **12 ms** |
+| Total for 200 requests | 2.528 s | **1.104 s** |
+| Failed requests | 0 | 0 |
+
+**2.29x the throughput (+129%) and 56% lower mean request time**, both routes returning the
+same 228 KB of HTML. Medians of three runs of 200 requests at concurrency 2 after warming, on
+one Puma worker with five threads over loopback, Ruby 3.4.5 +YJIT and SQLite.
+
+`/bind_memo` measures the same as `/bind_both` here (178.66 req/s, 11.20 ms, inside the
+run-to-run spread). Over HTTP the remaining time is dominated by the 10 queries and the request
+cycle, so the memo's extra saving only shows up in the in-process table.
+
+`ab` runs on the same machine as the server and competes with it for cores, and a laptop under
+load will not reproduce these exact figures. Run it against your own page.
+
+## What it does not change
+
+Each of these is a test in the suite, because each is a way this kind of optimisation usually
+goes wrong:
+
+| behaviour | test |
+| --- | --- |
+| Same HTML as `render` | `test_matches_what_render_produces` |
+| Locals, including strict locals | `test_passes_locals`, `test_supports_strict_locals` |
+| `_counter` / `_iteration` in collections | `test_collection_provides_counter_and_iteration` |
+| Per-locale / per-variant partials | `test_respects_locale` |
+| Per-view-path and per-prefix partials | `test_respects_view_paths`, `test_respects_prefixes_for_a_relative_path` |
+| Backtraces naming the real file and line | `test_backtrace_points_at_the_partial` |
+| Fragment cache digests busting on edits | `test_dependency_tracking_busts_fragment_digests` |
+| Works in a layout, and nested | `test_works_in_a_layout_and_nested_partials` |
+| Instance variables in nested partials | `test_instance_variables_reach_nested_partials` |
+| Missing partial still raises `MissingTemplate` | `test_missing_partial_raises_missing_template` |
+| `bind_capture` returns markup, `content_for` works | `test_bind_capture_works_with_content_for` |
+| A block raises instead of being dropped | `test_block_form_raises_instead_of_being_ignored` |
+| The output-buffer limitation stays as documented | `test_a_partial_that_hijacks_the_output_buffer_renders_nothing` |
+| Memo keys on the locals shape, not just values | `test_memo_does_not_collide_on_the_value_alone` |
+| Memo behaves the same with caching on and off | `test_memo_behaves_the_same_with_and_without_template_caching` |
+| Memo respects a variant or locale change | `test_memo_respects_a_variant_change` |
+| Memo never shares an entry between safe and escaped strings | `test_memo_does_not_share_an_entry_between_safe_and_unsafe_strings` |
+| Every helper form is tracked for digests | `test_tracker_finds_every_public_helper_form` |
+| Relative bound paths bust digests too | `test_dependency_tracking_busts_digests_for_a_relative_path` |
+| `clear_cache` invalidates a warmed view | `test_clear_cache_invalidates_a_warmed_view` |
+| A prefix edited in place is noticed | `test_notices_a_prefix_mutated_in_place` |
+| A nil prefix list still renders | `test_tolerates_nil_prefixes` |
+| A memo key cannot be forged by its value | `test_memo_cannot_be_forged_by_a_value_shaped_like_a_safety_marker` |
+| A SafeBuffer memo key gets its own copy | `test_memo_snapshots_a_safe_buffer_used_as_the_whole_key` |
+| A delegated memo call is timed at its own depth | `test_profiler_counts_a_delegated_memo_call_once` |
+| Memoised side effects run once, as documented | `test_memo_runs_side_effects_once` |
+| A strict-locals partial in a collection | `test_collection_supports_strict_locals` |
+| The railtie's per-request profile line | `test_profiling_logs_one_summary_per_request` |
+| The gem loads outside Rails | `test_loads_without_rails` |
+
+`rake coverage` runs the same suite under SimpleCov and fails below 100% line **and**
+branch coverage of `lib/`. The one branch a single process cannot reach — the railtie
+`require`, which is skipped only where `Rails::Railtie` is undefined — is covered by the
+child process in `test_loads_without_rails`, whose result is merged into the suite's.
+
+CI runs the suite against Rails 7.1, 7.2 and 8.0 (`gemfiles/`), and against the newest
+release through the default `Gemfile` (8.1 today, unpinned), because the fast path calls
+ActionView internals that move between versions. The dependency remains `actionview >= 7.1`.
+`ViewBind.fast_path_available?` detects missing methods and selects `Template#render`, but
+method existence cannot guarantee compatible signatures or behavior in future Rails releases.
+Validate framework upgrades against your application's rendering tests before deploying them.
+
+In development, templates are re-resolved on every call (guarded on
+`ActionView::Resolver.caching?`), so editing a partial works without a restart — and Rails'
+debug error page is unchanged. A `NoMethodError` inside a bound partial reports:
+
+```
+Showing .../views/shared/_button.html.erb where line #3 raised:
+undefined method 'nonexistent_method' for an instance of String
+```
+
+with the partial's own source extracted around the failing line, exactly as `render` does.
+That is not a trick this gem plays: the partial is a normal compiled template, so
+`backtrace_locations`, `SourceMapLocation` and ErrorHighlight all resolve it the usual way.
+
+## Seeing where the time goes
+
+Bound partials produce no `render_partial.action_view` events — that is part of what makes them
+cheap — so the per-partial log lines go with them. In their place, one summary per request:
+
+```ruby
+# config/environments/development.rb
+ViewBind.profile = true
+```
+
+```
+ViewBind: 302 calls, 24.10ms in bound partials
+  posts/card_memo                    x20      17.76ms
+  shared/sidebar_bound               x1        3.66ms
+  posts/author_bound                 x20       3.33ms
+  posts/ownership_bound              x20       1.80ms  (19 memo)
+  shared/button                      x61       1.70ms
+```
+
+Sorted by time, top ten, one line per partial rather than one per render. Per-partial times nest
+exactly as Rails' own do — `posts/card_memo` includes everything its children spent — so the
+header totals only the outermost calls rather than summing rows that overlap. The measurement
+starts before the binding lookup, so it covers what a call actually costs, not just the partial. `(19 memo)` counts the
+calls `bind_render_memo` served without rendering — the hit rate, which is the number worth
+checking before deciding whether memoisation earns its place.
+
+The store is cleared when an action starts as well as when it ends, so renders from a mailer or
+a job on the same thread cannot be attributed to the next request.
+
+Off by default. While off the cost is a single boolean test per call; switched on it adds two
+clock reads, about **0.26 µs per call** — fine for development, not something to leave on in
+production.
+
+## Limitations
+
+- No `:layout`, `:spacer_template`, `:cached` or `:object` options. Use `render` where you need
+  them — the two can be mixed freely in the same template.
+- The dependency tracker finds `bind_render "some/partial"` by literal string, in every helper
+  form and with or without parentheses, and resolves a relative name against the template's own
+  directory the way the renderer does. A path built at runtime is invisible to it, so a `cache`
+  block above a dynamically bound partial can go stale. Same caveat as Rails' own tracker with
+  dynamic `render`.
+- Dependency tracking is registered for ERB only. For another engine, add
+  `ViewBind::Tracker.register_for(:haml)` in an initializer. Registration extends whatever
+  tracker is already installed for that handler rather than replacing it.
+- No `render` instrumentation is emitted for bound partials, by design. Your APM will show
+  fewer view events, and Rails' per-partial `Rendered …` log lines disappear for them — 65
+  lines become 2 on the benchmark page. The `Completed … (Views: 16.9ms)` total is unaffected.
+  See **Seeing where the time goes** below for the replacement.
+- An ERB partial on the direct path that reassigns `@output_buffer` without restoring it
+  loses its output. That path writes into the buffer it is given, whereas `render` builds
+  its own buffer and takes whatever the partial returns, so it survives that. `capture`
+  and `with_output_buffer` restore the buffer and are unaffected; only code that assigns
+  the ivar and walks away is.
+  Inside `bind_render_each` such an item takes the rest of the collection with it.
+- The resolved-template cache is not evicted. It is keyed per call site, per resolver context
+  (lookup details, view paths and prefixes), so it is bounded in practice — but passing a varying
+  set of locals keys to the same partial grows it.
+
+## When not to use it
+
+If a page makes a handful of render calls, this changes nothing measurable. Reach for it when a
+partial is called once per row and there are many rows. Before that, check whether you are
+loading ActiveRecord objects you only read from (`pluck` is usually a bigger win) or rendering
+more rows than anyone will look at.
+
+## The dummy app
+
+`benchmarks/app.rb` is a single-file Rails application with a persistent SQLite database by
+default, or PostgreSQL when `DB=postgres`. The templates share presentation copy, inline CSS
+and the same database workload across all rendering modes.
+
+```sh
+bin/rails s
+# Open http://localhost:3000/?per=6 for a short visual preview.
+
+# Production caching, with request and completion logs:
+RAILS_ENV=production LOG_LEVEL=info bin/rails s
+
+# The original launcher is also available on port 9292:
+bundle exec rake dummy
+```
+
+Development writes normal Rails request, rendering and SQL logs to the terminal and enables
+ViewBind profiling summaries. Production disables profiling and discards logs by default; set
+`LOG_LEVEL=info` to write request logs to the terminal. Stop an existing server with Ctrl-C
+before restarting on the same port.
+
+Benchmarking is separate: `benchmarks/run.rb` turns profiling off in every environment, so it
+never times bound renders through `Profiler.measure` while leaving the baseline's `render`
+untouched, and runs stay quiet unless `LOG_LEVEL` is set. `bundle exec rake smoke` checks that
+logging configuration without running a benchmark.
+
+| route | layout | view |
+| --- | --- | --- |
+| `/` | `render` | `render` |
+| `/bind_view` | `render` | `bind_render` |
+| `/bind_layout` | `bind_render` | `render` |
+| `/bind_both` | `bind_render` | `bind_render` |
+| `/bind_memo` | `bind_render` | bound cards with a memoized ownership subtree |
+
+This is a rendering fixture, not a complete publication app: post/tag detail routes and
+account, sharing and saving actions are placeholders.
+
+## Development
+
+```sh
+bin/setup
+bundle exec rake test
+bundle exec rake coverage
+bundle exec rake bench
+bundle exec rake dummy
+BUNDLE_GEMFILE=gemfiles/rails_7.1.gemfile bundle install
+BUNDLE_GEMFILE=gemfiles/rails_7.1.gemfile bundle exec rake test
+BUNDLE_GEMFILE=gemfiles/rails_8.0.gemfile bundle install
+BUNDLE_GEMFILE=gemfiles/rails_8.0.gemfile bundle exec rake test
+```
+
+## License
+
+MIT.

data/lib/view_bind/helper.rb

@@ -0,0 +1,319 @@
+# frozen_string_literal: true
+
+module ViewBind
+  # Helpers available in every view, partial and layout.
+  module Helper
+    # Cap on distinct memo entries per partial, per locals shape, per HTML-safety mask, per
+    # resolver context. The memo dies with the request, so this only bounds a single page
+    # built from an unbounded set of locals values.
+    #
+    # The mask is part of what is counted, so a partial whose locals arrive sometimes
+    # html_safe and sometimes not can hold this many entries per mask it actually sees.
+    # Counting across masks instead would put a sum over the mask table on the hot path of
+    # every call, which costs more than the bound is worth: the masks a call site produces
+    # are bounded by 2**locals.size and the whole memo dies with the request.
+    MEMO_LIMIT_PER_SHAPE = 512
+    # Names `render` treats as options rather than locals. Every keyword these helpers take is
+    # a local, so a `render "card", object: post` mechanically ported to bind_render would
+    # silently become a local named `object` and the partial would render with the wrong data.
+    # None of these options are implemented -- use `render` where you need them -- so passing
+    # one raises instead. A Hash rather than an Array: the check runs per call.
+    RENDER_OPTIONS = %i[partial collection object locals layout spacer_template cached as]
+                     .to_h { |name| [name, true] }.freeze
+    # Rails' own rule for `as`, from ActionView's AbstractRenderer.
+    AS_PATTERN = /\A[a-z_][a-zA-Z_0-9]*\z/
+    # Render a partial by calling its own compiled method, straight into the current buffer.
+    #
+    #   <%= bind_render "shared/header" %>
+    #   <%= bind_render "posts/card", post: post %>
+    #
+    # Writes into the buffer and returns nil, so `<%= %>` appends nothing extra. When you
+    # need the markup as a value -- `content_for(:side, ...)`, a helper argument -- use
+    # #bind_capture, which returns a string.
+    def bind_render(path, **locals, &block)
+      raise ArgumentError, "bind_render does not support a block; use render for the block form" if block
+      reject_render_options!(:bind_render, locals)
+
+      unless ViewBind.profile?
+        render_bound(ViewBind.bound_for_locals(self, path, locals), locals)
+        return nil
+      end
+
+      # The lookup is part of what a call costs, so it is inside the measurement.
+      ViewBind::Profiler.measure(path) do
+        render_bound(ViewBind.bound_for_locals(self, path, locals), locals)
+      end
+      nil
+    end
+
+    # Render a partial and return its HTML instead of writing it to the buffer.
+    #
+    #   <% content_for :sidebar, bind_capture("shared/widget") %>
+    def bind_capture(path, **locals, &block)
+      raise ArgumentError, "bind_capture does not support a block; use render for the block form" if block
+      # Returning the buffer makes Rails preserve even empty or whitespace-only output.
+      capture { bind_render(path, **locals); output_buffer }
+    end
+
+    # Render a partial once per distinct set of locals *values*, reusing the markup for
+    # every repeat within this request.
+    #
+    #   <%= bind_render_memo "shared/tag", tag: tag %>
+    #
+    # For a partial that is a pure function of its locals -- no ivars, no `Time.now`, no
+    # counters, nothing but the values passed in -- this collapses hundreds of renders into
+    # a handful. A page listing 600 tags drawn from eight distinct strings renders eight.
+    #
+    # A hit appends the stored markup without running the partial, so anything the partial
+    # does besides producing markup happens once: `content_for`, `provide`, incrementing an
+    # ivar, registering an asset. Memoise markup, not side effects.
+    #
+    # Only values it can safely compare are memoised (String, Symbol, Numeric, true, false,
+    # nil), except zero-valued Floats whose signs compare equal. Other values fall through
+    # to a normal render, so passing a record cannot serve you a stale card. The memo lives
+    # on the view, but request state can change during a render: helper state and side
+    # effects must still be excluded from a memoised partial.
+    def bind_render_memo(path, **locals, &block)
+      raise ArgumentError, "bind_render_memo does not support a block" if block
+      reject_render_options!(:bind_render_memo, locals)
+      # The key walk is part of what a memo call costs -- that is the number worth comparing
+      # against the render it replaces -- so it happens inside the measurement.
+      return (memo_render(path, locals); nil) unless ViewBind.profile?
+
+      ViewBind::Profiler.measure_memo(path) { memo_render(path, locals) }
+      nil
+    end
+
+    # Collection form. Resolves once, then one render per item reusing a single locals hash,
+    # the same way ActionView's own CollectionRenderer does.
+    #
+    #   <%= bind_render_each "posts/card", @posts, as: :post %>
+    #
+    # Provides `<as>_counter` and `<as>_iteration` exactly like `render collection:`.
+    def bind_render_each(path, collection, as:, **shared, &block)
+      raise ArgumentError, "bind_render_each does not support a block" if block
+      reject_render_options!(:bind_render_each, shared)
+      as = normalize_as(as)
+
+      # PartialIteration ships with the collection renderer, which an app with eager_load
+      # disabled has not necessarily loaded yet. Required here rather than at gem load time,
+      # so that requiring view_bind before Rails cannot blow up.
+      require "action_view/renderer/collection_renderer" unless defined?(ActionView::PartialIteration)
+
+      collection = collection.to_a
+      locals     = shared.dup
+      counter    = :"#{as}_counter"
+      iteration  = :"#{as}_iteration"
+      bound      = ViewBind.bound_for(self, path, locals.keys + [as, counter, iteration])
+      buffer     = output_buffer
+
+      partial_iteration = ActionView::PartialIteration.new(collection.size)
+      locals[iteration] = partial_iteration
+
+      if bound.slow
+        render_buffer = buffer if bound.writes_to_buffer
+        implicit_locals = [counter, iteration]
+        measuring_collection(path, collection.size) do
+          collection.each do |item|
+            locals[as]      = item
+            locals[counter] = partial_iteration.index
+            rendered = bound.template.render(self, locals, render_buffer, implicit_locals: implicit_locals)
+            buffer << rendered unless render_buffer
+            partial_iteration.iterate!
+          end
+        end
+        return nil
+      end
+
+      # Every item renders the same template, so the view bookkeeping is saved and restored
+      # once for the whole collection instead of once per item.
+      previous_buffer   = @output_buffer
+      previous_path     = @virtual_path
+      previous_template = @current_template
+      @current_template = bound.template
+      @output_buffer    = buffer
+      render_method     = bound.unbound_method
+
+      begin
+        measuring_collection(path, collection.size) do
+          collection.each do |item|
+            locals[as]      = item
+            locals[counter] = partial_iteration.index
+            render_method.bind_call(self, locals, buffer)
+            partial_iteration.iterate!
+          end
+        end
+      rescue StandardError => e
+        bound.template.send(:handle_render_error, self, e)
+      ensure
+        @output_buffer    = previous_buffer
+        @virtual_path     = previous_path
+        @current_template = previous_template
+      end
+      nil
+    end
+
+    private
+
+    # `as` may be given as a String, the way `render collection:` accepts it, and has to name a
+    # local the compiled template can actually declare.
+    def normalize_as(as)
+      name = as.to_sym
+      unless AS_PATTERN.match?(name.name)
+        raise ArgumentError, "The value (#{as}) of the option `as` is not a valid Ruby " \
+                             "identifier; make sure it starts with lowercase letter, and is " \
+                             "followed by any combination of letters, numbers and underscores."
+      end
+      if RENDER_OPTIONS[name]
+        raise ArgumentError, "`as: #{name.inspect}` collides with a render option name; " \
+                             "pick another name for the item local."
+      end
+      name
+    end
+
+    # Raises when a caller passes one of render's option names as a local. Iterating the locals
+    # rather than the option list keeps this at one hash lookup for the usual one-local call.
+    def reject_render_options!(helper, locals)
+      locals.each_key do |key|
+        next unless RENDER_OPTIONS[key]
+
+        raise ArgumentError, "#{helper} takes locals, not render's options, and would have " \
+                             "passed #{key.inspect} to the partial as a local. " \
+                             "Use render if you need the #{key.inspect} option."
+      end
+    end
+
+    # Runs the block, timed as one row of `size` renders when profiling is on. Both collection
+    # loop bodies go through here: a strict-locals collection is still a supported render, so
+    # leaving it out made the summary silently disagree with the page.
+    def measuring_collection(path, size)
+      return yield unless ViewBind.profile?
+
+      ViewBind::Profiler.measure(path, count: size) { yield }
+    end
+
+    # Walks the memo, appends the markup and reports whether the call was a hit. A partial
+    # whose locals cannot be keyed on renders here too rather than being handed back to
+    # bind_render, so that the one measurement wrapping this call is the one that records it.
+    def memo_render(path, locals)
+      values = locals.values
+      # No block, no intermediate array: the type test is on the hot path of every call.
+      #
+      # `safety` records which values are html_safe. A SafeBuffer and an equal plain String
+      # are eql? and hash alike, but ERB escapes only the plain one, so they must not share a
+      # memo entry: whichever rendered first would decide the escaping for both, and markup
+      # meant to be escaped would be emitted raw. Keying on a separate mask rather than on a
+      # marker inside the value allocates nothing per call, and cannot be forged by a local
+      # that happens to start with the marker. A SafeBuffer whose html_safe? is false escapes
+      # exactly like a String, so it shares.
+      safety = 0
+      i = 0
+      while i < values.size
+        case (value = values[i])
+        when String
+          safety |= (1 << i) if value.html_safe?
+          i += 1
+        when Float
+          # Hash treats 0.0 and -0.0 as the same key, but they render different text.
+          if value.zero?
+            render_bound(ViewBind.bound_for_locals(self, path, locals), locals)
+            return false
+          end
+          i += 1
+        when Symbol, Numeric, true, false, nil then i += 1
+        else
+          # Going back through bind_render would time this render one level deeper than it
+          # really is, and its own measurement would then be discarded as nested: the row
+          # showed the elapsed time but the header total counted none of it.
+          render_bound(ViewBind.bound_for_locals(self, path, locals), locals)
+          return false
+        end
+      end
+
+      # Keyed by resolver context, then path, then the locals names, then which of them are
+      # html_safe, then their values.
+      #
+      # The context covers formats, locale, variants, view paths and prefixes: without it, a
+      # partial memoised before `lookup_context.variants = [:phone]`, inside
+      # `I18n.with_locale`, or under a different view path keeps serving the markup it was
+      # first rendered with. The names matter too -- `primary: "New"` and `secondary: "New"`
+      # are different renderings of one partial. A view that leaves a context and comes back
+      # to it gets a fresh context object and so an empty memo, which re-renders rather than
+      # serving anything stale.
+      memo      = (@__view_bind_memo ||= {}.compare_by_identity)
+      by_path   = (memo[ViewBind.context_for(self)] ||= {})
+      by_shape  = (by_path[path] ||= {})
+      by_safety = (by_shape[locals.keys] ||= {})
+      by_value  = (by_safety[safety] ||= {})
+      # One local is overwhelmingly the common case, and a bare value keys far cheaper than
+      # an array: no allocation, no array hashing.
+      key = values.size == 1 ? values[0] : values
+      hit = by_value.key?(key)
+
+      output_buffer << memo_fetch(by_value, key, hit, path, locals)
+      hit
+    end
+
+    # Returns the memoised markup, rendering and storing it on a miss. Rendering goes through
+    # the resolved binding rather than bind_render, so the profiler counts the call once.
+    def memo_fetch(by_value, key, hit, path, locals)
+      return by_value[key] if hit
+
+      bound = ViewBind.bound_for_locals(self, path, locals)
+      # Return the buffer so capture preserves blank output as a safe string, including
+      # spaces that separate surrounding text. Empty output is a cacheable result too.
+      rendered = capture { render_bound(bound, locals); output_buffer }
+      by_value[memo_key_snapshot(key)] = rendered if by_value.size < MEMO_LIMIT_PER_SHAPE
+      rendered
+    end
+
+    # Hash copies and freezes a key of its own accord only when that key's class is exactly
+    # String -- not a SafeBuffer, and not a String held inside an Array key. Anything the
+    # caller could still mutate therefore gets its own frozen copy here, or a later `<<` on
+    # the value that was passed would move the stored entry out of its own bucket. Only the
+    # miss path pays for this; a lookup goes on using the caller's value, which hashes the
+    # same. Copying a bare String too costs nothing, since it is the copy Hash would make.
+    def memo_key_snapshot(key)
+      case key
+      when Array  then key.map { |value| memo_key_snapshot(value) }
+      when String then key.frozen? ? key : key.dup.freeze
+      else key
+      end
+    end
+
+    # Template#render owns strict-locals validation. ERB can still reuse our buffer; other
+    # handlers return their output, which we append with normal Rails escaping.
+    def render_bound(bound, locals)
+      if bound.slow
+        if bound.writes_to_buffer
+          bound.template.render(self, locals, output_buffer)
+        else
+          output_buffer << bound.template.render(self, locals)
+        end
+      else
+        bind_run(bound, locals, output_buffer)
+      end
+    end
+
+    # Mirrors ActionView::Base#_run. This lives in the helper, which is included in the view
+    # class, so it can save and restore the view's own ivars directly -- going through
+    # instance_variable_get/set costs more than the render it is wrapping.
+    def bind_run(bound, locals, buffer)
+      previous_buffer   = @output_buffer
+      previous_path     = @virtual_path
+      previous_template = @current_template
+
+      @current_template = bound.template
+      @output_buffer    = buffer
+      bound.unbound_method.bind_call(self, locals, buffer)
+      nil
+    rescue StandardError => e
+      # Same wrapping Template#render does, so the error page still names the partial.
+      bound.template.send(:handle_render_error, self, e)
+    ensure
+      @output_buffer    = previous_buffer
+      @virtual_path     = previous_path
+      @current_template = previous_template
+    end
+  end
+end

data/lib/view_bind/profiler.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module ViewBind
+  # Bound partials emit no render_partial.action_view events -- that is part of what makes
+  # them cheap -- so Rails' per-partial "Rendered ..." log lines disappear for them. This is
+  # the replacement: one line per request instead of one per render.
+  #
+  #   # config/environments/development.rb
+  #   ViewBind.profile = true
+  #
+  #   ViewBind: 2662 calls, 4.12ms
+  #     posts/card_bound   x200   1.83ms
+  #     shared/tag         x600   0.91ms
+  #
+  # Off by default, and when off the only cost is one boolean test per call.
+  module Profiler
+    KEY = :view_bind_profile
+    DEPTH = :view_bind_profile_depth
+
+    class << self
+      # Times a bound render. Nesting is tracked so the header can total only the outermost
+      # calls: a parent's duration already contains its children's, and adding every row
+      # would count the children twice.
+      def measure(path, count: 1, memo_hits: 0)
+        depth = Thread.current[DEPTH] || 0
+        Thread.current[DEPTH] = depth + 1
+        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        yield
+      ensure
+        Thread.current[DEPTH] = depth
+        record(path, Process.clock_gettime(Process::CLOCK_MONOTONIC) - started,
+               count: count, memo_hits: memo_hits, top_level: depth.zero?)
+      end
+
+      # Same as #measure, for bind_render_memo: whether the call was a hit is only known once
+      # the block has run, so the block reports it by returning true (hit) or false (miss).
+      def measure_memo(path)
+        depth = Thread.current[DEPTH] || 0
+        Thread.current[DEPTH] = depth + 1
+        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        hit = yield
+      ensure
+        Thread.current[DEPTH] = depth
+        record(path, Process.clock_gettime(Process::CLOCK_MONOTONIC) - started,
+               memo_hits: hit ? 1 : 0, top_level: depth.zero?)
+      end
+
+      # count: how many renders this call represents (a collection counts as its size).
+      # memo_hits: how many of them were served from bind_render_memo without rendering.
+      # top_level: whether this call was not nested inside another bound render.
+      def record(path, elapsed, count: 1, memo_hits: 0, top_level: true)
+        row = store[path]
+        row[0] += count
+        row[1] += elapsed
+        row[2] += memo_hits
+        row[3] += elapsed if top_level
+      end
+
+      def store
+        Thread.current[KEY] ||= Hash.new { |hash, key| hash[key] = [0, 0.0, 0, 0.0] }
+      end
+
+      # Called at the start and the end of an action. Renders outside a controller action --
+      # a mailer, a job, ActionCable -- would otherwise be counted against whichever request
+      # next runs on this thread.
+      def reset
+        Thread.current[KEY] = nil
+        Thread.current[DEPTH] = nil
+      end
+
+      # A pure read: returns nil when nothing was recorded, so the caller logs nothing and
+      # can ask twice without the second answer being empty.
+      def summary(limit: 10)
+        rows = Thread.current[KEY]
+        return nil if rows.nil? || rows.empty?
+
+        calls = rows.sum { |_, row| row[0] }
+        # Only outermost calls, so a parent and its children are not both counted.
+        total = rows.sum { |_, row| row[3] }
+        lines = ["ViewBind: #{calls} calls, #{format('%.2f', total * 1000)}ms in bound partials"]
+        rows.sort_by { |_, row| -row[1] }.first(limit).each do |path, (count, seconds, hits, _)|
+          suffix = hits.positive? ? "  (#{hits} memo)" : ""
+          lines << format("  %-34s x%-6d %6.2fms%s", path, count, seconds * 1000, suffix)
+        end
+        omitted = rows.size - limit
+        lines << "  … and #{omitted} more #{'partial'.pluralize(omitted)}" if omitted.positive?
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/view_bind/railtie.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module ViewBind
+  class Railtie < ::Rails::Railtie
+    initializer "view_bind.helper" do |app|
+      ActiveSupport.on_load(:action_view) do
+        include ViewBind::Helper
+
+        require "action_view/dependency_tracker"
+        ViewBind::Tracker.register_for(:erb)
+      end
+
+      # One summary per request, in place of the per-partial lines bound partials no longer
+      # produce. Subscribed once; does nothing while profiling is off.
+      ActiveSupport::Notifications.subscribe("start_processing.action_controller") do
+        ViewBind::Profiler.reset if ViewBind.profile?
+      end
+
+      ActiveSupport::Notifications.subscribe("process_action.action_controller") do
+        next unless ViewBind.profile?
+
+        summary = ViewBind::Profiler.summary
+        Rails.logger.info(summary) if summary
+        ViewBind::Profiler.reset
+      end
+
+      # A code reload rebuilds view classes and template caches; ours has to go with them.
+      # Without this an app that enables cache_template_loading in development would keep
+      # rendering the version of a partial it first resolved.
+      app.reloader.to_prepare { ViewBind.clear_cache }
+    end
+  end
+end

data/lib/view_bind/tracker.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module ViewBind
+  # Teaches ActionView::Digestor about bind_render, so a fragment cache key still changes
+  # when a bound partial changes. Without this, editing a partial that is only reached
+  # through bind_render leaves every parent's `cache` key untouched and serves stale HTML.
+  #
+  # Only handlers this is registered for are tracked. ERB is registered automatically; for
+  # another template engine, call ViewBind::Tracker.register_for(:haml) in an initializer.
+  class Tracker
+    # Every public helper form: bind_render, bind_capture, bind_render_each,
+    # bind_render_memo, with or without parentheses. Missing one leaves a parent's fragment
+    # digest unchanged when the partial it names is edited.
+    #
+    # The path may only start a new line once a parenthesis has been opened. Allowing a bare
+    # line break would make a plain string literal on the line after an argument-less call
+    # look like that call's path.
+    # `#` cannot appear in a virtual path, so excluding it drops interpolated names such as
+    # "posts/#{kind}_card" rather than reporting a dependency that resolves to nothing. Rails'
+    # own tracker turns those into a "posts/*_card" wildcard; matching that is a larger job
+    # than this regex, and reporting nothing is the same answer it gives for a dynamic path.
+    DIRECTIVE = /\bbind_(?:render|capture)(?:_each|_memo)?(?:[ \t]*\(\s*|[ \t]+)["']([^"'#]+)["']/
+
+    # handler => the tracker that was registered before us, so we extend rather than replace
+    @wrapped = {}
+
+    class << self
+      attr_reader :wrapped
+
+      def supports_view_paths? = true
+
+      # Registers for `extension`, keeping whatever tracker was already registered for that
+      # handler so its dependencies are still reported. Another gem's custom ERB tracker
+      # must not disappear just because this gem loaded after it.
+      def register_for(extension)
+        require "action_view/dependency_tracker"
+        handler = ActionView::Template.handler_for_extension(extension)
+        @wrapped[handler] ||= existing_tracker_for(handler)
+        ActionView::DependencyTracker.register_tracker(extension, self)
+      end
+
+      def call(name, template, view_paths = nil)
+        inherited = wrapped[template.handler]
+        base = inherited || default_tracker
+        base.call(name, template, view_paths) | bound_dependencies(name, template)
+      end
+
+      # Rails' default for ERB. Named `:ruby` (AST) from Rails 8.1; 7.1 and 8.0 only ship the
+      # regex tracker, and ActionView.render_tracker does not exist there at all.
+      def default_tracker
+        # Reachable before the railtie's on_load hook has fired -- an app with eager_load
+        # off has not necessarily touched ActionView::DependencyTracker yet.
+        require "action_view/dependency_tracker"
+
+        if ActionView.respond_to?(:render_tracker) && ActionView.render_tracker == :ruby
+          ActionView::DependencyTracker::RubyTracker
+        else
+          ActionView::DependencyTracker::ERBTracker
+        end
+      end
+
+      private
+
+      # The paths this template binds, resolved the way the renderer resolves them: a name
+      # with no slash is relative to the template's own directory, so `bind_render "card"`
+      # inside `audit/bound` depends on `audit/card`. Reported verbatim it names a partial
+      # the digestor cannot find, and the parent's fragment then survives an edit to the
+      # child. Rails' ERB and Ruby trackers normalise identically.
+      def bound_dependencies(name, template)
+        directory = name.split("/")[0..-2].join("/")
+        template.source.scan(DIRECTIVE).flatten.map do |path|
+          path.include?("/") ? path : "#{directory}/#{path}"
+        end
+      end
+
+      # DependencyTracker exposes no reader for a handler's tracker, so this reaches for the
+      # registry directly and falls back to the framework default if that ever changes.
+      def existing_tracker_for(handler)
+        registry = ActionView::DependencyTracker.instance_variable_get(:@trackers)
+        found = registry.respond_to?(:[]) ? registry[handler] : nil
+        found unless found == self
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/view_bind/version.rb

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

data/lib/view_bind.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+require_relative "view_bind/version"
+require_relative "view_bind/helper"
+require_relative "view_bind/tracker"
+require_relative "view_bind/profiler"
+require_relative "view_bind/railtie" if defined?(Rails::Railtie)
+
+# ViewBind renders a partial by calling the method Rails already compiled for it,
+# instead of walking the full `render` path on every call.
+#
+# What is skipped per call: the options hash, a fresh PartialRenderer, extract_details,
+# the template lookup, the ActiveSupport notification, a per-partial OutputBuffer and the
+# string copy out of it. What is NOT skipped: the partial is still an ordinary compiled
+# template, so backtraces name the real file and line, `local_assigns` works, strict locals
+# work, development reloading works and fragment cache digests still bust.
+#
+# Nothing here requires ActionView at load time: the gem may be required before Rails.
+module ViewBind
+  # A resolved partial. `slow` means render it through ActionView::Template#render rather
+  # than by calling its compiled method: strict-locals partials (Template#render owns the
+  # argument checking and its error message), non-ERB handlers (which may return output
+  # instead of writing to the supplied buffer), and Rails whose internals we cannot reach.
+  # `writes_to_buffer` lets ERB keep sharing the caller's buffer on the slow path too.
+  Bound = Struct.new(:template, :method_name, :slow, :unbound_method, :writes_to_buffer)
+
+  # resolver context => virtual path => [[locals keys, Bound], ...]
+  #
+  # The context is everything `find_template` consults besides the path -- the details key
+  # (formats, locale, variants), the view paths and the prefixes -- plus the cache
+  # generation. Keying on the details key alone is not enough: two lookup contexts that differ
+  # only in view paths (a themed or tenant path, an engine, an override) or in prefixes (a
+  # relative partial name rendered from two controllers) share a details key and would
+  # otherwise share a template.
+  #
+  # The compiled method container is deliberately not part of it. A Bound holds the name of a
+  # method compiled into one container, and Rails maintains exactly one per details key:
+  # ActionView caches `DetailsKey.view_context_class`, and `DetailsKey.clear` drops that
+  # class, the resolver caches and every details key together (lookup_context.rb). A new
+  # container therefore always arrives with new details keys and new Templates. Stock `render`
+  # relies on the same invariant -- a Template compiles once, and a second container built by
+  # hand raises NoMethodError there too.
+  #
+  # A hit still allocates nothing: the composite key is built once per view per context and
+  # memoised on the view by #context_for, and the array scan below runs against the inner map.
+  CACHE = Concurrent::Map.new
+
+  # Bumped by .clear_cache so that a view which already memoised a bindings map stops using
+  # it. Clearing CACHE alone leaves such a view rendering the templates it resolved before.
+  @generation = 0
+
+  class << self
+    # Log one summary line per request instead of Rails' one line per partial, which bound
+    # partials no longer produce. Off by default; see ViewBind::Profiler.
+    attr_writer :profile
+
+    def profile? = @profile == true
+
+    def bound_for(view, path, keys)
+      # In development ActionView::Resolver.caching? is false: resolve every time so that
+      # edits to a partial are picked up without a restart.
+      return build(view, path, keys) unless ActionView::Resolver.caching?
+
+      by_path = bindings_for(view)
+      entries = by_path[path]
+      entries&.each { |keys_for_entry, bound| return bound if keys_for_entry == keys }
+
+      build(view, path, keys).tap do |bound|
+        # compute is atomic: two threads first-rendering the same partial with different
+        # locals cannot lose each other's entry.
+        by_path.compute(path) { |existing| (existing || []) + [[keys, bound]] }
+      end
+    end
+
+    # Same lookup, taking the locals hash instead of its keys: a hit compares against the
+    # cached key array in place, so the common path allocates nothing at all. `keys` is only
+    # materialised when the partial has to be resolved.
+    def bound_for_locals(view, path, locals)
+      return build(view, path, locals.keys) unless ActionView::Resolver.caching?
+
+      entries = bindings_for(view)[path]
+      entries&.each do |keys, bound|
+        return bound if keys.size == locals.size && keys.all? { |key| locals.key?(key) }
+      end
+
+      bound_for(view, path, locals.keys)
+    end
+
+    # This view's resolver context, memoised on the view itself: a request renders hundreds of
+    # partials through the same one, and re-deriving it per call costs more than the array
+    # scan it guards. Re-checked rather than assumed on every call, because a single view can
+    # switch formats, variants, view paths or prefixes part-way through a render.
+    #
+    # The last slot holds the bindings map, so #bindings_for is a memoised read too. Building
+    # the context does not touch CACHE, which lets the per-request memo in Helper key on it
+    # without populating a cache that development deliberately does not use.
+    def context_for(view)
+      lookup = view.lookup_context
+      cached = view.instance_variable_get(:@__view_bind_context)
+      if cached &&
+         cached[0].equal?(lookup.details_key) &&
+         cached[1].equal?(lookup.view_paths) &&
+         cached[2] == lookup.prefixes &&
+         cached[3] == @generation
+        return cached
+      end
+
+      # prefixes is a plain Array the caller owns; a copy is what makes the check above catch
+      # an in-place edit, and keeps the CACHE key from rotting under one.
+      context = [lookup.details_key, lookup.view_paths,
+                 snapshot_prefixes(lookup.prefixes), @generation, nil]
+      view.instance_variable_set(:@__view_bind_context, context)
+      context
+    end
+
+    # The map of bindings resolved under this view's resolver context.
+    def bindings_for(view)
+      context = context_for(view)
+      context[4] ||= CACHE.fetch_or_store(context[0, 4]) { Concurrent::Map.new }
+    end
+
+    # Drops every resolved template. The railtie hooks this to ActiveSupport::Reloader, so
+    # a code reload cannot leave a stale template behind even in an app that turns
+    # `cache_template_loading` on in development.
+    def clear_cache
+      # Views alive across the clear hold a memoised context pointing at a map that is about
+      # to be emptied; the generation is what makes them rebuild instead of reusing it.
+      @generation += 1
+      CACHE.clear
+    end
+
+    # The fast path calls three of ActionView::Template's :nodoc: methods. If a future Rails
+    # renames one, every partial quietly goes back through Template#render instead of
+    # raising NoMethodError on the first request after the upgrade.
+    def fast_path_available?
+      return @fast_path_available unless @fast_path_available.nil?
+
+      @fast_path_available = %i[compile! method_name handle_render_error].all? do |method|
+        ActionView::Template.private_method_defined?(method) ||
+          ActionView::Template.method_defined?(method)
+      end
+    end
+
+    private
+
+    # Copies the array *and* its strings. A shallow dup shares the elements, so a caller that
+    # mutates a prefix in place -- `prefix.replace("beta")` rather than assigning a new array
+    # -- would change this snapshot along with the live one, the check in #context_for would
+    # see no difference, and the view would go on rendering the partial it first resolved.
+    # The CACHE key holds these strings too, so they have to stop moving.
+    #
+    # nil passes straight through: `prefixes` is a public accessor and Rails resolves a name
+    # against a nil prefix list perfectly well (see LookupContext#normalize_name), so this
+    # must not be where that stops working.
+    def snapshot_prefixes(prefixes)
+      prefixes&.map { |prefix| prefix.frozen? ? prefix : prefix.dup.freeze }
+    end
+
+    def build(view, path, keys)
+      template = resolve(view, path, keys)
+      # Only the stock ERB handler is known to append to the caller's buffer. Other
+      # handlers, including raw and static HTML, can return a string or a new buffer.
+      writes_to_buffer = template.handler.instance_of?(ActionView::Template::Handlers::ERB)
+      if template.strict_locals? || !writes_to_buffer || !fast_path_available?
+        return Bound.new(template, nil, true, nil, writes_to_buffer)
+      end
+
+      template.send(:compile!, view)
+      method_name = template.send(:method_name)
+      # bind_call on the UnboundMethod dispatches faster than public_send, and the method
+      # lives on the container, so it can be looked up once here rather than per call.
+      Bound.new(template, method_name, false,
+                view.compiled_method_container.instance_method(method_name), true)
+    end
+
+    def resolve(view, path, keys)
+      prefix, _, name = path.rpartition("/")
+      prefixes = prefix.empty? ? view.lookup_context.prefixes : [prefix]
+      # find_template raises ActionView::MissingTemplate itself; there is no nil to guard.
+      view.lookup_context.find_template(name, prefixes, true, keys, {})
+    end
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: view_bind
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Igor Kasyanchuk
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: 'bind_render and bind_render_each resolve a partial once and then call
+  the method ActionView already compiled for it. Partials stay ordinary partials:
+  backtraces, locals, strict locals, development reloading and fragment cache digests
+  all keep working.'
+email:
+- igorkasyanchuk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/view_bind.rb
+- lib/view_bind/helper.rb
+- lib/view_bind/profiler.rb
+- lib/view_bind/railtie.rb
+- lib/view_bind/tracker.rb
+- lib/view_bind/version.rb
+homepage: https://github.com/igorkasyanchuk/view_bind
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/igorkasyanchuk/view_bind
+  changelog_uri: https://github.com/igorkasyanchuk/view_bind/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Render Rails partials by calling their compiled method, skipping the per-call
+  render machinery.
+test_files: []