Merge pull request #18 from devimteam/feature/generator-refactor

Feature/generator refactor

Author: cv21

.gitignore

@@ -24,3 +24,5 @@ _testmain.go
 *.exe
 *.test
 *.prof
+
+vendor/

Gopkg.lock

@@ -20,11 +20,10 @@
 #  name = "github.com/x/y"
 #  version = "2.4.0"
 
-
 [[constraint]]
-  name = "github.com/davecgh/go-spew"
-  version = "1.1.0"
+  name = "github.com/devimteam/jennifer"
+  version = "0.15.0"
 
 [[constraint]]
-  name = "github.com/dave/jennifer"
-  version = "^0.14.0"
+  name = "github.com/vetcher/godecl"
+  version = "^0.2.0"

Gopkg.toml

@@ -1,6 +1,7 @@
 # Microgen
 
-Tool to generate microservices, based on [go-kit](https://gokit.io/), by specified service interface.
+Tool to generate microservices, based on [go-kit](https://gokit.io/), by specified service interface.  
+The goal is to generate code for service which not fun to write but it should be written.
 
 ## Install
 ```
@@ -11,42 +12,108 @@ go get -u github.com/devimteam/microgen/cmd/microgen
 ``` sh
 microgen [OPTIONS]
 ```
-microgen is stable, so you can generate without flag `-init` any time your interface changed (e.g. added new method)
+microgen tool search in file first `type * interface` with docs, that contains `// @microgen`.
+
+generation parameters provides through ["tags"](#tags) in interface docs after general `// @microgen` tag (space before @ __required__).
+
 ### Options
 
-| Name        | Default          | Description                                                                   |
-|:------------|:-----------------|:------------------------------------------------------------------------------|
-| -file       | service.go       | Relative path to source file with service interface                           |
-| -interface* |                  | Service interface name in source file                                         |
-| -out        | writes to stdout | Relative or absolute path to directory, where you want to see generated files |
-| -package*   |                  | Package path of your service interface source file                            |
-| -debug      | false            | Display some debug information                                                |
-| -grpc       | false            | Render client, server and converters for gRPC protocol                        |
-| -init       | false            | With flag `-grpc` generate stub methods for converters                        |
+| Name   | Default    | Description                                                                   |
+|:------ |:-----------|:------------------------------------------------------------------------------|
+| -file  | service.go | Relative path to source file with service interface                           |
+| -out   | .          | Relative or absolute path to directory, where you want to see generated files |
+| -force | false      | With flag generate stub methods.                                              |
+| -help  | false      | Print usage information                                                       |
 
 \* __Required option__
 
+### Markers
+Markers is a general tags, that participate in generation process.
+Typical syntax is: `// @<tag-name>:`
+
+#### @microgen
+Main tag for microgen tool. Microgen scan file for the first interface which docs contains this tag.  
+To add templates for generation, add their tags, separated by comma after `@microgen:`
+Example:
+```go
+// @microgen middleware, logging
+type StringService interface {
+    ServiceMethod()
+}
+```
+#### @protobuf
+Protobuf tag is used for package declaration of compiled with `protoc` grpc package.  
+Example:
+```go
+// @microgen grpc-server
+// @protobuf github.com/user/repo/path/to/protobuf
+type StringService interface {
+    ServiceMethod()
+}
+```
+`@protobuf` tag is optional, but required for `grpc`, `grpc-server`, `grpc-client` generation.  
+#### @grpc-addr
+gRPC address tag is used for gRPC go-kit-based client generation.
+Example:
+```go
+// @microgen grpc
+// @protobuf github.com/user/repo/path/to/protobuf
+// @grpc-addr some.service.address
+type StringService interface {
+    ServiceMethod()
+}
+```
+`@grpc-addr` tag is optional, but required for `grpc-client` generation.  
+
+### Method's tags
+#### @logs-ignore
+This tag is used for logging middleware, when some arguments or results should not be logged, e.g. passwords or files.  
+If `context.Context` is first, it ignored by default.  
+Provide parameters names, separated by comma, to exclude them from logs.  
+Example:
+```go
+// @microgen logging
+type FileService interface {
+    // @logs-ignore data
+    UploadFile(ctx context.Context, name string, data []byte) (link string, err error)
+}
+```
+
+### Tags
+All allowed tags for customize generation provided here.
+
+| Tag         | Description                                                                            |
+|:------------|:---------------------------------------------------------------------------------------|
+| middleware  | General application middleware interface                                               |
+| logging     | Middleware that writes to logger all request/response information with handled time    |
+| grpc-client | Generates client for grpc transport with request/response encoders/decoders            |
+| grpc-server | Generates server for grpc transport with request/response encoders/decoders            |
+| grpc        | Generates client and server for grpc transport with request/response encoders/decoders |
+
 ## Example
 Follow this short guide to try microgen tool.
 
 1. Create file `service.go` inside GOPATH and add code below.
-``` golang
+```go
 package stringsvc
 
 import (
-	"context"
+    "context"
 
-	drive "google.golang.org/api/drive/v3"
+    drive "google.golang.org/api/drive/v3"
 )
 
+// @microgen grpc, middleware, logging
+// @protobuf github.com/devimteam/proto-utils
+// @grpc-addr test.address
 type StringService interface {
-	Uppercase(ctx context.Context, str string) (ans string, err error)
-	Count(ctx context.Context, text string, symbol string) (count int, positions []int)
-	TestCase(ctx context.Context, comments []*drive.Comment) (err error)
+    Uppercase(ctx context.Context, str string) (ans string, err error)
+    Count(ctx context.Context, text string, symbol string) (count int, positions []int)
+    TestCase(ctx context.Context, comments []*drive.Comment) (err error)
 }
 ```
 2. Open command line next to your `service.go`.
-3. Enter `microgen -file ./service.go -interface StringService -out . -grpc -init`. __*__
+3. Enter `microgen`. __*__
 4. You should see something like that:
 ```
 exchanges.go
@@ -65,23 +132,14 @@ All files successfully generated
 
 __*__ `GOPATH/bin` should be in your PATH.
 
-### Interface declaration rules
+## Interface declaration rules
 For correct generation, please, follow rules below.
 
 * All interface method's arguments and results should be named and should be different (name duplicating unacceptable).
 * First argument of each method should be of type `context.Context` (from [standard library](https://golang.org/pkg/context/)).
-* Method results should contain at least one variable of `error` type.
-* [Some names](#not-allowed-names) are not allowed to be an argument or result.
+* Last result should should be `error` type.
+---
+* Name of _protobuf_ service should be the same, as interface name.
+* Function names in _protobuf_ should be the same, as in interface.
+* Message names in _protobuf_ should be named `<FunctionName>Request` or `<FunctionName>Response` for request/response message respectively.
 * Field names in _protobuf_ messages should be the same, as in interface methods (_protobuf_ - snake_case, interface - camelCase).
-
-#### Not allowed names:
-```
-req
-request
-resp
-response
-```
-
-### Misc
-
-Microgen uses __0.9.*__ version of [devimteam/go-kit](https://github.com/devimteam/go-kit)

README.md

@@ -3,116 +3,77 @@ package main
 import (
 	"flag"
 	"fmt"
-	"go/ast"
-	astparser "go/parser"
-	"go/token"
 	"os"
-	"path/filepath"
 	"strings"
 
-	"github.com/davecgh/go-spew/spew"
 	"github.com/devimteam/microgen/generator"
-	"github.com/devimteam/microgen/generator/template"
-	"github.com/devimteam/microgen/parser"
+	"github.com/devimteam/microgen/util"
+	"github.com/vetcher/godecl/types"
 )
 
 var (
 	flagFileName  = flag.String("file", "service.go", "Name of file where described interface definition")
-	flagIfaceName = flag.String("interface", "", "Interface name")
-	flagOutputDir = flag.String("out", "", "Output directory")
-	flagGRPC      = flag.Bool("grpc", false, "Render gRPC transport")
-	flagDebug     = flag.Bool("debug", false, "Debug mode")
+	flagOutputDir = flag.String("out", ".", "Output directory")
 	flagHelp      = flag.Bool("help", false, "Show help")
-	flagInit      = flag.Bool("init", false, "With flag `-grpc` generate stub methods for converters")
+	flagForce     = flag.Bool("force", false, "Overwrite all files, as it generates for the first time")
 )
 
 func init() {
 	flag.Parse()
 }
 
 func main() {
-	if *flagHelp || *flagFileName == "" || *flagIfaceName == "" {
+	if *flagHelp || *flagFileName == "" {
 		flag.Usage()
 		os.Exit(0)
 	}
 
-	currentDir, err := os.Getwd()
+	info, err := util.ParseFile(*flagFileName)
 	if err != nil {
-		fmt.Println(err)
+		fmt.Println("fatal:", err)
 		os.Exit(1)
 	}
 
-	path := filepath.Join(currentDir, *flagFileName)
-	fset := token.NewFileSet()
-	f, err := astparser.ParseFile(fset, path, nil, astparser.ParseComments)
-	if err != nil {
-		fmt.Printf("error when parse file: %v\n", err)
-		os.Exit(1)
-	}
-	i, err := parser.ParseInterface(f, *flagIfaceName)
-	if err != nil {
-		fmt.Printf("error when parse interface from file : %v\n", err)
+	i := findInterface(info)
+	if i == nil {
+		fmt.Println("fatal: could not find interface with @microgen tag")
 		os.Exit(1)
 	}
 
-	if *flagDebug {
-		ast.Print(fset, f)
-		spew.Dump(i)
-	}
-
-	var strategy generator.Strategy
-	if *flagOutputDir == "" {
-		strategy = generator.NewWriterStrategy(os.Stdout)
-	} else {
-		strategy = generator.NewFileStrategy(*flagOutputDir)
+	if err := generator.ValidateInterface(i); err != nil {
+		fmt.Println("validation:", err)
+		os.Exit(1)
 	}
 
-	packagePath := resolvePackagePath(*flagOutputDir)
-	templates := []generator.Template{
-		&template.ExchangeTemplate{},
-		&template.EndpointsTemplate{},
-		&template.ClientTemplate{},
-		&template.MiddlewareTemplate{PackagePath: packagePath},
-		&template.LoggingTemplate{PackagePath: packagePath},
+	units, err := generator.ListTemplatesForGen(i, *flagForce, info.Name, *flagOutputDir, *flagFileName)
+	if err != nil {
+		fmt.Println("fatal:", err)
+		os.Exit(1)
 	}
-	if *flagGRPC {
-		templates = append(templates,
-			&template.GRPCServerTemplate{},
-			&template.GRPCClientTemplate{PackagePath: packagePath},
-			&template.GRPCEndpointConverterTemplate{PackagePath: packagePath},
-		)
-		if *flagInit {
-			templates = append(templates,
-				&template.StubGRPCTypeConverterTemplate{PackagePath: packagePath},
-			)
+	for _, unit := range units {
+		err := unit.Generate()
+		if err != nil {
+			fmt.Println("fatal:", err)
+			os.Exit(1)
 		}
 	}
-
-	gen := generator.NewGenerator(templates, i, strategy)
-	err = gen.Generate()
-	if err != nil {
-		fmt.Println(err.Error())
-	}
+	fmt.Println("All files successfully generated")
 }
 
-func resolvePackagePath(outPath string) string {
-	gopath := os.Getenv("GOPATH")
-	if gopath == "" {
-		fmt.Println("GOPATH is empty")
-		os.Exit(1)
-	}
-
-	absOutPath, err := filepath.Abs(outPath)
-	if err != nil {
-		fmt.Println(err.Error())
-		os.Exit(1)
+func findInterface(file *types.File) *types.Interface {
+	for i := range file.Interfaces {
+		if docsContainMicrogenTag(file.Interfaces[i].Docs) {
+			return &file.Interfaces[i]
+		}
 	}
+	return nil
+}
 
-	gopathSrc := filepath.Join(gopath, "src")
-	if !strings.HasPrefix(absOutPath, gopathSrc) {
-		fmt.Println("-out not in GOPATH")
-		os.Exit(1)
+func docsContainMicrogenTag(strs []string) bool {
+	for _, str := range strs {
+		if strings.HasPrefix(str, generator.TagMark+generator.MicrogenGeneralTag) {
+			return true
+		}
 	}
-
-	return absOutPath[len(gopathSrc)+1:]
+	return false
 }

cmd/microgen/main.go

@@ -0,0 +1,10 @@
+package entity
+
+import "time"
+
+// Example structure
+type Comment struct {
+	Text     string
+	Relates  *Comment
+	PostedAt time.Time
+}