schemagraphy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: af25a161a4a5cb922cb4686ab1e646c6b956a7b5d51b38501f6aba4f4d2a3f7c
+  data.tar.gz: 144e3abb6f698a525f77b10e01ccd9845e05d8b7ea42ccfcf42694e6de7c7aa9
+SHA512:
+  metadata.gz: 01b5f00420d26307215a11fc6e07b14ee3b6ae32b44a144bdf592aef741c27006e7970f7f8762a31e8356fd4cf8c89d8d7d641bfcedbd77898c81d51e7e41e5a
+  data.tar.gz: 8456db9732c0a1f14aed8d363e095331f235667b83048d17e718cd95146ba9dcc5a0dbdeaaa0b06ef594464d187bbb1d0e51c64af4d1379b19ee6807b81039fc

data/README.adoc

@@ -0,0 +1,260 @@
+= SchemaGraphy
+:toc: macro
+:toclevels: 3
+// tag::ai-prompt[]
+// tag::global-settings[]
+:this_proj_slug: schemagraphy
+:this_proj_name: {doctitle}
+// tag::universal-settings[]
+// ALL changes within this block must be made in prime template:
+//  DocOps/lab/gems/docopslab-dev/templates/README.asciidoc
+:docopslab_src_www_url: https://github.com/DocOps
+:docopslab_domain: docopslab.org
+:docopslab_www_url: https://{docopslab_domain}
+:docopslab_io_www_url: https://docopslab.github.io
+:docopslab_ruby_version: 3.2.7
+:docopslab_git_src_uri: git@github.com:DocOps
+:docopslab_src_raw_url: https://raw.githubusercontent.com/DocOps
+:this_proj_src_www_url: {docopslab_src_www_url}/{this_proj_slug}
+:this_proj_src_raw_url: {docopslab_src_raw_url}/{this_proj_slug}
+:this_proj_src_main_raw_url: {this_proj_src_raw_url}/main
+:this_proj_src_main_files_url: {this_proj_src_www_url}/blob/main
+:this_proj_src_git_uri: {docopslab_git_src_uri}/{this_proj_slug}.git
+:this_proj_ruby_version: {docopslab_ruby_version}
+// tag::env-settings[]
+:docs_extn:
+ifdef::env-github[]
+:docs_extn: .adoc
+:icons: font
+:caution-caption: :fire:
+:important-caption: :exclamation:
+:note-caption: :paperclip:
+:tip-caption: :bulb:
+:warning-caption: :warning:
+endif::[]
+// end::env-settings[]
+// Settings likely to be overridden locally
+:this_prod_slug: {this_proj_slug}
+:this_prod_name: {this_proj_name}
+:this_prod_src_www_url: {this_proj_src_www_url}
+// end::universal-settings[]
+// tag::product-settings[]
+// tag::version-settings[]
+:this_prod_ruby_version_prime: {docopslab_ruby_version_prime}
+:this_prod_ruby_version_range: {docopslab_ruby_version_range}
+:this_prod_vrsn_major: 0
+:this_prod_vrsn_minor: 1
+:this_prod_vrsn_majmin: {this_prod_vrsn_major}.{this_prod_vrsn_minor}
+:this_prod_vrsn_patch: 0
+:this_prod_vrsn_suffix:
+:this_prod_vrsn: {this_prod_vrsn_majmin}.{this_prod_vrsn_patch}{this_prod_vrsn_suffix}
+:next_prod_vrsn_majmin: 0.2
+:next_prod_vrsn_patch: 0
+:next_prod_vrsn: {next_prod_vrsn_majmin}.{next_prod_vrsn_patch}
+// end::version-settings[]
+:this_prod_www_url: https://{this_proj_slug}.{docopslab_domain}
+:this_prod_docs_url: {this_prod_www_url}/docs
+:gem_config_definition_path: ./specs/data/config-def.yml
+:app_default_config_path: ./.{this_prod_slug}.yml
+:docker_run_command: docker run -it --rm --user $(id -u):$(id -g) -v $(pwd):/workdir docopslab/{this_prod_slug} {this_prod_slug}
+// end::product-settings[]
+// end::global-settings[]
+// end::ai-prompt[]
+
+*SchemaGraphy* is an aspirational framework for governing data and technical content in flat-file formats.
+It is based in a modestly extended form of YAML syntax and preprocessing, and is designed to be used in a variety of contexts.
+
+For now, the _released and supported_ version of this project is a Ruby gem that provides a simple API for processing and validating specially formatted YAML files, mainly for generating single-sourced documentation from them.
+This gem is being released to support divergent downstream projects (so far: ReleaseHx and DocOps Lab's Jekyll extensions suite).
+
+SchemaGraphy is basically an extension of YAML, enabling Ruby developers and end users more broadly to powerfully interpret and schematize YAML-based data.
+Most relevant to our case, as enabled by the `SchemaGraphy` module in this gem, is its handling of *YAML custom tags*, *attribute resolution*, and what I am calling *"`templated fields`"*, where the value of a YAML node is a String that is intended to be further processed by a templating engine like Liquid or ERB, either immediately upon ingest or later in the runtime stack, when it can be mixed with additional data.
+
+SchemaGraphy facilitates handling these and other quirky power-ups we use with our fully valid YAML files, so low-code users can pass some dynamism along in their YAML configs and so forth.
+
+API reference documentation is published at link:https://rubydoc.info/gems/schemagraphy[rubydoc.info/gems/schemagraphy].
+
+
+[[attribute-resolution]]
+== Attribute Resolution
+
+SchemaGraphy provides *attribute resolution* capabilities through the `AttributeResolver` component.
+This enables YAML files to reference external attributes using placeholder syntax like `{attribute_name}`.
+
+When loading YAML with `.load_yaml_with_attributes(file_path, attributes)`, SchemaGraphy:
+
+. Loads the YAML file normally
+. Searches for `{attribute_name}` patterns in String values  
+. Replaces them with corresponding values from the provided attributes Hash
+. Returns the resolved YAML data structure
+
+This is used extensively in ReleaseHx's configuration system to enable single-sourcing of defaults from README attributes.
+
+
+[[custom-yaml-tag-handling]]
+== Custom YAML Tag Handling
+
+To enable end users to pass meta-instructions along with their data, wherever it will make sense to do so, SchemaGraphy offers a straightforward handling system.
+
+Wherever you parse YAML-formatted data using `.load_yaml_with_tags`, custom-tagged Scalar nodes are converted into Maps like so:
+
+.User's YAML
+[source,yaml]
+----
+some_property: !liquid "{{ some_value }}"
+----
+
+.Converted data TagMap
+[source,yaml]
+----
+some_property:
+  __tag__: liquid
+  value: "{{ some_value }}"
+----
+
+Developers may therefore conditionally interpret ingested data based on user-defined classifications, wherever the developer supports such things.
+
+Whether a Scalar has been transformed into a TagMap, you can resolve it using:
+
+[source,ruby]
+----
+SchemaGraphy::TagUtils.detag(some_property)
+# Or, with a local alias
+detag = ->(val) { SchemaGraphy::TagUtils.detag(val) }
+detag(some_property)
+----
+
+When tags are used this way, to convey a syntax/engine for processing a template or other dynamic content, SchemaGraphy can even help us handle the content in the manner designated by the tag.
+This will come up again in <<templated-fields,the next section>>.
+
+[NOTE]
+This capability is only available on Scalar node values.
+For now, tags applied to other compound node types (Arrays/sequences, Maps/mappings) will be ignored by SchemaGraphy interpreters.
+
+[WARNING]
+When you use `load_yaml_with_tags`, you will encounter errors downstream if a user places a tag on a node where you do not expect it.
+
+
+[[templated-fields]]
+== Templated Property Values in YAML
+
+We are calling these "`templated fields`" to specify that we are talking about enabling end users to use Liquid, ERB, or eventually other templating syntaxes in YAML node values.
+
+In so doing, developer are able to designate that the value of certain YAML nodes should be handled by a templating engine, as well as when and how.
+
+We'll look at how this is done in <<templated-fields-handling>>.
+For now, the point is that sometimes files like `specs/data/config-def.yml` or an API-mapping file call for a little more runtime dynamism than a low-code solution like pure YAML can support.
+
+Therefore, when the value of a user-configurable or environment-deterimined "`setting`" is a string that must be generated from data defined outside that field, we parse and render the template at runtime, using data from the environment or elsewhere.
+For now, it is up to our calling code to provide the appropriate variables to the template depending on the context.
+
+
+[[config-def]]
+== Configuration Definition (CFGYML)
+
+All user-configurable settings have a definition, if not also a default value.
+For single-sourcing purposes, these are defined in a YAML format called CFGYML -- a configuration-file modeling language.
+
+The file is at `{gem_config_definition_path}`.
+It is used to establish the literal default settings carried by the application, and also to document those settings for the user.
+
+This practice lets developers give end users extremely detailed configurations, always well documented.
+
+[[attribute-resolution-in-cfgyml]]
+=== Attribute Resolution in CFGYML
+
+CFGYML supports *attribute resolution* from AsciiDoc files (like this README) using placeholder syntax.
+Default values can reference README attributes using `{attribute_name}` syntax:
+
+[source,yaml]
+----
+properties:
+  $meta:
+    properties:
+      markup:
+        dflt: "{default_markup}"  # Resolved from README.adoc :default_markup: attribute
+----
+
+This enables single-sourcing of configuration defaults from README attributes, ensuring that documentation and defaults stay synchronized.
+
+[[cfgyml-schema-structure]]
+=== CFGYML Schema Structure
+
+The basic schema is somewhat straightforward.
+Essentially, you're nesting Map objects within a YAML key `properties`, and each property (setting) of the defined config file can be described and constrained.
+
+Each setting can have a type, description (`desc`), default (`dflt`), and templated-field instructions (`templating`).
+If the setting is itself a of type `Map` (YAML "`mapping`", JSON "`object`"), its own nested parameters can be established with a `properties:` block.
+
+For now, you can designate the type, which you will have to enforce in your code, as well as a default value.
+
+
+[[sgyml-schemas]]
+== SGYML Schemas
+
+Similar to but more complicated than CFGYML definition files are SchemaGraphy schema files.
+This is a partially specified, partially developed, and as-yet-incomplete syntax for designating and constraining YAML documents.
+
+ReleaseHx and CFGYML at this time make active use of only minimal aspects of these schemas.
+
+Each of the YAML formats used by ReleaseHx has its own schema in the repo.
+The cfgyml-schema.yaml file will eventually be spun off, but the `specs/data/rhyml-schema.yaml` and `specs/data/rhyml-mapping-schema.yaml` files will stay here, defining valid formats for the types of files they apply to.
+
+Since SchemaGraphy itself is still unreleased, CFGYML as introduced in this gem offers only a subset of what it will enable down the road.
+
+Once SchemaGraphy is generally available, this gem will call it as a dependency.
+At that point, a file like `specs/data/config-def.yml` (CFGYML) will be able to impose a more detailed `$schema` for any property.
+
+
+[[templated-fields-handling]]
+== Dynamic Templated-field Handling
+
+The most powerful function of SchemaGraphy schemas that is now available in ReleaseHx is the ability to instruct how templated fields should be processed at different stages, and also to parse and render them as needed.
+
+Templated-field handling can be established between a combination of (1) CFGYML definition files or SGYML schema files and (2) configuration files to be applied at runtime.
+
+Developers can designate a given property to be `type: Template` in a schema or definition.
+This "`typing`" can be a trigger for downstream parsing/rendering of the template.
+
+[NOTE]
+Liquid uses these two stages.
+The _parse_ operation compiles a template into a `Liquid::Template` object.
+The _render_ operation applies a dataset to the loaded template, generating a String with Liquid tags resolved.
+
+[[nyi]]
+== Not Yet Implemented
+
+Most aspects of SchemaGraphy/SGYML are planned but not yet available, but some are worth pointing out.
+
+data types::
+As of now, the `type` node of any property in `specs/data/config-def.yml` is not particularly functional.
+I do have a whole table of "`data types`" in SGYML, most of which are extremely self-explanatory and drawn from fairly platonic, cross-language terms.
++
+However, these are entirely unenforced in ReleaseHx -- for now, data still has to be type checked explicitly in the Ruby code, and user configs are not validated against any kind of typing system.
+
+schema docs::
+The schema files do not yet generate complete reference docs for the subject files that they govern.
+So for instance, you'll have to read files like `specs/data/rhyml-schema.yaml` and `specs/data/rhyml-mapping-schema.yaml` directly to understand the format of RHYML files and how they are mapped to REST response payloads.
+
+SGYML validation and resolvers::
+The SGYML schemas are not yet being used to validate YAML files or to dereference `$ref` nodes and other enhancements.
+
+URIx specification::
+A lightweight standard for designating and parsing extended URIs to enable identification of structured data/text in flat files at any address.
+
+[[future]]
+=== The Future of SchemaGraphy
+
+// tag::features[]
+* Add [.buzz]*transclusion* (`$ref`) capability to YAML documents
+* Govern [.buzz]*serialized, nested data* objects, including default properties and _inter-object relationships_.
+* Constrain [.buzz]*AsciiDoc*, [.buzz]*Markdown*, [.buzz]*restructuredText*, and any other lightweight markup _text formatting_ to meet your custom standards.
+* Generate [.buzz]*linter definitions* based on your schemas.
+* Automatically [.buzz]*generate documentation* for APIs, config files, and marked-up datasets.
+* Even [.buzz.nokey]*validate HTML and rich-test* output of your source markup!
+* Port to and from third-party schema models like [.buzz]*JSON Schema** and [.buzz]*GraphQL*.
+* [.buzz.nokey]*Render HTML forms* for data collection with one click.
+* Ingest [.buzz.nokey]*default values* from a config file definition.
+* [.buzz.nokey]*Generate stubs/drafts* data and documents.
+* All with [.buzz.nokey]*human-friendly YAML* files and objects, with AsciiDoc supported internally...
+// end::features[]

data/lib/schemagraphy/attribute_resolver.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SchemaGraphy
+  # The AttributeResolver module provides methods for resolving AsciiDoc attribute references
+  # within a schema hash. It is used to substitute placeholders like `\{attribute_name}`
+  # with actual values.
+  module AttributeResolver
+    # Recursively walk a schema Hash and resolve `\{attribute_name}` references
+    # in 'dflt' values.
+    #
+    # @param schema [Hash] The schema or definition hash to process.
+    # @param attrs [Hash] The key-value pairs from AsciiDoc attributes to use for resolution.
+    # @return [Hash] The schema with resolved attributes.
+    def self.resolve_attributes! schema, attrs
+      case schema
+      when Hash
+        schema.transform_values! do |value|
+          if value.is_a?(Hash)
+            if value.key?('dflt') && value['dflt'].is_a?(String)
+              value['dflt'] = resolve_attribute_reference(value['dflt'], attrs)
+            end
+            resolve_attributes!(value, attrs)
+          else
+            value
+          end
+        end
+      end
+      schema
+    end
+
+    # Replace `\{attribute_name}` patterns with corresponding values from the attrs hash.
+    #
+    # @param value [String] The string to process.
+    # @param attrs [Hash] The attributes to use for resolution.
+    # @return [String] The processed string with attribute references replaced.
+    def self.resolve_attribute_reference value, attrs
+      # Handle \{attribute_name} references
+      if value.match?(/\{[^}]+\}/)
+        value.gsub(/\{([^}]+)\}/) do |match|
+          attr_name = ::Regexp.last_match(1)
+          attrs[attr_name] || match # Keep original if no matching attribute
+        end
+      else
+        value
+      end
+    end
+  end
+end

