docs-kit 0.1.0

data/lib/docs_kit/open_api/document.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module DocsKit
+  module OpenApi
+    # A parsed OpenAPI 3.x document. Indexes every path/verb operation and offers
+    # two lookups — by operationId, or by (method, path) for specs that omit ids —
+    # plus the shared local-$ref resolver every Operation/Schema reads through.
+    #
+    # Keys stay Strings internally (that's how both YAML and JSON parse), so the
+    # model never guesses at symbol/string key shape.
+    class Document
+      # The HTTP verbs an OpenAPI path item may carry, lower-cased as they appear
+      # in the spec.
+      HTTP_METHODS = %w[get put post delete options head patch trace].freeze
+
+      def initialize(raw)
+        @raw = raw
+      end
+
+      # Look up an operation. Two forms:
+      #   operation("createInvoice")           — by operationId
+      #   operation(:post, "/v1/invoices")     — by HTTP method + path
+      # Raises OperationNotFound (naming the available ids) when nothing matches.
+      def operation(id_or_method, path = nil)
+        found = path.nil? ? by_operation_id(id_or_method) : by_method_and_path(id_or_method, path)
+        found || raise(OperationNotFound, not_found_message(id_or_method, path))
+      end
+
+      # Every operation across every path, in document order.
+      def operations
+        @operations ||= build_operations
+      end
+
+      # Resolve a local $ref ("#/components/schemas/Foo") to the referenced node.
+      # An external/remote ref (not starting "#/") raises UnsupportedRef. Used by
+      # Operation and Schema so ref handling lives in exactly one place.
+      def resolve_ref(ref)
+        raise UnsupportedRef, "external/remote $ref is not supported: #{ref}" unless ref.start_with?("#/")
+
+        ref.delete_prefix("#/").split("/").reduce(@raw) do |node, segment|
+          # JSON Pointer escaping: ~1 → "/", ~0 → "~".
+          key = segment.gsub("~1", "/").gsub("~0", "~")
+          node.is_a?(Hash) ? node[key] : nil
+        end
+      end
+
+      # Follow a node's $ref (if any) one hop to the referenced node; a node
+      # without a $ref is returned unchanged.
+      def deref(node)
+        node.is_a?(Hash) && node.key?("$ref") ? resolve_ref(node["$ref"]) : node
+      end
+
+      private
+
+      def build_operations
+        paths.flat_map do |path, item|
+          next [] unless item.is_a?(Hash)
+
+          item.filter_map do |verb, op|
+            next unless HTTP_METHODS.include?(verb.to_s.downcase)
+            next unless op.is_a?(Hash)
+
+            Operation.new(self, method: verb, path: path, raw: op)
+          end
+        end
+      end
+
+      def paths
+        @raw["paths"] || {}
+      end
+
+      def by_operation_id(id)
+        operations.find { |op| op.operation_id == id.to_s }
+      end
+
+      def by_method_and_path(method, path)
+        verb = method.to_s.downcase
+        operations.find { |op| op.http_method.downcase == verb && op.path == path }
+      end
+
+      def not_found_message(id_or_method, path)
+        if path
+          "no operation #{id_or_method.to_s.upcase} #{path} in the OpenAPI spec"
+        else
+          ids = operations.filter_map(&:operation_id)
+          "unknown operationId #{id_or_method.inspect}; available: #{ids.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/docs_kit/open_api/operation.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module DocsKit
+  module OpenApi
+    # One OpenAPI operation (a path + verb), exposing exactly the shapes the kit's
+    # render targets consume:
+    #   #parameter_rows / #body_rows → DocsUI::FieldTable
+    #   #error_rows                  → DocsUI::ErrorTable
+    #   #example_body / #success_example → DocsUI::JsonResponse / RequestExample body
+    #   #example_path / #example_query   → the RequestExample snippet URL
+    #   #code_samples                → DocsUI::Example tabs (x-codeSamples)
+    #
+    # It never renders — it's the bridge value object DocsUI::OpenApiOperation
+    # reads. All schema traversal delegates to DocsKit::OpenApi::Schema.
+    class Operation
+      # Both spellings of the code-samples vendor extension seen in the wild
+      # (Redoc uses x-codeSamples; older tooling x-code-samples).
+      CODE_SAMPLE_KEYS = %w[x-codeSamples x-code-samples].freeze
+
+      # The media type the bridge reads bodies/examples from.
+      JSON_MEDIA_TYPE = "application/json"
+
+      attr_reader :path
+
+      def initialize(document, method:, path:, raw:)
+        @document = document
+        @method = method
+        @path = path
+        @raw = raw
+      end
+
+      def http_method = @method.to_s.upcase
+      def operation_id = @raw["operationId"]
+      def summary = @raw["summary"]
+      def description = @raw["description"]
+      def deprecated? = @raw["deprecated"] == true
+
+      # The section title: the summary, else the operationId, else the verb+path.
+      def title
+        summary || operation_id || "#{http_method} #{path}"
+      end
+
+      # FieldTable rows for the operation's query/path/header parameters.
+      def parameter_rows
+        parameters.map do |param|
+          {
+            name: param["name"],
+            type: Schema.new(@document, param["schema"]).type_label,
+            required: param["required"] == true,
+            description: description_cell(param["description"])
+          }
+        end
+      end
+
+      # FieldTable rows for the request-body schema (flattened, nested-dotted).
+      def body_rows
+        schema = request_body_schema
+        return [] unless schema
+
+        Schema.new(@document, schema).rows
+      end
+
+      # ErrorTable rows for the 4xx/5xx responses: status + scenario (the response
+      # description) + an optional error type read from the response example.
+      def error_rows
+        error_responses.map do |status, response|
+          {
+            status: status,
+            scenario: response_description(response),
+            type: error_type_for(response)
+          }
+        end
+      end
+
+      # A synthesized (or explicit) request body example Hash, or nil when the
+      # operation has no request body.
+      def example_body
+        schema = request_body_schema
+        return unless schema
+
+        media = request_body_media
+        return media["example"] if media&.key?("example")
+
+        first_examples_value(media) || Schema.new(@document, schema).example_value
+      end
+
+      # The path with each path-parameter placeholder replaced by its example
+      # (copy-pasteable), leaving {placeholders} without an example untouched.
+      def example_path
+        path.gsub(/\{(\w+)\}/) do
+          name = Regexp.last_match(1)
+          param = path_parameters.find { |p| p["name"] == name }
+          example = param && param["example"]
+          example.nil? ? "{#{name}}" : example.to_s
+        end
+      end
+
+      # { name => value } for query params that carry an explicit example (never
+      # invent a value for a required-but-example-less param — it stays doc-only).
+      def example_query
+        query_parameters.each_with_object({}) do |param, acc|
+          acc[param["name"]] = param["example"] if param.key?("example")
+        end
+      end
+
+      # The first 2xx response's example body (explicit or synthesized), or nil.
+      def success_example
+        _, response = success_response
+        return unless response
+
+        media = json_media(response)
+        return unless media
+
+        return media["example"] if media.key?("example")
+
+        first_examples_value(media) || example_from_schema(media["schema"])
+      end
+
+      # x-codeSamples entries as { lang:, label:, source: } (either spelling).
+      def code_samples
+        raw_samples.map do |sample|
+          {
+            lang: sample["lang"],
+            label: sample["label"],
+            source: sample["source"].to_s
+          }
+        end
+      end
+
+      private
+
+      def parameters
+        Array(@raw["parameters"]).map { |p| @document.deref(p) }
+      end
+
+      def path_parameters = parameters.select { |p| p["in"] == "path" }
+      def query_parameters = parameters.select { |p| p["in"] == "query" }
+
+      def request_body
+        @document.deref(@raw["requestBody"])
+      end
+
+      def request_body_media
+        body = request_body
+        return unless body.is_a?(Hash)
+
+        (body["content"] || {})[JSON_MEDIA_TYPE]
+      end
+
+      def request_body_schema
+        media = request_body_media
+        media && media["schema"]
+      end
+
+      def responses = @raw["responses"] || {}
+
+      def error_responses
+        responses.select { |status, _| status.to_s =~ /\A[45]/ }
+                 .transform_values { |r| @document.deref(r) }
+      end
+
+      def success_response
+        responses.map { |status, r| [status, @document.deref(r)] }
+                 .find { |status, _| status.to_s.start_with?("2") }
+      end
+
+      def json_media(response)
+        return unless response.is_a?(Hash)
+
+        (response["content"] || {})[JSON_MEDIA_TYPE]
+      end
+
+      def response_description(response)
+        desc = response["description"]
+        desc.nil? || desc.to_s.strip.empty? ? http_method : desc.to_s
+      end
+
+      # An error type is not a first-class OpenAPI field. When a response example
+      # carries a top-level "type" string, surface it; otherwise nil.
+      def error_type_for(response)
+        media = json_media(response)
+        return unless media
+
+        example = media["example"] || first_examples_value(media)
+        example.is_a?(Hash) ? example["type"] : nil
+      end
+
+      # The value of the first entry in an `examples` (plural) map, or nil.
+      def first_examples_value(media)
+        return unless media.is_a?(Hash)
+
+        examples = media["examples"]
+        return unless examples.is_a?(Hash) && !examples.empty?
+
+        entry = @document.deref(examples.values.first)
+        entry.is_a?(Hash) ? entry["value"] : nil
+      end
+
+      def example_from_schema(schema)
+        schema && Schema.new(@document, schema).example_value
+      end
+
+      def description_cell(text)
+        text && !text.to_s.strip.empty? ? [:md, text.to_s] : nil
+      end
+
+      def raw_samples
+        key = CODE_SAMPLE_KEYS.find { |k| @raw.key?(k) }
+        key ? Array(@raw[key]) : []
+      end
+    end
+  end
+end

