sinatra-inertia 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e51ad95f421e2dc7d2eadc72b2c17b06377e2a72748a591e09d48106500786e
-  data.tar.gz: 3f110beacd7e7eb6778440a800e6f31768d0cb44ff75546607a94ee22c50e066
+  metadata.gz: d9172865c13484ad3352d36558c065514b1f3f175fd70ec8ce4f7cde77fbc3f8
+  data.tar.gz: f308c6741aed6cf48f7fc0588e7e0e11a7d5bad99b07000a20982fa01ee894b4
 SHA512:
-  metadata.gz: 3ab6eda91b4f83b63d90d3cd56281edb83222e99692396748544497dd5c4637aedaf8f557bf7777b3f03c743ab15c1ec483d50f8b88e415d15aef071aade9a47
-  data.tar.gz: 4d1b984e23f72254fad4e1a6da82498cb35ca8f26f5270c5ab1ddaa4149118926a1c9a00ce5c7c061318e9d9da7693d412b50c4952432ba9d909a82394376914
+  metadata.gz: 0c4c38a5f2a2a2f16b5f3d449d442a7bd378fb491ae078c67a71543c6501e4412b93fc85751d54a0da0dd907d5f66340602aeef51a0899a990de921c495a5e28
+  data.tar.gz: 73fabe7fc1fb6191b1c454785b5450f2889e784ea12890587d203e7ccf216ca1143f51241ab06ea7eff6347bd83fb0c7b5066fb0b95e4ac413af55f0b8cc77ab

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.1.5 — 2026-06-25
+
+- Extract the Ruby-way Kagero layer into the separate `sinatra-kagero` gem.
+- Keep `sinatra-inertia` focused on the Inertia v2 wire protocol.
+- Remove Phlex and Literal from the `sinatra-inertia` runtime dependency surface.
+
+## 0.1.4 — 2026-05-03
+
+- Add the recommended Sinatra-native page API: `render 'Component', props`,
+  `share_props`, `set :page_version`, `set :page_layout`, and route helpers
+  `defer`, `always`, `optional`, `lazy`, `merge`, `page_errors`,
+  `clear_history!`, and `encrypt_history!`.
+- Keep existing `inertia_*` helpers/settings and `Inertia.*` prop wrappers
+  working for compatibility.
+
 ## 0.1.3 — 2026-04-29
 
 - `lib/sinatra/inertia/async_sources.rb` registers under

data/README.md

@@ -2,8 +2,8 @@
 
 A Sinatra extension that implements the full **Inertia.js v2** wire protocol —
 page-object responses, version-mismatch detection, partial reloads,
