sinatra-kagero 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d3f5f3c5e03dd426b4ea2f76d4dfbbba1220d5d366cbc368784675fd27c6944d
+  data.tar.gz: 7b71df421ac13b8575d459d0a0a25eadd6108b26271f5581e80f28d397fcc5d4
+SHA512:
+  metadata.gz: e99c1e6efea707ff1d72ff992a2bb18ac80a214f8bf99d63a645c664b471eba89f03f6f37702f91291dd262ebc019991141ba7a01d2d476e536f6f52e83deace
+  data.tar.gz: 49012fc6c23ab5d6923b84c826bdfdec376f569145b94961855d48b0dba686eed8c68846783014ee88126cd026194be576c6794b9136be20917e468d6dcb0231

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## 1.0.0 — 2026-06-25
+
+- Extract Kagero from `sinatra-inertia` into its own gem.
+- Provide Ruby page classes, props validation, command validation, and the hidden Kagero browser runtime.
+- Keep `sinatra-inertia` as the lower-level Inertia protocol adapter.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kazuhiro Homma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,36 @@
+# sinatra-kagero
+
+Ruby-way Inertia-style application layer for Sinatra and Homura.
+
+`sinatra-kagero` sits above `sinatra-inertia`. The lower gem owns the
+Inertia v2 wire protocol; Kagero owns the Ruby authoring model:
+
+- `Kagero::Page` classes render HTML with Phlex
+- page props are declared and validated in Ruby
+- form input is modeled with `Kagero::Command`
+- a hidden browser runtime handles visits, forms, history, scroll, partial reloads, and asset-version hard reloads
+
+## Install
+
+```ruby
+gem "sinatra-kagero"
+```
+
+## Usage
+
+```ruby
+require "sinatra/base"
+require "sinatra/kagero"
+
+class App < Sinatra::Base
+  register Sinatra::Kagero
+
+  get "/" do
+    page(Pages::Todos::Index, todos: Todo.all, errors: {})
+  end
+end
+```
+
+Kagero intentionally keeps JavaScript out of the main application authoring
+surface. The client runtime exists, but route handlers, pages, props, forms,
+validation, and persistence remain Ruby.

data/lib/sinatra/kagero/command.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module Kagero
+    class Command
+      class << self
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@kagero_attributes, kagero_attributes.dup)
+          subclass.instance_variable_set(:@kagero_validations, kagero_validations.dup)
+        end
+
+        def attribute(name, type = String, required: false, default: nil)
+          kagero_attributes <<
+            {
+              name: name.to_sym,
+              type: type,
+              required: required,
+              default: default
+            }
+          attr_reader(name)
+        end
+
+        def validates_presence_of(*names, message: "is required")
+          names.each do |name|
+            kagero_validations <<
+              {
+                kind: :presence,
+                name: name.to_sym,
+                message: message
+              }
+          end
+        end
+
+        def validates_length_of(name, maximum:, message: nil)
+          kagero_validations <<
+            {
+              kind: :length,
+              name: name.to_sym,
+              maximum: maximum,
+              message: message || "must be #{maximum} characters or less"
+            }
+        end
+
+        def kagero_attributes
+          @kagero_attributes ||= []
+        end
+
+        def kagero_validations
+          @kagero_validations ||= []
+        end
+      end
+
+      attr_reader :errors
+
+      def initialize(input = {})
+        @errors = {}
+        self.class.kagero_attributes.each do |attribute|
+          name = attribute.fetch(:name)
+          value = fetch_value(input, name)
+          value = default_value(attribute.fetch(:default)) if missing?(value)
+          value = coerce_value(value, attribute.fetch(:type))
+          instance_variable_set(:"@#{name}", value)
+        end
+      end
+
+      def valid?
+        @errors = {}
+        self.class.kagero_validations.each { |validation| apply_validation(validation) }
+        @errors.empty?
+      end
+
+      def invalid?
+        !valid?
+      end
+
+      def to_h
+        self
+          .class
+          .kagero_attributes
+          .map do |attribute|
+            name = attribute.fetch(:name)
+            [name, instance_variable_get(:"@#{name}")]
+          end
+          .to_h
+      end
+
+      private
+
+      def fetch_value(input, name)
+        return input[name] if input.respond_to?(:key?) && input.key?(name)
+
+        string_name = name.to_s
+        return input[string_name] if input.respond_to?(:key?) && input.key?(string_name)
+
+        nil
+      end
+
+      def missing?(value)
+        value.nil?
+      end
+
+      def default_value(default)
+        default.respond_to?(:call) ? default.call : default
+      end
+
+      def coerce_value(value, type)
+        return value if value.nil?
+        return value.to_s if type == String
+        return value.to_i if type == Integer
+        return value == true || value.to_s == "true" || value.to_s == "1" if type == :boolean
+
+        value
+      end
+
+      def apply_validation(validation)
+        name = validation.fetch(:name)
+        value = instance_variable_get(:"@#{name}")
+        case validation.fetch(:kind)
+        when :presence
+          add_error(name, validation.fetch(:message)) if value.nil? || value.to_s.strip.empty?
+        when :length
+          maximum = validation.fetch(:maximum)
+          add_error(name, validation.fetch(:message)) if value && value.to_s.length > maximum
+        end
+      end
+
+      def add_error(name, message)
+        @errors[name] ||= message
+      end
+    end
+  end
+end

