inertia_jb 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5318dc498cde30ce2dfada1a46e68138c4a85dfef6a7cf275b411f861e059d67
-  data.tar.gz: abb2907bdaba0907f38376557c750e99d918988dc28e2b36e02bd209bbcedd37
+  metadata.gz: c821eb8ccc74579d17f768744858bb9a14f7838201dd2ff89be61f8f70298780
+  data.tar.gz: 4e385aefbe3adcdcd6069b422382cd91cc7cbe208f2275230433110a761a4d3d
 SHA512:
-  metadata.gz: 8039dfc4f8d98b88c328c622a007f9baf110bed9024b828443bac26ef12cc05853c5c59087b472f454de9dace0693c34cd864914822541f4be1879db76e7f500
-  data.tar.gz: 535c7d2247b8da621a0f55ab3973006b27a2dab97a0af71cfd2294bebd65b9a2406a5ab8ba6956c3097a5bbff85472e3c9b7db8a1f32b678ad1b8495d8a90168
+  metadata.gz: fb985df39ed4ec250604244d93c968884b8d4a47588e031126d48f5b9489e5015192fc021de81c4b4e4d06018714065ed757046ec9728ed7804f930f073dd95e
+  data.tar.gz: d3e94480c54b50667a66c9416a59d6124e410b6d5da165e3344137128c9b2b88b111e07897ffccc0b56a915c955e060a0c103129813d476a99e085af337f2ccf

data/README.md

@@ -63,9 +63,6 @@ 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.
 
-> Coming from `props_template`? That gem streams JSON strings, which don't map
-> cleanly onto Inertia's Hash-based resolver. jb's plain-Hash output is the
-> natural fit, which is why this gem is built on it.
 
 ## Installation
 
@@ -87,6 +84,15 @@ 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
+a layout; Inertia (XHR) visits always return a bare JSON body with no layout.
+
+The layout is chosen from inertia-rails' `config.layout`, matching
+`InertiaRails::Renderer`'s own semantics:
+
+
 ## Templates and partials
 
 - **Page templates** live at `app/views/<controller>/<action>.html.inertia` and
@@ -111,11 +117,75 @@ You do **not** need to call `use_inertia_instance_props`.
 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.
 
+## 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:
+
+```ruby
+# app/views/messages/_message.jb
+{
+  id:      message.id,
+  content: message.content,
+  author:  render(partial: "authors/author", object: message.author)
+}
+```
+
+```ruby
+# app/views/messages/show.html.inertia   — the Inertia page
+{ **render(partial: "messages/message", object: @message) }
+```
+
+```ruby
+# app/views/messages/index.html.inertia   — nested under a key
+{ messages: render(partial: "messages/message", collection: @messages, as: :message) }
+```
+
+```ruby
+# app/views/messages/show.json.jb        — a plain JSON endpoint
+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.
+
+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]) }
+```
+
 ## 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