data/lib/docs_kit/open_api/schema.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module DocsKit
+  module OpenApi
+    # A thin wrapper over one OpenAPI schema node that answers the three questions
+    # the render targets ask: what's its display type label, what FieldTable rows
+    # do its properties flatten to, and what example value does it synthesize.
+    #
+    # All traversal is cycle-safe (a $ref that loops back stops descending) and
+    # depth-capped, because a real spec can be deeply nested or self-referential
+    # (Invoice.parent → Invoice).
+    class Schema
+      # How deep object/property flattening and example synthesis descend before
+      # stopping — guards both accidental depth and $ref cycles.
+      MAX_DEPTH = 6
+
+      def initialize(document, node)
+        @document = document
+        @node = node || {}
+      end
+
+      # A human display type for a FieldTable "Type" cell:
+      #   "string", "integer", "array of string", "usd | eur | gbp" (enum),
+      #   "one of: A | B" (oneOf/anyOf), "object".
+      def type_label
+        node = merged
+        return enum_label(node["enum"]) if node["enum"]
+        return one_of_label(node) if node["oneOf"] || node["anyOf"]
+        return "array of #{Schema.new(@document, deref(node['items'])).type_label}" if array?(node)
+
+        node["type"] || "object"
+      end
+
+      # The recursion state threaded through property flattening: the dotted-name
+      # prefix, the current depth, and the $ref chain seen so far (for cycles).
+      Cursor = Data.define(:prefix, :depth, :seen) do
+        def self.root = new(prefix: "", depth: 0, seen: [])
+        def descend(name, ref) = self.class.new(prefix: name, depth: depth + 1, seen: seen + [ref].compact)
+        def dotted(name) = prefix.empty? ? name : "#{prefix}.#{name}"
+      end
+
+      # Flatten this schema's properties into FieldTable-ready rows. Nested object
+      # properties dot their names (customer.id); required is read from the
+      # object's `required` list. The Cursor threads prefix/depth/seen recursion.
+      def rows(cursor: Cursor.root)
+        node = merged
+        return [] if cursor.depth >= MAX_DEPTH
+        return [] unless node["properties"].is_a?(Hash)
+
+        required = Array(node["required"])
+        node["properties"].flat_map do |name, prop_node|
+          property_rows(prop_node, name: name, required: required.include?(name), cursor: cursor)
+        end
+      end
+
+      # Synthesize an example value for this schema: the node's own `example`,
+      # else `default`, else the first enum value, else a per-type placeholder
+      # (recursing into object properties / array items). Cycle-safe via `seen`.
+      def example_value(depth: 0, seen: [])
+        node = merged
+        return node["example"] if node.key?("example")
+        return node["default"] if node.key?("default")
+        return node["enum"].first if node["enum"].is_a?(Array) && !node["enum"].empty?
+        return [] if depth >= MAX_DEPTH
+
+        synthesize(node, depth, seen)
+      end
+
+      private
+
+      attr_reader :document
+
+      # The node with any single $ref followed and allOf branches shallow-merged,
+      # so callers see one flat schema. oneOf/anyOf are left for #type_label.
+      def merged
+        node = deref(@node)
+        return {} unless node.is_a?(Hash)
+        return merge_all_of(node) if node["allOf"].is_a?(Array)
+
+        node
+      end
+
+      def merge_all_of(node)
+        node["allOf"].each_with_object(node.except("allOf")) do |branch, acc|
+          merge_branch!(acc, Schema.new(@document, branch).send(:merged))
+        end
+      end
+
+      def merge_branch!(acc, resolved)
+        acc["properties"] = (acc["properties"] || {}).merge(resolved["properties"] || {})
+        acc["required"] = Array(acc["required"]) | Array(resolved["required"])
+        acc["type"] ||= resolved["type"]
+      end
+
+      def property_rows(prop_node, name:, required:, cursor:)
+        dotted = cursor.dotted(name)
+        resolved = deref(prop_node)
+        ref = prop_node.is_a?(Hash) ? prop_node["$ref"] : nil
+        own_row = row(dotted, prop_node, required)
+
+        # A $ref cycle, or a leaf: emit the row without descending.
+        return [own_row] if (ref && cursor.seen.include?(ref)) || !object_with_properties?(resolved)
+
+        child = Schema.new(@document, resolved).rows(cursor: cursor.descend(dotted, ref))
+        [own_row, *child]
+      end
+
+      def row(name, prop_node, required)
+        schema = Schema.new(@document, prop_node)
+        {
+          name: name,
+          type: schema.type_label,
+          required: required,
+          description: description_cell(deref(prop_node))
+        }
+      end
+
+      # An OpenAPI description is CommonMark, so hand it to FieldTable as an inline
+      # Markdown cell ([:md, ...]); a description-less property gets no cell (the
+      # component falls back to the em-dash).
+      def description_cell(node)
+        desc = node.is_a?(Hash) ? node["description"] : nil
+        desc && !desc.to_s.strip.empty? ? [:md, desc.to_s] : nil
+      end
+
+      def synthesize(node, depth, seen)
+        # A typeless node with properties is an implicit object.
+        return synthesize_object(node, depth, seen) if node["type"] == "object" || node["properties"]
+
+        case node["type"]
+        when "array" then [synthesize_array_item(node, depth, seen)]
+        when "integer", "number" then 0
+        when "boolean" then true
+        else "string"
+        end
+      end
+
+      def synthesize_array_item(node, depth, seen)
+        Schema.new(@document, deref(node["items"])).example_value(depth: depth + 1, seen: seen)
+      end
+
+      def synthesize_object(node, depth, seen)
+        props = node["properties"]
+        return {} unless props.is_a?(Hash)
+
+        props.each_with_object({}) do |(name, prop_node), acc|
+          ref = prop_node.is_a?(Hash) ? prop_node["$ref"] : nil
+          next if ref && seen.include?(ref) # cycle: drop the looping property
+
+          acc[name] = Schema.new(@document, prop_node)
+                            .example_value(depth: depth + 1, seen: seen + [ref].compact)
+        end
+      end
+
+      def array?(node)
+        node["type"] == "array" || node.key?("items")
+      end
+
+      def object_with_properties?(node)
+        node.is_a?(Hash) && node["properties"].is_a?(Hash)
+      end
+
+      def enum_label(values)
+        Array(values).join(" | ")
+      end
+
+      def one_of_label(node)
+        branches = node["oneOf"] || node["anyOf"]
+        labels = branches.map { |b| Schema.new(@document, b).type_label }
+        "one of: #{labels.join(' | ')}"
+      end
+
+      def deref(node)
+        @document.deref(node)
+      end
+    end
+  end
+end

