feat(gen): refactoring gs-http-gen

Author: lvan100

gen/gen.go

@@ -1,3 +1,19 @@
+/*
+ * Copyright 2025 The Go-Spring Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package gen
 
 import (
@@ -8,19 +24,20 @@ import (
 
 	"github.com/go-spring/gs-http-gen/gen/generator"
 	"github.com/go-spring/gs-http-gen/gen/generator/golang"
-	"github.com/go-spring/gs-http-gen/lib/parser"
+	"github.com/go-spring/gs-http-gen/lib/tidl"
 )
 
 func init() {
 	generator.RegisterGenerator("go", &golang.Generator{})
 }
 
+// Gen is the entry point for generating code for the given language.
 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.IDLDir)
+	files, meta, err := parse(config.IDLSrcDir)
 	if err != nil {
 		return err
 	}
@@ -30,14 +47,12 @@ func Gen(language string, config *generator.Config) error {
 	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)
+// parse scans the given directory for IDL files and the meta.json file.
+func parse(dir string) (files map[string]tidl.Document, meta *tidl.MetaInfo, err error) {
+	files = make(map[string]tidl.Document)
 	entries, err := os.ReadDir(dir)
 	if err != nil {
 		return nil, nil, err
@@ -48,18 +63,20 @@ func parse(dir string) (files map[string]parser.Document, meta *parser.MetaInfo,
 		}
 		fileName := e.Name()
 
+		// Parse meta.json file if found
 		if fileName == "meta.json" {
 			if meta, err = parseMeta(dir, fileName); err != nil {
 				return nil, nil, err
 			}
 			continue
 		}
 
+		// Skip non-IDL files
 		if !strings.HasSuffix(fileName, ".idl") {
 			continue
 		}
 
-		var doc parser.Document
+		var doc tidl.Document
 		doc, err = parseFile(dir, fileName)
 		if err != nil {
 			return nil, nil, err
@@ -69,20 +86,22 @@ func parse(dir string) (files map[string]parser.Document, meta *parser.MetaInfo,
 	return
 }
 
-func parseMeta(dir string, fileName string) (*parser.MetaInfo, error) {
+// parseMeta reads and parses the meta.json file to extract service metadata.
+func parseMeta(dir string, fileName string) (*tidl.MetaInfo, error) {
 	fileName = filepath.Join(dir, fileName)
 	b, err := os.ReadFile(fileName)
 	if err != nil {
 		return nil, err
 	}
-	return parser.ParseMeta(string(b))
+	return tidl.ParseMeta(string(b))
 }
 
-func parseFile(dir string, fileName string) (parser.Document, error) {
+// parseFile reads and parses a single IDL file into a document.
+func parseFile(dir string, fileName string) (tidl.Document, error) {
 	fileName = filepath.Join(dir, fileName)
 	b, err := os.ReadFile(fileName)
 	if err != nil {
-		return parser.Document{}, err
+		return tidl.Document{}, err
 	}
-	return parser.Parse(string(b))
+	return tidl.Parse(string(b))
 }

gen/gen_test.go

@@ -1,3 +1,19 @@
+/*
+ * Copyright 2025 The Go-Spring Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package gen
 
 import (
@@ -41,15 +57,15 @@ func testProject(t *testing.T, dir string) {
 	idlDir := filepath.Join(dir, "idl")
 	for lang, c := range m {
 		outDir := filepath.Join(dir, lang, "proto")
-		os.RemoveAll(outDir)
-		os.Mkdir(outDir, os.ModePerm)
+		_ = os.RemoveAll(outDir)
+		_ = os.Mkdir(outDir, os.ModePerm)
 		config := &generator.Config{
-			IDLDir:  idlDir,
-			OutDir:  outDir,
-			Version: "v0.0.0",
-			Server:  c.Server,
-			Client:  c.Client,
-			PkgName: "proto",
+			IDLSrcDir:    idlDir,
+			OutputDir:    outDir,
+			EnableServer: c.Server,
+			EnableClient: c.Client,
+			PackageName:  "proto",
+			ToolVersion:  "v0.0.1",
 		}
 		if err = Gen(lang, config); err != nil {
 			t.Fatal(err)

gen/generator/generator.go

@@ -1,74 +1,91 @@
+/*
+ * Copyright 2025 The Go-Spring Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package generator
 
 import (
 	"fmt"
-	"strings"
 
-	"github.com/go-spring/gs-http-gen/lib/parser"
+	"github.com/go-spring/gs-http-gen/lib/tidl"
 )
 
+// Config holds the configuration options for the code generator.
 type Config struct {
-	IDLDir  string
-	OutDir  string
-	Version string
-	Server  bool
-	Client  bool
-	PkgName string
+	IDLSrcDir    string // Directory containing source IDL files
+	OutputDir    string // Directory where generated code will be written
+	EnableServer bool   // Whether to generate server code
+	EnableClient bool   // Whether to generate client code
+	PackageName  string // Go package name for generated code
+	ToolVersion  string // Version of the code generation tool
 }
 
 var generators = map[string]Generator{}
 
+// Generator defines the interface that any language-specific generator
+// must implement. The Gen method generates code based on the given
+// configuration, documents, and metadata.
 type Generator interface {
-	Gen(config *Config, files map[string]parser.Document, meta *parser.MetaInfo) error
+	Gen(config *Config, files map[string]tidl.Document, meta *tidl.MetaInfo) error
 }
 
+// GetGenerator retrieves a registered generator for a given language.
 func GetGenerator(language string) (Generator, bool) {
 	g, ok := generators[language]
 	return g, ok
 }
 
+// RegisterGenerator registers a new generator for the given language.
 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 {
+// GetEnum searches all documents for an enum type with the given name.
+func GetEnum(files map[string]tidl.Document, name string) (tidl.Enum, bool) {
 	for _, doc := range files {
-		for _, t := range doc.Types {
-			if t.Name == name {
-				return t
+		for _, e := range doc.Enums {
+			if CapitalizeASCII(e.Name) == name {
+				return e, true
 			}
 		}
 	}
-	return nil
+	return tidl.Enum{}, false
 }
 
-func GetAnnotation(arr []parser.Annotation, name string) (parser.Annotation, bool) {
-	for _, a := range arr {
-		if a.Key == name {
-			return a, true
+// GetType searches all documents for a type with the given name.
+func GetType(files map[string]tidl.Document, name string) (tidl.Type, bool) {
+	for _, doc := range files {
+		for _, t := range doc.Types {
+			if CapitalizeASCII(t.Name) == name {
+				return t, true
+			}
 		}
 	}
-	return parser.Annotation{}, false
+	return tidl.Type{}, 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:])
-		}
+// CapitalizeASCII capitalizes the first ASCII letter of a string.
+func CapitalizeASCII(s string) string {
+	if len(s) == 0 {
+		return s
+	}
+	if s[0] >= 'a' && s[0] <= 'z' {
+		return string(s[0]-'a'+'A') + s[1:]
 	}
-	return sb.String()
+	return s
 }

gen/generator/golang/client.go

@@ -1,9 +1,26 @@
+/*
+ * Copyright 2025 The Go-Spring Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package golang
 
 import (
-	"github.com/go-spring/gs-http-gen/lib/parser"
+	"github.com/go-spring/gs-http-gen/lib/tidl"
 )
 
-func (g *Generator) genClient(ctx Context, rpcs []*parser.RPC) error {
+// genClient generates the HTTP client code for a given service.
+func (g *Generator) genClient(ctx Context, rpcs []tidl.RPC) error {
 	return nil
 }