inertia_jb 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c821eb8ccc74579d17f768744858bb9a14f7838201dd2ff89be61f8f70298780
-  data.tar.gz: 4e385aefbe3adcdcd6069b422382cd91cc7cbe208f2275230433110a761a4d3d
+  metadata.gz: 37e2ba2d8b4c896a4a4f7f006aa32cbee162cc7b798a77e78daab8a305512c65
+  data.tar.gz: 7d1f22f9ba1596965f7d8fc52c7ccc3f7f7aae78d3a1093464b77791ed858a27
 SHA512:
-  metadata.gz: fb985df39ed4ec250604244d93c968884b8d4a47588e031126d48f5b9489e5015192fc021de81c4b4e4d06018714065ed757046ec9728ed7804f930f073dd95e
-  data.tar.gz: d3e94480c54b50667a66c9416a59d6124e410b6d5da165e3344137128c9b2b88b111e07897ffccc0b56a915c955e060a0c103129813d476a99e085af337f2ccf
+  metadata.gz: 69f29e30c55a3efe39d54695948fec6de98ef96cf1a788dcb7806fb05186bc6e04f3f92cdb4ae5d175457489b042a1a3d5c8e692df2fdb07d7559d22f13edea3
+  data.tar.gz: c666ba929d8d67a7daaed36b39985ac9642b546d182dbccf30abc0281b5c115daef7f395157bbee6a0e35943c29cdb5b2ce84d07a528993d6ee528db0e269eea

data/README.md

@@ -90,7 +90,7 @@ 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:
+`InertiaRails::Renderer`'s own semantics.
 
 
 ## Templates and partials

data/lib/inertia_jb/helper.rb

@@ -4,49 +4,78 @@ module InertiaJb
   # Optional syntax sugar available inside `.html.inertia` templates, so you can
   # write `optional { ... }` instead of `InertiaRails.optional { ... }`.
   #
-  # These simply delegate to the +InertiaRails+ factory methods; the returned
-  # prop objects are resolved by +InertiaRails::PropsResolver+ when the page is
-  # built (respecting partial reloads, grouping, etc.).
+  # These delegate to the +InertiaRails+ factory methods; the returned prop
+  # objects are resolved by +InertiaRails::PropsResolver+ when the page is built
+  # (respecting partial reloads, grouping, etc.).
+  #
+  # Every block is bound to the current view with {InertiaJb.bind_to_view} so
+  # that a lazy prop's block runs in the *same* context an eager prop would —
+  # see that method for why this matters.
   module Helper
     # Only fetched when explicitly requested in a partial reload.
     def optional(&block)
-      ::InertiaRails.optional(&block)
+      ::InertiaRails.optional(&InertiaJb.bind_to_view(self, block))
     end
 
     # Always fetched, even when not requested in a partial reload.
     def always(&block)
-      ::InertiaRails.always(&block)
+      ::InertiaRails.always(&InertiaJb.bind_to_view(self, block))
     end
 
     # Excluded from the initial load; fetched in a follow-up request.
-    def defer(...)
-      ::InertiaRails.defer(...)
+    def defer(*args, **kwargs, &block)
+      ::InertiaRails.defer(*args, **kwargs, &InertiaJb.bind_to_view(self, block))
     end
 
     # Infinite-scroll prop (accepts a paginator or explicit metadata).
-    def scroll(...)
-      ::InertiaRails.scroll(...)
+    def scroll(*args, **kwargs, &block)
+      ::InertiaRails.scroll(*args, **kwargs, &InertiaJb.bind_to_view(self, block))
     end
 
     # Merged with existing client-side data instead of replacing it.
-    def merge(...)
-      ::InertiaRails.merge(...)
+    def merge(*args, **kwargs, &block)
+      ::InertiaRails.merge(*args, **kwargs, &InertiaJb.bind_to_view(self, block))
     end
 
     # Deep-merged with existing client-side data.
-    def deep_merge(...)
-      ::InertiaRails.deep_merge(...)
+    def deep_merge(*args, **kwargs, &block)
+      ::InertiaRails.deep_merge(*args, **kwargs, &InertiaJb.bind_to_view(self, block))
     end
 
     # Sent once and cached client-side; skipped on later visits unless reset or expired.
