{{GrantedFeats|list:"wiki-list wiki-inline-list"}}`, page)
if err != nil {
t.Fatalf("render template: %v", err)
}
for _, want := range []string{
``,
`- [[Feats/Literate|Literate]]
`,
`- [[Feats/Armor_Proficiency_light|Armor Proficiency (light)]]
`,
} {
if !strings.Contains(got, want) {
t.Fatalf("expected rendered output to contain %q:\n%s", want, got)
}
}
if strings.Contains(got, "Literate]], [[") {
t.Fatalf("expected list filter not to render comma-separated links:\n%s", got)
}
}
func TestWikiTemplateCanRenderRacialFactsAndFeatListInHTML(t *testing.T) {
ctx := &wikiContext{
wikiDataProviders: map[string]wikiDataProviderDefinition{
"RaceFeats": {Source: "race_feats"},
},
classIDToKey: map[int]string{7: "classes:paladin"},
featIDToKey: map[int]string{
10: "feat:darkvision",
11: "feat:daylight:aasimar",
},
classRows: map[string]map[string]any{
"classes:paladin": {"Name": "Paladin"},
},
featRows: map[string]map[string]any{
"feat:darkvision": {"FEAT": "Darkvision"},
"feat:daylight:aasimar": {"FEAT": "Daylight (aasimar)"},
},
visibleWikiKeys: map[string]bool{
"classes:paladin": true,
"feat:darkvision": true,
"feat:daylight:aasimar": true,
},
}
page := wikiTemplatePage{
PageID: "racialtypes:aasimar",
Category: "racialtypes",
Key: "racialtypes:aasimar",
Title: "Aasimar",
Row: map[string]any{
"WISAdjust": "2",
"CHAAdjust": "2",
"Favored": "7",
"FeatsTable": []any{"10", "11"},
},
}
template := `
| Ability Adjustments | {{ability_adjustments()}} |
|---|
{{#if present(Favored)}}
| Favored Class | {{Favored|ref:"classes"|wiki}} |
|---|
{{/if}}
{{#each RaceFeats}}
- {{FeatKey|link:FeatName|wiki}}
{{/each}}
`
got, err := ctx.renderWikiTemplateString("racialtypes.html", template, page)
if err != nil {
t.Fatalf("render template: %v", err)
}
for _, want := range []string{
`Ability Adjustments | +2 Wisdom, +2 Charisma | `,
`Favored Class | [[Classes/Paladin|Paladin]] | `,
`- [[Feats/Darkvision|Darkvision]]
`,
`- [[Feats/Daylight_aasimar|Daylight (aasimar)]]
`,
} {
if !strings.Contains(got, want) {
t.Fatalf("expected rendered output to contain %q:\n%s", want, got)
}
}
}
func TestWikiTemplateRacialOptionalFactsRenderOnlyWhenPresent(t *testing.T) {
ctx := &wikiContext{}
template := `{{#if present(ECL)}}ECL={{ECL}}{{/if}}
{{#if present(PreferredAlignments)}}Preferred={{PreferredAlignments}}{{/if}}
{{#if present(StartLanguages)}}Start={{StartLanguages}}{{/if}}
{{#if present(BonusLanguages)}}Bonus={{BonusLanguages}}{{/if}}`
page := wikiTemplatePage{
PageID: "racialtypes:human",
Category: "racialtypes",
Key: "racialtypes:human",
Title: "Human",
Row: map[string]any{
"ECL": 0,
"PreferredAlignments": "0x00",
"StartLanguages": "regional",
"BonusLanguages": "all",
},
}
got, err := ctx.renderWikiTemplateString("racialtypes.html", template, page)
if err != nil {
t.Fatalf("render template: %v", err)
}
for _, want := range []string{
"ECL=0",
"Preferred=0x00",
"Start=regional",
"Bonus=all",
} {
if !strings.Contains(got, want) {
t.Fatalf("expected rendered output to contain %q:\n%s", want, got)
}
}
page.Row = map[string]any{
"ECL": nil,
"PreferredAlignments": "",
"StartLanguages": "****",
}
got, err = ctx.renderWikiTemplateString("racialtypes.html", template, page)
if err != nil {
t.Fatalf("render template with absent values: %v", err)
}
for _, unwanted := range []string{
"ECL=",
"Preferred=",
"Start=",
"Bonus=",
} {
if strings.Contains(got, unwanted) {
t.Fatalf("expected rendered output to omit %q for absent values:\n%s", unwanted, got)
}
}
}
func TestWikiTemplateFormatsPreferredAlignments(t *testing.T) {
ctx := &wikiContext{}
template := `{{alignments(PreferredAlignments)}}`
tests := []struct {
name string
value any
want string
}{
{name: "encoded list", value: "0x120C01", want: "Lawful Evil, Chaotic Good, True Neutral"},
{name: "authored list", value: []any{"le", "CG", "tn"}, want: "Lawful Evil, Chaotic Good, True Neutral"},
{name: "authored object alignments", value: map[string]any{"alignments": []any{"ce", "ne"}}, want: "Chaotic Evil, Neutral Evil"},
{name: "legacy authored object list", value: map[string]any{"list": []any{"ce", "ne"}}, want: "Chaotic Evil, Neutral Evil"},
{name: "zero", value: 0, want: "Any"},
{name: "encoded zero", value: "0x00", want: "Any"},
{name: "null", value: nil, want: "Any"},
{name: "missing", value: nil, want: "Any"},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
row := map[string]any{}
if test.name != "missing" {
row["PreferredAlignments"] = test.value
}
page := wikiTemplatePage{
PageID: "racialtypes:human",
Category: "racialtypes",
Key: "racialtypes:human",
Title: "Human",
Row: row,
}
got, err := ctx.renderWikiTemplateString("racialtypes.html", template, page)
if err != nil {
t.Fatalf("render template: %v", err)
}
if got != test.want {
t.Fatalf("expected %q, got %q", test.want, got)
}
})
}
}
func TestWikiTemplateFormatsPreferredAlignmentsWithConfiguredLinks(t *testing.T) {
ctx := &wikiContext{alignmentLinkPattern: "Guides/Alignment/{alignment}"}
page := wikiTemplatePage{
PageID: "racialtypes:tiefling",
Category: "racialtypes",
Key: "racialtypes:tiefling",
Title: "Tiefling",
Row: map[string]any{
"PreferredAlignments": map[string]any{"alignments": []any{"le", "ne", "ce"}},
},
}
got, err := ctx.renderWikiTemplateString("racialtypes.html", `{{alignments(PreferredAlignments)}}`, page)
if err != nil {
t.Fatalf("render template: %v", err)
}
want := "[[Guides/Alignment/Lawful_Evil|Lawful Evil]], [[Guides/Alignment/Neutral_Evil|Neutral Evil]], [[Guides/Alignment/Chaotic_Evil|Chaotic Evil]]"
if got != want {
t.Fatalf("expected %q, got %q", want, got)
}
}
func TestWikiTemplateFormatsPreferredAlignmentsWithConfiguredRootAnchors(t *testing.T) {
ctx := &wikiContext{
alignmentLinkPattern: "/wiki/Guides/Alignment/{alignment}",
alignmentLinkFormat: "html_anchor",
}
page := wikiTemplatePage{
PageID: "racialtypes:tiefling",
Category: "racialtypes",
Key: "racialtypes:tiefling",
Title: "Tiefling",
Row: map[string]any{
"PreferredAlignments": map[string]any{"alignments": []any{"le"}},
},
}
got, err := ctx.renderWikiTemplateString("racialtypes.html", `{{alignments(PreferredAlignments)}}`, page)
if err != nil {
t.Fatalf("render template: %v", err)
}
want := `Lawful Evil`
if got != want {
t.Fatalf("expected %q, got %q", want, got)
}
}
func TestWikiTemplateDescriptionFiltersExtractParagraphsAndSections(t *testing.T) {
ctx := &wikiContext{}
page := wikiTemplatePage{
PageID: "feat:test",
Category: "feat",
Key: "feat:test",
Title: "Test Feat",
Row: map[string]any{
"DESCRIPTION": map[string]any{"tlk": map[string]any{"text": strings.Join([]string{
"Type of Feat: General",
"",
"Prerequisite: Dexterity 13+",
"",
"Specifics: You gain a +2 dodge bonus.",
"The bonus applies only while unarmored.",
"",
"Use: Automatic.",
}, "\n")}},
},
}
tests := []struct {
name string
template string
want string
reject string
}{
{
name: "first paragraph",
template: `{{DESCRIPTION|text|paragraph:first}} `,
want: `Type of Feat: General `,
reject: `Prerequisite`,
},
{
name: "specifics after marker as html",
template: `{{DESCRIPTION|text|after:"Specifics:"|before:"Use:"|trim|html}}`,
want: `You gain a +2 dodge bonus.
The bonus applies only while unarmored. `,
reject: `Use: Automatic`,
},
{
name: "first and last paragraphs",
template: `{{DESCRIPTION|text|paragraphs:"first,last"|html}} `,
want: `Type of Feat: General Use: Automatic. {{title}}
{{table:ClassProgression}}`, page)
if err != nil {
t.Fatalf("render table template: %v", err)
}
for _, expected := range []string{
``,
`| Lvl | `,
`Saves | `,
`1st | `,
`+1 | `,
`2 | `,
`[[Feats/Literate|Literate]], [[Feats/Simple_Weapon_Proficiency|Simple Weapon Proficiency]] | `,
`1-10 | `,
`[[Feats/Weapon_Specialization|Weapon Specialization]] first available. | `,
} {
if !strings.Contains(got, expected) {
t.Fatalf("expected %q in rendered table:\n%s", expected, got)
}
}
}
func TestWikiTemplateRendersConfiguredClassProgressionSpellColumns(t *testing.T) {
ctx := testWikiTableContext(t, `
tables:
ClassProgression:
source: class_progression
class: "wiki-table wiki-class-progression"
rows:
levels: 1-2
columns:
- key: level
label: Lvl
value: "{{Level}}"
- key: per_day
label: Base spells per day
when: "{{HasSpellsPerDay}}"
children:
- key: per_day_0
label: 0
value: "{{SpellsPerDay0}}"
empty: "-"
- key: per_day_1
label: 1
value: "{{SpellsPerDay1}}"
empty: "-"
- key: known
label: Known spells
when: "{{HasSpellsKnown}}"
children:
- key: known_0
label: 0
value: "{{SpellsKnown0}}"
empty: "-"
- key: known_1
label: 1
value: "{{SpellsKnown1}}"
empty: "-"
`)
ctx.classSpellGainTables["classes/spellsgained:bard"] = wikiTable{Rows: []map[string]any{
{"Level": 1, "SpellLevel0": 2, "SpellLevel1": 1},
{"Level": 2, "SpellLevel0": 3, "SpellLevel1": nil},
}}
ctx.classSpellKnownTables["classes/spellsknown:bard"] = wikiTable{Rows: []map[string]any{
{"Level": 1, "SpellLevel0": 4, "SpellLevel1": 2},
{"Level": 2, "SpellLevel0": 5, "SpellLevel1": 3},
}}
page := wikiTemplatePage{
PageID: "classes:bard",
Category: "classes",
Key: "classes:bard",
Title: "Bard",
Row: map[string]any{
"SpellCaster": 1,
"SpellGainTable": map[string]any{"table": "classes/spellsgained:bard"},
"SpellKnownTable": map[string]any{"table": "classes/spellsknown:bard"},
},
}
got, err := ctx.renderWikiTemplateString("classes.html", `{{table:ClassProgression}}`, page)
if err != nil {
t.Fatalf("render table template: %v", err)
}
for _, expected := range []string{
`Base spells per day | `,
`Known spells | `,
`| 1 | 2 | 1 | 4 | 2 | `,
`| 2 | 3 | - | 5 | 3 | `,
} {
if !strings.Contains(got, expected) {
t.Fatalf("expected %q in rendered table:\n%s", expected, got)
}
}
}
func TestWikiTemplateHidesUnusedConfiguredClassSpellColumns(t *testing.T) {
ctx := testWikiTableContext(t, `
tables:
ClassProgression:
source: class_progression
class: "wiki-table wiki-class-progression"
rows:
levels: 1-2
columns:
- key: level
label: Lvl
value: "{{Level}}"
- key: per_day
label: Base spells per day
when: "{{HasSpellsPerDay}}"
children:
- key: per_day_0
label: 0
value: "{{SpellsPerDay0}}"
when: "{{SpellsPerDay0}}"
- key: per_day_1
label: 1
value: "{{SpellsPerDay1}}"
when: "{{SpellsPerDay1}}"
- key: per_day_2
label: 2
value: "{{SpellsPerDay2}}"
when: "{{SpellsPerDay2}}"
`)
ctx.classSpellGainTables["classes/spellsgained:bard"] = wikiTable{Rows: []map[string]any{
{"Level": 1, "SpellLevel0": 2, "SpellLevel1": 1, "SpellLevel2": nil},
{"Level": 2, "SpellLevel0": 3, "SpellLevel1": 2, "SpellLevel2": nil},
}}
page := wikiTemplatePage{
PageID: "classes:bard",
Category: "classes",
Key: "classes:bard",
Title: "Bard",
Row: map[string]any{
"SpellCaster": 1,
"SpellGainTable": map[string]any{"table": "classes/spellsgained:bard"},
},
}
got, err := ctx.renderWikiTemplateString("classes.html", `{{table:ClassProgression}}`, page)
if err != nil {
t.Fatalf("render table template: %v", err)
}
if !strings.Contains(got, `Base spells per day | `) {
t.Fatalf("expected only two visible spell columns:\n%s", got)
}
if strings.Contains(got, `2 | `) {
t.Fatalf("expected unused spell level 2 column to be hidden:\n%s", got)
}
}
func TestWikiTemplateOmitsSpellColumnsForPreparedAndNonCasterClasses(t *testing.T) {
ctx := testWikiTableContext(t, `
tables:
ClassProgression:
source: class_progression
rows:
levels: 1
columns:
- key: level
label: Lvl
value: "{{Level}}"
- key: per_day
label: Base spells per day
when: "{{HasSpellsPerDay}}"
children:
- key: per_day_0
label: 0
value: "{{SpellsPerDay0}}"
- key: known
label: Known spells
when: "{{HasSpellsKnown}}"
children:
- key: known_0
label: 0
value: "{{SpellsKnown0}}"
`)
ctx.classSpellGainTables["classes/spellsgained:cleric"] = wikiTable{Rows: []map[string]any{
{"Level": 1, "SpellLevel0": 3},
}}
prepared := wikiTemplatePage{
PageID: "classes:cleric",
Category: "classes",
Key: "classes:cleric",
Title: "Cleric",
Row: map[string]any{
"SpellCaster": 1,
"SpellGainTable": map[string]any{"table": "classes/spellsgained:cleric"},
},
}
nonCaster := wikiTemplatePage{
PageID: "classes:fighter",
Category: "classes",
Key: "classes:fighter",
Title: "Fighter",
Row: map[string]any{"SpellCaster": 0},
}
gotPrepared, err := ctx.renderWikiTemplateString("classes.html", `{{table:ClassProgression}}`, prepared)
if err != nil {
t.Fatalf("render prepared caster table: %v", err)
}
if !strings.Contains(gotPrepared, `Base spells per day`) || strings.Contains(gotPrepared, `Known spells`) {
t.Fatalf("expected prepared caster to render per-day but not known columns:\n%s", gotPrepared)
}
gotNonCaster, err := ctx.renderWikiTemplateString("classes.html", `{{table:ClassProgression}}`, nonCaster)
if err != nil {
t.Fatalf("render non-caster table: %v", err)
}
if strings.Contains(gotNonCaster, `Base spells per day`) || strings.Contains(gotNonCaster, `Known spells`) {
t.Fatalf("expected non-caster to omit spell columns:\n%s", gotNonCaster)
}
}
func TestWikiTemplateRendersClassSpellbookProviderBySpellLevel(t *testing.T) {
root := t.TempDir()
dataPath := filepath.Join(root, "data.yaml")
writeFile(t, dataPath, `
providers:
ClassSpellbook:
source: class_spellbook
`+"\n")
providers, err := loadWikiDataProviders(dataPath)
if err != nil {
t.Fatalf("load data providers: %v", err)
}
ctx := testWikiTableContext(t, "")
ctx.wikiDataPath = dataPath
ctx.wikiDataProviders = providers
ctx.spellRows = map[string]map[string]any{
"spells:light": {"Name": map[string]any{"tlk": map[string]any{"text": "Light"}}},
"spells:cure_light_wounds": {"Name": map[string]any{"tlk": map[string]any{"text": "Cure Light Wounds"}}},
"spells:bless": {"Name": map[string]any{"tlk": map[string]any{"text": "Bless"}}},
}
ctx.classSpellbooks = map[string]classSpellbookSpec{
"classes:acolyte": {
Class: "classes:acolyte",
Levels: map[int][]string{
0: {"spells:light"},
1: {"spells:cure_light_wounds", "spells:bless"},
},
},
}
page := wikiTemplatePage{
PageID: "classes:acolyte",
Category: "classes",
Key: "classes:acolyte",
Title: "Acolyte",
Row: map[string]any{"SpellCaster": 1},
}
got, err := ctx.renderWikiTemplateString("classes.html", `{{#each ClassSpellbook}}
{{SpellLevelLabel}}{{Spells|list:"wiki-list wiki-spellbook-list"}}
{{/each}}`, page)
if err != nil {
t.Fatalf("render spellbook provider: %v", err)
}
for _, expected := range []string{
`0-level spells`,
`1st-level spells- [[Spells/Bless|Bless]]
`,
`- [[Spells/Cure_Light_Wounds|Cure Light Wounds]]
`,
} {
if !strings.Contains(got, expected) {
t.Fatalf("expected %q in rendered spellbook:\n%s", expected, got)
}
}
}
func TestLoadWikiTablesFromDirsSupportsCanonicalAndLegacyClassTableDirs(t *testing.T) {
root := t.TempDir()
mkdirAll(t, filepath.Join(root, "bonusfeats"))
mkdirAll(t, filepath.Join(root, "bfeat"))
writeFile(t, filepath.Join(root, "bonusfeats", "fighter.json"), `{
"key": "classes/bonusfeats:fighter",
"output": "cls_bfeat_fight.2da",
"rows": [{"id": 1, "Bonus": "1"}]
}`+"\n")
writeFile(t, filepath.Join(root, "bfeat", "commoner.json"), `{
"key": "classes/bonusfeats:commoner",
"output": "cls_bfeat_comm.2da",
"rows": [{"id": 1, "Bonus": "0"}]
}`+"\n")
tables, err := loadWikiTablesFromDirs(filepath.Join(root, "bonusfeats"), filepath.Join(root, "bfeat"))
if err != nil {
t.Fatalf("load wiki tables from aliases: %v", err)
}
for _, key := range []string{"classes/bonusfeats:fighter", "cls_bfeat_fight", "classes/bonusfeats:commoner", "cls_bfeat_comm"} {
if _, ok := tables[key]; !ok {
t.Fatalf("expected table key %q in merged alias tables: %#v", key, tables)
}
}
}
func TestWikiTableMissingFieldReportsTableAndColumn(t *testing.T) {
ctx := testWikiTableContext(t, `
tables:
Broken:
source: class_progression
rows:
levels: 1
columns:
- key: missing
label: Missing
value: "{{NoSuchField}}"
`)
page := wikiTemplatePage{
PageID: "classes:fighter",
Category: "classes",
Key: "classes:fighter",
Row: map[string]any{
"AttackBonusTable": "cls_atk_1",
"HitDie": 10,
"SavingThrowTable": map[string]any{"table": "classes/saves:fortitude"},
},
}
_, err := ctx.renderWikiTemplateString("classes.html", `{{table:Broken}}`, page)
if err == nil {
t.Fatal("expected missing field error")
}
for _, expected := range []string{`classes:fighter`, `table Broken`, `column missing`, `NoSuchField`} {
if !strings.Contains(err.Error(), expected) {
t.Fatalf("expected error to contain %q, got %v", expected, err)
}
}
}
func TestWikiTableRejectsImpossibleNestedHeader(t *testing.T) {
_, err := parseWikiTableDefinitions([]byte(`
tables:
Broken:
source: class_progression
rows:
levels: 1
columns:
- key: bad
label: Bad
value: "{{Level}}"
children:
- key: child
label: Child
value: "{{Level}}"
`), "test-tables.yaml")
if err == nil || !strings.Contains(err.Error(), "cannot have both value and children") {
t.Fatalf("expected impossible nested header error, got %v", err)
}
}
func TestWikiVisibilityPolicyRejectsNullLikeFeatsAndHiddenReferences(t *testing.T) {
root := testProjectRoot(t)
for _, dir := range []string{
filepath.Join(root, "topdata", "data", "classes", "core"),
filepath.Join(root, "topdata", "data", "classes", "feats"),
filepath.Join(root, "topdata", "data", "classes", "skills"),
filepath.Join(root, "topdata", "data", "feat"),
filepath.Join(root, "topdata", "data", "skills"),
filepath.Join(root, "topdata", "wiki"),
filepath.Join(root, "topdata", "wiki", "templates", "pages"),
} {
mkdirAll(t, dir)
}
writeFile(t, filepath.Join(root, "topdata", "base_dialog.json"), "{}\n")
writeFile(t, filepath.Join(root, "topdata", "wiki", "templates", "pages", "classes.html"), `{{title}}
{{format:SkillList}}
{{table:FeatProgression}}`+"\n")
writeFile(t, filepath.Join(root, "topdata", "wiki", "tables.yaml"), `
tables:
FeatProgression:
source: class_feats
columns:
- key: feat
label: Feat
value: "{{link(FeatKey, FeatName)}}"
allow_wiki_markup: true
`+"\n")
writeFile(t, filepath.Join(root, "topdata", "wiki", "visibility.yaml"), `
reference_sets:
class_feats:
target_dataset: feat
sources:
- dataset: classes
table_field: FeatsTable
table_kind: class_feats
row_ref_field: FeatIndex
datasets:
classes:
eligibility:
when: "{{all_present(Name, Description)}}"
include:
- when: "{{PlayerClass == 1}}"
feat:
eligibility:
when: "{{all_present(FEAT, DESCRIPTION)}}"
include:
- when: "{{ALLCLASSESCANUSE == 1}}"
- reference_set: class_feats
exclude:
- when: "{{PreReqEpic == 1}}"
skills:
eligibility:
when: "{{all_present(Name, Description)}}"
include:
- when: "{{true}}"
exclude:
- when: "{{HideFromLevelUp == 1}}"
`+"\n")
writeFile(t, filepath.Join(root, "topdata", "data", "skills", "base.json"), `{
"output": "skills.2da",
"columns": ["Label", "Name", "Description", "HideFromLevelUp"],
"rows": [
{"id": 0, "key": "skills:athletics", "Label": "Athletics", "Name": {"tlk": {"text": "Athletics"}}, "Description": {"tlk": {"text": "Visible skill."}}, "HideFromLevelUp": "0"},
{"id": 1, "key": "skills:secret", "Label": "Secret", "Name": {"tlk": {"text": "Secret"}}, "Description": {"tlk": {"text": "Hidden skill."}}, "HideFromLevelUp": "1"}
]
}`+"\n")
writeFile(t, filepath.Join(root, "topdata", "data", "skills", "lock.json"), `{"skills:athletics":0,"skills:secret":1}`+"\n")
writeFile(t, filepath.Join(root, "topdata", "data", "feat", "base.json"), `{
"output": "feat.2da",
"columns": ["LABEL", "FEAT", "DESCRIPTION", "ALLCLASSESCANUSE", "PreReqEpic"],
"rows": [
{"id": 0, "key": "feat:visible", "LABEL": "Visible", "FEAT": {"tlk": {"text": "Visible Feat"}}, "DESCRIPTION": {"tlk": {"text": "Visible feat description."}}, "ALLCLASSESCANUSE": "1", "PreReqEpic": "0"},
{"id": 1, "key": "feat:epic", "LABEL": "Epic", "FEAT": {"tlk": {"text": "Epic Feat"}}, "DESCRIPTION": {"tlk": {"text": "Epic feat description."}}, "ALLCLASSESCANUSE": "1", "PreReqEpic": "1"},
{"id": 2, "key": "feat:nullfeat", "LABEL": "Null", "FEAT": "****", "DESCRIPTION": {"tlk": {"text": "Null feat description."}}, "ALLCLASSESCANUSE": "1", "PreReqEpic": "0"},
{"id": 3, "key": "feat:class_only", "LABEL": "ClassOnly", "FEAT": {"tlk": {"text": "Class Feat"}}, "DESCRIPTION": {"tlk": {"text": "Class feat description."}}, "ALLCLASSESCANUSE": "0", "PreReqEpic": "0"}
]
}`+"\n")
writeFile(t, filepath.Join(root, "topdata", "data", "feat", "lock.json"), `{"feat:visible":0,"feat:epic":1,"feat:nullfeat":2,"feat:class_only":3}`+"\n")
writeFile(t, filepath.Join(root, "topdata", "data", "classes", "core", "base.json"), `{
"output": "classes.2da",
"columns": ["Label", "Name", "Description", "PlayerClass", "SkillsTable", "FeatsTable"],
"rows": [
{"id": 0, "key": "classes:fighter", "Label": "Fighter", "Name": {"tlk": {"text": "Fighter"}}, "Description": {"tlk": {"text": "Fighter text."}}, "PlayerClass": "1", "SkillsTable": {"table": "classes/skills:fighter"}, "FeatsTable": {"table": "classes/feats:fighter"}}
]
}`+"\n")
writeFile(t, filepath.Join(root, "topdata", "data", "classes", "core", "lock.json"), `{"classes:fighter":0}`+"\n")
writeFile(t, filepath.Join(root, "topdata", "data", "classes", "skills", "fighter.json"), `{
"key": "classes/skills:fighter",
"output": "cls_skill_fight.2da",
"columns": ["SkillIndex", "ClassSkill"],
"rows": [
{"SkillIndex": {"id": "skills:athletics"}, "ClassSkill": "1"},
{"SkillIndex": {"id": "skills:secret"}, "ClassSkill": "1"}
]
}`+"\n")
writeFile(t, filepath.Join(root, "topdata", "data", "classes", "feats", "fighter.json"), `{
"key": "classes/feats:fighter",
"output": "cls_feat_fight.2da",
"columns": ["FeatIndex", "GrantedOnLevel", "List"],
"rows": [
{"FeatIndex": {"id": "feat:class_only"}, "GrantedOnLevel": "1", "List": "3"},
{"FeatIndex": {"id": "feat:epic"}, "GrantedOnLevel": "1", "List": "3"},
{"FeatIndex": {"id": "feat:nullfeat"}, "GrantedOnLevel": "1", "List": "3"}
]
}`+"\n")
proj := testProject(root)
proj.Config.TopData.ReferenceBuilder = ""
proj.Config.TopData.Wiki.VisibilityFile = "visibility.yaml"
if _, err := buildWiki(proj, BuildResult{}, true, nil); err != nil {
t.Fatalf("buildWiki failed: %v", err)
}
for _, path := range []string{
filepath.Join(root, ".cache", "wiki", "pages", "skills", "secret.html"),
filepath.Join(root, ".cache", "wiki", "pages", "feat", "epic.html"),
filepath.Join(root, ".cache", "wiki", "pages", "feat", "nullfeat.html"),
} {
if _, err := os.Stat(path); !os.IsNotExist(err) {
t.Fatalf("expected hidden or ineligible wiki page %s to be omitted, got %v", path, err)
}
}
for _, path := range []string{
filepath.Join(root, ".cache", "wiki", "pages", "feat", "Visible_Feat.html"),
filepath.Join(root, ".cache", "wiki", "pages", "feat", "Class_Feat.html"),
} {
if _, err := os.Stat(path); err != nil {
t.Fatalf("expected visible wiki page %s: %v", path, err)
}
}
classPage, err := os.ReadFile(filepath.Join(root, ".cache", "wiki", "pages", "classes", "Fighter.html"))
if err != nil {
t.Fatalf("read class page: %v", err)
}
classText := string(classPage)
for _, hidden := range []string{"Secret", "Epic Feat", "Null"} {
if strings.Contains(classText, hidden) {
t.Fatalf("expected hidden %q reference to be omitted from class page:\n%s", hidden, classText)
}
}
for _, visible := range []string{"[[Skills/Athletics|Athletics]]", "[[Feats/Class_Feat|Class Feat]]"} {
if !strings.Contains(classText, visible) {
t.Fatalf("expected visible %q reference in class page:\n%s", visible, classText)
}
}
indexRaw, err := os.ReadFile(filepath.Join(root, ".cache", "wiki", "page-index.json"))
if err != nil {
t.Fatalf("read page index: %v", err)
}
if strings.Contains(string(indexRaw), `"page_id": "skills:secret"`) ||
strings.Contains(string(indexRaw), `"page_id": "feat:epic"`) ||
strings.Contains(string(indexRaw), `"page_id": "feat:nullfeat"`) {
t.Fatalf("expected hidden and ineligible pages out of page index:\n%s", string(indexRaw))
}
}
func TestWikiVisibilityPredicatesTreatNullLikeFieldsAsAbsent(t *testing.T) {
policy, err := parseWikiVisibilityDefinitions([]byte(`
datasets:
feat:
eligibility:
when: "{{all_present(FEAT, DESCRIPTION)}}"
include:
- when: "{{true}}"
`), "visibility.yaml")
if err != nil {
t.Fatalf("parse visibility policy: %v", err)
}
ctx := &wikiContext{}
for name, row := range map[string]map[string]any{
"missing": {"DESCRIPTION": "Description"},
"null": {"FEAT": nil, "DESCRIPTION": "Description"},
"nwn-null": {"FEAT": "****", "DESCRIPTION": "Description"},
"empty": {"FEAT": "", "DESCRIPTION": "Description"},
"present": {"FEAT": "Feat", "DESCRIPTION": "Description"},
"missing-desc": {"FEAT": "Feat"},
} {
got, err := ctx.evalWikiVisibilityPredicate(policy.Datasets["feat"].Eligibility.When, row)
if err != nil {
t.Fatalf("%s predicate failed: %v", name, err)
}
if want := name == "present"; got != want {
t.Fatalf("%s expected eligibility %v, got %v", name, want, got)
}
}
}
func TestWikiVisibilityPolicyRejectsInvalidDatasetAndReferenceSet(t *testing.T) {
tests := []struct {
name string
yaml string
want string
}{
{
name: "unknown dataset",
yaml: `
datasets:
traps:
include:
- when: "{{true}}"
`,
want: `unknown dataset "traps"`,
},
{
name: "unknown reference set",
yaml: `
datasets:
feat:
include:
- reference_set: missing
`,
want: `unknown reference_set "missing"`,
},
{
name: "bad table kind",
yaml: `
reference_sets:
feats:
target_dataset: feat
sources:
- dataset: classes
table_field: FeatsTable
table_kind: unsupported
row_ref_field: FeatIndex
datasets:
feat:
include:
- reference_set: feats
`,
want: `unsupported table_kind`,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
_, err := parseWikiVisibilityDefinitions([]byte(tt.yaml), "visibility.yaml")
if err == nil || !strings.Contains(err.Error(), tt.want) {
t.Fatalf("expected %q error, got %v", tt.want, err)
}
})
}
}
func TestWikiVisibilityCanExcludeUnreachableFeatPrerequisites(t *testing.T) {
policy, err := parseWikiVisibilityDefinitions([]byte(`
datasets:
feat:
include:
- when: "{{true}}"
exclude:
- when: "{{hidden_ref(PREREQFEAT1, \"feat\")}}"
- when: "{{hidden_ref(REQSKILL, \"skills\")}}"
- when: "{{all_hidden_refs(OrReqFeat0, OrReqFeat1, OrReqFeat2, OrReqFeat3, OrReqFeat4, \"feat\")}}"
`), "visibility.yaml")
if err != nil {
t.Fatalf("parse visibility policy: %v", err)
}
ctx := &wikiContext{
visibilityPolicy: &policy,
visibleWikiKeys: map[string]bool{
"feat:visible": true,
"feat:hidden": false,
"skills:visible": true,
"skills:hidden": false,
},
featIDToKey: map[int]string{1: "feat:visible", 2: "feat:hidden"},
skillIDToKey: map[int]string{1: "skills:visible", 2: "skills:hidden"},
}
definition := policy.Datasets["feat"]
featRow := func(values map[string]any) map[string]any {
row := map[string]any{"FEAT": "Test Feat", "DESCRIPTION": "Description"}
for key, value := range values {
row[key] = value
}
return row
}
for name, tt := range map[string]struct {
row map[string]any
want bool
}{
"visible required feat": {
row: featRow(map[string]any{"PREREQFEAT1": 1}),
want: true,
},
"hidden required feat": {
row: featRow(map[string]any{"PREREQFEAT1": 2}),
want: false,
},
"missing required feat is unreachable": {
row: featRow(map[string]any{"PREREQFEAT1": 999}),
want: false,
},
"visible required skill": {
row: featRow(map[string]any{"REQSKILL": "skills:visible"}),
want: true,
},
"hidden required skill": {
row: featRow(map[string]any{"REQSKILL": "skills:hidden"}),
want: false,
},
"null prerequisite fields are ignored": {
row: featRow(map[string]any{"PREREQFEAT1": "****", "REQSKILL": "****"}),
want: true,
},
"or group with visible option remains reachable": {
row: featRow(map[string]any{"OrReqFeat0": 2, "OrReqFeat1": 1}),
want: true,
},
"or group with only hidden options is unreachable": {
row: featRow(map[string]any{"OrReqFeat0": 2, "OrReqFeat1": "feat:missing"}),
want: false,
},
"empty or group is ignored": {
row: featRow(map[string]any{"OrReqFeat0": "****", "OrReqFeat1": "****"}),
want: true,
},
} {
got, err := ctx.evaluateWikiVisibility("feat", "feat:"+name, tt.row, definition, nil)
if err != nil {
t.Fatalf("%s visibility evaluation failed: %v", name, err)
}
if got != tt.want {
t.Fatalf("%s expected visibility %v, got %v", name, tt.want, got)
}
}
}
func TestWikiVisibilityIndexUsesBuiltVisibilityForReferenceHelpers(t *testing.T) {
policy, err := parseWikiVisibilityDefinitions([]byte(`
datasets:
feat:
include:
- when: "{{true}}"
exclude:
- when: "{{hidden_ref(PREREQFEAT1, \"feat\")}}"
`), "visibility.yaml")
if err != nil {
t.Fatalf("parse visibility policy: %v", err)
}
ctx := &wikiContext{
visibilityPolicy: &policy,
featRows: map[string]map[string]any{
"feat:zbase": {
"FEAT": "Base Feat",
"DESCRIPTION": "Description",
},
"feat:dependent": {
"FEAT": "Dependent Feat",
"DESCRIPTION": "Description",
"PREREQFEAT1": 1,
},
"feat:chain_dependent": {
"FEAT": "Chain Dependent Feat",
"DESCRIPTION": "Description",
"PREREQFEAT1": 2,
},
"feat:missing_prereq": {
"FEAT": "Missing Prereq Feat",
"DESCRIPTION": "Description",
"PREREQFEAT1": 999,
},
},
featIDToKey: map[int]string{1: "feat:zbase", 2: "feat:dependent"},
}
visible, err := ctx.buildWikiVisibilityIndex(&policy)
if err != nil {
t.Fatalf("build visibility index: %v", err)
}
if !visible["feat:zbase"] {
t.Fatalf("expected base feat to be visible")
}
if !visible["feat:dependent"] {
t.Fatalf("expected feat with visible prerequisite to remain visible")
}
if !visible["feat:chain_dependent"] {
t.Fatalf("expected feat with transitive visible prerequisite to remain visible")
}
if visible["feat:missing_prereq"] {
t.Fatalf("expected feat with missing prerequisite to be hidden")
}
}
func TestWikiVisibilityMetadataOverrideCannotBypassEligibility(t *testing.T) {
policy, err := parseWikiVisibilityDefinitions([]byte(`
datasets:
feat:
eligibility:
when: "{{present(FEAT)}}"
include:
- when: "{{ALLCLASSESCANUSE == 1}}"
exclude:
- when: "{{PreReqEpic == 1}}"
`), "visibility.yaml")
if err != nil {
t.Fatalf("parse visibility policy: %v", err)
}
ctx := &wikiContext{}
definition := policy.Datasets["feat"]
for name, tt := range map[string]struct {
row map[string]any
want bool
}{
"exclude overridden": {
row: map[string]any{
"FEAT": "Visible",
"DESCRIPTION": "Description",
"PreReqEpic": "1",
"ALLCLASSESCANUSE": "1",
"meta": map[string]any{"wiki": map[string]any{"generate": "1"}},
},
want: true,
},
"eligibility preserved": {
row: map[string]any{
"FEAT": "****",
"DESCRIPTION": "Description",
"ALLCLASSESCANUSE": "1",
"meta": map[string]any{"wiki": map[string]any{"generate": "1"}},
},
want: false,
},
} {
got, err := ctx.evaluateWikiVisibility("feat", "feat:"+name, tt.row, definition, nil)
if err != nil {
t.Fatalf("%s visibility evaluation failed: %v", name, err)
}
if got != tt.want {
t.Fatalf("%s expected visibility %v, got %v", name, tt.want, got)
}
}
}
func testWikiTableContext(t *testing.T, yamlSource string) *wikiContext {
t.Helper()
ctx := &wikiContext{
featRows: map[string]map[string]any{},
featIDToKey: map[int]string{},
classFeatTables: map[string]wikiTable{},
classBonusTables: map[string]wikiTable{},
classSaveTables: map[string]wikiTable{},
classSpellGainTables: map[string]wikiTable{},
classSpellKnownTables: map[string]wikiTable{},
classSpellbooks: map[string]classSpellbookSpec{},
wikiTablesPath: "test-tables.yaml",
}
ctx.featRows["feat:literate"] = map[string]any{"FEAT": map[string]any{"tlk": map[string]any{"text": "Literate"}}}
ctx.featRows["feat:weapon_proficiency_simple"] = map[string]any{"FEAT": map[string]any{"tlk": map[string]any{"text": "Simple Weapon Proficiency"}}}
ctx.featRows["feat:weapon_specialization"] = map[string]any{"FEAT": map[string]any{"tlk": map[string]any{"text": "Weapon Specialization"}}}
ctx.classFeatTables["cls_feat_fight"] = wikiTable{OutputStem: "cls_feat_fight", Rows: []map[string]any{
{"FeatIndex": map[string]any{"id": "feat:literate"}, "GrantedOnLevel": "1", "List": "3"},
{"FeatIndex": map[string]any{"id": "feat:weapon_proficiency_simple"}, "GrantedOnLevel": "1", "List": "3"},
}}
ctx.classFeatTables["classes/feats:fighter"] = ctx.classFeatTables["cls_feat_fight"]
ctx.classBonusTables["cls_bfeat_fight"] = wikiTable{OutputStem: "cls_bfeat_fight", Rows: []map[string]any{
{"id": 1, "Bonus": "1"}, {"id": 2, "Bonus": "1"}, {"id": 3, "Bonus": "0"}, {"id": 4, "Bonus": "1"},
}}
ctx.classBonusTables["classes/bonusfeats:fighter"] = ctx.classBonusTables["cls_bfeat_fight"]
ctx.classSaveTables["cls_savthr_fort"] = wikiTable{OutputStem: "cls_savthr_fort", Rows: []map[string]any{
{"Level": "1", "FortSave": "2", "RefSave": "0", "WillSave": "0"},
{"Level": "2", "FortSave": "3", "RefSave": "0", "WillSave": "0"},
{"Level": "3", "FortSave": "3", "RefSave": "1", "WillSave": "1"},
{"Level": "4", "FortSave": "4", "RefSave": "1", "WillSave": "1"},
}}
ctx.classSaveTables["classes/saves:fortitude"] = ctx.classSaveTables["cls_savthr_fort"]
tables, err := parseWikiTableDefinitions([]byte(yamlSource), ctx.wikiTablesPath)
if err != nil {
t.Fatalf("parse table definitions: %v", err)
}
ctx.wikiTableDefinitions = tables
return ctx
}
func TestWikiManagedHashIgnoresPreservedSectionBody(t *testing.T) {
first := strings.Join([]string{
``,
``,
`Acolyte`,
``,
`Original user edit. `,
``,
`Generated. `,
``,
}, "\n")
second := strings.Replace(first, "Original user edit. ", "Changed by a user. ", 1)
if computeManagedHash(first) != computeManagedHash(second) {
t.Fatalf("expected preserved section body not to affect managed hash")
}
}
func TestWikiSourceDigestIncludesTemplates(t *testing.T) {
root := t.TempDir()
mkdirAll(t, filepath.Join(root, "data", "skills"))
mkdirAll(t, filepath.Join(root, "wiki", "templates", "pages"))
writeFile(t, filepath.Join(root, "data", "skills", "base.json"), `{"rows":[]}`+"\n")
templatePath := filepath.Join(root, "wiki", "templates", "pages", "skills.html")
writeFile(t, templatePath, `{{title}}`+"\n")
proj := &project.Project{
Root: root,
Config: project.Config{
Module: project.ModuleConfig{Name: "Test", ResRef: "test"},
TopData: project.TopDataConfig{Source: ".", Wiki: project.TopDataWikiConfig{Source: "wiki"}},
},
}
before, err := computeWikiSourceDigest(proj)
if err != nil {
t.Fatalf("compute initial digest: %v", err)
}
writeFile(t, templatePath, `{{title}}Changed `+"\n")
after, err := computeWikiSourceDigest(proj)
if err != nil {
t.Fatalf("compute changed digest: %v", err)
}
if before == after {
t.Fatalf("expected template edit to change wiki source digest")
}
}
func TestBuildWikiHonorsConfiguredWikiPaths(t *testing.T) {
root := t.TempDir()
mkdirAll(t, filepath.Join(root, "topdata", "data", "skills"))
mkdirAll(t, filepath.Join(root, "docs", "wiki", "page-fragments"))
mkdirAll(t, filepath.Join(root, "docs", "wiki", "config"))
mkdirAll(t, filepath.Join(root, "docs", "wiki", "sections"))
writeFile(t, filepath.Join(root, "topdata", "base_dialog.json"), "{}\n")
writeFile(t, filepath.Join(root, "topdata", "data", "skills", "base.json"), `{
"columns": ["Label", "Name"],
"rows": [
{
"id": 0,
"key": "skills:athletics",
"Label": "Athletics",
"Name": {"tlk": {"key": "skills:athletics.name", "text": "Athletics"}}
}
]
}`+"\n")
writeFile(t, filepath.Join(root, "topdata", "data", "skills", "lock.json"), `{"skills:athletics":0}`+"\n")
writeFile(t, filepath.Join(root, "docs", "wiki", "page-fragments", "skills.html"), `{{title}}`+"\n")
writeFile(t, filepath.Join(root, "docs", "wiki", "config", "providers.yaml"), "providers: {}\n")
writeFile(t, filepath.Join(root, "docs", "wiki", "config", "paths.yaml"), "page_paths: {}\n")
writeFile(t, filepath.Join(root, "docs", "wiki", "config", "tables.yaml"), "tables: {}\n")
writeFile(t, filepath.Join(root, "docs", "wiki", "config", "visibility.yaml"), "datasets: {}\n")
writeFile(t, filepath.Join(root, "docs", "wiki", "sections", "defaults.yaml"), `
manual_sections:
- id: user_top
heading: Custom Top
`)
statusPages := false
proj := &project.Project{
Root: root,
Config: project.Config{
Module: project.ModuleConfig{Name: "Test", ResRef: "test"},
Paths: project.PathConfig{Build: "build", Cache: ".cache"},
TopData: project.TopDataConfig{
Source: "topdata",
Build: ".cache",
Wiki: project.TopDataWikiConfig{
Source: "docs/wiki",
DataFile: "config/providers.yaml",
PagePathsFile: "config/paths.yaml",
TablesFile: "config/tables.yaml",
VisibilityFile: "config/visibility.yaml",
PageTemplatesDir: "page-fragments",
ManualSectionsFile: "sections/defaults.yaml",
PageIndexFile: "manifest/pages.json",
StatusPages: &statusPages,
},
},
},
}
result, err := buildWiki(proj, BuildResult{}, true, nil)
if err != nil {
t.Fatalf("build wiki with configured paths: %v", err)
}
if result.PageCount != 1 {
t.Fatalf("expected generated skill page, got %d", result.PageCount)
}
pagePath := filepath.Join(root, ".cache", "wiki", "pages", "skills", "Athletics.html")
pageRaw, err := os.ReadFile(pagePath)
if err != nil {
t.Fatalf("read configured-path wiki page: %v", err)
}
if !strings.Contains(string(pageRaw), "Custom Top") {
t.Fatalf("expected configured manual section file to be used, got:\n%s", pageRaw)
}
if _, err := os.Stat(filepath.Join(root, ".cache", "wiki", "manifest", "pages.json")); err != nil {
t.Fatalf("expected configured page-index file: %v", err)
}
}
func TestWikiPageIDForKeyNormalizesSlashSeparatorsOnly(t *testing.T) {
got := wikiPageIDForKey("feat:special/attacks_bull_rush")
if want := "feat:special_attacks_bull_rush"; got != want {
t.Fatalf("expected normalized page ID %q, got %q", want, got)
}
if got := wikiPageIDForKey("feat:bardic_music_inspire_competence"); got != "feat:bardic_music_inspire_competence" {
t.Fatalf("expected underscore to remain in page ID leaf, got %q", got)
}
if got := wikiPageIDForKey("feat:bardic_music/inspire_competence"); got != "feat:bardic_music_inspire_competence" {
t.Fatalf("expected slash-authored key to stay in one page ID leaf, got %q", got)
}
}
func TestWikiPageOutputRelPathUsesCanonicalTitleLeaf(t *testing.T) {
if got, want := wikiPageOutputRelPath("feat:bardic_music_inspire_competence", "Inspire Competence"), filepath.FromSlash("feat/Inspire_Competence.html"); got != want {
t.Fatalf("expected underscore page ID to stay in one file leaf, got %q want %q", got, want)
}
if got, want := wikiPageOutputRelPath(wikiPageIDForKey("feat:bardic_music/inspire_competence"), "Inspire Competence"), filepath.FromSlash("feat/Inspire_Competence.html"); got != want {
t.Fatalf("expected slash-authored key to stay in one file leaf, got %q want %q", got, want)
}
}
func TestSaveWikiPageIndexRejectsDuplicateOutputPaths(t *testing.T) {
err := saveWikiPageIndex(filepath.Join(t.TempDir(), "page-index.json"), wikiPageIndex{
Version: wikiGeneratorVersion,
Pages: []wikiPageIndexEntry{
{PageID: "feat:special:attacks:bull:rush", OutputPath: "pages/feat/special/attacks/bull/rush.html"},
{PageID: "feat:special/attacks:bull:rush", OutputPath: "pages/feat/special/attacks/bull/rush.html"},
},
})
if err == nil || !strings.Contains(err.Error(), "duplicate wiki page-index output_path") {
t.Fatalf("expected duplicate output_path validation error, got %v", err)
}
}
func TestSaveWikiPageIndexRejectsDuplicatePublicPaths(t *testing.T) {
err := saveWikiPageIndex(filepath.Join(t.TempDir(), "page-index.json"), wikiPageIndex{
Version: wikiGeneratorVersion,
Pages: []wikiPageIndexEntry{
{PageID: "spells:darkness", PublicPath: "Spells/Darkness", OutputPath: "pages/spells/darkness.html"},
{PageID: "spells:gwildshape:driderdarkness", PublicPath: "Spells/Darkness", OutputPath: "pages/spells/gwildshape/driderdarkness.html"},
},
})
if err == nil || !strings.Contains(err.Error(), "duplicate wiki page-index public_path") {
t.Fatalf("expected duplicate public_path validation error, got %v", err)
}
}
func TestSaveWikiPageIndexRejectsFoldedDuplicatePublicPaths(t *testing.T) {
err := saveWikiPageIndex(filepath.Join(t.TempDir(), "page-index.json"), wikiPageIndex{
Version: wikiGeneratorVersion,
Pages: []wikiPageIndexEntry{
{PageID: "spells:fear", PublicPath: "Magic/Fear", OutputPath: "pages/spells/fear.html"},
{PageID: "spells:accented_fear", PublicPath: "magic/fear", OutputPath: "pages/spells/accented_fear.html"},
},
})
if err == nil || !strings.Contains(err.Error(), "duplicate wiki page-index public_path") {
t.Fatalf("expected folded duplicate public_path validation error, got %v", err)
}
}
func TestPublicWikiPathSplitsTitlePathWithoutWhitespaceAroundSeparator(t *testing.T) {
ctx := &wikiContext{namespaceTitles: map[string]string{"spells": "Magic"}}
if got := ctx.publicWikiPath("spells", "Parent::Child"); got != "Magic/Parent/Child" {
t.Fatalf("expected NodeBB-style title path split, got %q", got)
}
if got := wikiPageOutputRelPath("spells:parent_child", "Parent::Child"); got != filepath.FromSlash("spells/Parent/Child.html") {
t.Fatalf("expected title-based output path split, got %q", got)
}
}
func TestParseWikiPagePathDeclarationsRejectsLegacySlugOverrides(t *testing.T) {
_, err := parseWikiPagePathDeclarations([]byte(`
page_paths:
slug_overrides:
- page_id: "spells:pdk:fear"
slug: "pdk-fear"
`), "wiki.yaml")
if err == nil || !strings.Contains(err.Error(), `page_paths.slug_overrides is retired`) {
t.Fatalf("expected retired slug override error, got %v", err)
}
}
func TestCanonicalWikiSegmentPreservesCaseAndUnderscoreSpaces(t *testing.T) {
tests := map[string]string{
`Inspire Competence`: "Inspire_Competence",
`Grandmaster's Battle Momentum`: "Grandmasters_Battle_Momentum",
`Bigby’s Clenched Fist`: "Bigbys_Clenched_Fist",
`"Quoted" ‘Curly’ “Title”`: "Quoted_Curly_Title",
`Hardiness vs. Enchantments`: "Hardiness_vs_Enchantments",
`Clairaudience/Clairvoyance`: "Clairaudience_Clairvoyance",
`Moon-on-a-Stick`: "Moon_on_a_Stick",
`Élite & Noble Houses`: "Elite_Noble_Houses",
`Rock 'n' Roll`: "Rock_n_Roll",
`Melf's Acid Arrow`: "Melfs_Acid_Arrow",
`Alpha!@#$%^&*()[]-=_+/?.,<>` + "`" + `~|\Omega`: "Alpha_Omega",
`Æther Œuvre Øresund Straße Þorn Łódź Đelta`: "Aether_Oeuvre_Oresund_Strasse_Thorn_Lodz_Delta",
}
for input, want := range tests {
if got := canonicalWikiSegment(input); got != want {
t.Fatalf("canonicalWikiSegment(%q) = %q, want %q", input, got, want)
}
}
}
func TestCanonicalWikiSegmentFoldedKeyMatchesPluginFixture(t *testing.T) {
tests := []struct {
source string
canonical string
folded string
}{
{source: "Inspire Competence", canonical: "Inspire_Competence", folded: "inspire competence"},
{source: "Grandmaster's Battle Momentum", canonical: "Grandmasters_Battle_Momentum", folded: "grandmasters battle momentum"},
{source: "Æther Œuvre Øresund Straße Þorn Łódź Đelta", canonical: "Aether_Oeuvre_Oresund_Strasse_Thorn_Lodz_Delta", folded: "aether oeuvre oresund strasse thorn lodz delta"},
}
for _, tt := range tests {
if got := canonicalWikiSegment(tt.source); got != tt.canonical {
t.Fatalf("canonicalWikiSegment(%q) = %q, want %q", tt.source, got, tt.canonical)
}
if got := canonicalWikiSegmentFoldedKey(tt.source); got != tt.folded {
t.Fatalf("canonicalWikiSegmentFoldedKey(%q) = %q, want %q", tt.source, got, tt.folded)
}
}
}
func TestWikiStatusPagesEmitCanonicalLinks(t *testing.T) {
ctx := &wikiContext{}
report := renderWikiStatusReportPage(map[string]map[string]any{
"skills": {
"status": wikiStatusVanilla,
"new": 0,
"modified": 0,
"vanilla": 1,
"total": 1,
},
}, []string{"skills"}, ctx)
if !strings.Contains(report, "[[Skills|Skills]]") || strings.Contains(report, "[[skills:index|Skills]]") {
t.Fatalf("expected status report namespace link to use canonical public path, got:\n%s", report)
}
listing := renderWikiStatusListingPage("Skills Vanilla Pages", []string{"skills:inspire_competence", "feat:grandmaster_battle_momentum"}, map[string]string{
"skills:inspire_competence": "Inspire Competence",
"feat:grandmaster_battle_momentum": "Grandmaster's Battle Momentum",
}, ctx)
for _, want := range []string{
"[[Skills/Inspire_Competence|Inspire Competence]]",
"[[Feats/Grandmasters_Battle_Momentum|Grandmaster's Battle Momentum]]",
} {
if !strings.Contains(listing, want) {
t.Fatalf("expected status listing canonical link %q, got:\n%s", want, listing)
}
}
if strings.Contains(listing, "[[skills:inspire_competence|") || strings.Contains(listing, "[[feat:grandmaster_battle_momentum|") {
t.Fatalf("expected status listing to omit generated page IDs as public targets, got:\n%s", listing)
}
customCtx := &wikiContext{
namespaceTitles: map[string]string{
"spells": "Magic",
},
}
customReport := renderWikiStatusReportPage(map[string]map[string]any{
"spells": {
"status": wikiStatusNew,
"new": 1,
"modified": 0,
"vanilla": 0,
"total": 1,
},
}, []string{"spells"}, customCtx)
if !strings.Contains(customReport, "[[Magic|Magic]]") || strings.Contains(customReport, "[[Spells|Spells]]") {
t.Fatalf("expected custom namespace status report link to use declared canonical title, got:\n%s", customReport)
}
customListing := renderWikiStatusListingPage("Magic New Pages", []string{"spells:fear"}, map[string]string{
"spells:fear": "Fear",
}, customCtx)
if !strings.Contains(customListing, "[[Magic/Fear|Fear]]") || strings.Contains(customListing, "[[Spells/Fear|Fear]]") {
t.Fatalf("expected custom namespace status listing link to use declared canonical title, got:\n%s", customListing)
}
}
func TestPublicWikiTargetUsesCanonicalNamespaceAndTitlePath(t *testing.T) {
ctx := &wikiContext{
namespaceTitles: map[string]string{
"feat": "Feats",
},
namespacePaths: map[string]string{
"feat": "Wiki/Feats",
},
rowsByKey: map[string]map[string]any{
"feat:hardiness_versus_enchantments": {"FEAT": map[string]any{"tlk": map[string]any{"text": "Hardiness vs. Enchantments"}}},
},
}
if got, want := ctx.publicWikiTargetForKey("feat:hardiness_versus_enchantments", "Display Alias"), "Wiki/Feats/Hardiness_vs_Enchantments"; got != want {
t.Fatalf("expected canonical title path %q, got %q", want, got)
}
}
func TestPublicWikiTargetUsesTargetTitleBeforeDisplayLabel(t *testing.T) {
ctx := &wikiContext{
namespaceTitles: map[string]string{
"feat": "Feats",
},
rowsByKey: map[string]map[string]any{
"feat:hardiness:versus:enchantments": {"FEAT": "Hardiness vs. Enchantments"},
},
}
if got, want := ctx.publicWikiTargetForKey("feat:hardiness:versus:enchantments", "Display Alias"), "Feats/Hardiness_vs_Enchantments"; got != want {
t.Fatalf("expected target title slug %q, got %q", want, got)
}
}
func TestBuildAndPackageBuildsWikiOnlyWhenRequested(t *testing.T) {
root := testProjectRoot(t)
mkdirAll(t, filepath.Join(root, "topdata", "data", "skills"))
writeFile(t, filepath.Join(root, "topdata", "base_dialog.json"), "{}\n")
writeFile(t, filepath.Join(root, "topdata", "data", "skills", "base.json"), `{
"output": "skills.2da",
"columns": ["Label", "Name", "Description", "HideFromLevelUp", "Untrained", "KeyAbility", "ArmorCheckPenalty", "Constant"],
"rows": [
{
"id": 0,
"key": "skills:athletics",
"Label": "Athletics",
"Name": {"tlk": {"key": "skills:athletics.name", "text": "Athletics"}},
"Description": {"tlk": {"key": "skills:athletics.description", "text": "Skill text."}},
"HideFromLevelUp": "0",
"Untrained": "1",
"KeyAbility": "STR",
"ArmorCheckPenalty": "1",
"Constant": "SKILL_ATHLETICS"
}
]
}`+"\n")
writeFile(t, filepath.Join(root, "topdata", "data", "skills", "lock.json"), `{"skills:athletics":0}`+"\n")
proj := testProject(root)
proj.Config.TopData.ReferenceBuilder = ""
result, err := BuildAndPackageWithOptions(proj, BuildAndPackageOptions{}, nil)
if err != nil {
t.Fatalf("BuildAndPackageWithOptions failed: %v", err)
}
if result.WikiOutputDir != "" || result.WikiPages != 0 {
t.Fatalf("expected wiki generation to be skipped by default, got dir=%q pages=%d", result.WikiOutputDir, result.WikiPages)
}
if _, err := os.Stat(filepath.Join(root, ".cache", "wiki", "state.json")); !os.IsNotExist(err) {
t.Fatalf("expected no wiki state without explicit wiki build, got %v", err)
}
result, err = BuildAndPackageWithOptions(proj, BuildAndPackageOptions{Force: true, BuildWiki: true}, nil)
if err != nil {
t.Fatalf("BuildAndPackageWithOptions with wiki failed: %v", err)
}
generatedHTMLCount := countGeneratedWikiHTMLFiles(t, filepath.Join(root, ".cache", "wiki", "pages"))
if result.WikiPages != generatedHTMLCount {
t.Fatalf("expected wiki page count to match generated HTML files when requested, got result=%d files=%d", result.WikiPages, generatedHTMLCount)
}
if _, err := os.Stat(filepath.Join(root, ".cache", "wiki", "state.json")); err != nil {
t.Fatalf("expected wiki state after explicit wiki build: %v", err)
}
}
func TestBuildNativeRegeneratesWikiWhenTLKTextChanges(t *testing.T) {
root := testProjectRoot(t)
mkdirAll(t, filepath.Join(root, "topdata", "data", "skills"))
writeFile(t, filepath.Join(root, "topdata", "base_dialog.json"), "{}\n")
basePath := filepath.Join(root, "topdata", "data", "skills", "base.json")
writeFile(t, basePath, `{
"output": "skills.2da",
"columns": ["Label", "Name", "Description", "HideFromLevelUp", "Untrained", "KeyAbility", "ArmorCheckPenalty", "Constant"],
"rows": [
{
"id": 0,
"key": "skills:athletics",
"Label": "Athletics",
"Name": {"tlk": {"key": "skills:athletics.name", "text": "Athletics"}},
"Description": {"tlk": {"key": "skills:athletics.description", "text": "Original text."}},
"HideFromLevelUp": "0",
"Untrained": "1",
"KeyAbility": "STR",
"ArmorCheckPenalty": "1",
"Constant": "SKILL_ATHLETICS"
}
]
}`+"\n")
writeFile(t, filepath.Join(root, "topdata", "data", "skills", "lock.json"), `{"skills:athletics":0}`+"\n")
proj := testProject(root)
proj.Config.TopData.ReferenceBuilder = ""
proj.Config.Autogen.Consumers = nil
if _, err := BuildNative(proj, nil); err != nil {
t.Fatalf("initial BuildNative failed: %v", err)
}
writeFile(t, basePath, `{
"output": "skills.2da",
"columns": ["Label", "Name", "Description", "HideFromLevelUp", "Untrained", "KeyAbility", "ArmorCheckPenalty", "Constant"],
"rows": [
{
"id": 0,
"key": "skills:athletics",
"Label": "Athletics",
"Name": {"tlk": {"key": "skills:athletics.name", "text": "Athletics"}},
"Description": {"tlk": {"key": "skills:athletics.description", "text": "Updated text."}},
"HideFromLevelUp": "0",
"Untrained": "1",
"KeyAbility": "STR",
"ArmorCheckPenalty": "1",
"Constant": "SKILL_ATHLETICS"
}
]
}`+"\n")
if _, err := BuildNative(proj, nil); err != nil {
t.Fatalf("BuildNative after text change failed: %v", err)
}
pagePath := filepath.Join(root, ".cache", "wiki", "pages", "skills", "Athletics.html")
got, err := os.ReadFile(pagePath)
if err != nil {
t.Fatalf("read regenerated page: %v", err)
}
if !strings.Contains(string(got), "Updated text.") {
t.Fatalf("expected regenerated page to contain updated description:\n%s", string(got))
}
}
func TestBuildPackageIgnoresWikiSourcesForFreshness(t *testing.T) {
root := testProjectRoot(t)
mkdirAll(t, filepath.Join(root, "topdata", "data", "skills"))
writeFile(t, filepath.Join(root, "topdata", "base_dialog.json"), "{}\n")
writeFile(t, filepath.Join(root, "topdata", "data", "skills", "base.json"), `{
"output": "skills.2da",
"columns": ["Label", "Name", "Description", "HideFromLevelUp", "Untrained", "KeyAbility", "ArmorCheckPenalty", "Constant"],
"rows": [
{
"id": 0,
"key": "skills:athletics",
"Label": "Athletics",
"Name": {"tlk": {"key": "skills:athletics.name", "text": "Athletics"}},
"Description": {"tlk": {"key": "skills:athletics.description", "text": "Skill text."}},
"HideFromLevelUp": "0",
"Untrained": "1",
"KeyAbility": "STR",
"ArmorCheckPenalty": "1",
"Constant": "SKILL_ATHLETICS"
}
]
}`+"\n")
writeFile(t, filepath.Join(root, "topdata", "data", "skills", "lock.json"), `{"skills:athletics":0}`+"\n")
proj := testProject(root)
proj.Config.TopData.ReferenceBuilder = ""
proj.Config.Autogen.Consumers = nil
if _, err := BuildNative(proj, nil); err != nil {
t.Fatalf("BuildNative failed: %v", err)
}
pagePath := filepath.Join(root, ".cache", "wiki", "pages", "skills", "Athletics.html")
newTime := time.Now().Add(2 * time.Second)
if err := os.Chtimes(pagePath, newTime, newTime); err != nil {
t.Fatalf("touch wiki page: %v", err)
}
if _, err := BuildPackage(proj, nil); err != nil {
t.Fatalf("expected wiki output to be ignored for freshness, got %v", err)
}
}
|