// NAME // clean - Clean all generated files // // DESCRIPTION // Clean all generated files and paths. // // OPTIONS // --backup, -b // clean all backup files (*~, #*) // --verbose, -v // run in verbose mode func TaskClean(t *tasking.T) { var paths []string paths = append( paths, ARMBinaryPath, "pkg", filepath.Join("bin", ProjectName), filepath.Join(AndroidPath, "bin"), filepath.Join(AndroidPath, "gen"), filepath.Join(AndroidPath, "libs"), filepath.Join(AndroidPath, "obj"), ) // Actually remove files using rm for _, path := range paths { err := rm_rf(t, path) if err != nil { t.Error(err) } } if t.Flags.Bool("backup") { err := t.Exec(`sh -c`, `"find ./ -name '*~' -print0 | xargs -0 rm -f"`) if err != nil { t.Error(err) } } if t.Failed() { t.Fatalf("%-20s %s\n", status(t.Failed()), "Clean all generated files and paths.") } t.Logf("%-20s %s\n", status(t.Failed()), "Clean all generated files and paths.") }
// NAME // clean - Clean all generated files // // DESCRIPTION // Clean all generated files and paths. // func TaskClean(t *tasking.T) { var paths []string paths = append( paths, ARMBinaryPath, "pkg", filepath.Join("bin"), filepath.Join(AndroidPath, "bin"), filepath.Join(AndroidPath, "gen"), filepath.Join(AndroidPath, "libs"), filepath.Join(AndroidPath, "obj"), ) // Actually remove files using rm for _, path := range paths { err := rm_rf(t, path) if err != nil { t.Error(err) } } if t.Failed() { t.Fatalf("%-20s %s\n", status(t.Failed()), "Clean all generated files and paths.") } t.Logf("%-20s %s\n", status(t.Failed()), "Clean all generated files and paths.") }
func deployAndroid(t *tasking.T) { buildAndroid(t) err := t.Exec("ant -f android/build.xml clean debug") if err != nil { t.Error(err) } uploadAndroid(t) }
func runXorg(t *tasking.T, flags string) { err := t.Exec( filepath.Join("bin", LibName), flags, ) if err != nil { t.Error(err) } }
func runXorg(t *tasking.T) { err := t.Exec( filepath.Join("bin", LibName), t.Flags.String("flags"), ) if err != nil { t.Error(err) } }
func runXorg(t *tasking.T) { buildXorg(t) err := t.Exec( filepath.Join("bin", ProjectName), t.Flags.String("flags"), ) if err != nil { t.Error(err) } }
func buildXorg(t *tasking.T) { err := t.Exec( `sh -c "`, "GOPATH=`pwd`:$GOPATH", `go get`, t.Flags.String("flags"), LibName, `"`, ) if err != nil { t.Error(err) } }
func buildXorg(t *tasking.T) { err := t.Exec( `sh -c "`, "GOPATH=`pwd`:$GOPATH", `go install`, t.Flags.String("buildflags"), ProjectName, `"`, ) if err != nil { t.Error(err) } }
// NAME // build - Build the tests // // DESCRIPTION // Build the tests for the given platforms (xorg/android). // // OPTIONS // --buildflags= // pass the given flags to the compiler // --verbose, -v // run in verbose mode func TaskBuild(t *tasking.T) { if len(t.Args) == 0 { t.Error("At least a platform name must be specified!") } if f, ok := buildFun[t.Args[0]]; ok { f(t) } if t.Failed() { t.Fatalf("%-20s %s\n", status(t.Failed()), "Build the tests for the given platforms.") } t.Logf("%-20s %s\n", status(t.Failed()), "Build the tests for the given platforms.") }
// NAME // build - Build the application // // DESCRIPTION // Build the application for the given platforms. // // OPTIONS // --flags=<FLAGS> // pass FLAGS to the compiler // --verbose, -v // run in verbose mode func TaskBuild(t *tasking.T) { if len(t.Args) < 1 { t.Error("You must specify a build platform!") } else { for _, platform := range t.Args { buildFun[platform](t) } } if t.Failed() { t.Fatalf("%-20s %s\n", status(t.Failed()), "Build the application for the given platforms.") } t.Logf("%-20s %s\n", status(t.Failed()), "Build the application for the given platforms.") }
// NAME // init - Initialize a new Mandala application // // DESCRIPTION // Initialize a new Mandala application based on application.json // func TaskInit(t *tasking.T) { var err error // read application.json app, err := readJSON(jsonPath) if err != nil { t.Error(err) } var paths []string // execute templates and copy the files err = filepath.Walk( "templates", func(path string, info os.FileInfo, err error) error { if !info.IsDir() { paths = append(paths, path) } return nil }, ) if err != nil { t.Error(err) } for _, path := range paths { var dstPath string splits := strings.Split(path, "/") if len(splits) > 1 { dstPath = filepath.Join(splits[1:]...) } else { dstPath = filepath.Base(path) } if err = copyFile(path, dstPath, app); err != nil { t.Error(err) } } // Rename paths accordly to app.LibName if err = os.Rename("_task.go", strings.ToLower(app.LibName)+"_task.go"); err != nil { t.Error(err) } if err = os.Rename("src/_app", filepath.Join("src", strings.ToLower(app.LibName))); err != nil { t.Error(err) } if t.Failed() { t.Fatalf("%-20s %s\n", status(t.Failed()), "Initialize a new Mandala application") } t.Logf("%-20s %s\n", status(t.Failed()), "Initialize a new Mandala application") }
// NAME // test-sqlite - check data generated from ModSQL into a SQLite database func TaskTestSQLite(t *tasking.T) { filename := dbname + ".db" defer func() { if err := os.Remove(filename); err != nil { t.Error(err) } }() db, err := sql.Open("sqlite3", filename) if err != nil { t.Fatal(err) } if err = modsql.Load(db, filepath.Join("data", "sql", "sqlite_init.sql")); err != nil { t.Error(err) } else { if err = modsql.Load(db, filepath.Join("data", "sql", "sqlite_test.sql")); err != nil { t.Error(err) } testInsert(t, db, modsql.SQLite) if err = modsql.Load(db, filepath.Join("data", "sql", "sqlite_drop.sql")); err != nil { t.Error(err) } } db.Close() if !t.Failed() { t.Log("--- PASS") } }
func buildXorg(t *tasking.T, buildAll bool) { allFlagString := "" if buildAll { allFlagString = "-a" } err := t.Exec( `sh -c "`, "GOPATH=`pwd`:$GOPATH", `go install`, allFlagString, LibName, `"`, ) if err != nil { t.Error(err) } }
func runAndroid(t *tasking.T) { buildAndroid(t) deployAndroid(t) err := t.Exec( fmt.Sprintf( "adb shell am start -a android.intent.action.MAIN -n net.mandala.%s/android.app.NativeActivity", ProjectName, )) if err != nil { t.Error(err) } err = t.Exec("adb shell logcat", "Mandala:* stdout:* stderr:* *:S") if err != nil { t.Error(err) } }
func buildAndroid(t *tasking.T, buildMode ...bool) { // Build mode for ant: // buildMode not specified or false => ant debug // buildMode true => ant release antBuildParam := "debug" if len(buildMode) > 0 && buildMode[0] == true { antBuildParam = "release" } // Generate AdmobActivity using the UnitId in admob.json err := generateAdmobActivity() if err != nil { t.Error(err) } os.MkdirAll("android/libs/armeabi-v7a", 0777) os.MkdirAll("android/obj/local/armeabi-v7a", 0777) err = t.Exec(`sh -c "`, `CC="$NDK_ROOT/bin/arm-linux-androideabi-gcc"`, "GOPATH=`pwd`:$GOPATH", `GOROOT=""`, "GOOS=linux", "GOARCH=arm", "GOARM=7", "CGO_ENABLED=1", "$GOANDROID/go get", t.Flags.String("flags"), "$GOFLAGS", `-ldflags=\"-android -shared -extld $NDK_ROOT/bin/arm-linux-androideabi-gcc -extldflags '-march=armv7-a -mfloat-abi=softfp -mfpu=vfpv3-d16'\"`, "-tags android", LibName, `"`, ) if err != nil { t.Error(err) } for _, path := range SharedLibraryPaths { err := t.Exec( "cp", filepath.Join(ARMBinaryPath, LibName), filepath.Join(path, "lib"+LibName+".so"), ) if err != nil { t.Error(err) } } if err == nil { err = t.Exec("ant -f android/build.xml clean", antBuildParam) if err != nil { t.Error(err) } } }
func runAndroid(t *tasking.T, flags string) { deployAndroid(t) err := t.Exec( fmt.Sprintf( "adb shell am start -a android.intent.action.MAIN -n %s.%s/android.app.NativeActivity", Domain, LibName, )) if err != nil { t.Error(err) } if t.Flags.Bool("logcat") { err = t.Exec("adb shell logcat") if err != nil { t.Error(err) } } }
func runAndroid(t *tasking.T) { deployAndroid(t) err := t.Exec( fmt.Sprintf( "adb shell am start -a android.intent.action.MAIN -n %s.%s/android.app.NativeActivity", Domain, LibName, )) if err != nil { t.Error(err) } if tags := t.Flags.String("logcat"); tags != "" { err = t.Exec("adb", "shell", "logcat", tags) if err != nil { t.Error(err) } } }
// NAME // gh-user - Get URL for a given GitHub user login // // DESCRIPTION // Given a GitHub user login, call the GitHub API to get this user and print out the user page URL. // // For example // // $ gotask git-hub-user jingweno // // OPTIONS // --verbose, -v // run in verbose mode func TaskGitHubUser(t *tasking.T) { if len(t.Args) == 0 { t.Error("No GitHub user login is provided!") return } login := t.Args[0] data, err := fetchGitHubUser(login) if err != nil { t.Error(err) return } url, ok := data["html_url"] if !ok { t.Errorf("No URL found for user login %s\n", login) return } t.Logf("The URL for user %s is %s\n", login, url) }
// NAME // test-mysql - check data generated from ModSQL into a MySQL database // // DESCRIPTION // // To create the database: // // mysql -p // mysql> create database modsql_test; // mysql> GRANT ALL PRIVILEGES ON modsql_test.* to USER@localhost; // // Note: substitute "USER" by your user name. // // To remove it: // // mysql> drop database modsql_test; func TaskTestMySQL(t *tasking.T) { // Format used in "github.com/serbaut/go-mysql" //db, err := sql.Open("mysql", fmt.Sprintf("mysql://%s@(unix)/%s?socket=%s", //username, dbname, host.mysql)) db, err := sql.Open("mysql", fmt.Sprintf("%s@unix(%s)/%s?parseTime=true", username, host.mysql, dbname)) if err != nil { t.Fatal(err) } if err = modsql.Load(db, filepath.Join("data", "sql", "mysql_init.sql")); err != nil { t.Error(err) } else { if err = modsql.Load(db, filepath.Join("data", "sql", "mysql_test.sql")); err != nil { t.Error(err) } testInsert(t, db, modsql.MySQL) if err = modsql.Load(db, filepath.Join("data", "sql", "mysql_drop.sql")); err != nil { t.Error(err) } } db.Close() if !t.Failed() { t.Log("--- PASS") } }
// NAME // check data generated from ModSQL into a Postgre database // // DESCRIPTION // // To create the database: // // sudo -u postgres createuser USER --no-superuser --no-createrole --no-createdb // sudo -u postgres createdb modsql_test --owner USER // // Note: substitute "USER" by your user name. // // To remove it: // // sudo -u postgres dropdb modsql_test func TaskTestPostgres(t *tasking.T) { db, err := sql.Open("postgres", fmt.Sprintf("user=%s dbname=%s host=%s sslmode=disable", username, dbname, host.postgres)) if err != nil { t.Fatal(err) } if err = modsql.Load(db, filepath.Join("data", "sql", "postgres_init.sql")); err != nil { t.Error(err) } else { if err = modsql.Load(db, filepath.Join("data", "sql", "postgres_test.sql")); err != nil { t.Error(err) } testInsert(t, db, modsql.Postgres) if err = modsql.Load(db, filepath.Join("data", "sql", "postgres_drop.sql")); err != nil { t.Error(err) } } db.Close() if !t.Failed() { t.Log("--- PASS") } }
func buildAndroid(t *tasking.T) { os.MkdirAll("android/libs/armeabi-v7a", 0777) os.MkdirAll("android/obj/local/armeabi-v7a", 0777) err := t.Exec(`sh -c "`, `CC="$NDK_ROOT/bin/arm-linux-androideabi-gcc"`, "GOPATH=`pwd`:$GOPATH", `GOROOT=""`, "GOOS=linux", "GOARCH=arm", "GOARM=7", "CGO_ENABLED=1", "$GOANDROID/go install", t.Flags.String("flags"), "$GOFLAGS", `-ldflags=\"-android -shared -extld $NDK_ROOT/bin/arm-linux-androideabi-gcc -extldflags '-march=armv7-a -mfloat-abi=softfp -mfpu=vfpv3-d16'\"`, "-tags android", ProjectName, `"`, ) if err != nil { t.Error(err) } os.MkdirAll(ARMBinaryPath, 0777) for _, path := range SharedLibraryPaths { err := t.Exec( "cp", filepath.Join(ARMBinaryPath, ProjectName), filepath.Join(path, "lib"+ProjectName+".so"), ) if err != nil { t.Error(err) } } }
func buildAndroid(t *tasking.T, buildAll bool) { allFlagString := "" os.MkdirAll("android/libs/armeabi-v7a", 0777) os.MkdirAll("android/obj/local/armeabi-v7a", 0777) if buildAll { allFlagString = "-a" } err := t.Exec(`sh -c "`, `CC="$NDK_ROOT/bin/arm-linux-androideabi-gcc"`, "GOPATH=`pwd`:$GOPATH", `GOROOT=""`, "GOOS=linux", "GOARCH=arm", "GOARM=7", "CGO_ENABLED=1", "$GOANDROID/go install", allFlagString, "$GOFLAGS", `-ldflags=\"-android -shared -extld $NDK_ROOT/bin/arm-linux-androideabi-gcc -extldflags '-march=armv7-a -mfloat-abi=softfp -mfpu=vfpv3-d16'\"`, "-tags android", LibName, `"`, ) if err != nil { t.Error(err) } for _, path := range SharedLibraryPaths { err := t.Exec( "cp", filepath.Join(ARMBinaryPath, LibName), filepath.Join(path, "lib"+LibName+".so"), ) if err != nil { t.Error(err) } } if err == nil { err = t.Exec("ant -f android/build.xml clean debug") if err != nil { t.Error(err) } } }
// Sign and zipalign Android application. func signAndroid(t *tasking.T) { unsignedAppPath := fmt.Sprintf("android/bin/%s-release-unsigned.apk", LibName) // Sign app cmdJarsigner := "jarsigner -verbose -sigalg SHA1withRSA -digestalg SHA1 -keystore %s %s %s" if err := t.Exec(fmt.Sprintf(cmdJarsigner, KeyStore, unsignedAppPath, KeyAlias)); err != nil { t.Error(err) } // Verify sign cmdJarsignerVerify := "jarsigner -verify -verbose -certs %s" if err := t.Exec(fmt.Sprintf(cmdJarsignerVerify, unsignedAppPath)); err != nil { t.Error(err) } // Align app cmdZipAlign := "zipalign -v 4 %s android/bin/%s.apk" if err := t.Exec(fmt.Sprintf(cmdZipAlign, unsignedAppPath, LibName)); err != nil { t.Error(err) } }
func deployAndroid(t *tasking.T) { err := t.Exec(fmt.Sprintf("adb install -r android/bin/%s-debug.apk", LibName)) if err != nil { t.Error(err) } }
// testInsert checks SQL statements generated from Go model. func testInsert(t *tasking.T, db *sql.DB, eng modsql.Engine) { modsql.InitStatements(db, eng, model.Insert) defer func() { if err := modsql.CloseStatements(); err != nil { t.Error(err) } }() // insert inserts data without transaction insert := func(model modsql.Modeler) { if _, err := model.StmtInsert().Exec(model.Args()...); err != nil { t.Error(err) } } // To remove nanoseconds in timestamps since the drivers return fewer digits. nsec := regexp.MustCompilePOSIX(`\.[0-9]+ \+`) // scan checks that output data is the same than input data. scan := func(query string, input, output modsql.Modeler) { rows := db.QueryRow(modsql.SQLReplacer(eng, query)) if err := rows.Scan(output.Args()...); err != nil { t.Errorf("query: %q\n%s", query, err) } else { in := fmt.Sprintf("%v", input) out := fmt.Sprintf("%v", output) if strings.Contains(out, "UTC") { // Field DateTime in = nsec.ReplaceAllLiteralString(in, " +") out = nsec.ReplaceAllLiteralString(out, " +") } if in != out { t.Errorf("got different data\ninput: %v\noutput: %v\n", in, out) } } } // Transaction inputTx := &model.Catalog{0, "a", "b", 1.32} err := insertFromTx(db, inputTx) if err != nil { modsql.CloseStatements() t.Error(err) } scan("SELECT * FROM catalog WHERE catalog_id = 0", inputTx, &model.Catalog{}) // Check data input from SQL files inputTypes := &model.Types{0, 8, 16, 32, 64, 1.32, 1.64, "one", []byte("12"), 'A', 'Z', true} scan("SELECT * FROM types WHERE int_ = 0", inputTypes, &model.Types{}) inputDef := &model.Default_value{0, 10, 10.10, "foo", []byte{'1', '2'}, 'a', 'z', false} scan("SELECT * FROM default_value WHERE Id = 0", inputDef, &model.Default_value{}) inputTimes0 := &model.Times{0, time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)} scan("SELECT * FROM times WHERE typeId = 0", inputTimes0, &model.Times{}) if inputTimes0.Datetime.IsZero() { t.Error("inputTimes0.Datetime: should not be zero:", inputTimes0.Datetime) } inputTimes1 := &model.Times{1, time.Time{}} scan("SELECT * FROM times WHERE typeId = 1", inputTimes1, &model.Times{}) if !inputTimes1.Datetime.IsZero() { t.Error("inputTimes1.Datetime: should be zero:", inputTimes1.Datetime) } // Direct insert input0 := &model.Types{1, 8, -16, -32, 64, -1.32, -1.64, "a", []byte{1, 2}, 8, 'r', true} insert(input0) scan("SELECT * FROM types WHERE int_ = 1", input0, &model.Types{}) input1 := &model.Default_value{1, 8, 1.32, "a", []byte{1, 2}, 8, 'r', false} insert(input1) scan("SELECT * FROM default_value WHERE id = 1", input1, &model.Default_value{}) input2 := &model.Times{2, time.Now().UTC()} insert(input2) scan("SELECT * FROM times WHERE typeId = 2", input2, &model.Times{}) if input2.Datetime.IsZero() { t.Error("input2.Datetime: should not be zero:", input2.Datetime) } input3 := &model.Account{11, 22, "a"} insert(input3) scan("SELECT * FROM account WHERE acc_num = 11", input3, &model.Account{}) input4 := &model.Sub_account{1, 11, 22, "a"} insert(input4) scan("SELECT * FROM sub_account WHERE sub_acc = 1", input4, &model.Sub_account{}) input5 := &model.Catalog{33, "a", "b", 1.32} insert(input5) scan("SELECT * FROM catalog WHERE catalog_id = 33", input5, &model.Catalog{}) input6 := &model.Magazine{33, "a"} insert(input6) scan("SELECT * FROM magazine WHERE catalog_id = 33", input6, &model.Magazine{}) input7 := &model.Mp3{33, 1, 1.32, "a"} insert(input7) scan("SELECT * FROM mp3 WHERE catalog_id = 33", input7, &model.Mp3{}) input8 := &model.Book{44, "a", "b"} insert(input8) scan("SELECT * FROM book WHERE book_id = 44", input8, &model.Book{}) input9 := &model.Chapter{1, "a", 44} insert(input9) scan("SELECT * FROM chapter WHERE chapter_id = 1", input9, &model.Chapter{}) input10 := &model.User{55, "a", "b"} insert(input10) scan("SELECT * FROM {Q}user{Q} WHERE user_id = 55", input10, &model.User{}) input11 := &model.Address{66, "a", "b", "c", "d"} insert(input11) scan("SELECT * FROM address WHERE address_id = 66", input11, &model.Address{}) input12 := &model.User_address{55, 66} insert(input12) scan("SELECT * FROM user_address WHERE user_id = 55", input12, &model.User_address{}) }
func uploadAndroid(t *tasking.T) { err := t.Exec(fmt.Sprintf("adb install -r android/bin/%s-debug.apk", ProjectName)) if err != nil { t.Error(err) } }