How deb4sh/yart works
Project type and purpose
• YART is an open-source, schema-based command-line templating tool (Java CLI application) that:
• Validates a YAML config against a JSON schema
• Renders Jinja2 templates (via Jinjava) into files and directories
• Supports one-level dynamic folder generation
• Offers an extension mechanism (ExtensionProvider subclasses loaded via reflection)
Key components from file structure & README
• Entry point & CLI parsing:
• de.b4sh.yart.Runtime uses picocli for parsing --templatedirectory, --schemadirectory, --configfile, --outputdirectory
• Schema handling:
• snakeyaml loads YAML config
• justify (JSON-schema) validates against the entry schema and any subschemas
• Template processing:
• de.b4sh.yart.Templater wraps Jinjava
• Data model (validated config) + loaded extensions → template rendering
• Extension mechanism:
• ExtensionLoader uses reflections to find all subclasses of ExtensionProvider under de.b4sh.yart.extensions
• Each provider exposes a namespace, function name, and implementation for use in templates
• File I/O & directory logic:
• FileHelper reads/writes files & directories
• Dynamic folder generation: directories prefixed with $ in the template tree are replicated per array element in config
• Packaging & deployment:
• Built with Maven (pom.xml), produces “jar-with-dependencies”
• Dockerfile under src/docker/ for containerized distribution
• GitHub Actions workflow for build & publish
Main components & interactions (
• User / CI pipeline → CLI Invocation (picocli)
↓
• Runtime Orchestrator
• Parses CLI args
• Delegates to modules in sequence:
1. Schema Validator (snakeyaml → justify)
2. Extension Loader (reflections → load ExtensionProviders)
3. Template Scanner (FileHelper scans template directory, detects dynamic dirs)
4. Templater Engine (Jinjava + extensions + validated data)
5. Output Writer (FileHelper writes files/folders to output directory)
↓
• File System (template directory, schema directory, config file) → Output Directory
Architectural patterns & design principles
• Modular pipeline: clear separation of concerns (validation, templating, I/O, extensibility)
• Reflection-based plugin architecture for extensions
• Single responsibility classes (Runtime, Templater, ExtensionLoader, FileHelper)
• Immutable data flow: load → validate → render → write
Technologies & external libraries
• CLI: picocli
• YAML parsing: snakeyaml
• JSON-schema validation: justify
• Templating: Jinjava
• Extension discovery: reflections
• Build: Maven (jar-with-dependencies), Docker
Essential elements
• Clear labels for: CLI Parser, Runtime, Schema Validator, Extension Loader, Templater, FileHelper
• CLI args → Runtime
• Runtime → Schema Validator → validated data
• Runtime → Extension Loader → list of functions → Jinjava
• Runtime → FileHelper (scan templates) → template tree + dynamic markers
• Templater + data + extensions → rendered file content → FileHelper (write)
• Blue: core modules
• Green: external libraries
• Gray: filesystem components