protobjc/main.go at main · protobj/protobjc · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
package main

import (
	"errors"
	"fmt"
	"io.protobj/protobjc"
	"io.protobj/protobjc/java"
	"io.protobj/protobjc/ts"
	"os"
	"path/filepath"
	"strings"
)

type ArgsType int32

const (
	Help         ArgsType = 0
	SourceDir    ArgsType = 1
	LanguageType ArgsType = 2
	OutputDir    ArgsType = 3
	OutputType   ArgsType = 4
)

type ArgsInfo struct {
	argsType    ArgsType
	names       []string
	description string
	required    bool
}

var argsList = []ArgsInfo{
	{argsType: Help, names: []string{"-help", "-h"}, description: "帮助", required: false},
	{argsType: SourceDir, names: []string{"-source_dir", "-s"}, description: "协议文件目录", required: true},
	{argsType: LanguageType, names: []string{"-language", "-lang"}, description: "生成的语言：Java,Go,Ts", required: true},
	{argsType: OutputDir, names: []string{"-output_dir", "-o"}, description: "输出目录", required: true},
	{argsType: OutputType, names: []string{"-output_type", "-o_type"}, description: "输出选项:all,schema,message 默认:all", required: false},
}

func main() {
	args := os.Args[1:]
	if len(args) == 0 {
		printUsage()
		return
	}
	parsedArgs, done := parseArgs(args)
	if done {
		return
	}

	files := getFiles(parsedArgs.SourceDir)
	messageMap := protobjc.Load(files)
	println("start generate")
	switch parsedArgs.LanguageType {
	case protobjc.JAVA:
		java.NewGenerator(messageMap, parsedArgs).Generate()
	case protobjc.TS:
		ts.NewGenerator(messageMap, parsedArgs).Generate()
	}
	println("generated...")
}

func getFiles(dir string) (files []string) {
	readDir, err := os.ReadDir(dir)
	if err != nil {
		panic(err)
	}
	for _, entry := range readDir {
		fileName := filepath.Join(dir, entry.Name())
		if entry.IsDir() {
			return getFiles(fileName)
		} else if strings.HasSuffix(entry.Name(), ".protobj") {
			files = append(files, fileName)
		}
	}
	return files
}

func parseArgs(args []string) (protobjc.ParsedArgs, bool) {
	var sourceDir *string
	var languageType *protobjc.LanguageType
	var outputDir *string
	var outputType protobjc.OutputType
	for i := 0; i < len(args); i++ {
		name := args[i]
		argsInfo, err := findArgsInfo(name)
		if err != nil {
			continue
		}
		argsType := argsInfo.argsType
		switch argsType {
		case Help:
			printUsage()
			return protobjc.ParsedArgs{}, true
		case SourceDir:
			sourceDir = &args[i+1]
			i++
		case LanguageType:
			langType, err := protobjc.ToLanguageType(args[i+1])
			if err != nil {
				println(err.Error())
				return protobjc.ParsedArgs{}, true
			}
			languageType = &langType
			i++
		case OutputDir:
			outputDir = &args[i+1]
			i++
		case OutputType:
			outputType = protobjc.ToOutputType(args[i+1])
			i++
		}
	}
	if sourceDir == nil {
		println("source_dir is required")
		return protobjc.ParsedArgs{}, true
	}
	if languageType == nil {
		println("language is required")
		return protobjc.ParsedArgs{}, true
	}
	if outputDir == nil {
		println("output_dir is required")
		return protobjc.ParsedArgs{}, true
	}

	return protobjc.ParsedArgs{
		SourceDir:    *sourceDir,
		OutputDir:    *outputDir,
		LanguageType: *languageType,
		OutputType:   outputType,
	}, false
}

func printUsage() {
	for _, info := range argsList {
		fmt.Println(protobjc.I("names:${0} desc:${1} required:${2}", info.names, info.description, info.required))
	}
}

func findArgsInfo(name string) (ArgsInfo, error) {
	for _, info := range argsList {
		for i := range info.names {
			if info.names[i] == name {
				return info, nil
			}
		}
	}
	return ArgsInfo{}, errors.New("unknown args:" + name)
}