data/lib/sinatra/kagero/page.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "phlex"
+
+module Sinatra
+  module Kagero
+    class Page < Phlex::HTML
+      class << self
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@kagero_props_schema, kagero_props_schema.dup)
+        end
+
+        def props(&block)
+          kagero_props_schema.instance_eval(&block) if block
+          kagero_props_schema
+        end
+
+        def prop(name, type = nil, **options)
+          kagero_props_schema.prop(name, type, **options)
+        end
+
+        def title(value = nil, &block)
+          @kagero_title = block || value unless value.nil? && block.nil?
+          @kagero_title
+        end
+
+        def kagero_component_name
+          name.to_s.sub(/\APages::/, "").gsub("::", "/")
+        end
+
+        def kagero_props_schema
+          @kagero_props_schema ||= Props::Schema.new
+        end
+      end
+
+      attr_reader :kagero_props
+
+      def initialize(**props)
+        @kagero_props = self.class.kagero_props_schema.coerce(props)
+        @kagero_props.each { |name, value| instance_variable_set(:"@#{name}", value) }
+        super()
+      end
+
+      def kagero_title
+        configured = self.class.title
+        return instance_exec(&configured).to_s if configured.respond_to?(:call)
+        return configured.to_s unless configured.nil?
+
+        self.class.kagero_component_name
+      end
+
+      private
+
+      def kagero_form(action:, method: "post", **attributes, &block)
+        attributes = kagero_data(attributes, "kagero" => "true")
+        attributes[:action] = action
+        attributes[:method] = method
+        form(**attributes, &block)
+      end
+
+      def kagero_link(href:, **attributes, &block)
+        attributes = kagero_data(attributes, "kagero" => "true")
+        attributes[:href] = href
+        a(**attributes, &block)
+      end
+
+      def kagero_partial_button(only:, **attributes, &block)
+        attributes = kagero_data(
+          attributes,
+          "kagero-reload" => "true",
+          "kagero-only" => Array(only).join(",")
+        )
+        attributes[:type] ||= "button"
+        button(**attributes, &block)
+      end
+
+      def kagero_data(attributes, data)
+        data.each { |key, value| attributes[:"data-#{key}"] = value }
+        attributes
+      end
+    end
+  end
+end

