#moon-mustache

#Project Summary

• Project name: moon-mustache
• Module name: Lyllyl789/mustache
• License: MIT
• Toolchain target: MoonBit 0.10.7
• Manifest format: current moon.mod / moon.pkg

#What It Supports

• Standard interpolation: {{var}}
• Unescaped interpolation: {{{var}}} and {{&var}}
• Sections: {{#var}}...{{/var}}
• Inverted sections: {{^var}}...{{/var}}
• Comments: {{! comment }}
• Partials: {{> partial}}
• Delimiter changes: {{=<% %>=}}
• Standalone tag trimming for comments, sections, partials, and delimiter changes
• Dotted lookup: {{user.profile.name}}
• Implicit iterator support with {{.}}

#Repository Layout

• mustache/ - core parser, renderer, lexer, AST, context, and tests
• examples/simple/ - minimal rendering example
• examples/partials/ - partial rendering example
• README.md - project overview and usage
• LICENSE - MIT license

#Quick Start

#1. Add the dependency

moon add Lyllyl789/mustache

import {
  "Lyllyl789/mustache/mustache",
}

#2. Render a template

fn main {
  let template = "Hello {{name}}! Welcome to {{location}}."
  let context : Json = {
    "name": "Lu Yilu",
    "location": "Beijing, China"
  }

  try {
    let output = @mustache.render_string(template, context)
    println(output)
  } catch {
    ParseError(msg) => println("Parse error: \{msg}")
    RenderError(msg) => println("Render error: \{msg}")
  }
}

#3. Run the examples

moon run examples/simple
moon run examples/partials

#Verification

moon check
moon build --target all
moon fmt --check
moon info
moon test

#Development Notes

• lexer.mbt converts Mustache syntax into tokens
• parser.mbt turns tokens into an AST
• context.mbt resolves variables and dotted paths
• render.mbt executes the AST against input JSON
• mustache_test.mbt covers interpolation, sections, inverted sections, comments, delimiter changes, partials, dotted lookup, implicit iterators, and standalone tag trimming

#Retrospective

• The renderer keeps parsing, context resolution, and output generation separate so each part can evolve independently.
• The test suite focuses on core Mustache behavior instead of a single happy path.
• MoonBit's built-in checks make it practical to keep formatting, interface generation, and tests in a single reproducible workflow.

#License

#Production API and safety boundaries

let options = @mustache.RenderOptions::new(
  max_partial_depth=32,
  missing_partial_is_error=true,
)
let html = @mustache.render_string_with_options(
  template,
  context,
  partials,
  options,
)

#Production tooling API

• Template::render_with_stats returns output together with visited-node, resolved-variable, missing-variable, section, partial, output-size, and recursion counters.
• Template::analyze, Template::references, and TemplateQuery expose static complexity, required variables, control-flow names, and partial dependencies without rendering user data.
• Template::validate and validate_string check empty references, maximum nesting, and the complete partial graph. Strict mode is suitable for a release gate; permissive mode reports optional partials as warnings.
• TemplateCache provides bounded compiled-template reuse with hit, miss, insertion, eviction, and invalidation counters.
• render_batch and Template::render_batch render independent records while preserving order and returning per-item failures rather than aborting a whole import job.
• TemplateBundle manages named templates and shared partials. TemplatePlan combines compiled code, source locations, cache keys, dependency metadata, validation, and checked rendering for build pipelines.
• TemplateCatalog publishes numbered revisions, tags them, and moves aliases such as stable without mutating an existing revision.
• TemplateRegistry supports atomic name replacement, revisions, enable/disable rollout, tag queries, source inspection, batch rendering, and release audits for long-running services.

let plan = @mustache.TemplatePlan::compile("Hello {{>card}} {{name}}")
let partials : Map[String, String] = { "card": "<b>{{name}}</b>" }
let options = @mustache.RenderOptions::new(
  max_output_chars=100000,
  max_nodes=10000,
  max_context_depth=32,
  missing_partial_is_error=true,
)
let output = plan.render_checked(
  { "name": "MoonBit" },
  partials~,
  options~,
)

#Behavior and boundary matrix

#Reproducible verification

moon version --all
moon update
moon check --target all --deny-warn
moon build --target all
moon fmt --check
moon info
moon test --target all
moon run examples/simple
moon run examples/partials
moon run examples/complex_html

#Open-source compliance

#Release checklist