inertia_jb 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37e2ba2d8b4c896a4a4f7f006aa32cbee162cc7b798a77e78daab8a305512c65
-  data.tar.gz: 7d1f22f9ba1596965f7d8fc52c7ccc3f7f7aae78d3a1093464b77791ed858a27
+  metadata.gz: e28cad09da1cc8c9b7098013dae68a3f87a17c9c770448955459672f4df53d38
+  data.tar.gz: f3b9082f2f747bd5b263710652d816a7f750eae331eb2fde9c2a86190e71b003
 SHA512:
-  metadata.gz: 69f29e30c55a3efe39d54695948fec6de98ef96cf1a788dcb7806fb05186bc6e04f3f92cdb4ae5d175457489b042a1a3d5c8e692df2fdb07d7559d22f13edea3
-  data.tar.gz: c666ba929d8d67a7daaed36b39985ac9642b546d182dbccf30abc0281b5c115daef7f395157bbee6a0e35943c29cdb5b2ce84d07a528993d6ee528db0e269eea
+  metadata.gz: b89149beecc268c316a4e91126c33df0b840a44b66a5b536a2b89bdfc21c74a3489ed699f2800185f7834fadd0daeca8b4653e2efcd2309f4b0c9e1c3a15205b
+  data.tar.gz: f95ce5ed914aa0477fa63a33af696da8dc921eeb3609f56cd45cda181f9c259820bb8080a2d308f9617c8b729505c25c3574c4c4f546ef3bf6376736b1961805

data/README.md

