github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/core/macros.go

package main

import (
	"fmt"
	"go/ast"
	"go/parser"
	"go/token"
	"html/template"
	"io"
	"log"
	"os"
	"os/exec"
	"strings"
	"unicode"
)

var (
	templateAcces = template.Must(template.New("").Parse(`
	// Acces{{ .Name }} est un pointeur sur l'objet {{ .Name }}
	// d'id donné.
	type Acces{{ .Name }} struct {
		Base *BaseLocale
		Id   int64
	}

	func(b *BaseLocale) New{{ .Name }}(id int64) Acces{{ .Name }} {
		return Acces{{ .Name }}{Base: b, Id: id}
	}

	// RawData renvoi les données sous-jacentes à l'accès.
	func (ac Acces{{ .Name }}) RawData() rd.{{ .Name }} {
		return ac.Base.{{ .Name }}s[ac.Id]
	}
	`))

	templateLoadBaseLocaleMain = `
	base.%ss, err = rd.SelectAll%ss(db)
	if err != nil {
		return nil, err
	}
	`

	templateLoadBaseLocalePartielMain = `
	base.%ss, err = rd.Select%ss(db, items["%ss"]...)
	if err != nil {
		return nil, err
	}
	`

	templateLoadBaseLocaleLink = `
	rl.%ss, err = rd.SelectAll%ss(db)
	if err != nil {
		return nil, err
	}
	`

	templateLoadBaseLocalePartielLink = `
	rl.%s, err = rd.Select%sById%s(db, items["%s"]...)
	if err != nil {
		return nil, err
	}
	`

	templateHashTable = `
	tmp = make(map[int64]uint32, len(base.%s))
	for id, v := range base.%s {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, err
		}
		tmp[id] = crc32.ChecksumIEEE(b)
	}
	baseHash["%s"] = tmp 
	`

	templateUpdateTable = `
	for id, v := range incomming.%s {
		base.%s[id] = v 
	}
	for _, id := range toDelete["%s"] {
		delete(base.%s, id)
	}
	`

	templateTestMarshal = template.Must(template.New("").Parse(`
	size, err = compressMesureSize(base.{{ .Name }}s)
	if err != nil {
		t.Fatal(err)
	}
	fmt.Println("{{ .Name }}s :", size / 1000, "KB")
	
	`))
)

type templateArg struct {
	Name string
}

func main() {
	parse()
}

func isMainItem(name string) bool {
	return len(strings.FieldsFunc(name, unicode.IsUpper)) == 1
}

var exclutedTables = []string{
	"User", "ContenuDocument", "Lettredirecteur", "Imageuploaded", "Inscription",
}

func isExcluded(s string) bool {
	for _, table := range exclutedTables {
		if s == table {
			return true
		}
	}
	return false
}

func parse() {
	baseLinkTables := parseBaseLocaleLinks()

	t := token.NewFileSet()
	f, err := parser.ParseFile(t, "rawdata/models.go", nil, parser.ParseComments)
	if err != nil {
		log.Fatal(err)
	}

	fAcces, err := os.Create("datamodel/acces_def.go")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Fprintln(fAcces, `
	// DO NOT EDIT -- auto-generated from rawadata.go
	package datamodel

	import (
		rd "github.com/benoitkugler/goACVE/server/core/rawdata"
	)
	`)

	var mainItems, linkItems []string
	for _, decl := range f.Decls {
		stm, ok := decl.(*ast.GenDecl)
		if !ok {
			continue
		}
		for _, spec := range stm.Specs {
			s, ok := spec.(*ast.TypeSpec)
			if !ok {
				continue
			}
			name := s.Name.String()
			if isExcluded(name) {
				continue
			}
			if isMainItem(name) {
				genereCode(fAcces, name)
				mainItems = append(mainItems, name)
			} else {
				linkItems = append(linkItems, name)
			}
		}
	}
	fLoadDB, err := os.Create("datamodel/ioload.go")
	if err != nil {
		log.Fatal(err)
	}
	genereCodeBase(fLoadDB, mainItems, linkItems, baseLinkTables)
	if err = fLoadDB.Close(); err != nil {
		log.Fatal(err)
	}

	fTest, err := os.Create("datamodel/ioload_test.go")
	if err != nil {
		log.Fatal(err)
	}
	genereTestCode(fTest, mainItems)
	if err = fTest.Close(); err != nil {
		log.Fatal(err)
	}

	_ = exec.Command("goreturns", "-w", "datamodel/ioload.go").Run()
	_ = exec.Command("goreturns", "-w", "datamodel/ioload_test.go").Run()
	_ = exec.Command("goreturns", "-w", "datamodel/acces_def.go").Run()
}