data/lib/docs_kit/open_api.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "json"
+require "pathname"
+
+module DocsKit
+  # The OpenAPI-bridge entry point. Loads an OpenAPI 3.x spec (a file path or an
+  # already-parsed Hash) into a narrow, gem-owned object model — a
+  # DocsKit::OpenApi::Document yielding DocsKit::OpenApi::Operation objects — that
+  # exposes ONLY what the existing render targets consume (FieldTable rows,
+  # ErrorTable rows, example bodies, code samples). No runtime parser dependency:
+  # YAML via Psych, JSON via the stdlib.
+  #
+  #   doc = DocsKit::OpenApi.load("openapi.yaml")
+  #   op  = doc.operation("createInvoice")   # or doc.operation(:post, "/v1/invoices")
+  #   op.body_rows      # => [{ name:, type:, required:, description: }, ...]  (FieldTable)
+  #   op.error_rows     # => [{ scenario:, status:, type: }, ...]             (ErrorTable)
+  #   op.success_example# => a Hash → JsonResponse
+  #
+  # DocsUI::OpenApiOperation renders one Operation through the kit; the `operation`
+  # page helper looks it up on DocsKit.configuration.openapi_document.
+  module OpenApi
+    # Raised when a requested operation isn't in the spec. The message lists the
+    # available operationIds so a typo is diagnosable at the call site.
+    class OperationNotFound < DocsKit::Error; end
+
+    # Raised on a $ref this bridge intentionally doesn't resolve — an external or
+    # remote reference (anything not starting "#/"). The message names the ref.
+    class UnsupportedRef < DocsKit::Error; end
+
+    # YAML types a real-world spec might legitimately carry (dates in examples).
+    PERMITTED_YAML_CLASSES = [Date, Time].freeze
+
+    module_function
+
+    # Load a spec from a String/Pathname path (`.json` parsed as JSON, anything
+    # else as YAML) or from an already-parsed Hash. Returns a Document.
+    def load(source)
+      Document.new(source.is_a?(Hash) ? source : parse_file(source))
+    end
+
+    # Parse a file by extension: JSON for `.json`, YAML (with alias support)
+    # otherwise. Kept module-level so Document#load-style reloads share it.
+    def parse_file(path)
+      pathname = Pathname.new(path)
+      contents = pathname.read
+      if pathname.extname.casecmp?(".json")
+        JSON.parse(contents)
+      else
+        YAML.safe_load(contents, aliases: true, permitted_classes: PERMITTED_YAML_CLASSES)
+      end
+    end
+  end
+end

