Merge commit '5309c72ef751bd4edb45d1702996eb279033b281' into develop

apiapp.go

@@ -69,7 +69,6 @@ EnableDocs = true
 var apiMaingo = `package main
 
 import (
-	_ "{{.Appname}}/docs"
 	_ "{{.Appname}}/routers"
 
 	"github.com/astaxie/beego"
@@ -87,7 +86,6 @@ func main() {
 var apiMainconngo = `package main
 
 import (
-	_ "{{.Appname}}/docs"
 	_ "{{.Appname}}/routers"
 
 	"github.com/astaxie/beego"
@@ -578,8 +576,6 @@ func createapi(cmd *Command, args []string) int {
 	fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", path.Join(apppath, "conf"), "\x1b[0m")
 	os.Mkdir(path.Join(apppath, "controllers"), 0755)
 	fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", path.Join(apppath, "controllers"), "\x1b[0m")
-	os.Mkdir(path.Join(apppath, "docs"), 0755)
-	fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", path.Join(apppath, "docs"), "\x1b[0m")
 	os.Mkdir(path.Join(apppath, "tests"), 0755)
 	fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", path.Join(apppath, "tests"), "\x1b[0m")
 	fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", path.Join(apppath, "conf", "app.conf"), "\x1b[0m")
@@ -606,7 +602,7 @@ func createapi(cmd *Command, args []string) int {
 		ColorLog("[INFO] Using '%s' as 'driver'\n", driver)
 		ColorLog("[INFO] Using '%s' as 'conn'\n", conn)
 		ColorLog("[INFO] Using '%s' as 'tables'\n", tables)
-		generateAppcode(string(driver), string(conn), "3", string(tables), path.Join(apppath, args[0]))
+		generateAppcode(string(driver), string(conn), "3", string(tables), apppath)
 	} else {
 		os.Mkdir(path.Join(apppath, "models"), 0755)
 		fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", path.Join(apppath, "models"), "\x1b[0m")
@@ -635,9 +631,6 @@ func createapi(cmd *Command, args []string) int {
 		fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", path.Join(apppath, "models", "user.go"), "\x1b[0m")
 		WriteToFile(path.Join(apppath, "models", "user.go"), apiModels2)
 
-		fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", path.Join(apppath, "docs", "doc.go"), "\x1b[0m")
-		WriteToFile(path.Join(apppath, "docs", "doc.go"), "package docs")
-
 		fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", path.Join(apppath, "main.go"), "\x1b[0m")
 		WriteToFile(path.Join(apppath, "main.go"),
 			strings.Replace(apiMaingo, "{{.Appname}}", packpath, -1))
@@ -652,9 +645,19 @@ func checkEnv(appname string) (apppath, packpath string, err error) {
 		ColorLog("[ERRO] Fail to start[ %s ]\n", "GOPATH environment variable is not set or empty")
 		os.Exit(2)
 	}
+	currpath, _ := os.Getwd()
+	currpath = path.Join(currpath, appname)
+	for _, gpath := range gps {
+		gsrcpath := path.Join(gpath, "src")
+		if strings.HasPrefix(currpath, gsrcpath) {
+			return currpath, currpath[len(gsrcpath)+1:], nil
+		}
+	}
+
 	// In case of multiple paths in the GOPATH, by default
 	// we use the first path
 	gopath := gps[0]
+	ColorLog("[%s]You current workdir is not a $GOPATH/src, bee will create the application in GOPATH: %s\n", WARN, gopath)
 	Debugf("GOPATH: %s", gopath)
 
 	gosrcpath := path.Join(gopath, "src")

g.go

@@ -170,11 +170,9 @@ func generateCode(cmd *Command, args []string) int {
 		upsql := ""
 		downsql := ""
 		if fields != "" {
-			upsql = `m.SQL("CREATE TABLE ` + mname + "(" + generateSQLFromFields(fields.String()) + `)");`
+			dbMigrator := newDBDriver()
-			downsql = `m.SQL("DROP TABLE ` + "`" + mname + "`" + `")`
+			upsql = dbMigrator.generateCreateUp(mname)
-			if driver == "postgres" {
+			downsql = dbMigrator.generateCreateDown(mname)
-				downsql = strings.Replace(downsql, "`", "", -1)
-			}
 		}
 		generateMigration(mname, upsql, downsql, currpath)
 	case "controller":

g_docs.go

@@ -405,6 +405,23 @@ func parserComments(comments *ast.CommentGroup, funcName, controllerName, pkgpat
 					}
 					modelsList[pkgpath+controllerName][st[2]] = mod
 					appendModels(cmpath, pkgpath, controllerName, realTypes)
+				} else if st[1] == "{array}" {
+					rs.Schema.Type = "array"
+					if sType, ok := basicTypes[st[2]]; ok {
+						typeFormat := strings.Split(sType, ":")
+						rs.Schema.Type = typeFormat[0]
+						rs.Schema.Format = typeFormat[1]
+					} else {
+						cmpath, m, mod, realTypes := getModel(st[2])
+						rs.Schema.Items = &swagger.Propertie{
+							Ref: "#/definitions/" + m,
+						}
+						if _, ok := modelsList[pkgpath+controllerName]; !ok {
+							modelsList[pkgpath+controllerName] = make(map[string]swagger.Schema, 0)
+						}
+						modelsList[pkgpath+controllerName][st[2]] = mod
+						appendModels(cmpath, pkgpath, controllerName, realTypes)
+					}
 				}
 				opts.Responses[st[0]] = rs
 			} else if strings.HasPrefix(t, "@Param") {

g_migration.go

@@ -25,15 +25,168 @@ import (
 const (
 	MPath       = "migrations"
 	MDateFormat = "20060102_150405"
+	DBPath      = "database"
 )
 
+type DBDriver interface {
+	generateCreateUp(tableName string) string
+	generateCreateDown(tableName string) string
+}
+
+type mysqlDriver struct{}
+
+func (m mysqlDriver) generateCreateUp(tableName string) string {
+	upsql := `m.SQL("CREATE TABLE ` + tableName + "(" + m.generateSQLFromFields(fields.String()) + `)");`
+	return upsql
+}
+
+func (m mysqlDriver) generateCreateDown(tableName string) string {
+	downsql := `m.SQL("DROP TABLE ` + "`" + tableName + "`" + `")`
+	return downsql
+}
+
+func (m mysqlDriver) generateSQLFromFields(fields string) string {
+	sql, tags := "", ""
+	fds := strings.Split(fields, ",")
+	for i, v := range fds {
+		kv := strings.SplitN(v, ":", 2)
+		if len(kv) != 2 {
+			ColorLog("[ERRO] Fields format is wrong. Should be: key:type,key:type " + v + "\n")
+			return ""
+		}
+		typ, tag := m.getSQLType(kv[1])
+		if typ == "" {
+			ColorLog("[ERRO] Fields format is wrong. Should be: key:type,key:type " + v + "\n")
+			return ""
+		}
+		if i == 0 && strings.ToLower(kv[0]) != "id" {
+			sql += "`id` int(11) NOT NULL AUTO_INCREMENT,"
+			tags = tags + "PRIMARY KEY (`id`),"
+		}
+		sql += "`" + snakeString(kv[0]) + "` " + typ + ","
+		if tag != "" {
+			tags = tags + fmt.Sprintf(tag, "`"+snakeString(kv[0])+"`") + ","
+		}
+	}
+	sql = strings.TrimRight(sql+tags, ",")
+	return sql
+}
+
+func (m mysqlDriver) getSQLType(ktype string) (tp, tag string) {
+	kv := strings.SplitN(ktype, ":", 2)
+	switch kv[0] {
+	case "string":
+		if len(kv) == 2 {
+			return "varchar(" + kv[1] + ") NOT NULL", ""
+		}
+		return "varchar(128) NOT NULL", ""
+	case "text":
+		return "longtext  NOT NULL", ""
+	case "auto":
+		return "int(11) NOT NULL AUTO_INCREMENT", ""
+	case "pk":
+		return "int(11) NOT NULL", "PRIMARY KEY (%s)"
+	case "datetime":
+		return "datetime NOT NULL", ""
+	case "int", "int8", "int16", "int32", "int64":
+		fallthrough
+	case "uint", "uint8", "uint16", "uint32", "uint64":
+		return "int(11) DEFAULT NULL", ""
+	case "bool":
+		return "tinyint(1) NOT NULL", ""
+	case "float32", "float64":
+		return "float NOT NULL", ""
+	case "float":
+		return "float NOT NULL", ""
+	}
+	return "", ""
+}
+
+type postgresqlDriver struct{}
+
+func (m postgresqlDriver) generateCreateUp(tableName string) string {
+	upsql := `m.SQL("CREATE TABLE ` + tableName + "(" + m.generateSQLFromFields(fields.String()) + `)");`
+	return upsql
+}
+
+func (m postgresqlDriver) generateCreateDown(tableName string) string {
+	downsql := `m.SQL("DROP TABLE ` + tableName + `")`
+	return downsql
+}
+
+func (m postgresqlDriver) generateSQLFromFields(fields string) string {
+	sql, tags := "", ""
+	fds := strings.Split(fields, ",")
+	for i, v := range fds {
+		kv := strings.SplitN(v, ":", 2)
+		if len(kv) != 2 {
+			ColorLog("[ERRO] Fields format is wrong. Should be: key:type,key:type " + v + "\n")
+			return ""
+		}
+		typ, tag := m.getSQLType(kv[1])
+		if typ == "" {
+			ColorLog("[ERRO] Fields format is wrong. Should be: key:type,key:type " + v + "\n")
+			return ""
+		}
+		if i == 0 && strings.ToLower(kv[0]) != "id" {
+			sql += "id interger serial primary key,"
+		}
+		sql += snakeString(kv[0]) + " " + typ + ","
+		if tag != "" {
+			tags = tags + fmt.Sprintf(tag, snakeString(kv[0])) + ","
+		}
+	}
+	if tags != "" {
+		sql = strings.TrimRight(sql+" "+tags, ",")
+	} else {
+		sql = strings.TrimRight(sql, ",")
+	}
+	return sql
+}
+
+func (m postgresqlDriver) getSQLType(ktype string) (tp, tag string) {
+	kv := strings.SplitN(ktype, ":", 2)
+	switch kv[0] {
+	case "string":
+		if len(kv) == 2 {
+			return "char(" + kv[1] + ") NOT NULL", ""
+		}
+		return "TEXT NOT NULL", ""
+	case "text":
+		return "TEXT NOT NULL", ""
+	case "auto", "pk":
+		return "serial primary key", ""
+	case "datetime":
+		return "TIMESTAMP WITHOUT TIME ZONE NOT NULL", ""
+	case "int", "int8", "int16", "int32", "int64":
+		fallthrough
+	case "uint", "uint8", "uint16", "uint32", "uint64":
+		return "integer DEFAULT NULL", ""
+	case "bool":
+		return "boolean NOT NULL", ""
+	case "float32", "float64", "float":
+		return "numeric NOT NULL", ""
+	}
+	return "", ""
+}
+
+func newDBDriver() DBDriver {
+	switch driver {
+	case "mysql":
+		return mysqlDriver{}
+	case "postgres":
+		return postgresqlDriver{}
+	default:
+		panic("driver not supported")
+	}
+}
+
 // generateMigration generates migration file template for database schema update.
 // The generated file template consists of an up() method for updating schema and
 // a down() method for reverting the update.
 func generateMigration(mname, upsql, downsql, curpath string) {
 	w := NewColorWriter(os.Stdout)
-
+	migrationFilePath := path.Join(curpath, DBPath, MPath)
-	migrationFilePath := path.Join(curpath, "database", MPath)
 	if _, err := os.Stat(migrationFilePath); os.IsNotExist(err) {
 		// create migrations directory
 		if err := os.MkdirAll(migrationFilePath, 0777); err != nil {

g_scaffold.go

@@ -1,9 +1,6 @@
 package main
 
-import (
+import "strings"
-	"fmt"
-	"strings"
-)
 
 func generateScaffold(sname, fields, currpath, driver, conn string) {
 	ColorLog("[INFO] Do you want to create a '%v' model? [Yes|No] ", sname)
@@ -31,11 +28,13 @@ func generateScaffold(sname, fields, currpath, driver, conn string) {
 		upsql := ""
 		downsql := ""
 		if fields != "" {
-			upsql = `m.SQL("CREATE TABLE ` + sname + "(" + generateSQLFromFields(fields) + `)");`
+			dbMigrator := newDBDriver()
-			downsql = `m.SQL("DROP TABLE ` + "`" + sname + "`" + `")`
+			upsql = dbMigrator.generateCreateUp(sname)
-			if driver == "" {
+			downsql = dbMigrator.generateCreateDown(sname)
-				downsql = strings.Replace(downsql, "`", "", -1)
+			//todo remove
-			}
+			//if driver == "" {
+			//	downsql = strings.Replace(downsql, "`", "", -1)
+			//}
 		}
 		generateMigration(sname, upsql, downsql, currpath)
 	}
@@ -47,108 +46,3 @@ func generateScaffold(sname, fields, currpath, driver, conn string) {
 	}
 	ColorLog("[INFO] All done! Don't forget to add  beego.Router(\"/%v\" ,&controllers.%vController{}) to routers/route.go\n", sname, strings.Title(sname))
 }
-
-func generateSQLFromFields(fields string) string {
-	sql := ""
-	tags := ""
-	fds := strings.Split(fields, ",")
-	for i, v := range fds {
-		kv := strings.SplitN(v, ":", 2)
-		if len(kv) != 2 {
-			ColorLog("[ERRO] Fields format is wrong. Should be: key:type,key:type " + v + "\n")
-			return ""
-		}
-		typ, tag := "", ""
-		switch driver {
-		case "mysql":
-			typ, tag = getSQLTypeMysql(kv[1])
-		case "postgres":
-			typ, tag = getSQLTypePostgresql(kv[1])
-		default:
-			typ, tag = getSQLTypeMysql(kv[1])
-		}
-		if typ == "" {
-			ColorLog("[ERRO] Fields format is wrong. Should be: key:type,key:type " + v + "\n")
-			return ""
-		}
-		if i == 0 && strings.ToLower(kv[0]) != "id" {
-			switch driver {
-			case "mysql":
-				sql = sql + "`id` int(11) NOT NULL AUTO_INCREMENT,"
-				tags = tags + "PRIMARY KEY (`id`),"
-			case "postgres":
-				sql = sql + "id interger serial primary key,"
-			default:
-				sql = sql + "`id` int(11) NOT NULL AUTO_INCREMENT,"
-				tags = tags + "PRIMARY KEY (`id`),"
-			}
-		}
-
-		sql = sql + "`" + snakeString(kv[0]) + "` " + typ + ","
-		if tag != "" {
-			tags = tags + fmt.Sprintf(tag, "`"+snakeString(kv[0])+"`") + ","
-		}
-	}
-	if driver == "postgres" {
-		sql = strings.Replace(sql, "`", "", -1)
-		tags = strings.Replace(tags, "`", "", -1)
-	}
-	sql = strings.TrimRight(sql+tags, ",")
-	return sql
-}
-
-func getSQLTypeMysql(ktype string) (tp, tag string) {
-	kv := strings.SplitN(ktype, ":", 2)
-	switch kv[0] {
-	case "string":
-		if len(kv) == 2 {
-			return "varchar(" + kv[1] + ") NOT NULL", ""
-		}
-		return "varchar(128) NOT NULL", ""
-	case "text":
-		return "longtext  NOT NULL", ""
-	case "auto":
-		return "int(11) NOT NULL AUTO_INCREMENT", ""
-	case "pk":
-		return "int(11) NOT NULL", "PRIMARY KEY (%s)"
-	case "datetime":
-		return "datetime NOT NULL", ""
-	case "int", "int8", "int16", "int32", "int64":
-		fallthrough
-	case "uint", "uint8", "uint16", "uint32", "uint64":
-		return "int(11) DEFAULT NULL", ""
-	case "bool":
-		return "tinyint(1) NOT NULL", ""
-	case "float32", "float64":
-		return "float NOT NULL", ""
-	case "float":
-		return "float NOT NULL", ""
-	}
-	return "", ""
-}
-
-func getSQLTypePostgresql(ktype string) (tp, tag string) {
-	kv := strings.SplitN(ktype, ":", 2)
-	switch kv[0] {
-	case "string":
-		if len(kv) == 2 {
-			return "char(" + kv[1] + ") NOT NULL", ""
-		}
-		return "TEXT NOT NULL", ""
-	case "text":
-		return "TEXT NOT NULL", ""
-	case "auto", "pk":
-		return "serial primary key", ""
-	case "datetime":
-		return "TIMESTAMP WITHOUT TIME ZONE NOT NULL", ""
-	case "int", "int8", "int16", "int32", "int64":
-		fallthrough
-	case "uint", "uint8", "uint16", "uint32", "uint64":
-		return "integer DEFAULT NULL", ""
-	case "bool":
-		return "boolean NOT NULL", ""
-	case "float32", "float64", "float":
-		return "numeric NOT NULL", ""
-	}
-	return "", ""
-}

new.go

@@ -56,26 +56,16 @@ func init() {
 
 func createApp(cmd *Command, args []string) int {
 	ShowShortVersionBanner()
-
 	w := NewColorWriter(os.Stdout)
-
 	if len(args) != 1 {
 		ColorLog("[ERRO] Argument [appname] is missing\n")
 		os.Exit(2)
 	}
-
+	apppath, packpath, err := checkEnv(args[0])
-	gps := GetGOPATHs()
+	if err != nil {
-	if len(gps) == 0 {
+		fmt.Println(err)
-		ColorLog("[ERRO] Fail to start[ %s ]\n", "GOPATH environment variable is not set or empty")
 		os.Exit(2)
 	}
-	// In case of multiple paths in the GOPATH, by default
-	// we use the first path
-	gopath := gps[0]
-	Debugf("GOPATH: %s", gopath)
-
-	gosrcpath := path.Join(gopath, "src") // User's workspace
-	apppath := path.Join(gosrcpath, args[0])
 
 	if isExist(apppath) {
 		ColorLog("[ERRO] Path (%s) already exists\n", apppath)
@@ -119,13 +109,13 @@ func createApp(cmd *Command, args []string) int {
 	WriteToFile(path.Join(apppath, "views", "index.tpl"), indextpl)
 
 	fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", path.Join(apppath, "routers", "router.go"), "\x1b[0m")
-	WriteToFile(path.Join(apppath, "routers", "router.go"), strings.Replace(router, "{{.Appname}}", strings.Join(strings.Split(apppath[len(gosrcpath)+1:], string(path.Separator)), "/"), -1))
+	WriteToFile(path.Join(apppath, "routers", "router.go"), strings.Replace(router, "{{.Appname}}", packpath, -1))
 
 	fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", path.Join(apppath, "tests", "default_test.go"), "\x1b[0m")
-	WriteToFile(path.Join(apppath, "tests", "default_test.go"), strings.Replace(test, "{{.Appname}}", strings.Join(strings.Split(apppath[len(gosrcpath)+1:], string(path.Separator)), "/"), -1))
+	WriteToFile(path.Join(apppath, "tests", "default_test.go"), strings.Replace(test, "{{.Appname}}", packpath, -1))
 
 	fmt.Fprintf(w, "\t%s%screate%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", path.Join(apppath, "main.go"), "\x1b[0m")
-	WriteToFile(path.Join(apppath, "main.go"), strings.Replace(maingo, "{{.Appname}}", strings.Join(strings.Split(apppath[len(gosrcpath)+1:], string(path.Separator)), "/"), -1))
+	WriteToFile(path.Join(apppath, "main.go"), strings.Replace(maingo, "{{.Appname}}", packpath, -1))
 
 	ColorLog("[SUCC] New application successfully created!\n")
 	return 0

rundocs.go

@@ -20,6 +20,7 @@ import (
 	"log"
 	"net/http"
 	"os"
+	"strings"
 )
 
 var cmdRundocs = &Command{
@@ -120,6 +121,7 @@ func unzipAndDelete(src string) error {
 	}
 	defer r.Close()
 
+	rp := strings.NewReplacer("swagger-"+swaggerVersion, "swagger")
 	for _, f := range r.File {
 		rc, err := f.Open()
 		if err != nil {
@@ -127,11 +129,12 @@ func unzipAndDelete(src string) error {
 		}
 		defer rc.Close()
 
+		fname := rp.Replace(f.Name)
 		if f.FileInfo().IsDir() {
-			os.MkdirAll(f.Name, f.Mode())
+			os.MkdirAll(fname, f.Mode())
 		} else {
 			f, err := os.OpenFile(
-				f.Name, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
+				fname, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
 			if err != nil {
 				return err
 			}
@@ -143,11 +146,6 @@ func unzipAndDelete(src string) error {
 			}
 		}
 	}
-	os.RemoveAll("swagger")
-	err = os.Rename("swagger-"+swaggerVersion, "swagger")
-	if err != nil {
-		ColorLog("[%s]Rename swagger-%s to swagger:%s\n", ERRO, swaggerVersion, err)
-	}
 	ColorLog("[%s]Start delete src file %s\n", INFO, src)
 	return os.RemoveAll(src)
 }