sinatra-inertia 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf6ac9b17727011296d39f42de745b6c9cd6e27b6cd6ed73ced25c0795dd0c34
-  data.tar.gz: a9c6f651bf9017f99e3baf93f849f68c22844c8dce63ae6645a570de65d77a42
+  metadata.gz: d9172865c13484ad3352d36558c065514b1f3f175fd70ec8ce4f7cde77fbc3f8
+  data.tar.gz: f308c6741aed6cf48f7fc0588e7e0e11a7d5bad99b07000a20982fa01ee894b4
 SHA512:
-  metadata.gz: 9178b8948981c792d0d40fe9c3bfc35649e3ca4f561c7c26dda9bbc63bb28fb6f7af82806ba035aa7e0c9dbe79d2d8427086325c0bbe485fea9ce9344bd12729
-  data.tar.gz: 913198985434b0955bfb790967406400491ec356f732df35bd1a793de4f28131a0a6b97672cb8f35f6f73e588a3f905f35550f1839a89c1cd071abb879dbf865
+  metadata.gz: 0c4c38a5f2a2a2f16b5f3d449d442a7bd378fb491ae078c67a71543c6501e4412b93fc85751d54a0da0dd907d5f66340602aeef51a0899a990de921c495a5e28
+  data.tar.gz: 73fabe7fc1fb6191b1c454785b5450f2889e784ea12890587d203e7ccf216ca1143f51241ab06ea7eff6347bd83fb0c7b5066fb0b95e4ac413af55f0b8cc77ab

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # 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`,

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

@@ -18,7 +18,7 @@ module Sinatra
     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
@@ -43,7 +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
-
     end
 
     class AlwaysProp < Prop
@@ -71,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
@@ -23,12 +24,13 @@ module Sinatra
         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,7 +71,7 @@ module Sinatra
 
         @page = page_hash
         @page_json = ::Rack::Utils.escape_html(page_json)
-        erb layout, layout: false
+        erb(layout, layout: false)
       end
 
       # Natural page-rendering API: `render 'Component', props_hash`.
@@ -80,10 +82,20 @@ module Sinatra
       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])
-        elsif first.is_a?(String) && args.length <= 2 && (args.length == 1 || args[1].is_a?(Hash))
+          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)
@@ -97,7 +109,7 @@ module Sinatra
       end
 
       def inertia_request?
-        request.env['HTTP_X_INERTIA'] == 'true'
+        request.env["HTTP_X_INERTIA"] == "true"
       end
 
       def page_request?
@@ -112,14 +124,14 @@ 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)
+      def defer(group: "default", &block)
         Sinatra::Inertia.defer(group: group, &block)
       end
 
@@ -143,10 +155,9 @@ 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
 
@@ -154,10 +165,11 @@ module Sinatra
       # Asset version
       def current_inertia_version
         v = if settings.respond_to?(:page_version)
-              settings.page_version
-            elsif settings.respond_to?(:inertia_version)
-              settings.inertia_version
-            end
+          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
 
@@ -210,9 +222,7 @@ 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

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.4'
+    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.
@@ -33,34 +34,44 @@ module Sinatra
     def self.registered(app)
       # 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)
-      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, []
+      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: lambda {
-        version = if app.settings.respond_to?(:page_version)
-                    app.settings.page_version
-                  else
-                    app.settings.inertia_version
-                  end
-        version.respond_to?(:call) ? version.call.to_s : version.to_s
-      }
+      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
+
+          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
 
@@ -68,7 +79,7 @@ module Sinatra
         inertia_share(&block)
       end
 
-      app.helpers Sinatra::Inertia::Helpers
+      app.helpers(Sinatra::Inertia::Helpers)
     end
 
     # Convenience module-level constructors so code can write

metadata

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