func parseBaseLocaleLinks() []string {
	var out []string
	t := token.NewFileSet()
	f, err := parser.ParseFile(t, "rawdata/properties.go", nil, parser.ParseComments)
	if err != nil {
		log.Fatal(err)
	}
	for _, decl := range f.Decls {
		stm, ok := decl.(*ast.GenDecl)
		if !ok {
			continue
		}
		for _, spec := range stm.Specs {
			s, ok := spec.(*ast.TypeSpec)
			if !ok {
				continue
			}
			if s.Name.String() != "Links" {
				continue
			}
			for _, field := range s.Type.(*ast.StructType).Fields.List {
				out = append(out, field.Names[0].String())
			}
		}
	}
	return out
}

func genereCode(buffer io.Writer, name string) {
	args := templateArg{Name: name}

	if err := templateAcces.Execute(buffer, args); err != nil {
		log.Fatal(err)
	}
}

func genereCodeBase(w io.Writer, mainItems, linkItems, baseLinks []string) {
	fmt.Fprintln(w, `
	// DO NOT EDIT -- auto-generated from rawadata.go
	package datamodel

	import (
		rd "github.com/benoitkugler/goACVE/server/core/rawdata"
	)

	// BaseLocale stocke en mémoire vive toutes les informations nécessaires,
	// sous forme brute.
	type BaseLocale struct {
	`)
	for _, item := range mainItems {
		fmt.Fprintf(w, "	%ss rd.%ss\n", item, item)
	}
	fmt.Fprintln(w, `
	
	rd.Links
	}`)
	fmt.Fprintln(w, `
	type RawLinks struct {
		`)
	for _, item := range linkItems {
		fmt.Fprintf(w, "	%ss rd.%ss\n", item, item)
	}

	fmt.Fprintln(w, "}")

	// chargement total de la base locale
	fmt.Fprintln(w, `
	func LoadRemoteBaseLocale(db rd.DB) (base *BaseLocale, err error) {
		base = new(BaseLocale)
		var rl RawLinks
	`)
	for _, item := range mainItems {
		fmt.Fprintf(w, templateLoadBaseLocaleMain, item, item)
	}
	for _, item := range linkItems {
		fmt.Fprintf(w, templateLoadBaseLocaleLink, item, item)
	}
	fmt.Fprintln(w, `
		base.ProcessRawLinks(rl)
		
		return base, nil
	}`)

	// chargment partiel
	fmt.Fprintln(w, `
	func LoadRemoteBaseLocalePartiel(db rd.DB, items map[string][]int64) (base *BaseLocale, err error) {
		base = new(BaseLocale)
	`)
	for _, item := range mainItems {
		fmt.Fprintf(w, templateLoadBaseLocalePartielMain, item, item, item)
	}
	fmt.Fprintln(w, `
		rl, err := loadLinksById(db, items)
		if err != nil {
			return nil, err
		}
		base.ProcessRawLinks(rl)
		
		return base, nil
	}`)

	// function de Hash
	fmt.Fprintln(w, `
	func (base BaseLocale) Hash() (BaseHash, error) {
		baseHash := make(BaseHash)
		var tmp map[int64]uint32
	`)
	for _, item := range mainItems {
		fmt.Fprintf(w, templateHashTable, item+"s", item+"s", item+"s")
	}
	for _, item := range baseLinks {
		fmt.Fprintf(w, templateHashTable, item, item, item)
	}
	fmt.Fprintln(w, `	
		return baseHash, nil
	}`)

	// function de fusion
	fmt.Fprintln(w, `
	func (base *BaseLocale) MergeFrom(incomming BaseLocale, toDelete map[string][]int64)  {
	`)
	for _, item := range mainItems {
		fmt.Fprintf(w, templateUpdateTable, item+"s", item+"s", item+"s", item+"s")
	}
	for _, item := range baseLinks {
		fmt.Fprintf(w, templateUpdateTable, item, item, item, item)
	}
	fmt.Fprintln(w, `	
	}`)

}

func genereTestCode(w io.Writer, mainItems []string) {
	fmt.Fprintln(w, `
	package datamodel

	// DONT EDIT - autogenerated

	func compressMesureSize(data interface{}) (int, error) {
		var b bytes.Buffer
		gzOut := gzip.NewWriter(&b)
		enc := json.NewEncoder(gzOut)
		enc.SetEscapeHTML(false)
		
		if err := enc.Encode(data); err != nil {
			return 0, err	
		}
		if err := gzOut.Close(); err != nil {
			return 0, err	
		}
		return len(b.Bytes()), nil
	}

	func TestSizes(t *testing.T) {
		var (
			size int
			err error
		)
		base := GetBase(true)
	
	`)

	for _, item := range mainItems {
		if err := templateTestMarshal.Execute(w, templateArg{Name: item}); err != nil {
			log.Fatal(err)
		}
	}

	// links
	if err := templateTestMarshal.Execute(w, templateArg{Name: "Link"}); err != nil {
		log.Fatal(err)
	}

	fmt.Fprintln(w, "}")
}