Get-ManifestsUnderPath @getManifestsUnderPathSplat

}

} else {

# Return all templates included with Plaster.

# When running from source this function is dot-sourced from Public/, so

# $PSScriptRoot points at Public/ and Templates/ lives one level up. The

# compiled build flattens everything to the module root, where the first path is correct.

$templatesRoot = Join-Path $PSScriptRoot 'Templates'

if (-not (Test-Path -LiteralPath $templatesRoot)) {

$templatesRoot = Join-Path (Split-Path $PSScriptRoot -Parent) 'Templates'

}

$getManifestsUnderPathSplat = @{

RootPath = $templatesRoot

Recurse = $true

Name = $Name

Tag = $Tag

begin {

$schemaPath = [System.IO.Path]::Combine($PSScriptRoot, "Schema", "PlasterManifest-v1.xsd")

# When running from source, this function is dot-sourced from Public/, so

# $PSScriptRoot points at Public/ and Schema/ lives one level up. The compiled

# build flattens everything to the module root, where the first path is correct.

if (-not (Test-Path -LiteralPath $schemaPath)) {

$schemaPath = [System.IO.Path]::Combine((Split-Path $PSScriptRoot -Parent), "Schema", "PlasterManifest-v1.xsd")

}

# Schema validation is not available on .NET Core - at the moment.

if ('System.Xml.Schema.XmlSchemaSet' -as [type]) {

$xmlSchemaSet = New-Object System.Xml.Schema.XmlSchemaSet

output/

[CmdletBinding()]

param()

$ErrorActionPreference = 'Stop'

$root = Split-Path $PSScriptRoot -Parent

$templates = Join-Path $PSScriptRoot 'templates'

$outputDir = Join-Path $PSScriptRoot 'output'

Import-Module (Join-Path $root 'Plaster\Plaster.psd1') -Force

function Write-Header($Text) {

Write-Host ''

Write-Host ('=' * 70) -ForegroundColor DarkBlue

Write-Host " $Text" -ForegroundColor Yellow

Write-Host ('=' * 70) -ForegroundColor DarkBlue

}

Write-Header 'DEMO 4a - Discover templates with Get-PlasterTemplate'

Write-Host "`n Templates that ship with Plaster:" -ForegroundColor Green

Get-PlasterTemplate | Format-Table Name, Version, Title -AutoSize

Write-Host " Your own templates (any folder, -Recurse):" -ForegroundColor Green

Get-PlasterTemplate -Path $templates -Recurse | Format-Table Name, Version, Title, Tags -AutoSize

Write-Header 'DEMO 4b - Author a new manifest with New-PlasterManifest'

$scratch = Join-Path $outputDir 'authored-template'

if (Test-Path $scratch) { Remove-Item $scratch -Recurse -Force }

New-Item $scratch -ItemType Directory | Out-Null

'Write-Host "Hello from <%= $PLASTER_PARAM_Thing %>"' | Set-Content (Join-Path $scratch 'thing.ps1')

'# Notes about <%= $PLASTER_PARAM_Thing %>' | Set-Content (Join-Path $scratch 'NOTES.md')

Write-Host "`n Generating plasterManifest.json (-AddContent scans the folder)..." -ForegroundColor Green

New-PlasterManifest -Path (Join-Path $scratch 'plasterManifest.json') `

-TemplateName 'MyTinyTemplate' -TemplateType Item `

-Title 'My Tiny Template' -Description 'Authored live on stage' `

-Author 'Grace Hopper' -Tags Demo, Authoring -AddContent

Write-Host " --- authored plasterManifest.json ---" -ForegroundColor DarkGray

Get-Content (Join-Path $scratch 'plasterManifest.json') | ForEach-Object { " $_" }

Write-Header 'DEMO 4c - Validate it with Test-PlasterManifest'

$manifest = Test-PlasterManifest -Path (Join-Path $scratch 'plasterManifest.json') 3>$null

if ($manifest) {

Write-Host "`n Valid. name='$($manifest.plasterManifest.metadata.name)' type='$($manifest.plasterManifest.templateType)'" -ForegroundColor Green

}

Write-Header 'DEMO 4d - Use the template we just authored'

$json = Get-Content (Join-Path $scratch 'plasterManifest.json') -Raw | ConvertFrom-Json

$json.parameters = @(

[pscustomobject]@{ name = 'Thing'; type = 'text'; prompt = 'Name the thing'; default = 'Sproket' }

)

foreach ($action in $json.content) { $action.type = 'templateFile' }

$json | ConvertTo-Json -Depth 10 | Set-Content (Join-Path $scratch 'plasterManifest.json')

$dst = Join-Path $outputDir '04-authored-output'

if (Test-Path $dst) { Remove-Item $dst -Recurse -Force }

Invoke-Plaster -TemplatePath $scratch -DestinationPath $dst -NoLogo -Thing 'Sproket'

Write-Host "`n --- thing.ps1 (generated from our authored template) ---" -ForegroundColor DarkGray

Get-Content (Join-Path $dst 'thing.ps1') | ForEach-Object { " $_" }

Write-Host "`nDemo 4 complete.`n" -ForegroundColor Cyan

Three ready-to-run demos showing **Plaster** scaffolding with both manifest formats,

using dummy data (Contoso / Fabrikam / Acme / Ada Lovelace).

| # | Format | Template | Shows off |

|---|--------|----------|-----------|

| 1 | **XML** | `templates/01-xml-greeter` | Classic format, `${PLASTER_PARAM_X}` syntax, `choice` param, `templateFile`, `message` |

| 2 | **JSON** | `templates/02-json-greeter` | Same template, modern format: `${X}` syntax, `&`-labels without XML escaping |

| 3 | **JSON** | `templates/03-json-module` | `multichoice` (native `[0,1]` array default), `pattern` validation, `user-fullname` (git), **conditional** content, `newModuleManifest`, `modify` |

| 4 | both | `Demo4-Discovery-Authoring.ps1` | The surrounding cmdlets: `Get-PlasterTemplate` (discover), `New-PlasterManifest` (author), `Test-PlasterManifest` (validate), then scaffold from the authored template |

Every parameter is passed on the command line, so nothing prompts and the run is

deterministic. Generated projects land in `demos/output/`.

Plaster turns each template parameter into a real cmdlet parameter *and* prompts for

any you omit. To demo the interactive Q&A, run a template by hand and leave parameters off:

You'll get prompts for the module name (with regex validation), author (pre-filled from

`git config user.name`), a single-choice license menu, and a multi-select feature list.

Run it from a real terminal — the VS Code integrated terminal works; piped/non-TTY hosts do not.

- **One engine, two formats.** Internally Plaster converts JSON manifests to the same XML

structure the engine has always used, so JSON is purely an authoring convenience with

zero behavioral difference. (See `Plaster/Private/ConvertFrom-JsonManifest.ps1`.)

- **Variable syntax differs by location:**

- *Manifest attributes* (`destination`, message `text`): JSON lets you write the short

`${ModuleName}`; Plaster rewrites it to `${PLASTER_PARAM_ModuleName}` automatically.

- *`condition` expressions* and *template file bodies* (`<%= ... %>`): use the **full**

`$PLASTER_PARAM_ModuleName` form — those paths are not rewritten.

- **Conditions exclude files.** In Demo 3, `Build` is deselected, so `build.ps1` is never

created — show the output tree to make the point.

- **`modify` edits an already-generated file.** Demo 3 generates `README.md` with a

`__LICENSE__` placeholder, then a `modify` action swaps in the chosen license.

- **Safety.** Templates are declarative and expressions run in a *constrained runspace* —

a template can't run arbitrary destructive code. (See `New-ConstrainedRunspace.ps1`.)

`01-xml-greeter/plasterManifest.xml` vs `02-json-greeter/plasterManifest.json` produce an

equivalent script. Good slide material for the XML-vs-JSON contrast:

- XML: `<choice label="&amp;Hello" .../>` → JSON: `{ "label": "&Hello" }` (no escaping)

- XML: `default="0"` string → JSON: `"default": 0` (and `[0, 1]` for multichoice)

- XML: `${PLASTER_PARAM_ScriptName}` → JSON: `${ScriptName}`

Running the templates from source surfaced three small bugs that these demos depend on; all

are fixed in this branch:

1. `Test-PlasterManifest` resolved the XML schema (`PlasterManifest-v1.xsd`) relative to

`Public/` when run from source — added a one-level-up fallback.

2. `ConvertFrom-JsonContentAction` leaked `AppendChild` return values into the pipeline for

`modify` actions, returning an array instead of a single element — suppressed with `$null =`.

3. `Get-PlasterTemplate` (no args) looked for the bundled `Templates/` folder relative to

`Public/` when run from source — added the same one-level-up fallback.

All three share one root cause: when the module runs from source its functions are

dot-sourced from `Public/`/`Private/`, so `$PSScriptRoot` points one level below the module

root. The compiled build in `Output/` flattens everything to the root, so it was already fine —

but it has been rebuilt (`.\build.ps1`) anyway so source and compiled match.

[CmdletBinding()]

param(

[ValidateSet('1', '2', '3', '4', 'All')]

[string]$Demo = 'All'

)

$ErrorActionPreference = 'Stop'

$root = Split-Path $PSScriptRoot -Parent

$outputDir = Join-Path $PSScriptRoot 'output'

$templates = Join-Path $PSScriptRoot 'templates'

$moduleToLoad = Join-Path $root 'Plaster\Plaster.psd1'

Write-Host "Loading Plaster from: $moduleToLoad" -ForegroundColor DarkGray

Import-Module $moduleToLoad -Force

if (Test-Path $outputDir) { Remove-Item $outputDir -Recurse -Force }

New-Item $outputDir -ItemType Directory | Out-Null

function Show-Tree($Path) {

Get-ChildItem $Path -Recurse -File |

ForEach-Object { ' ' + $_.FullName.Substring($Path.Length + 1) } |

Sort-Object

}

function Write-Header($Text) {

Write-Host ''

Write-Host ('=' * 70) -ForegroundColor DarkBlue

Write-Host " $Text" -ForegroundColor Yellow

Write-Host ('=' * 70) -ForegroundColor DarkBlue

}

if ($Demo -in '1', 'All') {

Write-Header 'DEMO 1 - XML manifest (classic greeter script)'

$dst = Join-Path $outputDir '01-xml-greeter'

Invoke-Plaster -TemplatePath (Join-Path $templates '01-xml-greeter') `

-DestinationPath $dst -NoLogo `

-ScriptName 'Greet-Contoso' -Greeting 'Howdy'

Write-Host "`n Files created:" -ForegroundColor Green

Show-Tree $dst

Write-Host "`n --- Greet-Contoso.ps1 ---" -ForegroundColor DarkGray

Get-Content (Join-Path $dst 'Greet-Contoso.ps1') | ForEach-Object { " $_" }

}

if ($Demo -in '2', 'All') {

Write-Header 'DEMO 2 - JSON manifest (same greeter, modern format)'

$dst = Join-Path $outputDir '02-json-greeter'

Invoke-Plaster -TemplatePath (Join-Path $templates '02-json-greeter') `

-DestinationPath $dst -NoLogo `

-ScriptName 'Greet-Fabrikam' -Greeting 'Salutations'

Write-Host "`n Files created:" -ForegroundColor Green

Show-Tree $dst

Write-Host "`n --- Greet-Fabrikam.ps1 ---" -ForegroundColor DarkGray

Get-Content (Join-Path $dst 'Greet-Fabrikam.ps1') | ForEach-Object { " $_" }

}

if ($Demo -in '3', 'All') {

Write-Header 'DEMO 3 - JSON manifest (full module: multichoice + conditions + modify)'

$dst = Join-Path $outputDir '03-json-module'

# Features is multichoice -> pass an array. Drop 'Build' to show a condition

# excluding a file (no build.ps1 is generated).

Invoke-Plaster -TemplatePath (Join-Path $templates '03-json-module') `

-DestinationPath $dst -NoLogo `

-ModuleName 'AcmeWidget' -Author 'Ada Lovelace' `

-License 'Apache' -Features 'Pester', 'Git'

Write-Host "`n Files created (note: build.ps1 was skipped by condition):" -ForegroundColor Green

Show-Tree $dst

Write-Host "`n --- AcmeWidget/README.md (note __LICENSE__ was replaced) ---" -ForegroundColor DarkGray

Get-Content (Join-Path $dst 'AcmeWidget\README.md') | ForEach-Object { " $_" }

}

if ($Demo -in '4', 'All') {

# Demo 4 (discovery + authoring) lives in its own script because it drives the

# surrounding cmdlets rather than scaffolding from a fixed template.

& (Join-Path $PSScriptRoot 'Demo4-Discovery-Authoring.ps1')

}

Write-Host "`nAll done. Output is in: $outputDir`n" -ForegroundColor Cyan

function <%= $PLASTER_PARAM_ScriptName %> {

[CmdletBinding()]

param(

[Parameter(Position = 0)]

[string]$Name = 'World'

)

"<%= $PLASTER_PARAM_Greeting %>, $Name!"

}

<?xml version="1.0" encoding="utf-8"?>

<plasterManifest xmlns="http://www.microsoft.com/schemas/PowerShell/Plaster/v1"

schemaVersion="1.1"

templateType="Item">

<metadata>

<name>XmlGreeter</name>

<id>9f3b1c20-0001-4a10-9aaa-111111111111</id>

<version>1.0.0</version>

<title>Greeter Script (XML format)</title>

<description>Classic XML manifest. Scaffolds a small greeter script.</description>

<author>Contoso Demo Team</author>

<tags>Demo, Script, XML</tags>

</metadata>

<parameters>

<parameter name="ScriptName" type="text" prompt="Name of the script" default="Greet-World" />

<parameter name="Greeting" type="choice" prompt="Pick a greeting" default="0">

<choice label="&amp;Hello" value="Hello" help="Friendly" />

<choice label="&amp;Howdy" value="Howdy" help="Casual" />

<choice label="&amp;Salutations" value="Salutations" help="Formal" />

</parameter>

</parameters>

<content>

<templateFile source="greeter.ps1" destination="${PLASTER_PARAM_ScriptName}.ps1" />

<message>&#10;Created '${PLASTER_PARAM_ScriptName}.ps1' that says '${PLASTER_PARAM_Greeting}'.</message>

</content>

</plasterManifest>

function <%= $PLASTER_PARAM_ScriptName %> {

[CmdletBinding()]

param(

[Parameter(Position = 0)]

[string]$Name = 'World'

)

"<%= $PLASTER_PARAM_Greeting %>, $Name!"

}