matrix-spec/layouts/partials/openapi/render-object-table.html

{{/*

  Render a table listing the properties of an object, given:

  * `title`: optional caption for the table

  * `anchor`: optional HTML element id for the table

  * `properties`: dictionary of the properties to list, each given as:
    `property_name` : `property_data`

  * `required`: array containing the names of required properties.
    In some cases (such as response body specifications) this isn't used, and
    instead properties have a `required` boolean attribute. We support this too.

*/}}

{{ $title := .title }}
{{ $properties := .properties}}
{{ $required := .required}}

{{ if $properties }}

<table{{ if .anchor }} id="{{ .anchor }}"{{ end }} class="object-table">
 {{ with $title }}
 <caption>{{ . }}</caption>
 {{ end }}
 <thead>
  <th class="col-name">Name</th>
  <th class="col-type">Type</th>
  <th class="col-description">Description</th>
 </thead>

    {{ range $property_name, $property := $properties }}

        {{ $property := partial "json-schema/resolve-allof" $property }}

        {{/*
          Handle two ways of indicating "required", one for simple parameters,
          the other for request and response body objects.
        */}}
        {{ $required := cond (or (in $required $property_name) ( eq $property.required true )) true false }}

 <tr>
  <td><code>{{ $property_name }}</code></td>
  <td><code>{{ partial "partials/property-type" $property }}</code></td>
  <td>
    {{ if $required }}<strong>Required: </strong>{{end -}}
    {{ $property.description | markdownify -}}
    {{ if $property.enum }}<p>One of: <code>[{{ delimit $property.enum ", " }}]</code>.</p>{{ end -}}
    {{ if (index $property "x-addedInMatrixVersion") }}{{ partial "added-in" (dict "v" (index $property "x-addedInMatrixVersion")) }}{{ end -}}
    {{ if (index $property "x-changedInMatrixVersion") }}{{ partial "changed-in" (dict "changes_dict" (index $property "x-changedInMatrixVersion")) }}{{ end -}}
  </td>
 </tr>

    {{ end }}

</table>

{{ end }}

{{/*
    Computes the type to display for a property.
*/}}
{{ define "partials/property-type" }}
    {{ $type := .type }}

    {{ if or (eq .type "object") (and .oneOf (reflect.IsSlice .oneOf)) }}
        {{ $type = partial "type-or-title" . }}
    {{ end }}

    {{/*
        If the property is an array, indicate this with square brackets,
        like `[type]`.
    */}}
    {{ if eq .type "array"}}
        {{ $items := .items }}
        {{ if .items }}
            {{ $items = partial "json-schema/resolve-allof" .items }}
        {{ end }}
        {{ $inner_type := partial "type-or-title" $items }}
        {{ $type = delimit (slice "[" $inner_type "]") "" }}
    {{ end }}

    {{ return $type }}
{{ end }}

{{/*
   Picks either the `title` of a property, or the `type`, to turn into the rendered type field.
   Also handles `additionalProperties`, if no `title` is present.
*/}}
{{ define "partials/type-or-title" }}
    {{ $type := "" }}
    {{ if .title }}
        {{/*
            If the property has a `title`, use that rather than `type`.
            This means we can write things like `EventFilter` rather than `object`.
        */}}
        {{ $type = .title }}
    {{ else if reflect.IsMap .additionalProperties }}
        {{/*
            If the property uses `additionalProperties` to describe its
            internal structure, handle this with a bit of recursion
        */}}
        {{ $additionalProperties := partial "json-schema/resolve-allof" .additionalProperties }}
        {{ $type = delimit (slice "{string: " (partial "property-type" $additionalProperties) "}" ) "" }}
    {{ else if reflect.IsMap .patternProperties }}
        {{/*
            If the property uses `patternProperties` to describe its
            internal structure, handle this with a bit of recursion.
            Note that we ignore the pattern as the current definitions
            always have a single pattern, but we might need to handle
            them later to differentiate schemas according to patterns.
        */}}
        {{ $types := slice }}

        {{ range $pattern, $schema := .patternProperties}}
            {{ $schema = partial "json-schema/resolve-allof" $schema }}
            {{ $types = $types | append (partial "property-type" $schema) }}
        {{ end }}

        {{ $type = delimit (slice "{string: " (delimit $types "|") "}" ) "" }}
    {{ else if reflect.IsSlice .type }}
        {{/* It's legal to specify an array of types. Join them together in that case */}}

        {{ $types := slice }}

        {{ range .type }}
            {{ $types = $types | append . }}
        {{ end }}

        {{ $type = delimit $types "|" }}
    {{ else if and .oneOf (reflect.IsSlice .oneOf) }}
        {{/*
            This is like an array of types except some of the types probably have a schema.
            Join them together too.
        */}}

        {{ $types := slice }}

        {{ range .oneOf }}
            {{ $types = $types | append (partial "type-or-title" .) }}
        {{ end }}

        {{ $type = delimit $types "|" }}
    {{ else }}
        {{ $type = .type }}
    {{ end }}
    {{ return $type }}
{{ end }}