data/lib/sinatra/kagero/props.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module Kagero
+    module Props
+      MISSING = Object.new
+
+      class ValidationError < ArgumentError
+        attr_reader :errors
+
+        def initialize(errors)
+          @errors = errors
+          super(errors.map { |name, message| "#{name}: #{message}" }.join(", "))
+        end
+      end
+
+      class Field
+        attr_reader :name, :type, :default
+
+        def initialize(name, type, required:, default:)
+          @name = name.to_sym
+          @type = type
+          @required = required
+          @default = default
+        end
+
+        def required?
+          @required
+        end
+
+        def coerce(input, errors)
+          value = fetch_value(input)
+          if value.equal?(MISSING)
+            return default_value unless default.equal?(MISSING)
+            errors[name] = "is required" if required?
+            return nil
+          end
+
+          unless valid_type?(value)
+            errors[name] = "must be #{type_name}"
+            return value
+          end
+
+          value
+        end
+
+        private
+
+        def fetch_value(input)
+          return input[name] if input.key?(name)
+          string_name = name.to_s
+          return input[string_name] if input.key?(string_name)
+
+          MISSING
+        end
+
+        def default_value
+          default.respond_to?(:call) ? default.call : default
+        end
+
+        def valid_type?(value)
+          return true if type.nil?
+          return value == true || value == false if type == :bool || type == :boolean
+          return value.is_a?(Array) if type == :array
+          return value.is_a?(Hash) if type == :hash
+
+          type === value
+        end
+
+        def type_name
+          case type
+          when :bool, :boolean
+            "Boolean"
+          when :array
+            "Array"
+          when :hash
+            "Hash"
+          else
+            type.to_s
+          end
+        end
+      end
+
+      class Schema
+        def initialize(fields = [])
+          @fields = fields
+        end
+
+        def dup
+          self.class.new(@fields.dup)
+        end
+
+        def prop(name, type = nil, required: true, default: MISSING)
+          @fields << Field.new(name, type, required: required, default: default)
+        end
+
+        def coerce(input)
+          errors = {}
+          output = {}
+          @fields.each do |field|
+            output[field.name] = field.coerce(input, errors)
+          end
+
+          raise ValidationError, errors unless errors.empty?
+
+          output
+        end
+
+        def to_h
+          @fields.map { |field| [field.name, field.type] }.to_h
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/kagero/runtime.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module Kagero
+    module Runtime
+      SOURCE = <<~JS
+        const root = document.querySelector("[data-kagero-root]");
+        let currentPage = null;
+        let currentScroll = { left: 0, top: 0 };
+
+        function readInitialPage() {
+          if (!root) return null;
+          const raw = root.getAttribute("data-page");
+          if (!raw) return null;
+          return JSON.parse(raw);
+        }
+
+        function pageHtml(page) {
+          return page && page.props && page.props.kagero && page.props.kagero.html;
+        }
+
+        function rememberScroll() {
+          currentScroll = { left: window.scrollX, top: window.scrollY };
+          if (history.state && history.state.kagero) {
+            history.replaceState({ ...history.state, scroll: currentScroll }, "", location.href);
+          }
+        }
+
+        function applyPage(page, { replace = false, preserveScroll = false } = {}) {
+          if (!root) return;
+          const html = pageHtml(page);
+          if (typeof html === "string") root.innerHTML = html;
+          root.setAttribute("data-page", JSON.stringify(page));
+          currentPage = page;
+
+          const state = { kagero: true, page, scroll: preserveScroll ? currentScroll : { left: 0, top: 0 } };
+          if (replace) history.replaceState(state, "", page.url);
+          else history.pushState(state, "", page.url);
+
+          if (!preserveScroll) window.scrollTo(0, 0);
+        }
+
+        async function visit(url, options = {}) {
+          rememberScroll();
+          const headers = new Headers(options.headers || {});
+          headers.set("X-Inertia", "true");
+          headers.set("X-Inertia-Version", currentPage ? currentPage.version : "");
+          headers.set("X-Requested-With", "XMLHttpRequest");
+          headers.set("Accept", "application/json, text/html;q=0.9");
+
+          const response = await fetch(url, {
+            method: options.method || "GET",
+            body: options.body,
+            headers,
+            credentials: "same-origin",
+            redirect: "follow"
+          });
+
+          if (response.status === 409 && response.headers.get("X-Inertia-Location")) {
+            location.href = response.headers.get("X-Inertia-Location");
+            return;
+          }
+
+          if (!response.ok) throw new Error(`Kagero visit failed: ${response.status}`);
+
+          const page = await response.json();
+          applyPage(page, {
+            replace: options.replace === true,
+            preserveScroll: options.preserveScroll === true
+          });
+        }
+
+        function formBody(form) {
+          const method = (form.getAttribute("method") || "GET").toUpperCase();
+          if (method === "GET") return null;
+          return new FormData(form);
+        }
+
+        function formUrl(form) {
+          const action = form.getAttribute("action") || location.href;
+          const method = (form.getAttribute("method") || "GET").toUpperCase();
+          if (method !== "GET") return action;
+
+          const url = new URL(action, location.href);
+          const data = new FormData(form);
+          for (const [key, value] of data.entries()) url.searchParams.set(key, value);
+          return url.toString();
+        }
+
+        document.addEventListener("click", (event) => {
+          const target = event.target;
+          if (!target || !target.closest) return;
+
+          const link = target.closest("a[data-kagero]");
+          if (link) {
+            event.preventDefault();
+            visit(link.href, {
+              replace: link.dataset.kageroReplace === "true",
+              preserveScroll: link.dataset.kageroPreserveScroll === "true"
+            });
+            return;
+          }
+
+          const reload = target.closest("[data-kagero-reload]");
+          if (reload) {
+            event.preventDefault();
+            const only = reload.dataset.kageroOnly || "";
+            const headers = {};
+            if (currentPage && only) {
+              headers["X-Inertia-Partial-Component"] = currentPage.component;
+              headers["X-Inertia-Partial-Data"] = only;
+            }
+            visit(location.href, { replace: true, preserveScroll: true, headers });
+          }
+        });
+
+        document.addEventListener("submit", (event) => {
+          const target = event.target;
+          if (!target || !target.closest) return;
+          const form = target.closest("form[data-kagero]");
+          if (!form) return;
+
+          event.preventDefault();
+          visit(formUrl(form), {
+            method: (form.getAttribute("method") || "GET").toUpperCase(),
+            body: formBody(form),
+            preserveScroll: form.dataset.kageroPreserveScroll === "true"
+          });
+        });
+
+        window.addEventListener("popstate", (event) => {
+          if (event.state && event.state.kagero && event.state.page) {
+            currentPage = event.state.page;
+            const html = pageHtml(currentPage);
+            if (typeof html === "string") root.innerHTML = html;
+            const scroll = event.state.scroll || { left: 0, top: 0 };
+            window.scrollTo(scroll.left, scroll.top);
+          } else {
+            location.reload();
+          }
+        });
+
+        currentPage = readInitialPage();
+        if (currentPage) {
+          history.replaceState({ kagero: true, page: currentPage, scroll: { left: 0, top: 0 } }, "", currentPage.url);
+        }
+
+        window.Kagero = { visit };
+      JS
+    end
+  end
+end

