`,
+ `| 1st | +1 | 1-10 |
`,
+ `| 2nd | +2 | 2-20 |
`,
+ } {
+ if !strings.Contains(got, want) {
+ t.Fatalf("expected rendered output to contain %q:\n%s", want, 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]] | `,
+ `[[feat/darkvision|Darkvision]]`,
+ `[[feat/daylight-aasimar|Daylight (aasimar)]]`,
+ } {
+ if !strings.Contains(got, want) {
+ t.Fatalf("expected rendered output to contain %q:\n%s", 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.
")), nil
+ case "html":
+ return wikiTemplateHTML(renderWikiTemplatePlainHTML(stringifyWikiTemplatePlain(value))), nil
+ case "wiki":
+ return wikiTemplateHTML(renderWikiLinks(stringifyWikiTemplatePlain(value))), nil
+ case "lower":
+ return strings.ToLower(stringifyWikiTemplatePlain(value)), nil
+ case "title":
+ return strings.Title(stringifyWikiTemplatePlain(value)), nil
+ case "sentence":
+ text := stringifyWikiTemplatePlain(value)
+ for i, r := range text {
+ if unicode.IsLetter(r) {
+ return text[:i] + string(unicode.ToUpper(r)) + text[i+len(string(r)):], nil
+ }
+ }
+ return text, nil
+ case "join":
+ return joinWikiTemplateValue(value, firstArg(args)), nil
+ case "ordinal":
+ return ordinalWikiTableValue(numericWikiTableValue(value)), nil
+ case "default":
+ if strings.TrimSpace(stringifyWikiTemplatePlain(value)) == "" {
+ return firstArg(args), nil
+ }
+ return value, nil
+ case "ref":
+ return ctx.renderTemplateReference(value, firstArg(args)), nil
+ case "link":
+ return ctx.renderTemplateLink(value, firstArg(args), state), nil
+ default:
+ return nil, fmt.Errorf("render wiki template %s for %s: unknown filter %q", state.path, state.page.PageID, name)
+ }
+}
+
+func parseWikiTemplateFilterArgs(raw string) ([]string, error) {
+ raw = strings.TrimSpace(raw)
+ if raw == "" {
+ return nil, nil
+ }
+ args := []string{}
+ for len(raw) > 0 {
+ raw = strings.TrimSpace(raw)
+ if !strings.HasPrefix(raw, `"`) {
+ if idx := strings.Index(raw, ","); idx >= 0 {
+ args = append(args, strings.TrimSpace(raw[:idx]))
+ raw = raw[idx+1:]
+ continue
+ }
+ args = append(args, strings.TrimSpace(raw))
+ break
+ }
+ var b strings.Builder
+ escaped := false
+ i := 1
+ for ; i < len(raw); i++ {
+ if escaped {
+ b.WriteByte(raw[i])
+ escaped = false
+ continue
+ }
+ if raw[i] == '\\' {
+ escaped = true
+ continue
+ }
+ if raw[i] == '"' {
+ break
+ }
+ b.WriteByte(raw[i])
+ }
+ if i >= len(raw) {
+ return nil, fmt.Errorf("unterminated quoted argument")
+ }
+ args = append(args, b.String())
+ raw = strings.TrimSpace(raw[i+1:])
+ if strings.HasPrefix(raw, ",") {
+ raw = raw[1:]
+ } else if raw != "" {
+ return nil, fmt.Errorf("unexpected argument text %q", raw)
+ }
+ }
+ return args, nil
+}
+
+func firstArg(args []string) string {
+ if len(args) == 0 {
+ return ""
+ }
+ return args[0]
+}
+
+func secondArg(args []string) string {
+ if len(args) < 2 {
+ return ""
+ }
+ return args[1]
+}
+
+func afterFirstMarker(text, marker string) string {
+ if marker == "" {
+ return text
+ }
+ idx := strings.Index(text, marker)
+ if idx < 0 {
+ return ""
+ }
+ return text[idx+len(marker):]
+}
+
+func beforeFirstMarker(text, marker string) string {
+ if marker == "" {
+ return text
+ }
+ idx := strings.Index(text, marker)
+ if idx < 0 {
+ return text
+ }
+ return text[:idx]
+}
+
+func selectWikiTemplateParagraphs(text, selector string) string {
+ paragraphs := splitWikiTemplateParagraphs(text)
+ if len(paragraphs) == 0 {
+ return ""
+ }
+ switch strings.TrimSpace(selector) {
+ case "first":
+ return paragraphs[0]
+ case "last":
+ return paragraphs[len(paragraphs)-1]
+ case "all", "":
+ return strings.Join(paragraphs, "\n\n")
+ default:
+ selected := []string{}
+ for _, part := range strings.Split(selector, ",") {
+ switch strings.TrimSpace(part) {
+ case "first":
+ selected = append(selected, paragraphs[0])
+ case "last":
+ selected = append(selected, paragraphs[len(paragraphs)-1])
+ default:
+ if idx, err := strconv.Atoi(strings.TrimSpace(part)); err == nil && idx > 0 && idx <= len(paragraphs) {
+ selected = append(selected, paragraphs[idx-1])
+ }
+ }
+ }
+ return strings.Join(selected, "\n\n")
+ }
+}
+
+func splitWikiTemplateParagraphs(text string) []string {
+ normalized := strings.ReplaceAll(text, "\r\n", "\n")
+ chunks := strings.Split(normalized, "\n\n")
+ out := []string{}
+ for _, chunk := range chunks {
+ if trimmed := strings.TrimSpace(chunk); trimmed != "" {
+ out = append(out, trimmed)
+ }
+ }
+ return out
+}
+
+func renderWikiTemplatePlainHTML(text string) string {
+ paragraphs := splitWikiTemplateParagraphs(text)
+ if len(paragraphs) == 0 {
+ return ""
+ }
+ out := strings.Builder{}
+ for _, paragraph := range paragraphs {
+ escaped := html.EscapeString(paragraph)
+ escaped = strings.ReplaceAll(escaped, "\n", "
")
+ out.WriteString("")
+ out.WriteString(escaped)
+ out.WriteString("
")
+ }
+ return out.String()
+}
+
+func joinWikiTemplateValue(value any, sep string) string {
+ switch typed := value.(type) {
+ case []string:
+ return strings.Join(typed, sep)
+ case []any:
+ parts := make([]string, 0, len(typed))
+ for _, item := range typed {
+ if text := stringifyWikiTemplatePlain(item); text != "" {
+ parts = append(parts, text)
+ }
+ }
+ return strings.Join(parts, sep)
+ default:
+ return stringifyWikiTemplatePlain(value)
+ }
+}
+
+func (ctx *wikiContext) renderTemplateReference(value any, dataset string) string {
+ return ctx.renderReference(value, ctx.wikiIDMapForDataset(dataset), ctx.wikiNameResolverForDataset(dataset))
+}
+
+func (ctx *wikiContext) wikiNameResolverForDataset(dataset string) func(string) string {
+ switch dataset {
+ case "classes":
+ return ctx.resolveClassName
+ case "feat":
+ return ctx.resolveFeatName
+ case "skills":
+ return ctx.resolveSkillName
+ default:
+ return func(string) string { return "" }
+ }
+}
+
+func (ctx *wikiContext) renderTemplateLink(value any, labelField string, state *wikiTemplateRenderState) string {
+ key := stringifyWikiTemplatePlain(value)
+ label := labelField
+ if state.row != nil {
+ if raw, ok := lookupField(state.row, labelField); ok {
+ label = stringifyWikiTemplatePlain(raw)
+ }
+ }
+ if label == "" {
+ label = key
+ }
+ if key == "" {
+ return label
+ }
+ if !ctx.canReferenceWikiKey(key) {
+ return ""
+ }
+ if target := ctx.publicWikiTargetForKey(key, label); target != "" {
+ key = target
+ }
+ return "[[" + key + "|" + label + "]]"
+}
+
+func stringifyWikiTemplateOutput(value any) string {
+ if htmlValue, ok := value.(wikiTemplateHTML); ok {
+ return string(htmlValue)
+ }
+ return html.EscapeString(stringifyWikiTemplatePlain(value))
+}
+
+func stringifyWikiTemplatePlain(value any) string {
+ if htmlValue, ok := value.(wikiTemplateHTML); ok {
+ return string(htmlValue)
+ }
+ return stringifyWikiTableValue(value)
+}