data/lib/docs_kit/registry.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+# parameterize/camelize/underscore/safe_constantize for the v2 `page` DSL. A
+# host Rails app already loads these; the gem requires them explicitly so the
+# registry derives slugs/views even when loaded standalone (the suite, a plain
+# Ruby consumer).
+require "active_support/core_ext/string/inflections"
+
+module DocsKit
+  # A mixin for an in-memory docs registry (guides, demos, component references).
+  #
+  # Two authoring styles, one shared lookup/grouping API:
+  #
+  # 1. The one-line `page` DSL (v2) — the default a site should reach for. slug
+  #    and view derive from the title (both overridable); instances get default
+  #    readers + view_class + href for free; the sidebar nav derives from the
+  #    registry with zero site code:
+  #
+  #      class Doc
+  #        extend DocsKit::Registry
+  #        path_prefix    "/docs"                 # href = "#{path_prefix}/#{slug}"
+  #        view_namespace "Views::Docs::Pages"    # view_class resolves under this
+  #        page "Installation",   group: "Guide"                       # slug "installation", view "Installation"
+  #        page "Getting started", group: "Guide", icon: "rocket"      # slug "getting-started", view "GettingStarted"
+  #        page "OAuth", group: "Guide", slug: "auth", view: "OauthGuide"  # every derivation overridable
+  #      end
+  #
+  # 2. The low-level hash `entries` API — for a registry with a bespoke schema
+  #    (custom fields, a non-default view namespace). The site writes its own
+  #    initialize/readers/view_class:
+  #
+  #      class Demo
+  #        extend DocsKit::Registry
+  #        entries [{ slug: "counter", title: "Counter", group: "Examples", view: "Counter" }]
+  #        attr_reader :slug, :title, :group, :view_name
+  #        def initialize(entry) = (@slug, @title, @group, @view_name = entry.values_at(:slug, :title, :group, :view))
+  #        def view_class = "Views::Docs::Pages::#{view_name}".safe_constantize
+  #      end
+  #
+  #   Doc.all                                    # => [entry instances]
+  #   Doc.from_slug("installation")              # => instance | nil
+  #   Doc.grouped                                # => { "Guide" => [instances] }
+  #   Doc.nav_items                              # => { "Guide" => [NavItem] } (authored pages only)
+  #
+  # A registry uses ONE style; mixing `page` and `entries` raises Registry::Error.
+  module Registry
+    # Raised on invalid registry declarations (e.g. mixing `page` and `entries`).
+    class Error < DocsKit::Error
+    end
+
+    # Declares the frozen registry data directly (the low-level hash API). Each
+    # entry is a Hash; the site supplies its own instance class behavior.
+    def entries(list = nil)
+      return @entries if list.nil?
+
+      raise Error, "cannot mix `page` and `entries` in one registry" if @pages&.any?
+
+      @entries = list.map(&:freeze).freeze
+    end
+
+    # Declares one page (the v2 DSL). slug/view derive from the title unless
+    # given. Appends to the registry in declaration order (== sidebar order).
+    #
+    #   page "Getting started", group: "Guide", icon: "rocket", slug: "start", view: "Start"
+    def page(title, group:, slug: nil, view: nil, icon: nil)
+      raise Error, "cannot mix `page` and `entries` in one registry" if defined?(@entries) && @entries
+
+      (@pages ||= []) << {
+        title: title,
+        group: group,
+        slug: slug || title.parameterize,
+        view: view || title.parameterize(separator: "_").camelize,
+        icon: icon
+      }.freeze
+    end
+
+    # href = "#{path_prefix}/#{slug}". Defaults to "/docs".
+    def path_prefix(value = nil)
+      @path_prefix = value if value
+      @path_prefix || "/docs"
+    end
+
+    # The namespace a page's view_class resolves under (v2 pages only), e.g.
+    # "Views::Docs::Pages". Required to resolve views via the default Entry.
+    def view_namespace(value = nil)
+      @view_namespace = value if value
+      @view_namespace
+    end
+
+    # The attribute used by #grouped (default :group).
+    def group_by_attribute(attr = nil)
+      @group_by_attribute = attr if attr
+      @group_by_attribute || :group
+    end
+
+    # All registry instances (built fresh each call — instances are cheap and a
+    # site may resolve view classes that change under code reload in development).
+    # v2 pages are wrapped in the default Entry; hash entries in the site's class.
+    def all
+      if defined?(@pages) && @pages
+        @pages.map { |attrs| Entry.new(attrs, path_prefix, view_namespace) }
+      else
+        (entries || []).map { |entry| new(entry) }
+      end
+    end
+
+    # The instance whose slug matches, or nil.
+    def from_slug(slug)
+      all.find { |item| item.slug.to_s == slug.to_s }
+    end
+
+    # { group_value => [instances] }, preserving registry order within a group.
+    def grouped
+      all.group_by { |item| item.public_send(group_by_attribute) }
+    end
+
+    # { group => [NavItem] } for authored pages only (a resolvable view_class),
+    # so the sidebar never links a page that isn't written yet. This is the
+    # transform every site used to hand-write in its nav lambda.
+    def nav_items
+      all.select { |item| item.respond_to?(:view_class) && item.view_class }
+         .group_by { |item| item.public_send(group_by_attribute) }
+         .transform_values do |items|
+        items.map { |item| DocsKit::NavItem.new(href: item.href, label: item.title, icon: item.icon) }
+      end
+    end
+
+    # The default instance for a v2 `page` entry: readers + href + view_class
+    # resolved under the registry's view_namespace (nil until the class exists,
+    # preserving the no-dead-links behavior).
+    class Entry
+      attr_reader :slug, :title, :group, :icon, :view_name, :href
+
+      def initialize(attrs, path_prefix, view_namespace)
+        @slug = attrs[:slug]
+        @title = attrs[:title]
+        @group = attrs[:group]
+        @icon = attrs[:icon]
+        @view_name = attrs[:view]
+        @view_namespace = view_namespace
+        @href = "#{path_prefix}/#{@slug}"
+      end
+
+      # The authored Phlex page class, or nil until it's written.
+      def view_class
+        return unless @view_namespace
+
+        "#{@view_namespace}::#{@view_name}".safe_constantize
+      end
+    end
+  end
+end