LCOV - code coverage report
Current view: top level - rawschema/rawcheck - rawcheck.go Coverage Total Hit
Test: coverage.lcov Lines: 65.2 % 69 45
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : // Package rawcheck は raw のデータを rawschema の CUE のスキーマで検証する。
       2              : //
       3              : // # 責務
       4              : //
       5              : // 形、値の制約、行の間の参照を、CUE のスキーマに照らして確かめる。違反はデータの位置ごとに Error へ集める。
       6              : //
       7              : // # 使い分け
       8              : //
       9              : // CUE のライブラリを持ち込むので、ゲームの本体からは import しない。テストだけが使う。raw は埋め込みの
      10              : // データなので、CI のテストで検証すれば足りる。
      11              : //
      12              : // # 仕様
      13              : //
      14              : // 検証するのは raws を JSON にした形である。Go の型に読み込んだあとの値を見るので、TOML で省いた
      15              : // 0 の値も埋まった状態で検証される。
      16              : package rawcheck
      17              : 
      18              : import (
      19              :         "cmp"
      20              :         "encoding/json"
      21              :         "errors"
      22              :         "fmt"
      23              :         "io/fs"
      24              :         "path"
      25              :         "slices"
      26              :         "strings"
      27              :         "sync"
      28              : 
      29              :         "cuelang.org/go/cue"
      30              :         "cuelang.org/go/cue/cuecontext"
      31              :         cueerrors "cuelang.org/go/cue/errors"
      32              :         "cuelang.org/go/cue/load"
      33              :         cuejson "cuelang.org/go/encoding/json"
      34              : 
      35              :         "github.com/kijimaD/ruins/internal/rawschema"
      36              : )
      37              : 
      38              : // Violation は1つの違反。Path はデータの位置で、items.3.melee.accuracy のように . で区切る。
      39              : type Violation struct {
      40              :         Path    string
      41              :         Message string
      42              : }
      43              : 
      44              : // Error は検証で見つかった違反の集まり。
      45              : type Error struct {
      46              :         Violations []Violation
      47              : }
      48              : 
      49              : func (e *Error) Error() string {
      50            0 :         lines := make([]string, len(e.Violations))
      51            0 :         for i, v := range e.Violations {
      52            0 :                 lines[i] = v.Path + ": " + v.Message
      53            0 :         }
      54            0 :         return strings.Join(lines, "\n")
      55              : }
      56              : 
      57              : // Paths は違反のあった位置を、重複を除いて並べて返す。1つの位置に複数の違反があることがある。
      58              : func (e *Error) Paths() []string {
      59            1 :         out := make([]string, len(e.Violations))
      60            1 :         for i, v := range e.Violations {
      61            1 :                 out[i] = v.Path
      62            1 :         }
      63            1 :         slices.Sort(out)
      64            1 :         return slices.Compact(out)
      65              : }
      66              : 
      67              : // errSchemaBuild は CUE のスキーマを組めないときに返す
      68              : var errSchemaBuild = errors.New("failed to build raw schema")
      69              : 
      70              : // checker はコンパイルしたスキーマを持つ。
      71              : type checker struct {
      72              :         ctx    *cue.Context
      73              :         schema cue.Value
      74              : }
      75              : 
      76              : var loadChecker = sync.OnceValues(newChecker)
      77              : 
      78              : func newChecker() (*checker, error) {
      79            1 :         const dir = "/rawschema"
      80            1 :         overlay := map[string]load.Source{}
      81            1 :         err := fs.WalkDir(rawschema.SchemaFiles, ".", func(p string, d fs.DirEntry, err error) error {
      82            1 :                 if err != nil || d.IsDir() {
      83            1 :                         return err
      84            1 :                 }
      85            1 :                 b, err := fs.ReadFile(rawschema.SchemaFiles, p)
      86            1 :                 if err != nil {
      87            0 :                         return err
      88            0 :                 }
      89            1 :                 overlay[path.Join(dir, p)] = load.FromBytes(b)
      90            1 :                 return nil
      91              :         })
      92            1 :         if err != nil {
      93            0 :                 return nil, fmt.Errorf("%w: %w", errSchemaBuild, err)
      94            0 :         }
      95            1 :         insts := load.Instances([]string{"."}, &load.Config{Dir: dir, Overlay: overlay})
      96            1 :         if len(insts) != 1 {
      97            0 :                 return nil, fmt.Errorf("%w: %d instances", errSchemaBuild, len(insts))
      98            0 :         }
      99            1 :         if err := insts[0].Err; err != nil {
     100            0 :                 return nil, fmt.Errorf("%w: %w", errSchemaBuild, err)
     101            0 :         }
     102            1 :         ctx := cuecontext.New()
     103            1 :         schema := ctx.BuildInstance(insts[0])
     104            1 :         if err := schema.Err(); err != nil {
     105            0 :                 return nil, fmt.Errorf("%w: %w", errSchemaBuild, err)
     106            0 :         }
     107            1 :         return &checker{ctx: ctx, schema: schema}, nil
     108              : }
     109              : 
     110              : // Validate は raws を CUE のスキーマで検証する。違反があれば *Error を返す。
     111              : func Validate(raws rawschema.Raws) error {
     112            1 :         c, err := loadChecker()
     113            1 :         if err != nil {
     114            0 :                 return err
     115            0 :         }
     116            1 :         b, err := json.Marshal(raws)
     117            1 :         if err != nil {
     118            0 :                 return err
     119            0 :         }
     120            1 :         expr, err := cuejson.Extract("raws.json", b)
     121            1 :         if err != nil {
     122            0 :                 return err
     123            0 :         }
     124            1 :         v := c.schema.Unify(c.ctx.BuildExpr(expr))
     125            1 :         if err := v.Validate(cue.Concrete(true)); err != nil {
     126            1 :                 return toError(err)
     127            1 :         }
     128            1 :         return nil
     129              : }
     130              : 
     131              : func toError(err error) error {
     132            1 :         var out Error
     133            1 :         seen := map[Violation]bool{}
     134            1 :         for _, e := range cueerrors.Errors(err) {
     135            1 :                 format, args := e.Msg()
     136            1 :                 v := Violation{Path: strings.Join(e.Path(), "."), Message: fmt.Sprintf(format, args...)}
     137            1 :                 if seen[v] {
     138            0 :                         continue
     139              :                 }
     140            1 :                 seen[v] = true
     141            1 :                 out.Violations = append(out.Violations, v)
     142              :         }
     143            1 :         slices.SortFunc(out.Violations, func(a, b Violation) int {
     144            0 :                 return cmp.Or(cmp.Compare(a.Path, b.Path), cmp.Compare(a.Message, b.Message))
     145            0 :         })
     146            1 :         return &out
     147              : }
        

Generated by: LCOV version 2.0-1