data/lib/schemagraphy/cfgyml/definition.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative '../loader'
+require_relative '../schema_utils'
+
+module SchemaGraphy
+  # A module for handling CFGYML, a schema-driven configuration system.
+  module CFGYML
+    # Represents a configuration definition loaded from a schema file.
+    # It provides methods for accessing defaults and rendering documentation.
+    class Definition
+      # @return [Hash] The loaded schema hash.
+      attr_reader :schema
+
+      # @return [Hash] The attributes used for resolving placeholders in the schema.
+      attr_reader :attributes
+
+      # @param schema_path [String] The path to the schema YAML file.
+      # @param attrs [Hash] A hash of attributes for placeholder resolution.
+      def initialize schema_path, attrs = {}
+        @schema = Loader.load_yaml_with_attributes(schema_path, attrs)
+        @attributes = attrs
+      end
+
+      # Extract default values from the loaded schema.
+      # @return [Hash] A hash of default values.
+      # @note This method is a placeholder. SchemaUtils.crawl_defaults/1 is not yet implemented.
+      def defaults
+        # TODO: Implement crawl_defaults in SchemaUtils
+        # For now, return an empty hash
+        {}
+      end
+
+      # Get the search paths for templates.
+      # @return [Array<String>] An array of template paths.
+      def template_paths
+        @template_paths ||= [
+          File.join(File.dirname(__FILE__), 'templates'),
+          *additional_template_paths
+        ]
+      end
+
+      # Render a configuration reference or sample in the specified format.
+      #
+      # @param format [Symbol] The output format (`:adoc` or `:yaml`).
+      # @return [String] The rendered output.
+      # @raise [ArgumentError] if the format is unsupported.
+      def render_reference format = :adoc
+        template = case format
+                   when :adoc
+                     'config-reference.adoc.liquid'
+                   when :yaml
+                     'sample-config.yaml.liquid'
+                   else
+                     raise ArgumentError, "Unsupported format: #{format}"
+                   end
+
+        render_template(template)
+      end
+
+      private
+
+      # Render a template using the Liquid engine.
+      def render_template template_name
+        template_path = find_template(template_name)
+        raise "Template not found: #{template_name}" unless template_path
+
+        require 'liquid'
+        template_content = File.read(template_path)
+        template = Liquid::Template.parse(template_content)
+
+        template.render(
+          'config_def' => @schema,
+          'attrs' => @attributes)
+      end
+
+      # Find a template file in the configured template paths.
+      def find_template name
+        template_paths.each do |path|
+          file = File.join(path, name)
+          return file if File.exist?(file)
+        end
+        nil
+      end
+
+      # Provides an extension point for subclasses to add more template paths.
+      def additional_template_paths
+        # Can be overridden by subclasses
+        []
+      end
+    end
+  end
+end

