diff --git a/g.go b/g.go index 77ca715..e6a331d 100644 --- a/g.go +++ b/g.go @@ -20,15 +20,15 @@ var cmdGenerate = &Command{ UsageLine: "generate [Command]", Short: "generate code based on application", Long: ` -bee g model [modelfile] [dbconfig] +bee generate model [modelfile] [dbconfig] generate model base on struct -bee g controller [modelfile] +bee generate controller [modelfile] generate RESTFul controllers based on modelfile -bee g router [controllerfile] +bee generate router [controllerfile] generate router based on controllerfile -bee g docs +bee generate docs generate swagger doc file -bee g test [routerfile] +bee generate test [routerfile] generate testcase `, } @@ -53,11 +53,11 @@ func generateCode(cmd *Command, args []string) { case "docs": generateDocs(curpath) case "model": - generateModel(curpath) + generateModel("mysql", "root@tcp(127.0.0.1:3306)/sgfas?charset=utf8", curpath) case "controller": - generateController(curpath) + generateController("mysql", "", curpath) case "router": - generateRouter(curpath) + generateRouter("mysql", "", curpath) default: ColorLog("[ERRO] command is missing\n") } diff --git a/g_mvcgen.go b/g_mvc.go similarity index 89% rename from g_mvcgen.go rename to g_mvc.go index 4b67e5c..2f532f4 100644 --- a/g_mvcgen.go +++ b/g_mvc.go @@ -5,6 +5,7 @@ import ( "fmt" "os" "os/exec" + "path" "regexp" "strings" @@ -12,16 +13,16 @@ import ( ) const ( - O_MODEL = 1 << iota + O_MODEL byte = 1 << iota O_CONTROLLER O_ROUTER ) -const ( - MODEL_PATH = "models" - CONTROLLER_PATH = "controllers" - ROUTER_PATH = "routers" -) +type MvcPath struct { + ModelPath string + ControllerPath string + RouterPath string +} // typeMapping maps a SQL data type to its corresponding Go data type var typeMapping = map[string]string{ @@ -176,21 +177,24 @@ func (tag *OrmTag) String() string { return fmt.Sprintf("`orm:\"%s\"`", strings.Join(ormOptions, ";")) } -func generateModel() { - +func generateModel(driver string, connStr string, currpath string) { + mode := O_MODEL + gen(driver, connStr, mode, currpath) } -func generateController() { - +func generateController(driver string, connStr string, currpath string) { + mode := O_MODEL | O_CONTROLLER + gen(driver, connStr, mode, currpath) } -func generateRouter() { - +func generateRouter(driver string, connStr string, currpath string) { + mode := O_MODEL | O_CONTROLLER | O_ROUTER + gen(driver, connStr, mode, currpath) } // Generate takes table, column and foreign key information from database connection // and generate corresponding golang source files -func Gen(dbms string, connStr string, mode byte) { +func gen(dbms string, connStr string, mode byte, currpath string) { db, err := sql.Open(dbms, connStr) if err != nil { fmt.Printf("error opening database: %v\n", err) @@ -198,8 +202,12 @@ func Gen(dbms string, connStr string, mode byte) { defer db.Close() tableNames := getTableNames(db) tables := getTableObjects(tableNames, db) - deleteAndRecreatePaths(mode) - writeSourceFiles(tables, mode) + mvcPath := new(MvcPath) + mvcPath.ModelPath = path.Join(currpath, "models") + mvcPath.ControllerPath = path.Join(currpath, "controllers") + mvcPath.RouterPath = path.Join(currpath, "routers") + deleteAndRecreatePaths(mode, mvcPath) + writeSourceFiles(tables, mode, mvcPath) } // getTables gets a list table names in current database @@ -369,42 +377,42 @@ func getColumns(db *sql.DB, table *Table, blackList map[string]bool) { } // deleteAndRecreatePaths removes several directories completely -func deleteAndRecreatePaths(mode byte) { +func deleteAndRecreatePaths(mode byte, paths *MvcPath) { if (mode & O_MODEL) == O_MODEL { - os.RemoveAll(MODEL_PATH) - os.Mkdir(MODEL_PATH, 0777) + os.RemoveAll(paths.ModelPath) + os.Mkdir(paths.ModelPath, 0777) } if (mode & O_CONTROLLER) == O_CONTROLLER { - os.RemoveAll(CONTROLLER_PATH) - os.Mkdir(CONTROLLER_PATH, 0777) + os.RemoveAll(paths.ControllerPath) + os.Mkdir(paths.ControllerPath, 0777) } if (mode & O_ROUTER) == O_ROUTER { - os.RemoveAll(ROUTER_PATH) - os.Mkdir(ROUTER_PATH, 0777) + os.RemoveAll(paths.RouterPath) + os.Mkdir(paths.RouterPath, 0777) } } // writeSourceFiles generates source files for model/controller/router // It will wipe the following directories and recreate them:./models, ./controllers, ./routers // Newly geneated files will be inside these folders. -func writeSourceFiles(tables []*Table, mode byte) { +func writeSourceFiles(tables []*Table, mode byte, paths *MvcPath) { if (O_MODEL & mode) == O_MODEL { - writeModelFiles(tables) + writeModelFiles(tables, paths.ModelPath) } if (O_CONTROLLER & mode) == O_CONTROLLER { - writeControllerFiles(tables) + writeControllerFiles(tables, paths.ControllerPath) } if (O_ROUTER & mode) == O_ROUTER { - writeRouterFile(tables) + writeRouterFile(tables, paths.RouterPath) } } // writeModelFiles generates model files -func writeModelFiles(tables []*Table) { +func writeModelFiles(tables []*Table, mPath string) { for _, tb := range tables { filename := getFileName(tb.Name) - path := fmt.Sprintf("%s/%s.go", MODEL_PATH, filename) - f, _ := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0666) + fpath := path.Join(mPath, filename+".go") + f, _ := os.OpenFile(fpath, os.O_CREATE|os.O_RDWR, 0666) defer f.Close() template := "" if tb.Pk == "" { @@ -415,32 +423,32 @@ func writeModelFiles(tables []*Table) { fileStr := strings.Replace(template, "{{modelStruct}}", tb.String(), 1) fileStr = strings.Replace(fileStr, "{{modelName}}", camelCase(tb.Name), -1) if _, err := f.WriteString(fileStr); err != nil { - fmt.Printf("error writing file(%s): %v", path, err) + fmt.Printf("error writing file(%s): %v", fpath, err) } - formatAndFixImports(path) + formatAndFixImports(fpath) } } // writeControllerFiles generates controller files -func writeControllerFiles(tables []*Table) { +func writeControllerFiles(tables []*Table, cPath string) { for _, tb := range tables { if tb.Pk == "" { continue } filename := getFileName(tb.Name) - path := fmt.Sprintf("%s/%s.go", CONTROLLER_PATH, filename) - f, _ := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0666) + fpath := path.Join(cPath, filename+".go") + f, _ := os.OpenFile(fpath, os.O_CREATE|os.O_RDWR, 0666) defer f.Close() fileStr := strings.Replace(CTRL_TPL, "{{ctrlName}}", camelCase(tb.Name), -1) if _, err := f.WriteString(fileStr); err != nil { - fmt.Printf("error writing file(%s): %v", path, err) + fmt.Printf("error writing file(%s): %v", fpath, err) } - formatAndFixImports(path) + formatAndFixImports(fpath) } } // writeRouterFile generates router file -func writeRouterFile(tables []*Table) { +func writeRouterFile(tables []*Table, rPath string) { var nameSpaces []string for _, tb := range tables { if tb.Pk == "" { @@ -452,14 +460,14 @@ func writeRouterFile(tables []*Table) { nameSpaces = append(nameSpaces, nameSpace) } // add export controller - path := ROUTER_PATH + "/router.go" + fpath := path.Join(rPath, "router.go") routerStr := strings.Replace(ROUTER_TPL, "{{nameSpaces}}", strings.Join(nameSpaces, ""), 1) - f, _ := os.OpenFile(path, os.O_CREATE|os.O_TRUNC|os.O_RDWR, 0666) + f, _ := os.OpenFile(fpath, os.O_CREATE|os.O_TRUNC|os.O_RDWR, 0666) defer f.Close() if _, err := f.WriteString(routerStr); err != nil { - fmt.Println("error writing file(%s): %v", path, err) + fmt.Println("error writing file(%s): %v", fpath, err) } - formatAndFixImports(path) + formatAndFixImports(fpath) } // formatAndFixImports formats source files (add imports, too)