-    def once(...)
-      ::InertiaRails.once(...)
+    def once(*args, **kwargs, &block)
+      ::InertiaRails.once(*args, **kwargs, &InertiaJb.bind_to_view(self, block))
     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(...)
+    def cache(*args, **kwargs, &block)
+      ::InertiaRails.cache(*args, **kwargs, &InertiaJb.bind_to_view(self, block))
     end
   end
+
+  # Binds a lazy-prop block to the view that declared it, so the block evaluates
+  # in the same view context as an eager prop.
+  #
+  # Eager props are evaluated while the +.inertia+ template renders, so their
+  # +render(partial: ...)+ is the *view* helper — it returns jb data and never
+  # touches +response_body+. Lazy props (+defer+/+optional+/+always+/...) are
+  # different: inertia-rails resolves them later via
+  # +controller.instance_exec(&block)+, i.e. in *controller* context, where the
+  # same +render(partial: ...)+ binds to +ActionController+'s +render+ and
+  # assigns +response_body+. inertia-rails then performs its own
+  # +render(json:)+, and the already-set +response_body+ raises
+  # +AbstractController::DoubleRenderError+.
+  #
+  # Wrapping the block in +view.instance_exec+ keeps every block — eager or
+  # lazy — running against the view, so +render+ behaves identically everywhere.
+  # Controller-exposed helpers still work in the view (e.g. +policy_scope+,
+  # +current_user+ via Pundit/Devise +helper_method+s); the only controller-only
+  # call that does not carry over is +render_to_string+ — use +render(partial:,
+  # formats: [:html])+ instead, which returns the same String in a view.
+  def self.bind_to_view(view, block)
+    return block if block.nil?
+
+    proc { view.instance_exec(&block) }
+  end
 end

data/lib/inertia_jb/version.rb

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

data/test/controller_test.rb

@@ -34,6 +34,12 @@ class TestController < ActionController::Base
   def cached
     @call_count = 0
   end
+
+  # lazy props (defer/optional) whose block renders a jb partial.
+  def lazy_partial
+    @author = { id: 42, name: "John" }
+    @comments = [{ body: "first" }, { body: "second" }]
+  end
 end
 
 class ControllerTest < ActionController::TestCase
@@ -55,7 +61,13 @@ class ControllerTest < ActionController::TestCase
       "{ 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 } }"
+      "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" =>
+      "{ deferredAuthor: defer { render(partial: 'authors/author', object: @author) }, " \
+      "optionalComments: optional { render(partial: 'comments/comment', collection: @comments) } }"
   }.freeze
 
   def setup
@@ -63,7 +75,7 @@ class ControllerTest < ActionController::TestCase
 
     @routes = ActionDispatch::Routing::RouteSet.new
     @routes.draw do
-      %i[index nested collection with_partial special cached].each do |action|
+      %i[index nested collection with_partial special cached lazy_partial].each do |action|
         get action.to_s => "test##{action}"
       end
     end
@@ -190,6 +202,35 @@ class ControllerTest < ActionController::TestCase
     refute page["props"].key?("flash"), "once prop should be absent when client reports it cached"
   end
 
+  # ---- lazy props that render jb partials ---------------------------------
+
+  def test_deferred_prop_rendering_jb_partial_does_not_double_render
+    inertia_get :lazy_partial,
+                headers: {
+                  "X-Inertia-Partial-Component" => "test/lazy_partial",
+                  "X-Inertia-Partial-Data" => "deferredAuthor"
+                }
+
+    assert_response :success
+    page = JSON.parse(response.body)
+    assert_equal({ "id" => 42, "name" => "John" }, page.dig("props", "deferredAuthor"))
+  end
+
+  def test_optional_prop_rendering_jb_partial_does_not_double_render
+    inertia_get :lazy_partial,
+                headers: {
+                  "X-Inertia-Partial-Component" => "test/lazy_partial",
+                  "X-Inertia-Partial-Data" => "optionalComments"
+                }
+
+    assert_response :success
+    page = JSON.parse(response.body)
+    assert_equal(
+      [{ "body" => "first" }, { "body" => "second" }],
+      page.dig("props", "optionalComments")
+    )
+  end
+
   # ---- cached props (server-cached) ---------------------------------------
 
   def test_cached_prop_serves_same_value_across_requests

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: inertia_jb
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - kikyous
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-24 00:00:00.000000000 Z
+date: 2026-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: inertia_rails