data/lib/schemagraphy/cfgyml/doc_builder.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module SchemaGraphy
+  module CFGYML
+    # Builds documentation-friendly CFGYML references for machine consumption.
+    module DocBuilder
+      module_function
+
+      def call schema, options = {}
+        pretty = options.fetch(:pretty, true)
+        data = reference_hash(schema)
+        pretty ? JSON.pretty_generate(data) : JSON.generate(data)
+      end
+
+      def reference_hash schema
+        {
+          'format' => 'releasehx-config-reference',
+          'version' => 1,
+          'properties' => build_properties(schema['properties'], [])
+        }
+      end
+
+      def build_properties properties, path
+        return {} unless properties.is_a?(Hash)
+
+        properties.each_with_object({}) do |(key, definition), acc|
+          next unless definition.is_a?(Hash)
+
+          current_path = path + [key]
+          entry = build_entry(current_path, definition)
+          children = build_properties(definition['properties'], current_path)
+          entry['properties'] = children unless children.empty?
+          acc[key] = entry
+        end
+      end
+
+      def build_entry path, definition
+        entry = {
+          'path' => path.join('.'),
+          'desc' => definition['desc'],
+          'docs' => definition['docs'],
+          'type' => definition['type'],
+          'templating' => definition['templating'],
+          'default' => definition.key?('dflt') ? definition['dflt'] : nil
+        }
+        entry.compact
+      end
+    end
+  end
+end