data/lib/sinatra/kagero/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sinatra
+  module Kagero
+    VERSION = "1.0.0"
+  end
+end

data/lib/sinatra/kagero.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "json"
+require "phlex"
+require "sinatra/inertia"
+
+require "sinatra/kagero/command"
+require "sinatra/kagero/props"
+require "sinatra/kagero/page"
+require "sinatra/kagero/runtime"
+require "sinatra/kagero/version"
+
+module Sinatra
+  # Ruby-way page API layered on the Inertia protocol.
+  module Kagero
+    def self.registered(app)
+      app.register(Sinatra::Inertia)
+      app.set(:kagero_root_id, "app") unless app.respond_to?(:kagero_root_id)
+      app.helpers(Helpers)
+    end
+
+    module Helpers
+      def page(page_class, **props)
+        render_kagero_page(page_class, props)
+      end
+
+      def render_page(page_class, **props)
+        render_kagero_page(page_class, props)
+      end
+
+      def redirect_page(path, page_class, **props)
+        return render_kagero_page(page_class, props, url: path) if inertia_request?
+
+        redirect(to(path), 303)
+      end
+
+      private
+
+      def render_kagero_page(page_class, props, url: request.fullpath)
+        component = page_class.kagero_component_name
+        page_instance = page_class.new(**props)
+        page_props = page_instance.kagero_props
+        body_html = page_instance.call
+
+        response_props = page_props.merge(
+          kagero: {
+            component: component,
+            html: body_html,
+            title: page_instance.kagero_title
+          }
+        )
+
+        if inertia_request?
+          render_kagero_json(component, response_props, url)
+        else
+          render_kagero_shell(component, response_props, url)
+        end
+      end
+
+      def render_kagero_json(component, props, url)
+        content_type("application/json; charset=utf-8")
+        headers("X-Inertia" => "true", "Vary" => "X-Inertia")
+        render_kagero_page_hash(component, props, url).to_json
+      end
+
+      def render_kagero_shell(component, props, url)
+        page_hash = render_kagero_page_hash(component, props, url)
+        page_json = ::Rack::Utils.escape_html(page_hash.to_json)
+        html = <<~HTML
+          <!doctype html>
+          <html lang="ja">
+            <head>
+              <meta charset="utf-8">
+              <meta name="viewport" content="width=device-width,initial-scale=1">
+              <title>#{::Rack::Utils.escape_html(props.dig(:kagero, :title).to_s)}</title>
+              <script type="module">#{Sinatra::Kagero::Runtime::SOURCE}</script>
+            </head>
+            <body>
+              <main id="#{::Rack::Utils.escape_html(settings.kagero_root_id)}" data-kagero-root data-page="#{page_json}">#{props.dig(:kagero, :html)}</main>
+            </body>
+          </html>
+        HTML
+
+        content_type("text/html; charset=utf-8")
+        html
+      end
+
+      def render_kagero_page_hash(component, props, url)
+        response_obj = Sinatra::Inertia::Response.new(
+          component: component,
+          props: props,
+          request: request,
+          version: current_inertia_version,
+          url: url,
+          encrypt_history: false,
+          clear_history: false,
+          shared: current_inertia_shared,
+          errors: inertia_errors_payload
+        )
+        page_hash = response_obj.to_h
+        sweep_inertia_session!
+        page_hash
+      end
+    end
+  end
+
+  register Kagero if respond_to?(:register)
+end
+
+::Kagero = Sinatra::Kagero unless defined?(::Kagero)