@@ -2,15 +2,16 @@
 
 InertiaJb lets you declare [Inertia.js](https://inertiajs.com/) props
 for your Rails frontend components inside **view templates**, using plain Ruby
-Hashes powered by [jb](https://github.com/amatsuda/jb).
+Hashes.
 
 It is built on top of the [inertia-rails](https://github.com/inertiajs/inertia-rails) gem.
 
-A `*.html.inertia` template is just Ruby code whose last expression is a Hash.
-That Hash is handed straight to `InertiaRails::Renderer`, so **every Inertia
-protocol feature works out of the box** — partial reloads (at any nesting
-depth), optional / always / deferred / scroll props, prop merging, shared data,
-and global key transforms.
+A `*.inertia` template is just Ruby code whose last expression is a Hash.
+`inertia` is registered as a real Rails template format, so the template renders
+through the ordinary Rails pipeline and its resulting Hash is handed straight to
+`InertiaRails::Renderer` — meaning **every Inertia protocol feature works out of
+the box**: partial reloads (at any nesting depth), optional / always / deferred /
+scroll props, prop merging, shared data, and global key transforms.
 
 ```ruby
 # app/controllers/messages_controller.rb
@@ -25,7 +26,7 @@ end
 ```
 
 ```ruby
-# app/views/messages/show.html.inertia
+# app/views/messages/show.inertia
 {
   message: {
     content: @message.content,
@@ -55,15 +56,6 @@ export default function Message({ user, message }) {
 }
 ```
 
-## Why jb?
-
-Inertia's server side is fundamentally about producing **a Hash of props** that
-`inertia-rails` then resolves and serializes. jb templates *are* plain Ruby
-Hashes, so there is zero impedance mismatch: no DSL to learn, no intermediate
-representation, and the full power of Ruby for building collections and
-conditionals.
-
-
 ## Installation
 
 Add the gem to your Gemfile:
@@ -72,8 +64,9 @@ Add the gem to your Gemfile:
 gem "inertia_jb"
 ```
 
-Then, in your inertia-rails initializer, **disable `default_render`** so that a
-normal implicit render falls through to your `.html.inertia` template:
+Then, in your inertia-rails initializer, keep `default_render` **off** (that is
+its own default) so a normal implicit render falls through to your `.inertia`
+template:
 
 ```ruby
 # config/initializers/inertia_rails.rb
@@ -82,8 +75,6 @@ InertiaRails.configure do |config|
 end
 ```
 
-You do **not** need to call `use_inertia_instance_props`.
-
 ## Layout
 
 On an **initial (non-XHR) page load** the `data-page` root element is wrapped in
@@ -95,13 +86,13 @@ The layout is chosen from inertia-rails' `config.layout`, matching
 
 ## Templates and partials
 
-- **Page templates** live at `app/views/<controller>/<action>.html.inertia` and
+- **Page templates** live at `app/views/<controller>/<action>.inertia` and
   must return a Hash (your Inertia props).
 - **Partials** are ordinary [jb](https://github.com/amatsuda/jb) partials named
-  `_name.html.jb`. They return a Hash, and compose naturally:
+  `_name.jb`. They return a Hash, and compose naturally:
 
 ```ruby
-# app/views/messages/show.html.inertia
+# app/views/messages/show.inertia
 {
   author:   render(partial: "authors/author", object: @message.author),
   comments: render(partial: "comments/comment", collection: @message.comments)
@@ -109,20 +100,20 @@ The layout is chosen from inertia-rails' `config.layout`, matching
 ```
 
 ```ruby
-# app/views/authors/_author.html.jb
+# app/views/authors/_author.jb
 { id: author.id, name: author.name }
 ```
 
 `render(partial:, collection:)` returns an **array of Hashes** (thanks to jb),
-which you embed directly. Don't name partials `.html.inertia` — that extension
-triggers the Inertia response wrapper and is only for top-level page templates.
+which you embed directly. Don't name partials `.inertia` — that format is for
+top-level page templates only, and turns the result into an Inertia response.
 
 ## Sharing a partial with a plain JSON API
 
 An Inertia page and a plain JSON endpoint are both, in the end, just **a Hash**,
 so a single jb partial can back both. Name the partial **without a format**
-(`_message.jb`, not `_message.html.jb`) so it resolves for the `html` format
-Inertia uses *and* the `json` format a normal API request uses:
+(`_message.jb`, not `_message.html.jb`) so it resolves for the formats an Inertia
+page renders under *and* the `json` format a normal API request uses:
 
 ```ruby
 # app/views/messages/_message.jb
@@ -134,12 +125,12 @@ Inertia uses *and* the `json` format a normal API request uses:
 ```
 
 ```ruby
-# app/views/messages/show.html.inertia   — the Inertia page
-{ **render(partial: "messages/message", object: @message) }
+# app/views/messages/show.inertia   — the Inertia page
+render(partial: "messages/message", object: @message)
 ```
 
 ```ruby
-# app/views/messages/index.html.inertia   — nested under a key
+# app/views/messages/index.inertia   — nested under a key
 { messages: render(partial: "messages/message", collection: @messages, as: :message) }
 ```
 
@@ -150,41 +141,22 @@ render(partial: "messages/message", object: @message)
 
 
 Note the asymmetry: the JSON endpoint can return that Array at the top level,
-but the Inertia page **must** nest it under a key (`{ posts: … }`) — Inertia
-props must be an object, never a top-level Array.
-
-> **Gotcha — wrap the page template in a Hash literal.** A `.html.inertia` page
-> must **not** be a bare top-level `render(partial: …)`:
->
-> ```ruby
-> # ❌ props get misread as the component name
-> render(partial: "messages/message", object: @message)
->
-> # ✅ spread into a real Hash literal
-> { **render(partial: "messages/message", object: @message) }
-> ```
->
-> jb's `render(partial:)` returns a `Jb::TemplateResult` (a delegator), not a
-> true `Hash`. inertia-rails decides *"is this props or a component name?"* with
-> `component.is_a?(Hash)`, so a bare partial result is taken for a component name
-> and your props end up in the `component` field. Wrapping it in a literal
-> `{ **… }` — or nesting it under a key, e.g. `{ message: render(…) }` — makes
-> the top-level value a genuine `Hash`, which inertia-rails reads as props. A
-> `.json.jb` endpoint never hits this, because jb serializes its top-level result
-> with `to_json` directly.
+but the Inertia page **must** nest it under a key (`{ messages: … }`) — Inertia
+props must be an object, never a top-level Array. An **object** partial is fine
+bare, as in `show.inertia` above.
 
 If you'd rather keep a format-specific partial (`_message.json.jb`), borrow the
 `:json` variant from the Inertia side with `formats:`:
 
 ```ruby
-# app/views/messages/show.html.inertia
-{ **render(partial: "messages/message", object: @message, formats: [:json]) }
+# app/views/messages/show.inertia
+render(partial: "messages/message", object: @message, formats: [:json])
 ```
 
 ## Inertia prop types
 
 Because props are just a Hash, Inertia's special prop types are plain values you
-drop in. Inside a `.html.inertia` template you can use the short helpers
+drop in. Inside a `.inertia` template you can use the short helpers
 (`optional`, `always`, `defer`, `scroll`, `merge`, `deep_merge`, `once`, `cache`) or the full
 `InertiaRails.*` methods.
 
@@ -246,8 +218,29 @@ Alternatively, just write camelCase keys directly in your templates.
 
 - Inertia props must be an **object**, so page templates should return a Hash
   (not a top-level Array).
-- Don't install this alongside `inertia-builder`; both register an `:inertia`
-  template handler.
+- The gem registers `inertia` as a `Mime::Type` **alias** of `text/html`. Because
+  it is an alias, it is skipped by content negotiation: `inertia` is a template
+  format, never a wire format, and `Accept` headers are unaffected.
+- If both `show.html.erb` and `show.inertia` exist for one action, Rails prefers
+  the exact format match — the ERB one.
+- If your app pins `config.action_view.default_formats`, you don't need to add
+  `inertia` to it: page templates carry no format extension, so they resolve under
+  whatever format the request already asked for.
+
+## Upgrading from 0.3.x
+
+1. **Rename page templates**: `show.html.inertia` → `show.inertia`. A leftover
+   `.html.inertia` template raises with the rename instruction, so nothing fails
+   silently. Jb partials (`_author.html.jb`, `_author.jb`) don't change.
+2. **Component names now follow the rendered template** rather than
+   `controller_path`/`action_name`. Identical for a normal implicit render; it
+   differs when you `render :other_action` (you now get `other_action`'s
+   component, which is the point) or when a template is inherited from a parent
+   controller's view directory (the component follows the template's directory).
+3. `{ **render(partial: …) }` in a page template can lose the wrapper — a bare
+   `render(partial: …)` is now read as props.
+
+`config.default_render = false` is still required, unchanged from 0.3.x.
 
 ## Development
 

data/lib/inertia_jb/controller.rb

@@ -1,28 +1,38 @@
 # frozen_string_literal: true
 
 module InertiaJb
-  # Controller concern that renders `.html.inertia` templates as Inertia
-  # responses.
+  # Controller concern that renders `*.inertia` templates as Inertia responses.
   #
-  # A `.html.inertia` page template is reached through Rails' normal implicit
-  # render. Its body (compiled by {Handler}) throws the props Hash back here,
-  # which aborts the implicit render — layout and all — before we re-render the
-  # page through inertia-rails' native renderer via `render inertia:`. Component
-  # resolution, shared data, `PropsResolver`/partial reloads, `config.layout`,
-  # SSR and the X-Inertia/Vary headers are therefore all handled by
-  # inertia-rails, identically to a plain inertia-rails app.
+  # There is no control-flow trickery here: an `.inertia` page goes through
+  # Rails' ordinary render pipeline and its *return value* — a {Props} object —
+  # comes back out of `render_to_body`. We recognise it there and re-enter with
+  # `inertia:`, which inertia-rails registered as a proper
+  # +ActionController::Renderers+ renderer. Component resolution, shared data,
+  # `PropsResolver`/partial reloads, `config.layout`, SSR and the
+  # X-Inertia/Vary headers therefore all stay with inertia-rails.
   #
-  # Plain (non-Inertia) `.html.erb` actions never throw, so `catch` falls
-  # through to `super` and they render exactly as in vanilla Rails.
+  # Because the hand-off keys on the rendered result, `default_render` needs no
+  # hook of its own: Rails' ordinary implicit render finds the `.inertia`
+  # template, and explicit renders work the same way — `render :new`,
+  # `render template: "other/page"`, `render :edit, status: :unprocessable_entity`.
+  #
+  # The one thing that *does* have to stay out of the way is inertia-rails'
+  # `config.default_render`, which short-circuits `default_render` into
+  # `render inertia: true` before any template is consulted; apps therefore set it
+  # to `false` (its own default).
   #
   # +InertiaRails::Controller+ is already mixed into +ActionController::Base+ by
   # inertia-rails' engine, so we don't include it again.
   module Controller
     extend ActiveSupport::Concern
 
-    def default_render(*)
-      props = catch(:__inertia_jb) { return super }
-      render(inertia: props)
+    def render_to_body(options = {})
+      body = super
+      return body unless body.is_a?(InertiaJb::Props)
+
+      # Second pass: `:inertia` is handled by inertia-rails' renderer, which
+      # returns a real String body, so this never recurses further.
+      render_to_body(inertia: body.component(inertia_configuration), props: body.props)
     end
   end
 end

data/lib/inertia_jb/handler.rb

@@ -1,21 +1,47 @@
 # frozen_string_literal: true
 
 module InertiaJb
-  # ActionView template handler for `*.html.inertia` templates.
+  # ActionView template handler for `*.inertia` page templates.
   #
-  # An `.html.inertia` template is jb-style Ruby: its last expression is a Hash
-  # of Inertia props. The handler evaluates that Hash and immediately `throw`s
-  # it back to {Controller#default_render}, which hands it to inertia-rails'
-  # native renderer. The `throw` also aborts this implicit render (and the
-  # layout it was about to apply), so the handler emits no body of its own.
+  # An `.inertia` template is jb-style Ruby: its last expression is a Hash of
+  # Inertia props. The handler compiles it into a {Props} object — the
+  # template's *return value*, produced by an otherwise completely ordinary
+  # Rails render. {Controller#render_to_body} recognises that value and hands it
+  # to inertia-rails' `:inertia` renderer.
+  #
+  # The `default_format` declaration is what makes `:inertia` a real Rails
+  # template format: a file named `show.inertia` carries no format extension, so
+  # +TemplateDetails#format_or_default+ falls back to this value and the built
+  # +ActionView::Template+ reports `format == :inertia`. Two things follow for
+  # free — the template still resolves for an ordinary `html` request (a
+  # format-less path matches any requested format), and no layout is ever found
+  # for it, because layout lookup runs against `formats.first` (`:inertia`) and
+  # `layouts/*.html.erb` simply does not match.
   class Handler
+    class_attribute :default_format
+    self.default_format = :inertia
+
     def self.call(template, source = nil)
       source ||= template.source
 
+      unless template.format == :inertia
+        raise ArgumentError, <<~MESSAGE
+          InertiaJb: #{template.identifier} has format #{template.format.inspect}, not :inertia.
+          Page templates must be named `<action>.inertia` (drop the `.html.`) so that
+          Rails resolves them as the :inertia format.
+        MESSAGE
+      end
+
       # `begin;#{source}` keeps the template's own line numbers aligned in
       # backtraces. The block evaluates to the template's last expression (the
-      # props Hash), which we throw up to the controller to render.
-      "throw(:__inertia_jb, begin;#{source}\nend)"
+      # props Hash). `@virtual_path` is assigned by Rails in the compiled
+      # method's preamble, so it is already set here.
+      "::InertiaJb::Props.new(@virtual_path, begin;#{source}\nend)"
+    end
+
+    # Hand the source to Ruby as-is, like Jb::Handler does.
+    def self.handles_encoding?
+      true
     end
   end
 end

data/lib/inertia_jb/props.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module InertiaJb
+  # The result of rendering an `*.inertia` template: the props Hash plus the
+  # template's virtual path.
+  #
+  # It exists so that {Controller#render_to_body} can tell "this is a set of
+  # Inertia props" from "this is a response body" without inspecting formats or
+  # guessing, and so the Inertia component name can be derived from the template
+  # that actually rendered.
+  class Props
+    attr_reader :virtual_path, :props
+
+    def initialize(virtual_path, props)
+      @virtual_path = virtual_path
+      @props = props
+    end
+
+    # The Inertia component name for this page.
+    #
+    # Derived from the rendered template rather than from
+    # `controller_path`/`action_name`, so an explicit `render :edit` points at
+    # the `edit` component instead of the acting `create`.
+    #
+    # The virtual path is split into the same `path:`/`action:` pair inertia-rails
+    # feeds its own resolver, and handed to `config.component_path_resolver`
+    # unconditionally — a custom resolver (camelizing, prefixing, ...) owns the
+    # result in every case, including a page template that sits at the root of a
+    # view path (`path:` is then `""`, which the default resolver renders as
+    # `"/name"`).
+    def component(configuration)
+      prefix, _, name = virtual_path.rpartition("/")
+
+      configuration.component_path_resolver(path: prefix, action: name)
+    end
+  end
+end

data/lib/inertia_jb/railtie.rb

@@ -5,14 +5,27 @@ require "rails/railtie"
 module InertiaJb
   class Railtie < ::Rails::Railtie
     initializer :inertia_jb do
-      ActiveSupport.on_load(:action_controller) do
-        include InertiaJb::Controller
+      # Makes `:inertia` a valid Rails template format (`Mime::SET.symbols` is
+      # what `ActionView::Template::Types.symbols` reads). Registered here, in
+      # the initializer body, so it lands before any template path is parsed —
+      # the resolvers memoize a regex built from the format list.
+      #
+      # `register_alias` rather than `register`: the latter would overwrite
+      # `LOOKUP["text/html"]` and break HTML content negotiation app-wide.
+      # An alias skips the mime-string lookup, so `:inertia` never takes part in
+      # Accept negotiation — it is a template format, not a wire format.
+      Mime::Type.register_alias "text/html", :inertia unless Mime[:inertia]
+
+      # `prepend`, not `include`: `render_to_body` has to sit ahead of
+      # +ActionController::Renderers+ in the ancestry so `super` reaches it, and
+      # prepending makes that position independent of gem load order.
+      ActiveSupport.on_load(:action_controller_base) do
+        prepend InertiaJb::Controller
       end
 
       ActiveSupport.on_load(:action_view) do
         ActionView::Template.register_template_handler :inertia, InertiaJb::Handler
         ActionView::Base.include InertiaJb::Helper
-        ActionView::TemplateRenderer.prepend InertiaJb::Renderer
       end
     end
   end

data/lib/inertia_jb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module InertiaJb
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/lib/inertia_jb.rb

@@ -4,8 +4,8 @@ require "jb"
 require "inertia_rails"
 
 require "inertia_jb/version"
+require "inertia_jb/props"
 require "inertia_jb/handler"
-require "inertia_jb/renderer"
 require "inertia_jb/controller"
 require "inertia_jb/helper"
 require "inertia_jb/railtie" if defined?(Rails::Railtie)
@@ -14,9 +14,12 @@ require "inertia_jb/railtie" if defined?(Rails::Railtie)
 # frontend components inside view templates, using plain Ruby Hashes powered by
 # the {https://github.com/amatsuda/jb jb} renderer.
 #
-# A `*.html.inertia` template is Ruby code whose last expression is a Hash of
-# props. That Hash is handed straight to +InertiaRails::Renderer+, so every
-# Inertia protocol feature (partial reloads, optional/always/deferred props,
-# merging, shared data, key transforms) works out of the box.
+# `:inertia` is registered as a real Rails template format, so a `*.inertia`
+# template is rendered by the ordinary Rails pipeline (and never wrapped in a
+# layout). Its return value is a {Props} object carrying the template's last
+# expression — a Hash of props — which {Controller#render_to_body} hands to
+# inertia-rails' `:inertia` renderer. Every Inertia protocol feature (partial
+# reloads, optional/always/deferred props, merging, shared data, key transforms)
+# therefore works out of the box.
 module InertiaJb
 end

data/test/controller_test.rb

@@ -5,8 +5,6 @@ require "action_view/testing/resolvers"
 require "json"
 
 class TestController < ActionController::Base
-  include InertiaJb::Controller
-
   layout "application"
 
   # Shared props are merged in automatically by inertia-rails.
@@ -49,23 +47,23 @@ class ControllerTest < ActionController::TestCase
 
   TEMPLATES = {
     "layouts/application.html.erb" => "<html><body><%= yield %></body></html>",
-    "test/index.html.inertia"      => "{ content: 'content' }",
-    "test/nested.html.inertia"     => "{ product: { id: 10, name: 'Keyboard', price: 29.99 } }",
-    "test/collection.html.inertia" => "{ products: @products.map { |p| { id: p[:id], name: p[:name] } } }",
-    "test/with_partial.html.inertia" =>
+    "test/index.inertia"      => "{ content: 'content' }",
+    "test/nested.inertia"     => "{ product: { id: 10, name: 'Keyboard', price: 29.99 } }",
+    "test/collection.inertia" => "{ products: @products.map { |p| { id: p[:id], name: p[:name] } } }",
+    "test/with_partial.inertia" =>
       "{ author: render(partial: 'authors/author', object: @author), " \
       "comments: render(partial: 'comments/comment', collection: @comments) }",
     "authors/_author.html.jb"  => "{ id: author[:id], name: author[:name] }",
     "comments/_comment.html.jb" => "{ body: comment[:body] }",
-    "test/special.html.inertia" =>
+    "test/special.inertia" =>
       "{ id: @id, stats: optional { { visits: 42 } }, feed: defer(group: :feed) { [1, 2, 3] } }",
-    "test/cached.html.inertia" =>
+    "test/cached.inertia" =>
       "{ flash: once { 'hello' }, " \
       "report: cache('report', expires_in: 1.minute) { Time.current.to_f } }",
     # A deferred/optional prop whose block renders a jb partial. The block is
     # resolved by inertia-rails in controller context, so a bare `render` there
     # would set response_body and collide with inertia's own render(json:).
-    "test/lazy_partial.html.inertia" =>
+    "test/lazy_partial.inertia" =>
       "{ deferredAuthor: defer { render(partial: 'authors/author', object: @author) }, " \
       "optionalComments: optional { render(partial: 'comments/comment', collection: @comments) } }"
   }.freeze

data/test/layout_suppression_test.rb

@@ -3,13 +3,15 @@
 require "test_helper"
 require "action_view/testing/resolvers"
 
-# Regression test for the "phantom layout render" bug.
+# Regression test: an `.inertia` page must never be wrapped in — or even resolve
+# — the controller's layout.
 #
-# An `.inertia` page throws its props before producing output, so the
-# controller's layout is always discarded. Rails must therefore never resolve,
-# compile, or *instrument* that layout while rendering the props template —
-# otherwise request logs and APM traces show a `crm/application` layout render
-# that never happened, with its timing absorbing the prop-building work.
+# This falls out of `:inertia` being a real template format: layout lookup runs
+# against `formats.first` (`:inertia`), which `layouts/*.html.erb` cannot match.
+# Nothing patches Rails to make it happen, so the guarantee is worth pinning:
+# were the layout resolved, request logs and APM traces would show a layout
+# render that contributes nothing to the response, and its timing would absorb
+# the prop-building work.
 #
 # The controller here uses `layout "application"` but points Inertia at a
 # *different* shell (`config.layout = "inertia"`), so the two are easy to tell
@@ -17,7 +19,6 @@ require "action_view/testing/resolvers"
 #   * the `.inertia` props template must be rendered with NO layout, and
 #   * `layouts/application` must never be rendered at all.
 class SuppressLayoutController < ActionController::Base
-  include InertiaJb::Controller
   layout "application"
   inertia_config layout: "inertia"
   def index; end
@@ -29,7 +30,7 @@ class LayoutSuppressionTest < ActionController::TestCase
   TEMPLATES = {
     "layouts/application.html.erb" => "<html><body><%= yield %></body></html>",
     "layouts/inertia.html.erb"     => "<main data-inertia-shell=\"1\"><%= yield %></main>",
-    "suppress_layout/index.html.inertia" => "{ ok: true }"
+    "suppress_layout/index.inertia" => "{ ok: true }"
   }.freeze
 
   def setup
@@ -47,7 +48,7 @@ class LayoutSuppressionTest < ActionController::TestCase
   def test_inertia_template_is_rendered_without_a_layout
     templates = capture("render_template.action_view") { get :index }
 
-    page = templates.find { |e| e.payload[:identifier].end_with?("index.html.inertia") }
+    page = templates.find { |e| e.payload[:identifier].end_with?("index.inertia") }
     assert page, "the .inertia props template should have been rendered"
     assert_nil page.payload[:layout],
                "the .inertia props template must be rendered without a layout, " \

data/test/layout_test.rb

@@ -9,21 +9,18 @@ require "json"
 # case gets its own controller and no global state is mutated.
 
 class LayoutDefaultController < ActionController::Base
-  include InertiaJb::Controller
   layout "application"
   # No `inertia_config` — `config.layout` defaults to `true`.
   def index; end
 end
 
 class LayoutFalseController < ActionController::Base
-  include InertiaJb::Controller
   layout "application"
   inertia_config layout: false
   def index; end
 end
 
 class LayoutNamedController < ActionController::Base
-  include InertiaJb::Controller
   layout "application"
   inertia_config layout: "inertia"
   def index; end
@@ -32,7 +29,6 @@ end
 # A plain (non-Inertia) HTML action living in an app that configured
 # `config.layout = false`. Its layout must behave like vanilla Rails.
 class PlainController < ActionController::Base
-  include InertiaJb::Controller
   layout "application"
   inertia_config layout: false
   def index; end
@@ -42,9 +38,9 @@ module LayoutTestHelpers
   TEMPLATES = {
     "layouts/application.html.erb" => "<html><body><%= yield %></body></html>",
     "layouts/inertia.html.erb"     => "<main data-inertia-layout=\"1\"><%= yield %></main>",
-    "layout_default/index.html.inertia" => "{ ok: true }",
-    "layout_false/index.html.inertia"   => "{ ok: true }",
-    "layout_named/index.html.inertia"   => "{ ok: true }",
+    "layout_default/index.inertia" => "{ ok: true }",
+    "layout_false/index.inertia"   => "{ ok: true }",
+    "layout_named/index.inertia"   => "{ ok: true }",
     "plain/index.html.erb"              => "plain-body-<%= 1 + 1 %>"
   }.freeze
 

data/test/rendering_test.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "action_view/testing/resolvers"
+require "json"
+
+# The hand-off from template to renderer keys on the *rendered result*, not on
+# `default_render`, so explicit renders are first-class. These tests pin that
+# down, plus the two boundaries of the `:inertia` format: it must take priority
+# over inertia-rails' `config.default_render`, and it must not leak into other
+# formats' template lookup.
+
+class RenderController < ActionController::Base
+  layout "application"
+
+  def implicit; end
+
+  # The Rails idiom after a failed create: re-render another action's template.
+  # (422 spelled numerically — `:unprocessable_entity` is deprecated in Rack 3.2
+  # while `:unprocessable_content` doesn't exist on older Rack.)
+  def create
+    render :implicit, status: 422
+  end
+
+  def cross_template
+    render template: "other/thing"
+  end
+
+  # A page template whose whole body is a bare `render(partial:)` — jb hands
+  # back a Jb::TemplateResult, which reaches inertia-rails as `props:` and so
+  # needs no `{ **... }` wrapping.
+  def bare_partial
+    @author = { id: 42, name: "John" }
+  end
+
+  # A plain JSON endpoint next door: `.json.jb` must keep serializing to JSON.
+  def api; end
+end
+
+# inertia-rails' `config.default_render` short-circuits `default_render` into
+# `render inertia: true`, which is why installing this gem asks for it to be off.
+class DefaultRenderController < ActionController::Base
+  layout "application"
+  inertia_config default_render: true
+
+  def with_template; end
+end
+
+# A template still carrying the pre-0.4 name.
+class LegacyNameController < ActionController::Base
+  def index; end
+end
+
+# The component name is always produced by inertia-rails' resolver, never
+# assembled by this gem.
+class CustomResolverController < ActionController::Base
+  inertia_config component_path_resolver: ->(path:, action:) { "#{path.camelize}/#{action.camelize}" }
+
+  def index; end
+end
+
+module RenderingTestHelpers
+  TEMPLATES = {
+    "layouts/application.html.erb" => "<html><body><%= yield %></body></html>",
+    "render/implicit.inertia"      => "{ page: 'implicit' }",
+    "render/cross_template.inertia" => "{ page: 'never rendered' }",
+    "other/thing.inertia"          => "{ page: 'other' }",
+    "render/bare_partial.inertia"  => "render(partial: 'authors/author', object: @author)",
+    "authors/_author.html.jb"      => "{ id: author[:id], name: author[:name] }",
+    "render/api.json.jb"           => "{ ok: true }",
+    "default_render/with_template.inertia" => "{ from: 'template' }",
+    "legacy_name/index.html.inertia" => "{ page: 'legacy' }",
+    "custom_resolver/index.inertia" => "{ ok: true }"
+  }.freeze
+
+  def setup
+    super
+    @controller.prepend_view_path(ActionView::FixtureResolver.new(TEMPLATES))
+  end
+
+  def teardown
+    super
+    @routes.clear!
+  end
+
+  private
+
+  def draw(*actions)
+    controller_path = @controller.class.controller_path
+    @routes = ActionDispatch::Routing::RouteSet.new
+    @routes.draw do
+      actions.each { |action| get action.to_s => "#{controller_path}##{action}" }
+    end
+  end
+
+  def inertia_get(action, **kwargs)
+    @request.headers["X-Inertia"] = "true"
+    get action, **kwargs
+  end
+
+  def page
+    JSON.parse(response.body)
+  end
+end
+
+class ExplicitRenderTest < ActionController::TestCase
+  include RenderingTestHelpers
+  tests RenderController
+
+  def setup
+    super
+    draw :implicit, :create, :cross_template, :bare_partial, :api
+  end
+
+  def test_implicit_render_uses_the_template_component
+    inertia_get :implicit
+
+    assert_response :success
+    assert_equal "application/json; charset=utf-8", response.content_type
+    assert_equal "render/implicit", page["component"]
+    assert_equal "implicit", page.dig("props", "page")
+  end
+
+  def test_full_page_load_is_html
+    get :implicit
+
+    assert_response :success
+    assert_equal "text/html; charset=utf-8", response.content_type
+    assert_includes response.body, "<html><body>"
+    assert_includes response.body, "data-page"
+  end
+
+  # The old throw/catch design raised UncaughtThrowError here.
+  def test_explicit_render_of_another_action_keeps_status_and_component
+    inertia_get :create
+
+    assert_response 422
+    assert_equal "render/implicit", page["component"],
+                 "the component must follow the rendered template, not the acting action"
+    assert_equal "implicit", page.dig("props", "page")
+  end
+
+  def test_explicit_render_template_across_directories
+    inertia_get :cross_template
+
+    assert_response :success
+    assert_equal "other/thing", page["component"]
+    assert_equal "other", page.dig("props", "page")
+  end
+
+  def test_page_template_may_be_a_bare_partial_render
+    inertia_get :bare_partial
+
+    assert_response :success
+    assert_equal({ "id" => 42, "name" => "John" }, page["props"].except("errors"))
+  end
+
+  # `:inertia` is a template format, not a wire format: it must not shadow the
+  # `.json.jb` lookup for a plain API request.
+  def test_json_endpoint_on_the_same_controller_is_untouched
+    get :api, format: :json
+
+    assert_response :success
+    assert_equal "application/json; charset=utf-8", response.content_type
+    assert_nil response.headers["X-Inertia"]
+    assert_equal({ "ok" => true }, page)
+  end
+end
+
+# Pins the reason the installation instructions ask for
+# `config.default_render = false`: with it on, inertia-rails answers
+# `default_render` itself and the `.inertia` template is never reached.
+class DefaultRenderTest < ActionController::TestCase
+  include RenderingTestHelpers
+  tests DefaultRenderController
+
+  def setup
+    super
+    draw :with_template
+  end
+
+  def test_config_default_render_true_short_circuits_before_the_template
+    inertia_get :with_template
+
+    assert_response :success
+    assert_equal "default_render/with_template", page["component"]
+    refute page["props"].key?("from"),
+           "config.default_render = true renders `inertia: true` without consulting " \
+           "the template — hence the initializer step"
+  end
+end
+
+class InertiaMimeTypeTest < ActiveSupport::TestCase
+  def test_inertia_is_a_valid_template_format
+    assert Mime[:inertia], "Mime[:inertia] must exist for `lookup_context.formats` to accept it"
+    assert_includes ActionView::Template::Types.symbols, :inertia
+  end
+
+  # Registered as an *alias* of text/html: `Mime::Type.register` would repoint
+  # `LOOKUP["text/html"]` at :inertia and break HTML negotiation app-wide.
+  def test_inertia_does_not_take_part_in_content_negotiation
+    assert_equal :html, Mime::Type.lookup("text/html").symbol
+    assert_equal [Mime[:html]], Mime::Type.parse("text/html")
+  end
+end
+
+class CustomComponentResolverTest < ActionController::TestCase
+  include RenderingTestHelpers
+  tests CustomResolverController
+
+  def setup
+    super
+    draw :index
+  end
+
+  def test_component_name_goes_through_config_component_path_resolver
+    inertia_get :index
+
+    assert_response :success
+    assert_equal "CustomResolver/Index", page["component"]
+  end
+end
+
+class LegacyTemplateNameTest < ActionController::TestCase
+  include RenderingTestHelpers
+  tests LegacyNameController
+
+  def setup
+    super
+    draw :index
+  end
+
+  def test_html_inertia_template_reports_the_rename
+    error = assert_raises(ActionView::Template::Error) { get :index }
+
+    assert_includes error.message, "`<action>.inertia`"
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: inertia_jb
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - kikyous
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-25 00:00:00.000000000 Z
+date: 2026-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: inertia_rails
@@ -81,12 +81,13 @@ files:
 - lib/inertia_jb/controller.rb
 - lib/inertia_jb/handler.rb
 - lib/inertia_jb/helper.rb
+- lib/inertia_jb/props.rb
 - lib/inertia_jb/railtie.rb
-- lib/inertia_jb/renderer.rb
 - lib/inertia_jb/version.rb
 - test/controller_test.rb
 - test/layout_suppression_test.rb
 - test/layout_test.rb
+- test/rendering_test.rb
 - test/test_helper.rb
 homepage: https://github.com/kikyous/inertia_jb
 licenses:
@@ -119,4 +120,5 @@ test_files:
 - test/controller_test.rb
 - test/layout_suppression_test.rb
 - test/layout_test.rb
+- test/rendering_test.rb
 - test/test_helper.rb

data/lib/inertia_jb/renderer.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module InertiaJb
-  # Prepended onto +ActionView::TemplateRenderer+ to guarantee that a
-  # `.html.inertia` template is never wrapped in a layout.
-  #
-  # An `.inertia` template's body (see {Handler}) throws its props Hash back to
-  # the controller before it produces any output, so a surrounding layout is
-  # always discarded. Left alone, Rails would still resolve and compile the
-  # controller's layout and emit phantom `render_layout.action_view` /
-  # `render_template.action_view` events for it — their `ensure` blocks fire as
-  # the `throw` unwinds the stack — whose timing absorbs the prop-building work,
-  # polluting request logs and APM traces with a layout render that never
-  # actually happened.
-  #
-  # +render_template+ is the one point where Rails has already resolved the
-  # template (so we can see its handler) but has not yet looked up the layout
-  # (`find_layout` runs one call deeper, in +render_with_layout+). Nulling the
-  # layout here for our handler skips the lookup entirely — cleanly, without the
-  # controller having to guess in advance which template an action will render.
-  #
-  # This only affects our own templates. The real Inertia shell is applied later
-  # by inertia-rails when it renders the `inertia` root template (an ERB
-  # template) with `config.layout`, and plain `.erb`/`.jb` templates keep their
-  # layouts exactly as in vanilla Rails.
-  module Renderer
-    private
-
-    def render_template(view, template, layout_name, locals)
-      layout_name = nil if template.handler == InertiaJb::Handler
-      super
-    end
-  end
-end