data/lib/schemagraphy/cfgyml/path_reference.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module SchemaGraphy
+  module CFGYML
+    # Loads and queries a JSON config reference using JSON Pointer.
+    class PathReference
+      def initialize data
+        @data = data
+      end
+
+      def self.load path
+        new(JSON.parse(File.read(path)))
+      end
+
+      def get pointer
+        SchemaGraphy::DataQuery::JSONPointer.resolve(@data, pointer)
+      end
+    end
+
+    Reference = PathReference
+  end
+end

data/lib/schemagraphy/cfgyml/templates/config-property.adoc.liquid

@@ -0,0 +1,57 @@
+{%- assign pname = include.property[0] %}
+{%- assign pbody = include.property[1] %}
+{%- assign pid   = include.ppty_path | replace: "__", "_" | replace: "<", "_" | replace: ">", "_" | replace: "$", "DOLLARSIGN_" | prepend: "conf_ppty_" %}
+{%- assign ppath = include.ppty_path | replace: "__", "." | replace: "DOLLARSIGN_", "$" %}
+{%- case include.tier %}
+{%- when 1 %}
+{%-   assign dlchars = "::" %}
+{%- when 2 %}
+{%-   assign dlchars = ":::" %}
+{%- when 3 %}
+{%-   assign dlchars = "::::" %}
+{%- else %}
+{%-   assign dlchars = ";;" %}
+{%- endcase %}
+
+[[{{ pid }},config.{{ ppath }}]]
+{{ ppath }}{{ dlchars }}
++
+--
+{{ pbody.desc }}
+{%- if pbody.docs %}
+{{ pbody.docs }}
+{%- endif %}
+
+[horizontal]
+{%-   if pbody.type %}
+type;; {{ pbody.type }}
+{%-   endif %}
+{%-   if pbody.templating %}
+templating;; {% if pbody.templating.default %}{{ pbody.templating.default }}{% if pbody.templating.delay %}, {% endif %}{% endif %}{% if pbody.templating.delay %} delayed{% else %} immediate{% endif %} rendering
+{%-   endif %}
+{%-   if pbody.dflt != nil %}
+default;;
++
+{%-     if pbody.dflt.first %}
+{%-       if pbody.dflt.size > 0 %}
+....
+{%-         for item in pbody.dflt %}
+- {{ item }}
+{%-         endfor %}
+....
+{%-       else %}
+[_empty array_]
+{%-       endif %}
+{%-     else %}
+{%-       if pbody.dflt contains '
+' or pbody.dflt.size > 20 %}
+....
+{{ pbody.dflt | trim }}
+....
+{%-        else %}
+`+++{{ pbody.dflt | trim }}+++`
+{%-        endif %}
+{%-     endif %}
+{%-   endif %}
+path;; `xref:{{ pid }}[{{ ppath | prepend: "config." }}]`
+--

data/lib/schemagraphy/cfgyml/templates/config-reference.adoc.liquid

@@ -0,0 +1,33 @@
+{%- for property in config_def.properties -%}
+{%-   assign ppty_key1 = property[0] -%}
+{%-   assign ppty_path_t1 = ppty_key1 -%}
+{%-   include config-property.adoc.liquid
+        test_string="test string"
+        property=property
+        tier=1
+        ppty_path=ppty_path_t1 -%}
+
+{%-   assign props_t2 = property[1].properties -%}
+{%-   if props_t2 -%}
+{%-     for propty in props_t2 -%}
+{%-       assign ppty_key2 = propty[0] -%}
+{%-       assign ppty_path_t2 = ppty_path_t1 | append: '__' | append: ppty_key2 -%}
+{%-       include config-property.adoc.liquid
+            property=propty
+            tier=2
+            ppty_path=ppty_path_t2 -%}
+
+{%-       assign props_t3 = propty[1].properties -%}
+{%-       if props_t2 -%}
+{%-         for ppty in props_t3 -%}
+{%-           assign ppty_key3 = ppty[0] -%}
+{%-           assign ppty_path_t3 = ppty_path_t2 | append: '__' | append: ppty_key3 -%}
+{%-           include config-property.adoc.liquid
+                property=ppty
+                tier=3
+                ppty_path=ppty_path_t3 -%}
+{%-         endfor -%}
+{%-       endif -%}
+{%-     endfor -%}
+{%-   endif -%}
+{%- endfor %}

data/lib/schemagraphy/cfgyml/templates/sample-config.yaml.liquid

@@ -0,0 +1,46 @@
+# Sample configuration file generated from the configuration definition.
+# All values are upstream (gem) defaults.
+# Properties without defaults are commented out.
+{%- for property_t1 in config_def.properties %}
+{%-   assign key1 = property_t1[0] %}
+{%-   assign val1 = property_t1[1] %}
+{%-   assign dflt1 = val1.dflt %}
+{%-   assign key1_first_char = key1 | slice: 0, 1 %}
+{%-   if key1_first_char == '<' or dflt1 == nil and val1.properties == nil %}
+{%-     assign nulled1 = true %}
+{%-   else %}
+{%-     assign nulled1 = false %}
+{%-   endif %}
+{%-   include sample-property.yaml.liquid property=property_t1 tier=1 nulled=nulled1 %}
+{%-   assign sub_properties_t2 = val1.properties %}
+{%-   if sub_properties_t2 %}
+{%-     for property_t2 in sub_properties_t2 %}
+{%-       assign key2 = property_t2[0] %}
+{%-       assign val2 = property_t2[1] %}
+{%-       assign dflt2 = val2.dflt %}
+{%-       assign key2_first_char = key2 | slice: 0, 1 %}
+{%-       if nulled1 or (key2_first_char == '<' or (dflt2 == nil and val2.properties == nil)) %}
+{%-         assign nulled2 = true %}
+{%-       else %}
+{%-         assign nulled2 = false %}
+{%-       endif %}
+{%-       include sample-property.yaml.liquid property=property_t2 tier=2 nulled=nulled2 %}
+
+{%-       assign sub_properties_t3 = val2.properties %}
+{%-       if sub_properties_t3 %}
+{%-         for property_t3 in sub_properties_t3 %}
+{%-           assign key3 = property_t3[0] %}
+{%-           assign val3 = property_t3[1] %}
+{%-           assign dflt3 = val3.dflt %}
+{%-           assign key3_first_char = key3 | slice: 0, 1 %}
+{%-           if nulled2 or (key3_first_char == '<' or (dflt3 == nil and val3.properties == nil)) %}
+{%-             assign nulled3 = true %}
+{%-           else %}
+{%-             assign nulled3 = false %}
+{%-           endif %}
+{%-           include sample-property.yaml.liquid property=property_t3 tier=3 nulled=nulled3 %}
+{%-         endfor %}
+{%-       endif %}
+{%-     endfor %}
+{%-   endif %}
+{%- endfor %}