-deferred / lazy / always / optional / merge / once props, encrypted history,
-303 redirect promotion, and error/flash session sweeps.
+deferred / lazy / always / optional / merge props, encrypted history, 303
+redirect promotion, and error/flash session sweeps.
 
 Pure Sinatra-compatible: depends only on `sinatra` and `rack`. Runs on
 MRI Ruby and on the [homura](https://github.com/kazuph/homura) Cloudflare
@@ -13,11 +13,12 @@ Workers + Opal stack.
 
 Two principles drove the API:
 
-1. **Sinatra慣習に乗る.** Rendering a page is `inertia 'Component', props: {...}` —
-   the same shape as Sinatra's `erb :index`. A `render inertia: 'Component'`
-   alias is also provided for Rails refugees.
-2. **Class-level config uses `set` and `inertia_share do ... end`,**
-   matching Sinatra's existing DSL surface (`set :views`, `helpers do … end`).
+1. **Routes render pages.** Application code should read like ordinary
+   Sinatra: `render 'Pages/Show', record: record`. The Inertia protocol stays
+   in the extension.
+2. **Class-level config uses Sinatra nouns.** Use `set :page_version`,
+   `set :page_layout`, and `share_props do ... end`. The older `inertia_*`
+   names still work for existing apps.
 
 ## Installation
 
@@ -33,10 +34,12 @@ gem 'sinatra-inertia'
 require 'sinatra'
 require 'sinatra/inertia'
 
-set :inertia_version, -> { ENV.fetch('ASSETS_VERSION', '1') }
+register Sinatra::Inertia
+
+set :page_version, -> { ENV.fetch('ASSETS_VERSION', '1') }
 
 get '/' do
-  inertia 'Pages/Hello', props: { name: 'world' }
+  render 'Pages/Hello', name: 'world'
 end
 ```
 
@@ -61,42 +64,49 @@ end
 
 | helper | purpose |
 |---|---|
-| `inertia(component, props:, layout:)` | Render an Inertia response (HTML on first hit, JSON on Inertia visit). |
-| `render(inertia: 'Comp', props: {...})` | Rails-style alias for the above. |
-| `inertia_request?` | True when `X-Inertia: true` header is present. |
-| `inertia_errors(payload = nil)` | Read or write validation errors that survive one redirect. |
-| `inertia_clear_history!` | Mark the next response's history as cleared. |
-| `inertia_encrypt_history!` | Mark the next response's history as encrypted. |
+| `render 'Comp', props_hash` | Render an Inertia response (HTML on first hit, JSON on Inertia visit). |
+| `render 'Comp', key: value` | Keyword-prop form of the same page render. |
+| `page_request?` | True when `X-Inertia: true` header is present. |
+| `page_errors(payload = nil)` | Read or write validation errors that survive one redirect. |
+| `clear_history!` | Mark the next response's history as cleared. |
+| `encrypt_history!` | Mark the next response's history as encrypted. |
+| `always`, `defer`, `optional`, `lazy`, `merge` | Prop wrappers for Inertia v2 transport modes. |
+
+Compatibility aliases remain available: `inertia`, `render(inertia: ...)`,
+`inertia_request?`, `inertia_errors`, `inertia_clear_history!`,
+`inertia_encrypt_history!`, and `Inertia.defer` / `Inertia.merge` / etc.
 
 ### Class-level DSL
 
 | DSL | purpose |
 |---|---|
-| `set :inertia_version, -> { ... }` | Asset version. Mismatch on Inertia GET → 409 + `X-Inertia-Location`. |
-| `set :inertia_layout, :layout` | ERB layout used for full-page rendering (default `:layout`). |
+| `set :page_version, -> { ... }` | Asset version. Mismatch on Inertia GET → 409 + `X-Inertia-Location`. |
+| `set :page_layout, :layout` | ERB layout used for full-page rendering (default `:layout`). |
 | `set :inertia_encrypt_history, true` | Default `encryptHistory: true` on every page. |
-| `inertia_share do … end` | Block whose return Hash is merged into every page's props. |
+| `share_props do … end` | Block whose return Hash is merged into every page's props. |
+
+Compatibility aliases remain available: `set :inertia_version`,
+`set :inertia_layout`, and `inertia_share do ... end`.
 
 ### Prop wrappers (Inertia v2 transport modes)
 
 ```ruby
-inertia 'Page', props: {
+render 'Page',
   todos:  -> { Todo.all },                        # plain lazy
-  csrf:   Inertia.always { csrf_token },          # always sent
-  stats:  Inertia.defer(group: 'meta') { stats }, # excluded from initial response
-  filter: Inertia.optional { params[:f] },        # only on partial-reload request
-  feed:   Inertia.merge(page_items)               # client-side array merge
-}
+  csrf:   always { csrf_token },                  # always sent
+  stats:  defer(group: 'meta') { stats },         # excluded from initial response
+  filter: optional { params[:f] },                # only on partial-reload request
+  feed:   merge(page_items)                       # client-side array merge
 ```
 
 | wrapper | semantics |
 |---|---|
 | bare `Proc`/`->` | resolved every request when included; partial-reload aware. |
-| `Inertia.always { … }` | always included, even on partials that omit it. |
-| `Inertia.defer(group:) { … }` | excluded on initial visit; client refetches in second roundtrip. |
-| `Inertia.optional { … }` | only resolved when explicitly requested via `X-Inertia-Partial-Data`. |
-| `Inertia.lazy { … }` | alias of `optional` (Inertia v1 name). |
-| `Inertia.merge(value)` | sent as a merge prop (`mergeProps` array on page object). Honours `X-Inertia-Reset: prop1,prop2` (Inertia 2.0) — reset props are emitted as plain values and dropped from `mergeProps`. |
+| `always { … }` | always included, even on partials that omit it. |
+| `defer(group:) { … }` | excluded on initial visit; client refetches in second roundtrip. |
+| `optional { … }` | only resolved when explicitly requested via `X-Inertia-Partial-Data`. |
+| `lazy { … }` | alias of `optional` (Inertia v1 name). |
+| `merge(value)` | sent as a merge prop (`mergeProps` array on page object). Honours `X-Inertia-Reset: prop1,prop2` (Inertia 2.0) — reset props are emitted as plain values and dropped from `mergeProps`. |
 
 ## Protocol features
 
@@ -110,9 +120,9 @@ inertia 'Page', props: {
   303 so the browser follows with GET.
 * **Partial reloads** — `X-Inertia-Partial-Component` + `X-Inertia-Partial-Data`
   / `X-Inertia-Partial-Except` headers narrow which props are resolved.
-* **Encrypted history / clear history** — set per-app via setting or
-  per-route via `inertia_encrypt_history!` / `inertia_clear_history!`.
-* **Errors session** — `inertia_errors(field: 'msg')` survives one redirect
+* **Encrypted history / clear history** — set per-app via setting or per-route
+  via `encrypt_history!` / `clear_history!`.
+* **Errors session** — `page_errors(field: 'msg')` survives one redirect
   and is automatically swept on render.
 
 ## Validation pattern (no 422, no client state)
@@ -120,7 +130,7 @@ inertia 'Page', props: {
 ```ruby
 post '/todos' do
   if params[:title].to_s.strip.empty?
-    inertia_errors title: "can't be blank"
+    page_errors title: "can't be blank"
     redirect back  # 303 by middleware; Inertia client follows
   else
     Todo.create(params)
@@ -129,10 +139,9 @@ post '/todos' do
 end
 
 get '/' do
-  inertia 'Todos/Index', props: {
+  render 'Todos/Index',
     todos: Todo.all,
     values: { title: params[:title] }
-  }
 end
 ```
 

data/lib/sinatra/inertia/async_sources.rb

@@ -12,7 +12,7 @@
 
 if defined?(::HomuraRuntime) && defined?(::HomuraRuntime::AsyncRegistry)
   ::HomuraRuntime::AsyncRegistry.register_async_source do
-    async_method 'Sinatra::Inertia::Response', :to_h
-    async_method 'Sinatra::Inertia::Response', :to_json
+    async_method("Sinatra::Inertia::Response", :to_h)
+    async_method("Sinatra::Inertia::Response", :to_json)
   end
 end

data/lib/sinatra/inertia/csrf_middleware.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'securerandom'
-require 'rack/utils'
+require "securerandom"
+require "rack/utils"
 
 module Sinatra
   module Inertia
@@ -36,9 +36,9 @@ module Sinatra
     # this only when the consumer ships its own CSRF defence. Safer
     # defaults assume the gem is responsible.
     class CSRFMiddleware
-      COOKIE_NAME = 'XSRF-TOKEN'
-      HEADER_KEY = 'HTTP_X_XSRF_TOKEN'
-      ENV_TOKEN_KEY = 'sinatra.inertia.csrf_token'
+      COOKIE_NAME = "XSRF-TOKEN"
+      HEADER_KEY = "HTTP_X_XSRF_TOKEN"
+      ENV_TOKEN_KEY = "sinatra.inertia.csrf_token"
       SAFE_METHODS = %w[GET HEAD OPTIONS].freeze
 
       def initialize(app, same_site: :Lax)
@@ -54,31 +54,34 @@ module Sinatra
         unless safe_method?(env)
           header = env[HEADER_KEY].to_s
           if existing.nil? || header.empty? || !secure_compare(header, existing)
-            return forbidden('CSRF token mismatch (expected matching X-XSRF-TOKEN header to XSRF-TOKEN cookie)')
+            return (forbidden(
+              "CSRF token mismatch (expected matching X-XSRF-TOKEN header to XSRF-TOKEN cookie)"
+            ))
           end
         end
 
         status, headers, body = @app.call(env)
-        unless existing == token
-          set_cookie!(headers, token)
-        end
+        set_cookie!(headers, token) unless existing == token
         [status, headers, body]
       end
 
       private
 
       def safe_method?(env)
-        SAFE_METHODS.include?(env['REQUEST_METHOD'])
+        SAFE_METHODS.include?(env["REQUEST_METHOD"])
       end
 
       def read_cookie(env)
-        cookie_header = env['HTTP_COOKIE'].to_s
+        cookie_header = env["HTTP_COOKIE"].to_s
         return nil if cookie_header.empty?
-        cookie_header.split(/;\s*/).each do |pair|
-          name, value = pair.split('=', 2)
-          next unless name == COOKIE_NAME
-          return value
-        end
+        cookie_header
+          .split(/;\s*/)
+          .each do |pair|
+            name, value = pair.split("=", 2)
+            next unless name == COOKIE_NAME
+            return value
+          end
+
         nil
       end
 
@@ -99,26 +102,34 @@ module Sinatra
 
       def set_cookie!(headers, token)
         attrs = "#{COOKIE_NAME}=#{token}; Path=/; SameSite=#{@same_site}"
-        existing = headers['Set-Cookie']
+        existing = headers["Set-Cookie"]
         # Normalise to a newline-joined String regardless of Rack 2/3
         # conventions or downstream worker-runtime quirks. The Cloudflare
         # Workers adapter that homura ships with serialises Array-shaped
         # `Set-Cookie` headers as a literal JSON array, which breaks
         # cookie parsing on the client.
         prev = case existing
-               when nil, '' then nil
-               when Array then existing.join("\n")
-               else existing.to_s
-               end
-        headers['Set-Cookie'] = prev ? "#{prev}\n#{attrs}" : attrs
+        when nil, ""
+          nil
+        when Array
+          existing.join("\n")
+        else
+          existing.to_s
+        end
+
+        headers["Set-Cookie"] = prev ? "#{prev}\n#{attrs}" : attrs
       end
 
       def forbidden(message)
         body = "#{message}\n"
-        [403, {
-          'Content-Type' => 'text/plain; charset=utf-8',
-          'Content-Length' => body.bytesize.to_s
-        }, [body]]
+        [
+          403,
+          {
+            "Content-Type" => "text/plain; charset=utf-8",
+            "Content-Length" => body.bytesize.to_s
+          },
+          [body]
+        ]
       end
     end
   end

data/lib/sinatra/inertia/deferred.rb

@@ -13,13 +13,12 @@ module Sinatra
     #     stats:  Inertia.defer { compute_stats } # excluded from initial response, fetched in 2nd request
     #     csrf:   Inertia.always { csrf_token }   # included even on partial reloads that omit it
     #     filter: Inertia.optional { params[:f] } # only included when explicitly requested via partial
-    #     feed:   Inertia.merge(page_items)       # array merged with existing client-side feed
-    #     once:   Inertia.once { current_time }   # delivered exactly once; subsequent visits suppress
+    #     feed:   merge(page_items)               # array merged with existing client-side feed
     #   }
     class Prop
       attr_reader :block, :value, :group
 
-      def initialize(block: nil, value: nil, group: 'default')
+      def initialize(block: nil, value: nil, group: "default")
         @block = block
         @value = value
         @group = group
@@ -44,9 +43,6 @@ module Sinatra
       # Should arrays returned by this prop be merged with the client's
       # existing array (Inertia 2 merge semantics)?
       def merge? = false
-
-      # Once-only delivery (cleared from session/state after first emission).
-      def once? = false
     end
 
     class AlwaysProp < Prop
@@ -74,7 +70,7 @@ module Sinatra
     module_function
 
     def always(value = nil, &block) = AlwaysProp.new(block: block, value: value)
-    def defer(group: 'default', &block) = DeferredProp.new(block: block, group: group)
+    def defer(group: "default", &block) = DeferredProp.new(block: block, group: group)
     def optional(&block) = OptionalProp.new(block: block)
     def lazy(&block) = LazyProp.new(block: block)
     def merge(value = nil, &block) = MergeProp.new(block: block, value: value)

data/lib/sinatra/inertia/helpers.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require 'json'
-require_relative 'response'
+require "json"
+
+require_relative "response"
 
 module Sinatra
   module Inertia
@@ -10,7 +11,7 @@ module Sinatra
     module Helpers
       # Render an Inertia response.
       #
-      #   inertia 'Todos/Index', props: { todos: -> { Todo.all } }
+      #   render 'Todos/Index', todos: -> { Todo.all }
       #
       # Layout selection: the configured layout (default `:layout`) is
       # rendered for full HTML responses. The view receives `@page_json`
@@ -18,17 +19,18 @@ module Sinatra
       # attribute) and `@page` (the underlying Hash, useful for SSR or
       # custom rendering).
       def inertia(component, props: {}, layout: nil)
-        layout = settings.respond_to?(:inertia_layout) ? settings.inertia_layout : :layout if layout.nil?
+        layout = current_page_layout if layout.nil?
 
         version = current_inertia_version
         shared = current_inertia_shared
         encrypt = if !@inertia_encrypt_history_override.nil?
-                    @inertia_encrypt_history_override == true
-                  elsif settings.respond_to?(:inertia_encrypt_history)
-                    settings.inertia_encrypt_history == true
-                  else
-                    false
-                  end
+          @inertia_encrypt_history_override == true
+        elsif settings.respond_to?(:inertia_encrypt_history)
+          settings.inertia_encrypt_history == true
+        else
+          false
+        end
+
         clear = @inertia_clear_history == true
 
         # Set the protocol response headers BEFORE we touch any async
@@ -40,8 +42,8 @@ module Sinatra
         # regardless of how the underlying runtime schedules the
         # awaited continuation.
         if inertia_request?
-          content_type 'application/json; charset=utf-8'
-          headers 'X-Inertia' => 'true', 'Vary' => 'X-Inertia'
+          content_type("application/json; charset=utf-8")
+          headers("X-Inertia" => "true", "Vary" => "X-Inertia")
         end
 
         # Read errors *before* sweeping so the response carries them, then
@@ -69,25 +71,49 @@ module Sinatra
 
         @page = page_hash
         @page_json = ::Rack::Utils.escape_html(page_json)
-        erb layout, layout: false
+        erb(layout, layout: false)
       end
 
-      # Rails-flavored alias: `render inertia: 'Component', props: {...}`
+      # Natural page-rendering API: `render 'Component', props_hash`.
+      # `render inertia: 'Component', props: {...}` remains available for
+      # existing apps, while non-page render calls still delegate to Sinatra.
       # We must preserve Sinatra's `render(engine, data = nil, options = {}, locals = {}, &block)`
       # signature for the non-inertia path, so we forward *args/**kwargs.
       def render(*args, **kwargs, &block)
         first = args.first
         if args.length == 1 && first.is_a?(Hash) && first.key?(:inertia)
-          inertia(first[:inertia], props: first[:props] || {}, layout: first[:layout])
+          inertia(
+            first[:inertia],
+            props: first[:props] || {},
+            layout: first[:layout]
+          )
         elsif kwargs.key?(:inertia) && args.empty?
-          inertia(kwargs[:inertia], props: kwargs[:props] || {}, layout: kwargs[:layout])
+          inertia(
+            kwargs[:inertia],
+            props: kwargs[:props] || {},
+            layout: kwargs[:layout]
+          )
+        elsif first.is_a?(String) &&
+            args.length <= 2 &&
+            (args.length == 1 || args[1].is_a?(Hash))
+          layout = kwargs.delete(:layout)
+          props = {}
+          props.merge!(args[1]) if args[1].is_a?(Hash)
+          explicit_props = kwargs.delete(:props)
+          props.merge!(explicit_props) if explicit_props.is_a?(Hash)
+          props.merge!(kwargs)
+          inertia(first, props: props, layout: layout)
         else
           super(*args, **kwargs, &block)
         end
       end
 
       def inertia_request?
-        request.env['HTTP_X_INERTIA'] == 'true'
+        request.env["HTTP_X_INERTIA"] == "true"
+      end
+
+      def page_request?
+        inertia_request?
       end
 
       # CSRF token for the current request. Mounted by CSRFMiddleware
@@ -98,7 +124,27 @@ module Sinatra
       # exchange is already handled by the Inertia client; this helper is
       # mainly for hidden-field forms or non-XHR submissions.
       def csrf_token
-        request.env['sinatra.inertia.csrf_token']
+        request.env["sinatra.inertia.csrf_token"]
+      end
+
+      def always(value = nil, &block)
+        Sinatra::Inertia.always(value, &block)
+      end
+
+      def defer(group: "default", &block)
+        Sinatra::Inertia.defer(group: group, &block)
+      end
+
+      def optional(&block)
+        Sinatra::Inertia.optional(&block)
+      end
+
+      def lazy(&block)
+        Sinatra::Inertia.lazy(&block)
+      end
+
+      def merge(value = nil, &block)
+        Sinatra::Inertia.merge(value, &block)
       end
 
       # ------------------------------------------------------------------
@@ -109,17 +155,21 @@ module Sinatra
         merged = {}
         blocks.each do |b|
           v = instance_exec(&b)
-          if v.is_a?(Hash)
-            merged = deep_merge(merged, v)
-          end
+          merged = deep_merge(merged, v) if v.is_a?(Hash)
         end
+
         merged
       end
 
       # ------------------------------------------------------------------
       # Asset version
       def current_inertia_version
-        v = settings.respond_to?(:inertia_version) ? settings.inertia_version : nil
+        v = if settings.respond_to?(:page_version)
+          settings.page_version
+        elsif settings.respond_to?(:inertia_version)
+          settings.inertia_version
+        end
+
         v.respond_to?(:call) ? v.call.to_s : v.to_s
       end
 
@@ -137,14 +187,26 @@ module Sinatra
         end
       end
 
+      def page_errors(payload = nil)
+        inertia_errors(payload)
+      end
+
       def inertia_clear_history!
         @inertia_clear_history = true
       end
 
+      def clear_history!
+        inertia_clear_history!
+      end
+
       def inertia_encrypt_history!(flag = true)
         @inertia_encrypt_history_override = flag
       end
 
+      def encrypt_history!(flag = true)
+        inertia_encrypt_history!(flag)
+      end
+
       def inertia_errors_payload
         errors = session[:_inertia_errors]
         return nil if errors.nil?
@@ -160,13 +222,21 @@ module Sinatra
         # assigning nil instead, which the JSON encoder still emits as
         # `null` and makes `inertia_errors_payload` treat the field as
         # absent on the next visit.
-        if session.respond_to?(:[]=)
-          session[:_inertia_errors] = nil
-        end
+        session[:_inertia_errors] = nil if session.respond_to?(:[]=)
       end
 
       private
 
+      def current_page_layout
+        if settings.respond_to?(:page_layout)
+          settings.page_layout
+        elsif settings.respond_to?(:inertia_layout)
+          settings.inertia_layout
+        else
+          :layout
+        end
+      end
+
       def deep_merge(a, b)
         a.merge(b) do |_k, av, bv|
           (av.is_a?(Hash) && bv.is_a?(Hash)) ? deep_merge(av, bv) : bv

data/lib/sinatra/inertia/middleware.rb

@@ -19,8 +19,8 @@ module Sinatra
     # The middleware is `register`-ed automatically by `Sinatra::Inertia`
     # via `app.use`, so consumer apps don't need to wire it manually.
     class Middleware
-      INERTIA_HEADER = 'HTTP_X_INERTIA'
-      INERTIA_VERSION_HEADER = 'HTTP_X_INERTIA_VERSION'
+      INERTIA_HEADER = "HTTP_X_INERTIA"
+      INERTIA_VERSION_HEADER = "HTTP_X_INERTIA_VERSION"
 
       def initialize(app, version:)
         @app = app
@@ -29,10 +29,10 @@ module Sinatra
 
       def call(env)
         if inertia_get?(env) && version_mismatch?(env)
-          location = env['REQUEST_URI'] || build_url(env)
+          location = env["REQUEST_URI"] || build_url(env)
           return [
             409,
-            { 'X-Inertia-Location' => location, 'Vary' => 'X-Inertia' },
+            {"X-Inertia-Location" => location, "Vary" => "X-Inertia"},
             []
           ]
         end
@@ -44,8 +44,9 @@ module Sinatra
         # requests: a Sinatra app may serve plain REST endpoints alongside
         # Inertia pages, and rewriting their 302s would silently change
         # HTTP semantics for non-Inertia clients.
-        if status == 302 && env[INERTIA_HEADER] == 'true' &&
-           %w[POST PUT PATCH DELETE].include?(env['REQUEST_METHOD'])
+        if status == 302 &&
+            env[INERTIA_HEADER] == "true" &&
+            %w[POST PUT PATCH DELETE].include?(env["REQUEST_METHOD"])
           status = 303
         end
 
@@ -55,7 +56,7 @@ module Sinatra
       private
 
       def inertia_get?(env)
-        env[INERTIA_HEADER] == 'true' && env['REQUEST_METHOD'] == 'GET'
+        env[INERTIA_HEADER] == "true" && env["REQUEST_METHOD"] == "GET"
       end
 
       def version_mismatch?(env)
@@ -70,10 +71,10 @@ module Sinatra
       end
 
       def build_url(env)
-        scheme = env['rack.url_scheme'] || 'http'
-        host = env['HTTP_HOST'] || env['SERVER_NAME']
-        path = env['PATH_INFO']
-        qs = env['QUERY_STRING']
+        scheme = env["rack.url_scheme"] || "http"
+        host = env["HTTP_HOST"] || env["SERVER_NAME"]
+        path = env["PATH_INFO"]
+        qs = env["QUERY_STRING"]
         full = +"#{scheme}://#{host}#{path}"
         full << "?#{qs}" if qs && !qs.empty?
         full

data/lib/sinatra/inertia/response.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'deferred'
+require_relative "deferred"
 
 module Sinatra
   module Inertia
@@ -12,12 +12,29 @@ module Sinatra
     # responses, or interpolated into the layout's `data-page` attribute
     # for full HTML responses.
     class Response
-      attr_reader :component, :props, :request, :version, :url,
-                  :encrypt_history, :clear_history, :shared, :errors
-
-      def initialize(component:, props:, request:, version:, url: nil,
-                     encrypt_history: false, clear_history: false,
-                     shared: {}, errors: nil)
+      attr_reader(
+        :component,
+        :props,
+        :request,
+        :version,
+        :url,
+        :encrypt_history,
+        :clear_history,
+        :shared,
+        :errors
+      )
+
+      def initialize(
+        component:,
+        props:,
+        request:,
+        version:,
+        url: nil,
+        encrypt_history: false,
+        clear_history: false,
+        shared: {},
+        errors: nil
+      )
         @component = component
         @props = props || {}
         @request = request
@@ -64,6 +81,7 @@ module Sinatra
           elsif value.is_a?(Prop) && value.deferred?
             (deferred_groups[value.group] ||= []) << k.to_s
           end
+
           i += 1
         end
 
@@ -85,19 +103,19 @@ module Sinatra
       private
 
       def partial_request?
-        request.env['HTTP_X_INERTIA_PARTIAL_COMPONENT'] == component
+        request.env["HTTP_X_INERTIA_PARTIAL_COMPONENT"] == component
       end
 
       def partial_data_keys
-        raw = request.env['HTTP_X_INERTIA_PARTIAL_DATA'].to_s
+        raw = request.env["HTTP_X_INERTIA_PARTIAL_DATA"].to_s
         return nil if raw.empty?
-        raw.split(',').map(&:strip).reject(&:empty?).map(&:to_sym)
+        raw.split(",").map(&:strip).reject(&:empty?).map(&:to_sym)
       end
 
       def partial_except_keys
-        raw = request.env['HTTP_X_INERTIA_PARTIAL_EXCEPT'].to_s
+        raw = request.env["HTTP_X_INERTIA_PARTIAL_EXCEPT"].to_s
         return nil if raw.empty?
-        raw.split(',').map(&:strip).reject(&:empty?).map(&:to_sym)
+        raw.split(",").map(&:strip).reject(&:empty?).map(&:to_sym)
       end
 
       # Inertia 2.0: `X-Inertia-Reset: a,b` tells the server "the client
@@ -106,29 +124,30 @@ module Sinatra
       # outbound `mergeProps` array — the value itself is still resolved
       # and emitted, so the client just doesn't accumulate it.
       def reset_keys
-        raw = request.env['HTTP_X_INERTIA_RESET'].to_s
+        raw = request.env["HTTP_X_INERTIA_RESET"].to_s
         return [] if raw.empty?
-        raw.split(',').map(&:strip).reject(&:empty?).map(&:to_sym)
+        raw.split(",").map(&:strip).reject(&:empty?).map(&:to_sym)
       end
 
       # Returns [included?, resolved_value]
       def decide(value, key, partial, partial_data, partial_except)
         if value.is_a?(Prop)
           if value.always?
-            return [true, value.resolve]
+            return true, value.resolve
           elsif value.deferred?
-            return [false, nil] unless partial && partial_data&.include?(key)
-            return [true, value.resolve]
+            return false, nil unless partial && partial_data&.include?(key)
+            return true, value.resolve
           elsif value.optional?
-            return [false, nil] unless partial && partial_data&.include?(key)
-            return [true, value.resolve]
+            return false, nil unless partial && partial_data&.include?(key)
+            return true, value.resolve
           else
             # merge / once / plain Prop
             if partial
-              return [false, nil] if partial_data && !partial_data.include?(key)
-              return [false, nil] if partial_except&.include?(key)
+              return false, nil if partial_data && !partial_data.include?(key)
+              return false, nil if partial_except&.include?(key)
             end
-            return [true, value.resolve]
+
+            return true, value.resolve
           end
         end
 
@@ -136,17 +155,19 @@ module Sinatra
           # A bare Proc/Lambda is treated as plain lazy: resolved every
           # request, but only when included.
           if partial
-            return [false, nil] if partial_data && !partial_data.include?(key)
-            return [false, nil] if partial_except&.include?(key)
+            return false, nil if partial_data && !partial_data.include?(key)
+            return false, nil if partial_except&.include?(key)
           end
-          return [true, value.call]
+
+          return true, value.call
         end
 
         # Plain value
         if partial
-          return [false, nil] if partial_data && !partial_data.include?(key)
-          return [false, nil] if partial_except&.include?(key)
+          return false, nil if partial_data && !partial_data.include?(key)
+          return false, nil if partial_except&.include?(key)
         end
+
         [true, value]
       end
 
@@ -167,7 +188,9 @@ module Sinatra
       # via `.__await__`. On MRI this branch is dead code (no Cloudflare
       # constant, no js_promise?), so plain Ruby tests are unaffected.
       def await_if_promise(value)
-        if defined?(::Cloudflare) && ::Cloudflare.respond_to?(:js_promise?) && ::Cloudflare.js_promise?(value)
+        if defined?(::Cloudflare) &&
+            ::Cloudflare.respond_to?(:js_promise?) &&
+            ::Cloudflare.js_promise?(value)
           value.__await__
         else
           value

data/lib/sinatra/inertia/version.rb

@@ -2,6 +2,6 @@
 
 module Sinatra
   module Inertia
-    VERSION = '0.1.3'
+    VERSION = "0.1.5"
   end
 end

data/lib/sinatra/inertia.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
 
-require 'sinatra/base'
-require_relative 'inertia/version'
-require_relative 'inertia/errors'
-require_relative 'inertia/deferred'
-require_relative 'inertia/response'
-require_relative 'inertia/middleware'
-require_relative 'inertia/csrf_middleware'
-require_relative 'inertia/helpers'
-require_relative 'inertia/async_sources'
+require "sinatra/base"
+
+require_relative "inertia/version"
+require_relative "inertia/errors"
+require_relative "inertia/deferred"
+require_relative "inertia/response"
+require_relative "inertia/middleware"
+require_relative "inertia/csrf_middleware"
+require_relative "inertia/helpers"
+require_relative "inertia/async_sources"
 
 module Sinatra
   # Inertia.js v2 protocol adapter for Sinatra.
@@ -16,47 +17,69 @@ module Sinatra
   #   class App < Sinatra::Base
   #     register Sinatra::Inertia
   #
-  #     set :inertia_version, -> { ASSETS_VERSION }
-  #     set :inertia_layout,  :layout
+  #     set :page_version, -> { ASSETS_VERSION }
+  #     set :page_layout,  :layout
   #
-  #     inertia_share do
+  #     share_props do
   #       { auth: { user: current_user }, flash: flash_payload }
   #     end
   #
   #     get '/' do
-  #       inertia 'Todos/Index', props: { todos: -> { Todo.all } }
+  #       render 'Todos/Index', todos: -> { Todo.all }
   #     end
   #   end
   #
   # See README.md for the full feature matrix.
   module Inertia
     def self.registered(app)
-      # Default settings — consumers override with `set :inertia_*` in app.
-      app.set :inertia_version, '1' unless app.respond_to?(:inertia_version)
-      app.set :inertia_layout,  :layout unless app.respond_to?(:inertia_layout)
-      app.set :inertia_encrypt_history, false unless app.respond_to?(:inertia_encrypt_history)
-      app.set :inertia_csrf_protection, true unless app.respond_to?(:inertia_csrf_protection)
-      app.set :inertia_share_blocks, []
+      # Default settings. `page_*` is the recommended application-facing API;
+      # `inertia_*` remains supported for existing apps and lower-level tuning.
+      app.set(:inertia_version, "1") unless app.respond_to?(:inertia_version)
+      app.set(:inertia_layout, :layout) unless app.respond_to?(:inertia_layout)
+      unless app.respond_to?(:inertia_encrypt_history)
+        app.set(:inertia_encrypt_history, false)
+      end
+
+      unless app.respond_to?(:inertia_csrf_protection)
+        app.set(:inertia_csrf_protection, true)
+      end
+
+      app.set(:inertia_share_blocks, [])
 
       # Mount CSRF middleware (double-submit XSRF-TOKEN cookie that
       # @inertiajs/* clients honour). Opt-out via
       # `set :inertia_csrf_protection, false` when the consumer ships
       # its own (e.g. Rack::Protection::AuthenticityToken).
       if app.settings.inertia_csrf_protection
-        app.use Sinatra::Inertia::CSRFMiddleware
+        app.use(Sinatra::Inertia::CSRFMiddleware)
       end
 
       # Mount protocol middleware (version mismatch + 303 redirect promotion).
-      app.use Sinatra::Inertia::Middleware, version: -> { app.settings.inertia_version }
+      app.use(
+        Sinatra::Inertia::Middleware,
+        version: lambda {
+          version = if app.settings.respond_to?(:page_version)
+            app.settings.page_version
+          else
+            app.settings.inertia_version
+          end
 
-      # Class-level DSL: `inertia_share { ... }` registers a block whose
-      # return value is merged into every page's `props.shared` payload.
+          version.respond_to?(:call) ? version.call.to_s : version.to_s
+        }
+      )
+
+      # Class-level DSL: `share_props { ... }` registers a block whose return
+      # value is merged into every page's props.
       app.define_singleton_method(:inertia_share) do |&block|
-        raise ArgumentError, 'inertia_share requires a block' unless block
+        raise ArgumentError, "inertia_share requires a block" unless block
         settings.inertia_share_blocks = settings.inertia_share_blocks + [block]
       end
 
-      app.helpers Sinatra::Inertia::Helpers
+      app.define_singleton_method(:share_props) do |&block|
+        inertia_share(&block)
+      end
+
+      app.helpers(Sinatra::Inertia::Helpers)
     end
 
     # Convenience module-level constructors so code can write
@@ -72,4 +95,3 @@ end
 # overwrite an existing `::Inertia` constant — if your app has one, use
 # `Sinatra::Inertia.defer` instead.
 ::Inertia = Sinatra::Inertia unless defined?(::Inertia)
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-inertia
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Kazuhiro Homma