claude: fold in old sow-tools

2026-06-13 09:49:29 +02:00
parent cdabf69aa2
commit cf89c166fe
112 changed files with 70812 additions and 74 deletions
@@ -0,0 +1,518 @@
+package topdata
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+)
+
+type wikiDataProvidersDocument struct {
+	Providers map[string]wikiDataProviderDefinition `json:"providers" yaml:"providers"`
+}
+
+type wikiDataProviderDefinition struct {
+	Source         string                          `json:"source" yaml:"source"`
+	Levels         string                          `json:"levels" yaml:"levels"`
+	ClassFeats     wikiDataProviderClassFeatConfig `json:"class_feats" yaml:"class_feats"`
+	Attacks        wikiDataProviderAttacksConfig   `json:"attacks" yaml:"attacks"`
+	Facts          wikiDataProviderFactsConfig     `json:"facts" yaml:"facts"`
+	Provider       string                          `json:"provider" yaml:"provider"`
+	Columns        int                             `json:"columns" yaml:"columns"`
+	ItemsPerColumn int                             `json:"items_per_column" yaml:"items_per_column"`
+	ForceColumns   bool                            `json:"force_columns" yaml:"force_columns"`
+}
+
+type wikiDataProviderClassFeatConfig struct {
+	Fields map[string]wikiDataProviderProjectionField `json:"fields" yaml:"fields"`
+}
+
+type wikiDataProviderProjectionField struct {
+	When string `json:"when" yaml:"when"`
+}
+
+type wikiDataProviderFactsConfig struct {
+	Rows []wikiDataProviderFactRow `json:"rows" yaml:"rows"`
+}
+
+type wikiDataProviderFactRow struct {
+	Key   string `json:"key" yaml:"key"`
+	Label string `json:"label" yaml:"label"`
+	Value string `json:"value" yaml:"value"`
+	When  string `json:"when" yaml:"when"`
+}
+
+type wikiDataProviderAttacksConfig struct {
+	Field      string                               `json:"field" yaml:"field"`
+	CountField string                               `json:"count_field" yaml:"count_field"`
+	Mode       string                               `json:"mode" yaml:"mode"`
+	Step       int                                  `json:"step" yaml:"step"`
+	Attacks    int                                  `json:"attacks" yaml:"attacks"`
+	Thresholds []wikiDataProviderAttackThreshold    `json:"thresholds" yaml:"thresholds"`
+	Overrides  []wikiDataProviderAttackOverrideRule `json:"overrides" yaml:"overrides"`
+}
+
+type wikiDataProviderAttackThreshold struct {
+	MinBAB  int `json:"min_bab" yaml:"min_bab"`
+	Attacks int `json:"attacks" yaml:"attacks"`
+}
+
+type wikiDataProviderAttackOverrideRule struct {
+	Classes []string `json:"classes" yaml:"classes"`
+	Levels  any      `json:"levels" yaml:"levels"`
+	Attacks int      `json:"attacks" yaml:"attacks"`
+	Add     int      `json:"add" yaml:"add"`
+}
+
+func loadWikiDataProviders(path string) (map[string]wikiDataProviderDefinition, error) {
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return map[string]wikiDataProviderDefinition{}, nil
+		}
+		return nil, fmt.Errorf("read wiki data providers %s: %w", path, err)
+	}
+	var doc wikiDataProvidersDocument
+	if err := yaml.Unmarshal(raw, &doc); err != nil {
+		return nil, fmt.Errorf("parse wiki data providers %s: %w", path, err)
+	}
+	for name, def := range doc.Providers {
+		if strings.TrimSpace(name) == "" {
+			return nil, fmt.Errorf("wiki data providers %s: provider name must not be empty", path)
+		}
+		if strings.TrimSpace(def.Source) == "" {
+			return nil, fmt.Errorf("wiki data providers %s: provider %s missing source", path, name)
+		}
+		source := strings.TrimSpace(def.Source)
+		switch source {
+		case "class_progression":
+			for field, projection := range def.ClassFeats.Fields {
+				if strings.TrimSpace(field) == "" {
+					return nil, fmt.Errorf("wiki data providers %s: provider %s has class feat projection without field name", path, name)
+				}
+				if strings.TrimSpace(projection.When) == "" {
+					return nil, fmt.Errorf("wiki data providers %s: provider %s class feat projection %s missing when", path, name, field)
+				}
+			}
+			if err := validateWikiDataProviderAttacks(path, name, def.Attacks); err != nil {
+				return nil, err
+			}
+		case "columns":
+			if len(def.ClassFeats.Fields) > 0 {
+				return nil, fmt.Errorf("wiki data providers %s: provider %s class feat projections require source class_progression", path, name)
+			}
+			if strings.TrimSpace(def.Attacks.Mode) != "" {
+				return nil, fmt.Errorf("wiki data providers %s: provider %s attacks config requires source class_progression", path, name)
+			}
+			if strings.TrimSpace(def.Provider) == "" {
+				return nil, fmt.Errorf("wiki data providers %s: provider %s columns provider missing provider", path, name)
+			}
+			if strings.TrimSpace(def.Provider) == name {
+				return nil, fmt.Errorf("wiki data providers %s: provider %s columns provider must not reference itself", path, name)
+			}
+			if def.Columns <= 0 {
+				return nil, fmt.Errorf("wiki data providers %s: provider %s columns must be a positive integer", path, name)
+			}
+			if def.ItemsPerColumn <= 0 {
+				return nil, fmt.Errorf("wiki data providers %s: provider %s items_per_column must be a positive integer", path, name)
+			}
+		case "facts":
+			if len(def.Facts.Rows) == 0 {
+				return nil, fmt.Errorf("wiki data providers %s: provider %s facts source requires rows", path, name)
+			}
+			for index, row := range def.Facts.Rows {
+				if strings.TrimSpace(row.Label) == "" {
+					return nil, fmt.Errorf("wiki data providers %s: provider %s facts row %d missing label", path, name, index+1)
+				}
+				if strings.TrimSpace(row.Value) == "" {
+					return nil, fmt.Errorf("wiki data providers %s: provider %s facts row %d missing value", path, name, index+1)
+				}
+			}
+		case "class_feats", "class_skills", "class_summary", "class_spellbook", "race_feats", "race_name_forms":
+			if len(def.ClassFeats.Fields) > 0 {
+				return nil, fmt.Errorf("wiki data providers %s: provider %s class feat projections require source class_progression", path, name)
+			}
+			if strings.TrimSpace(def.Attacks.Mode) != "" {
+				return nil, fmt.Errorf("wiki data providers %s: provider %s attacks config requires source class_progression", path, name)
+			}
+		default:
+			return nil, fmt.Errorf("wiki data providers %s: provider %s has unknown source %q", path, name, def.Source)
+		}
+	}
+	for name, def := range doc.Providers {
+		if strings.TrimSpace(def.Source) != "columns" {
+			continue
+		}
+		if _, ok := doc.Providers[strings.TrimSpace(def.Provider)]; !ok {
+			return nil, fmt.Errorf("wiki data providers %s: provider %s columns provider references missing provider %q", path, name, def.Provider)
+		}
+	}
+	if doc.Providers == nil {
+		return map[string]wikiDataProviderDefinition{}, nil
+	}
+	return doc.Providers, nil
+}
+
+func (ctx *wikiContext) wikiDataProviderRows(name string, page wikiTemplatePage) ([]map[string]any, error) {
+	def, ok := ctx.wikiDataProviders[name]
+	if !ok {
+		return nil, fmt.Errorf("missing wiki data provider %q in %s", name, ctx.wikiDataPath)
+	}
+	switch strings.TrimSpace(def.Source) {
+	case "columns":
+		sourceRows, err := ctx.wikiDataProviderRows(strings.TrimSpace(def.Provider), page)
+		if err != nil {
+			return nil, err
+		}
+		return wikiColumnProviderRows(sourceRows, def.Columns, def.ItemsPerColumn, def.ForceColumns), nil
+	case "class_progression":
+		if page.Category != "classes" {
+			return nil, nil
+		}
+		return ctx.classProgressionRows(def.Levels, def.ClassFeats.Fields, def.Attacks, page.Key, page.Row)
+	case "facts":
+		return ctx.wikiFactRows(name, def.Facts, page)
+	case "class_feats":
+		if page.Category != "classes" {
+			return nil, nil
+		}
+		return ctx.classFeatRows(page.Row), nil
+	case "class_skills":
+		if page.Category != "classes" {
+			return nil, nil
+		}
+		return ctx.classSkillRows(page.Row), nil
+	case "class_summary":
+		if page.Category != "classes" {
+			return nil, nil
+		}
+		return ctx.classSummaryRows(page.Row), nil
+	case "class_spellbook":
+		if page.Category != "classes" {
+			return nil, nil
+		}
+		return ctx.classSpellbookRows(page.Key, page.Row), nil
+	case "race_feats":
+		if page.Category != "racialtypes" {
+			return nil, nil
+		}
+		return ctx.raceFeatRows(page.Row), nil
+	case "race_name_forms":
+		if page.Category != "racialtypes" {
+			return nil, nil
+		}
+		return ctx.raceNameFormRows(page.Row), nil
+	default:
+		return nil, fmt.Errorf("unknown wiki data provider source %q", def.Source)
+	}
+}
+
+func (ctx *wikiContext) wikiFactRows(providerName string, cfg wikiDataProviderFactsConfig, page wikiTemplatePage) ([]map[string]any, error) {
+	out := []map[string]any{}
+	renderCtx := wikiTableRenderContext{Page: page, TableName: providerName, Path: ctx.wikiDataPath}
+	for index, spec := range cfg.Rows {
+		if strings.TrimSpace(spec.When) != "" {
+			value, err := ctx.evalWikiDataProviderTemplate(spec.When, page.Row, renderCtx)
+			if err != nil {
+				return nil, fmt.Errorf("facts provider %s row %d condition %q: %w", providerName, index+1, spec.When, err)
+			}
+			if !truthyWikiTableValue(value) {
+				continue
+			}
+		}
+		value, err := ctx.evalWikiDataProviderTemplate(spec.Value, page.Row, renderCtx)
+		if err != nil {
+			return nil, fmt.Errorf("facts provider %s row %d value %q: %w", providerName, index+1, spec.Value, err)
+		}
+		text := stringifyWikiTableValue(value)
+		if strings.TrimSpace(text) == "" || strings.TrimSpace(text) == nullValue {
+			continue
+		}
+		key := strings.TrimSpace(spec.Key)
+		if key == "" {
+			key = wikiFactKeyFromLabel(spec.Label)
+		}
+		out = append(out, map[string]any{
+			"Key":   key,
+			"Label": spec.Label,
+			"Value": text,
+		})
+	}
+	return out, nil
+}
+
+func (ctx *wikiContext) evalWikiDataProviderTemplate(template string, row map[string]any, renderCtx wikiTableRenderContext) (any, error) {
+	template = strings.TrimSpace(template)
+	if strings.HasPrefix(template, "{{") && strings.HasSuffix(template, "}}") {
+		expr := strings.TrimSpace(strings.TrimSuffix(strings.TrimPrefix(template, "{{"), "}}"))
+		parser := wikiExprParser{tokens: tokenizeWikiExpr(expr), row: row, ctx: ctx, renderCtx: renderCtx, allowMissingFields: true}
+		value, err := parser.parseComparison()
+		if err != nil {
+			return nil, err
+		}
+		if parser.peek().kind != wikiExprEOF {
+			return nil, fmt.Errorf("unexpected token %q", parser.peek().text)
+		}
+		return value, nil
+	}
+	if strings.Contains(template, "{{") {
+		return nil, fmt.Errorf("mixed literal/expression templates are not supported")
+	}
+	return template, nil
+}
+
+func wikiFactKeyFromLabel(label string) string {
+	key := strings.ToLower(strings.TrimSpace(label))
+	key = strings.Map(func(r rune) rune {
+		switch {
+		case r >= 'a' && r <= 'z':
+			return r
+		case r >= '0' && r <= '9':
+			return r
+		case r == ' ' || r == '-' || r == '_':
+			return '_'
+		default:
+			return -1
+		}
+	}, key)
+	for strings.Contains(key, "__") {
+		key = strings.ReplaceAll(key, "__", "_")
+	}
+	return strings.Trim(key, "_")
+}
+
+func validateWikiDataProviderAttacks(path, provider string, cfg wikiDataProviderAttacksConfig) error {
+	if strings.TrimSpace(cfg.Mode) == "" {
+		return nil
+	}
+	switch strings.TrimSpace(cfg.Mode) {
+	case "fixed":
+		if cfg.Attacks < 1 {
+			return fmt.Errorf("wiki data providers %s: provider %s attacks fixed mode requires positive attacks", path, provider)
+		}
+	case "bab_thresholds":
+		if len(cfg.Thresholds) == 0 {
+			return fmt.Errorf("wiki data providers %s: provider %s attacks bab_thresholds mode requires thresholds", path, provider)
+		}
+		for i, threshold := range cfg.Thresholds {
+			if threshold.MinBAB < 0 {
+				return fmt.Errorf("wiki data providers %s: provider %s attacks threshold %d min_bab must be non-negative", path, provider, i+1)
+			}
+			if threshold.Attacks < 1 {
+				return fmt.Errorf("wiki data providers %s: provider %s attacks threshold %d attacks must be positive", path, provider, i+1)
+			}
+		}
+	default:
+		return fmt.Errorf("wiki data providers %s: provider %s attacks has unknown mode %q", path, provider, cfg.Mode)
+	}
+	for i, override := range cfg.Overrides {
+		if len(override.Classes) == 0 {
+			return fmt.Errorf("wiki data providers %s: provider %s attacks override %d missing classes", path, provider, i+1)
+		}
+		for _, class := range override.Classes {
+			if strings.TrimSpace(class) == "" {
+				return fmt.Errorf("wiki data providers %s: provider %s attacks override %d has empty class", path, provider, i+1)
+			}
+		}
+		if _, err := parseWikiAttackLevels(override.Levels); err != nil {
+			return fmt.Errorf("wiki data providers %s: provider %s attacks override %d bad levels: %w", path, provider, i+1, err)
+		}
+		if override.Attacks != 0 && override.Add != 0 {
+			return fmt.Errorf("wiki data providers %s: provider %s attacks override %d must not set both attacks and add", path, provider, i+1)
+		}
+		if override.Attacks == 0 && override.Add == 0 {
+			return fmt.Errorf("wiki data providers %s: provider %s attacks override %d must set attacks or add", path, provider, i+1)
+		}
+		if override.Attacks < 0 {
+			return fmt.Errorf("wiki data providers %s: provider %s attacks override %d attacks must be positive", path, provider, i+1)
+		}
+	}
+	return nil
+}
+
+func parseWikiAttackLevels(raw any) (map[int]struct{}, error) {
+	out := map[int]struct{}{}
+	addLevel := func(value any) error {
+		switch typed := value.(type) {
+		case int:
+			if typed < 1 {
+				return fmt.Errorf("level must be positive")
+			}
+			out[typed] = struct{}{}
+			return nil
+		case int64:
+			if typed < 1 {
+				return fmt.Errorf("level must be positive")
+			}
+			out[int(typed)] = struct{}{}
+			return nil
+		case float64:
+			level := int(typed)
+			if typed != float64(level) || level < 1 {
+				return fmt.Errorf("level must be a positive integer")
+			}
+			out[level] = struct{}{}
+			return nil
+		case string:
+			text := strings.TrimSpace(typed)
+			if text == "" {
+				return fmt.Errorf("level must not be empty")
+			}
+			if strings.Contains(text, "-") {
+				start, end, err := parseLevelRange(text)
+				if err != nil {
+					return err
+				}
+				for level := start; level <= end; level++ {
+					out[level] = struct{}{}
+				}
+				return nil
+			}
+			level, err := strconv.Atoi(text)
+			if err != nil || level < 1 {
+				return fmt.Errorf("level must be a positive integer")
+			}
+			out[level] = struct{}{}
+			return nil
+		default:
+			return fmt.Errorf("unsupported level value")
+		}
+	}
+	switch typed := raw.(type) {
+	case nil:
+		return nil, fmt.Errorf("levels is required")
+	case []any:
+		if len(typed) == 0 {
+			return nil, fmt.Errorf("levels must not be empty")
+		}
+		for _, value := range typed {
+			if err := addLevel(value); err != nil {
+				return nil, err
+			}
+		}
+	default:
+		if err := addLevel(raw); err != nil {
+			return nil, err
+		}
+	}
+	return out, nil
+}
+
+func wikiColumnProviderRows(sourceRows []map[string]any, configuredColumns, itemsPerColumn int, forceColumns bool) []map[string]any {
+	if configuredColumns <= 0 || itemsPerColumn <= 0 {
+		return nil
+	}
+	needed := 0
+	if len(sourceRows) > 0 {
+		needed = (len(sourceRows) + itemsPerColumn - 1) / itemsPerColumn
+	}
+	total := needed
+	if forceColumns && configuredColumns > total {
+		total = configuredColumns
+	}
+	if total == 0 {
+		return nil
+	}
+	rows := make([]map[string]any, 0, total)
+	for i := 0; i < total; i++ {
+		start := i * itemsPerColumn
+		end := start + itemsPerColumn
+		if start > len(sourceRows) {
+			start = len(sourceRows)
+		}
+		if end > len(sourceRows) {
+			end = len(sourceRows)
+		}
+		items := make([]map[string]any, 0, end-start)
+		for _, source := range sourceRows[start:end] {
+			items = append(items, cloneRowMap(source))
+		}
+		rows = append(rows, map[string]any{
+			"Index": i + 1,
+			"Count": len(items),
+			"Items": items,
+		})
+	}
+	return rows
+}
+
+func (ctx *wikiContext) classSkillRows(classRow map[string]any) []map[string]any {
+	table := ctx.tableForValue(fieldValue(classRow, "SkillsTable"), ctx.classSkillTables)
+	if table == nil {
+		return nil
+	}
+	rows := []map[string]any{}
+	for _, source := range table.Rows {
+		if stringValue(source, "ClassSkill") != "1" {
+			continue
+		}
+		key := resolveReferenceKey(fieldValue(source, "SkillIndex"), ctx.skillIDToKey)
+		if key == "" {
+			key = resolveReferenceKey(fieldValue(source, "SkillIndex"), nil)
+		}
+		if key == "" || !ctx.canReferenceWikiKey(key) {
+			continue
+		}
+		row := cloneRowMap(source)
+		row["SkillKey"] = key
+		row["SkillName"] = ctx.resolveSkillName(key)
+		if skillRow := ctx.skillRows[key]; skillRow != nil {
+			row["SkillAbility"] = stringValue(skillRow, "KeyAbility")
+		}
+		rows = append(rows, row)
+	}
+	return rows
+}
+
+func (ctx *wikiContext) raceFeatRows(raceRow map[string]any) []map[string]any {
+	values := []any{}
+	switch typed := fieldValue(raceRow, "FeatsTable").(type) {
+	case []any:
+		values = append(values, typed...)
+	case []string:
+		for _, value := range typed {
+			values = append(values, value)
+		}
+	default:
+		if table := ctx.tableForValue(typed, ctx.raceFeatTables); table != nil {
+			for _, row := range table.Rows {
+				values = append(values, fieldValue(row, "FeatIndex"))
+			}
+		}
+	}
+	rows := []map[string]any{}
+	for _, value := range values {
+		key := resolveReferenceKey(value, ctx.featIDToKey)
+		if key == "" {
+			key = resolveReferenceKey(value, nil)
+		}
+		if key == "" || !ctx.canReferenceWikiKey(key) {
+			continue
+		}
+		rows = append(rows, map[string]any{
+			"FeatKey":  key,
+			"FeatName": ctx.resolveFeatName(key),
+		})
+	}
+	return rows
+}
+
+func (ctx *wikiContext) raceNameFormRows(raceRow map[string]any) []map[string]any {
+	candidates := []struct {
+		label string
+		field string
+	}{
+		{"Plural", "NamePlural"},
+		{"Converted Name", "ConverName"},
+		{"Lower Name", "ConverNameLower"},
+	}
+	rows := []map[string]any{}
+	for _, candidate := range candidates {
+		if value := ctx.resolveTextValue(fieldValue(raceRow, candidate.field), nil); value != "" {
+			rows = append(rows, map[string]any{"Label": candidate.label, "Value": value})
+		}
+	}
+	return rows
+}