data/runtime/kagero.js

@@ -0,0 +1,138 @@
+const root = document.querySelector("[data-kagero-root]");
+
+let currentPage = null;
+let currentScroll = { left: 0, top: 0 };
+
+function readInitialPage() {
+  if (!root) return null;
+  const raw = root.getAttribute("data-page");
+  if (!raw) return null;
+  return JSON.parse(raw);
+}
+
+function pageHtml(page) {
+  return page && page.props && page.props.kagero && page.props.kagero.html;
+}
+
+function rememberScroll() {
+  currentScroll = { left: window.scrollX, top: window.scrollY };
+  if (history.state && history.state.kagero) {
+    history.replaceState({ ...history.state, scroll: currentScroll }, "", location.href);
+  }
+}
+
+function applyPage(page, { replace = false, preserveScroll = false } = {}) {
+  if (!root) return;
+  const html = pageHtml(page);
+  if (typeof html === "string") root.innerHTML = html;
+  root.setAttribute("data-page", JSON.stringify(page));
+  currentPage = page;
+
+  const state = { kagero: true, page, scroll: preserveScroll ? currentScroll : { left: 0, top: 0 } };
+  if (replace) history.replaceState(state, "", page.url);
+  else history.pushState(state, "", page.url);
+
+  if (!preserveScroll) window.scrollTo(0, 0);
+}
+
+async function visit(url, options = {}) {
+  rememberScroll();
+  const headers = new Headers(options.headers || {});
+  headers.set("X-Inertia", "true");
+  headers.set("X-Inertia-Version", currentPage ? currentPage.version : "");
+  headers.set("X-Requested-With", "XMLHttpRequest");
+  headers.set("Accept", "application/json, text/html;q=0.9");
+
+  const response = await fetch(url, {
+    method: options.method || "GET",
+    body: options.body,
+    headers,
+    credentials: "same-origin",
+    redirect: "follow"
+  });
+
+  if (response.status === 409 && response.headers.get("X-Inertia-Location")) {
+    location.href = response.headers.get("X-Inertia-Location");
+    return;
+  }
+
+  if (!response.ok) throw new Error(`Kagero visit failed: ${response.status}`);
+
+  const page = await response.json();
+  applyPage(page, {
+    replace: options.replace === true,
+    preserveScroll: options.preserveScroll === true
+  });
+}
+
+function formBody(form) {
+  const method = (form.getAttribute("method") || "GET").toUpperCase();
+  if (method === "GET") return null;
+  return new FormData(form);
+}
+
+function formUrl(form) {
+  const action = form.getAttribute("action") || location.href;
+  const method = (form.getAttribute("method") || "GET").toUpperCase();
+  if (method !== "GET") return action;
+
+  const url = new URL(action, location.href);
+  const data = new FormData(form);
+  for (const [key, value] of data.entries()) url.searchParams.set(key, value);
+  return url.toString();
+}
+
+document.addEventListener("click", (event) => {
+  const link = event.target.closest("a[data-kagero]");
+  if (link) {
+    event.preventDefault();
+    visit(link.href, {
+      replace: link.dataset.kageroReplace === "true",
+      preserveScroll: link.dataset.kageroPreserveScroll === "true"
+    });
+    return;
+  }
+
+  const reload = event.target.closest("[data-kagero-reload]");
+  if (reload) {
+    event.preventDefault();
+    const only = reload.dataset.kageroOnly || "";
+    const headers = {};
+    if (currentPage && only) {
+      headers["X-Inertia-Partial-Component"] = currentPage.component;
+      headers["X-Inertia-Partial-Data"] = only;
+    }
+    visit(location.href, { replace: true, preserveScroll: true, headers });
+  }
+});
+
+document.addEventListener("submit", (event) => {
+  const form = event.target.closest("form[data-kagero]");
+  if (!form) return;
+
+  event.preventDefault();
+  visit(formUrl(form), {
+    method: (form.getAttribute("method") || "GET").toUpperCase(),
+    body: formBody(form),
+    preserveScroll: form.dataset.kageroPreserveScroll === "true"
+  });
+});
+
+window.addEventListener("popstate", (event) => {
+  if (event.state && event.state.kagero && event.state.page) {
+    currentPage = event.state.page;
+    const html = pageHtml(currentPage);
+    if (typeof html === "string") root.innerHTML = html;
+    const scroll = event.state.scroll || { left: 0, top: 0 };
+    window.scrollTo(scroll.left, scroll.top);
+  } else {
+    location.reload();
+  }
+});
+
+currentPage = readInitialPage();
+if (currentPage) {
+  history.replaceState({ kagero: true, page: currentPage, scroll: { left: 0, top: 0 } }, "", currentPage.url);
+}
+
+window.Kagero = { visit };

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: sinatra-kagero
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Kazuhiro Homma
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra-inertia
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: phlex
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.4'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.4'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: literal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: |
+  Kagero is a Ruby-first application layer on top of sinatra-inertia:
+  Phlex page classes, Literal-style props schemas, Ruby form/command
+  validation, and a hidden browser runtime for SPA-like navigation without
+  exposing JavaScript as the primary userland authoring model.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/sinatra/kagero.rb
+- lib/sinatra/kagero/command.rb
+- lib/sinatra/kagero/page.rb
+- lib/sinatra/kagero/props.rb
+- lib/sinatra/kagero/runtime.rb
+- lib/sinatra/kagero/version.rb
+- runtime/kagero.js
+homepage: https://github.com/kazuph/homura
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/kazuph/homura
+  source_code_uri: https://github.com/kazuph/homura/tree/main/gems/sinatra-kagero
+  bug_tracker_uri: https://github.com/kazuph/homura/issues
+  changelog_uri: https://github.com/kazuph/homura/blob/main/gems/sinatra-kagero/CHANGELOG.md
+  readme_uri: https://github.com/kazuph/homura/blob/main/gems/sinatra-kagero/README.md
+  homura.auto_await: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Ruby-way Inertia experience for Sinatra and Homura
+test_files: []