Initial commit

Author: lianghuan

gen/gen.go

@@ -0,0 +1,88 @@
+package gen
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/go-spring/gs-gen/gen/generator"
+	"github.com/go-spring/gs-gen/gen/generator/golang"
+	"github.com/go-spring/gs-gen/lib/parser"
+)
+
+func init() {
+	generator.RegisterGenerator("go", &golang.Generator{})
+}
+
+func Gen(language string, config *generator.Config) error {
+	g, ok := generator.GetGenerator(language)
+	if !ok {
+		return fmt.Errorf("unsupported language: %s", language)
+	}
+	files, meta, err := parse(config.ProjectDir)
+	if err != nil {
+		return err
+	}
+	if meta == nil {
+		return fmt.Errorf("no meta file")
+	}
+	if len(files) == 0 {
+		return fmt.Errorf("no idl file")
+	}
+	if err = parser.Verify(files, meta); err != nil {
+		return err
+	}
+	return g.Gen(config, files, meta)
+}
+
+func parse(dir string) (files map[string]parser.Document, meta *parser.MetaInfo, err error) {
+	files = make(map[string]parser.Document)
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return nil, nil, err
+	}
+	for _, e := range entries {
+		if e.IsDir() {
+			continue
+		}
+		fileName := e.Name()
+
+		if fileName == "meta.json" {
+			if meta, err = parseMeta(dir, fileName); err != nil {
+				return nil, nil, err
+			}
+			continue
+		}
+
+		if !strings.HasSuffix(fileName, ".idl") {
+			continue
+		}
+
+		var doc parser.Document
+		doc, err = parseFile(dir, fileName)
+		if err != nil {
+			return nil, nil, err
+		}
+		files[fileName] = doc
+	}
+	return
+}
+
+func parseMeta(dir string, fileName string) (*parser.MetaInfo, error) {
+	fileName = filepath.Join(dir, fileName)
+	b, err := os.ReadFile(fileName)
+	if err != nil {
+		return nil, err
+	}
+	return parser.ParseMeta(string(b))
+}
+
+func parseFile(dir string, fileName string) (parser.Document, error) {
+	fileName = filepath.Join(dir, fileName)
+	b, err := os.ReadFile(fileName)
+	if err != nil {
+		return parser.Document{}, err
+	}
+	return parser.Parse(string(b))
+}

gen/gen_test.go

@@ -0,0 +1,78 @@
+package gen
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+
+	"github.com/go-spring/gs-gen/gen/generator"
+)
+
+func TestGen(t *testing.T) {
+	root := "testdata"
+	entries, err := os.ReadDir(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, e := range entries {
+		if !e.IsDir() {
+			continue
+		}
+		dir := filepath.Join(root, e.Name())
+		testProject(t, dir)
+	}
+}
+
+func testProject(t *testing.T, dir string) {
+	b, err := os.ReadFile(filepath.Join(dir, "test.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var m map[string]struct {
+		Server bool
+	}
+	if err = json.Unmarshal(b, &m); err != nil {
+		t.Fatal(err)
+	}
+
+	idlDir := filepath.Join(dir, "idl")
+	for lang, c := range m {
+		projectDir := filepath.Join(dir, lang)
+
+		if c.Server {
+			dstDir := filepath.Join(projectDir, "server")
+			copyFiles(t, idlDir, dstDir)
+			config := &generator.Config{
+				ProjectDir: dstDir,
+				Version:    "v0.0.0",
+				Server:     true,
+			}
+			if err = Gen(lang, config); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+}
+
+func copyFiles(t *testing.T, srcDir, dstDir string) {
+	srcDir, err := filepath.Abs(srcDir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dstDir, err = filepath.Abs(dstDir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	srcDir = filepath.Join(srcDir, "*")
+
+	script := fmt.Sprintf("cp %s %s", srcDir, dstDir)
+	cmd := exec.Command("/bin/bash", "-c", script)
+	b, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("%s: %s", err, b)
+	}
+}

gen/generator/generator.go

@@ -0,0 +1,71 @@
+package generator
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/go-spring/gs-gen/lib/parser"
+)
+
+type Config struct {
+	ProjectDir string
+	Version    string
+	Server     bool
+}
+
+var generators = map[string]Generator{}
+
+type Generator interface {
+	Gen(config *Config, files map[string]parser.Document, meta *parser.MetaInfo) error
+}
+
+func GetGenerator(language string) (Generator, bool) {
+	g, ok := generators[language]
+	return g, ok
+}
+
+func RegisterGenerator(language string, g Generator) {
+	if _, ok := generators[language]; ok {
+		panic(fmt.Errorf("duplicate generator for %s", language))
+	}
+	generators[language] = g
+}
+
+func GetType(files map[string]parser.Document, name string) *parser.Type {
+	for _, doc := range files {
+		for _, t := range doc.Types {
+			if t.Name == name {
+				return t
+			}
+		}
+	}
+	return nil
+}
+
+func GetAnnotation(arr []parser.Annotation, name string) (parser.Annotation, bool) {
+	for _, a := range arr {
+		if a.Key == name {
+			return a, true
+		}
+	}
+	return parser.Annotation{}, false
+}
+
+func ToPascal(s string) string {
+	var sb strings.Builder
+	parts := strings.Split(s, "_")
+	for _, part := range parts {
+		if part == "" {
+			continue
+		}
+		c := part[0]
+		if 'a' <= c && c <= 'z' {
+			c = c - 'a' + 'A'
+		}
+		sb.WriteByte(c)
+		if len(part) > 1 {
+			sb.WriteString(part[1:])
+		}
+	}
+	return sb.String()
+}

gen/generator/golang/client.go

@@ -0,0 +1,9 @@
+package golang
+
+import (
+	"github.com/go-spring/gs-gen/lib/parser"
+)
+
+func (g *Generator) genClient(ctx Context, rpcs []*parser.RPC) error {
+	return nil
+}

gen/generator/golang/main.go

@@ -0,0 +1,53 @@
+package golang
+
+import (
+	"sort"
+
+	"github.com/go-spring/gs-gen/gen/generator"
+	"github.com/go-spring/gs-gen/lib/parser"
+)
+
+type Context struct {
+	config *generator.Config
+	meta   *parser.MetaInfo
+	files  map[string]parser.Document
+}
+
+type Generator struct{}
+
+func (g *Generator) Gen(config *generator.Config, files map[string]parser.Document, meta *parser.MetaInfo) error {
+	ctx := Context{
+		config: config,
+		meta:   meta,
+		files:  files,
+	}
+
+	if err := g.genMeta(meta); err != nil {
+		return err
+	}
+
+	var rpcs []*parser.RPC
+	for fileName, doc := range files {
+		if err := g.genType(ctx, fileName, doc); err != nil {
+			return err
+		}
+		for _, c := range doc.RPCs {
+			rpcs = append(rpcs, c)
+		}
+	}
+
+	sort.Slice(rpcs, func(i, j int) bool {
+		return rpcs[i].Name < rpcs[j].Name
+	})
+
+	if config.Server {
+		if err := g.genServer(ctx, rpcs); err != nil {
+			return err
+		}
+	} else {
+		if err := g.genClient(ctx, rpcs); err != nil {
+			return err
+		}
+	}
+	return nil
+}

gen/generator/golang/meta.go

@@ -0,0 +1,9 @@
+package golang
+
+import (
+	"github.com/go-spring/gs-gen/lib/parser"
+)
+
+func (g *Generator) genMeta(meta *parser.MetaInfo) error {
+	return nil
+}