-(`optional`, `always`, `defer`, `scroll`, `merge`, `deep_merge`) or the full
+(`optional`, `always`, `defer`, `scroll`, `merge`, `deep_merge`, `once`, `cache`) or the full
 `InertiaRails.*` methods.
 
 ```ruby
@@ -137,23 +207,24 @@ drop in. Inside a `.html.inertia` template you can use the short helpers
   # Infinite scrolling (accepts a paginator or explicit metadata).
   feed: scroll(@pagy) {
     render(partial: "feed/item", collection: @items)
+  },
+
+  # Sent once and cached client-side; skipped on later visits until reset.
+  flash: once { session.delete(:flash) },
+
+  # Server-side cached via Rails.cache; the block's JSON output is reused
+  # across requests until the cache entry expires.
+  report: cache("posts/#{@post.id}/report", expires_in: 5.minutes) {
+    render(partial: "reports/report", object: @post.report)
   }
 }
 ```
 
 See the inertia-rails docs for [partial reloads](https://inertiajs.com/partial-reloads),
-[deferred props](https://inertiajs.com/deferred-props), and
-[infinite scroll](https://inertia-rails.dev/guide/infinite-scroll).
-
-## Caching
-
-Use plain Rails caching — you're caching Ruby Hashes:
-
-```ruby
-@posts.map do |post|
-  Rails.cache.fetch(post) { render(partial: "posts/post", object: post) }
-end
-```
+[deferred props](https://inertiajs.com/deferred-props),
+[infinite scroll](https://inertia-rails.dev/guide/infinite-scroll),
+[once props](https://inertia-rails.dev/guide/once-props), and
+[prop caching](https://inertia-rails.dev/guide/prop-caching).
 
 ## camelCase keys
 

data/lib/inertia_jb/controller.rb

@@ -1,42 +1,28 @@
 # frozen_string_literal: true
 
 module InertiaJb
-  # Controller concern that makes `.html.inertia` templates behave like proper
-  # Inertia responses.
+  # Controller concern that renders `.html.inertia` templates as Inertia
+  # responses.
   #
-  # Our {Renderer} only computes the page hash (it does not go through
-  # +InertiaRails::Renderer#render+), so we set the Inertia response headers and
-  # skip the layout for Inertia (XHR) requests here — mirroring inertia-builder.
+  # 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.
   #
-  # +InertiaRails::Controller+ (which provides +inertia_share+, shared data and
-  # +default_render+) is already mixed into +ActionController::Base+ by
+  # Plain (non-Inertia) `.html.erb` actions never throw, so `catch` falls
+  # through to `super` and they render exactly as in vanilla Rails.
+  #
+  # +InertiaRails::Controller+ is already mixed into +ActionController::Base+ by
   # inertia-rails' engine, so we don't include it again.
   module Controller
     extend ActiveSupport::Concern
 
-    included do
-      before_action :format_inertia_jb_response, if: -> { inertia_json_request? }
-    end
-
-    private
-
-    def format_inertia_jb_response
-      response.headers["Vary"] = if response.headers["Vary"].blank?
-                                   "X-Inertia"
-                                 else
-                                   "#{response.headers['Vary']}, X-Inertia"
-                                 end
-      response.set_header("X-Inertia", "true")
-    end
-
-    # Inertia (XHR) requests return a bare JSON body — no application layout.
-    # Initial page loads keep the layout so the `data-page` root is wrapped.
-    def action_has_layout?
-      !inertia_json_request? && super
-    end
-
-    def inertia_json_request?
-      request.headers["X-Inertia"] == "true"
+    def default_render(*)
+      props = catch(:__inertia_jb) { return super }
+      render(inertia: props)
     end
   end
 end

data/lib/inertia_jb/handler.rb

@@ -4,21 +4,18 @@ module InertiaJb
   # ActionView template handler for `*.html.inertia` templates.
   #
   # An `.html.inertia` template is jb-style Ruby: its last expression is a Hash
-  # of Inertia props. We evaluate it, then hand the resulting Hash to
-  # {Renderer}, whose return value becomes the rendered body.
-  #
-  # Unlike props_template, there is no shared builder state to guard: jb
-  # partials each return their own Hash independently, so no `@__json`-style
-  # finalize dance is needed here.
+  # 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.
   class Handler
     def self.call(template, source = nil)
       source ||= template.source
 
       # `begin;#{source}` keeps the template's own line numbers aligned in
-      # backtraces. The begin/end block evaluates to the template's last
-      # expression (the props Hash).
-      "__inertia_props = begin;#{source}\nend\n" \
-        "::InertiaJb::Renderer.new(self, __inertia_props, true).render"
+      # 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)"
     end
   end
 end

data/lib/inertia_jb/helper.rb

@@ -37,5 +37,16 @@ module InertiaJb
     def deep_merge(...)
       ::InertiaRails.deep_merge(...)
     end
+
+    # Sent once and cached client-side; skipped on later visits unless reset or expired.
+    def once(...)
+      ::InertiaRails.once(...)
+    end
+
+    # Server-side cached via Rails.cache; the block's result is stored as JSON
+    # and reused on subsequent requests until the cache expires.
+    def cache(...)
+      ::InertiaRails.cache(...)
+    end
   end
 end

data/lib/inertia_jb/railtie.rb

@@ -12,6 +12,7 @@ module InertiaJb
       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/renderer.rb

@@ -1,41 +1,34 @@
 # frozen_string_literal: true
 
 module InertiaJb
-  # Bridges a props Hash (built by a `.html.inertia` template) to the Inertia
-  # protocol via +InertiaRails::Renderer+.
+  # Prepended onto +ActionView::TemplateRenderer+ to guarantee that a
+  # `.html.inertia` template is never wrapped in a layout.
   #
-  # Because the props are already a plain Ruby Hash, +InertiaRails::Renderer+
-  # can walk them natively: shared data is merged in, Procs and prop objects
-  # (optional/always/defer/scroll) are resolved, and partial reloads are
-  # filtered at any nesting depth.
-  class Renderer
-    def initialize(view_context, props, component)
-      @view_context = view_context
-      @inertia_renderer = ::InertiaRails::Renderer.new(
-        component,
-        view_context.controller,
-        view_context.request,
-        view_context.response,
-        view_context.controller.method(:render),
-        props: props
-      )
-    end
-
-    def render
-      # `page` computes the full Inertia page hash (running PropsResolver)
-      # without triggering a controller render, so we can return the body
-      # ourselves from inside the template rendering pipeline.
-      page = @inertia_renderer.send(:page)
+  # 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
 
-      if @view_context.request.headers["X-Inertia"]
-        page.to_json
-      else
-        @view_context.controller.render_to_string(
-          template: "inertia",
-          layout: false,
-          locals: { page: page }
-        )
-      end
+    def render_template(view, template, layout_name, locals)
+      layout_name = nil if template.handler == InertiaJb::Handler
+      super
     end
   end
 end

data/lib/inertia_jb/version.rb

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

data/test/controller_test.rb

@@ -29,11 +29,18 @@ class TestController < ActionController::Base
   def special
     @id = 1
   end
+
+  # once (client-cached) + cache (server-cached).
+  def cached
+    @call_count = 0
+  end
 end
 
 class ControllerTest < ActionController::TestCase
   tests TestController
 
+  include ActiveSupport::Testing::TimeHelpers
+
   TEMPLATES = {
     "layouts/application.html.erb" => "<html><body><%= yield %></body></html>",
     "test/index.html.inertia"      => "{ content: 'content' }",
@@ -45,7 +52,10 @@ class ControllerTest < ActionController::TestCase
     "authors/_author.html.jb"  => "{ id: author[:id], name: author[:name] }",
     "comments/_comment.html.jb" => "{ body: comment[:body] }",
     "test/special.html.inertia" =>
-      "{ id: @id, stats: optional { { visits: 42 } }, feed: defer(group: :feed) { [1, 2, 3] } }"
+      "{ id: @id, stats: optional { { visits: 42 } }, feed: defer(group: :feed) { [1, 2, 3] } }",
+    "test/cached.html.inertia" =>
+      "{ flash: once { 'hello' }, " \
+      "report: cache('report', expires_in: 1.minute) { Time.current.to_f } }"
   }.freeze
 
   def setup
@@ -53,7 +63,7 @@ class ControllerTest < ActionController::TestCase
 
     @routes = ActionDispatch::Routing::RouteSet.new
     @routes.draw do
-      %i[index nested collection with_partial special].each do |action|
+      %i[index nested collection with_partial special cached].each do |action|
         get action.to_s => "test##{action}"
       end
     end
@@ -65,6 +75,7 @@ class ControllerTest < ActionController::TestCase
   def teardown
     super
     @routes.clear!
+    Rails.cache.clear
   end
 
   # ---- basic rendering -----------------------------------------------------
@@ -158,6 +169,50 @@ class ControllerTest < ActionController::TestCase
     assert_equal({ "feed" => ["feed"] }, page["deferredProps"])
   end
 
+  # ---- once props (client-cached) -----------------------------------------
+
+  def test_once_prop_included_on_first_visit
+    inertia_get :cached
+    page = JSON.parse(response.body)
+
+    assert_equal "hello", page.dig("props", "flash")
+    assert_equal({ "flash" => { "prop" => "flash" } }, page["onceProps"])
+  end
+
+  def test_once_prop_excluded_when_client_reports_it_cached
+    inertia_get :cached,
+                headers: {
+                  "X-Inertia-Partial-Component" => "test/cached",
+                  "X-Inertia-Except-Once-Props" => "flash"
+                }
+    page = JSON.parse(response.body)
+
+    refute page["props"].key?("flash"), "once prop should be absent when client reports it cached"
+  end
+
+  # ---- cached props (server-cached) ---------------------------------------
+
+  def test_cached_prop_serves_same_value_across_requests
+    inertia_get :cached
+    first = JSON.parse(response.body).dig("props", "report")
+
+    inertia_get :cached
+    second = JSON.parse(response.body).dig("props", "report")
+
+    assert_equal first, second, "cached prop should return the same value across requests"
+  end
+
+  def test_cached_prop_recomputes_after_expiry
+    inertia_get :cached
+    first = JSON.parse(response.body).dig("props", "report")
+
+    travel_to 2.minutes.from_now do
+      inertia_get :cached
+      second = JSON.parse(response.body).dig("props", "report")
+      refute_equal first, second, "cached prop should recompute after expiry"
+    end
+  end
+
   private
 
   def inertia_get(action, headers: {})

data/test/layout_suppression_test.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "action_view/testing/resolvers"
+
+# Regression test for the "phantom layout render" bug.
+#
+# 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.
+#
+# The controller here uses `layout "application"` but points Inertia at a
+# *different* shell (`config.layout = "inertia"`), so the two are easy to tell
+# apart in the instrumentation stream:
+#   * 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
+end
+
+class LayoutSuppressionTest < ActionController::TestCase
+  tests SuppressLayoutController
+
+  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 }"
+  }.freeze
+
+  def setup
+    super
+    @routes = ActionDispatch::Routing::RouteSet.new
+    @routes.draw { get "index" => "suppress_layout#index" }
+    @controller.prepend_view_path(ActionView::FixtureResolver.new(TEMPLATES))
+  end
+
+  def teardown
+    super
+    @routes.clear!
+  end
+
+  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") }
+    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, " \
+               "got #{page.payload[:layout].inspect}"
+  end
+
+  def test_controller_layout_is_never_rendered_for_an_inertia_page
+    layouts = capture("render_layout.action_view") { get :index }
+    identifiers = layouts.map { |e| e.payload[:identifier] }
+
+    assert identifiers.none? { |id| id.include?("layouts/application") },
+           "the controller layout must not be rendered for an Inertia page, saw #{identifiers.inspect}"
+    # Sanity check: the real Inertia shell (config.layout) still wraps the root.
+    assert identifiers.any? { |id| id.include?("layouts/inertia") },
+           "the Inertia shell layout should still wrap the data-page root, saw #{identifiers.inspect}"
+  end
+
+  def test_rendered_output_is_wrapped_only_by_the_inertia_shell
+    get :index
+
+    assert_response :success
+    assert_includes response.body, "data-inertia-shell"
+    assert_includes response.body, "data-page"
+    refute_includes response.body, "<html><body>"
+  end
+
+  private
+
+  # Collects the instrumentation events for `name` emitted while the block runs.
+  def capture(name)
+    events = []
+    subscriber = ActiveSupport::Notifications.subscribe(name) do |*args|
+      events << ActiveSupport::Notifications::Event.new(*args)
+    end
+    yield
+    events
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber)
+  end
+end

data/test/layout_test.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "action_view/testing/resolvers"
+require "json"
+
+# Controllers exercising inertia-rails' `config.layout` for initial page loads.
+# `config.layout` is scoped per controller class via `inertia_config`, so each
+# 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
+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
+end
+
+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 }",
+    "plain/index.html.erb"              => "plain-body-<%= 1 + 1 %>"
+  }.freeze
+
+  def setup
+    super
+    controller_path = @controller.class.controller_path
+    @routes = ActionDispatch::Routing::RouteSet.new
+    @routes.draw { get "index" => "#{controller_path}#index" }
+    @controller.prepend_view_path(ActionView::FixtureResolver.new(TEMPLATES))
+  end
+
+  def teardown
+    super
+    @routes.clear!
+  end
+end
+
+# config.layout = true (default): the controller's default layout wraps the root.
+class LayoutDefaultTest < ActionController::TestCase
+  include LayoutTestHelpers
+  tests LayoutDefaultController
+
+  def test_default_layout_wraps_the_data_page_root
+    get :index
+
+    assert_response :success
+    assert_includes response.body, "<html><body>"
+    assert_includes response.body, 'id="app"'
+    assert_includes response.body, "data-page"
+  end
+end
+
+# config.layout = false: no layout at all — just the bare `data-page` root.
+class LayoutFalseTest < ActionController::TestCase
+  include LayoutTestHelpers
+  tests LayoutFalseController
+
+  def test_disabled_layout_renders_bare_root
+    get :index
+
+    assert_response :success
+    assert_includes response.body, 'id="app"'
+    assert_includes response.body, "data-page"
+    refute_includes response.body, "<html><body>"
+    refute_includes response.body, "data-inertia-layout"
+  end
+
+  def test_xhr_still_returns_json_when_layout_disabled
+    @request.headers["X-Inertia"] = "true"
+    get :index
+
+    assert_equal "true", response.headers["X-Inertia"]
+    page = JSON.parse(response.body)
+    assert_equal true, page.dig("props", "ok")
+    refute_includes response.body, "data-page"
+  end
+end
+
+# config.layout = "inertia": the named layout wraps the root, not the
+# controller's own `layout "application"`.
+class LayoutNamedTest < ActionController::TestCase
+  include LayoutTestHelpers
+  tests LayoutNamedController
+
+  def test_named_layout_wraps_the_root
+    get :index
+
+    assert_response :success
+    assert_includes response.body, "data-inertia-layout"
+    assert_includes response.body, 'id="app"'
+    refute_includes response.body, "<html><body>"
+  end
+end
+
+# A non-Inertia `.html.erb` action must keep its layout even when the app set
+# `config.layout = false` for Inertia responses.
+class PlainHtmlLayoutTest < ActionController::TestCase
+  include LayoutTestHelpers
+  tests PlainController
+
+  def test_plain_html_action_is_unaffected_by_inertia_config_layout
+    get :index
+
+    assert_response :success
+    assert_includes response.body, "<html><body>"
+    assert_includes response.body, "plain-body-2"
+    refute_includes response.body, "data-page"
+  end
+end

data/test/test_helper.rb

@@ -6,6 +6,7 @@ require "action_controller/railtie"
 require "inertia_rails"
 require "inertia_jb"
 require "active_support/testing/autorun"
+require "active_support/testing/time_helpers"
 
 ActiveSupport.test_order = :random
 
@@ -14,6 +15,7 @@ ActiveSupport.test_order = :random
 Class.new(Rails::Application) do
   config.secret_key_base = "secret"
   config.eager_load = false
+  config.cache_store = :memory_store
 end.initialize!
 
 InertiaRails.configure do |c|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: inertia_jb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - kikyous
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-22 00:00:00.000000000 Z
+date: 2026-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: inertia_rails
@@ -85,6 +85,8 @@ files:
 - lib/inertia_jb/renderer.rb
 - lib/inertia_jb/version.rb
 - test/controller_test.rb
+- test/layout_suppression_test.rb
+- test/layout_test.rb
 - test/test_helper.rb
 homepage: https://github.com/kikyous/inertia_jb
 licenses:
@@ -115,4 +117,6 @@ summary: Declare Inertia.js props in Rails view templates with plain Ruby Hashes
   by jb)
 test_files:
 - test/controller_test.rb
+- test/layout_suppression_test.rb
+- test/layout_test.rb
 - test/test_helper.rb