Esempio n. 1
0
File: main.go Progetto: THEY/godo
func buildMain(src string) string {
	mustBeMain(src)

	exeFile := "godobin-" + godo.Version
	if isWindows {
		exeFile += ".exe"
	}

	dir := filepath.Dir(src)
	exe := filepath.Join(dir, exeFile)
	reasonFormat := "Godofile changed. Rebuilding %s...\n"

	argm := minimist.Parse()
	rebuild := argm.ZeroBool("rebuild")
	if rebuild {
		os.Remove(exe)
	}

	// see if last run exists .godoinfo
	fiExe, err := os.Stat(exe)
	build := os.IsNotExist(err)
	if build {
		reasonFormat = "Building %s...\n"
	}

	fiGodofile, err := os.Stat(src)
	if os.IsNotExist(err) {
		log.Fatalln(err)
		os.Exit(1)
	}
	build = build || fiExe.ModTime().Before(fiGodofile.ModTime())

	if build {
		util.Debug("godo", reasonFormat, exe)

		err := godo.Run("go build -a -o "+exeFile, godo.In{dir})
		if err != nil {
			panic(err)
		}
	}

	if rebuild {
		util.Info("godo", "ok")
		os.Exit(0)
	}

	return exe
}
Esempio n. 2
0
File: cli.go Progetto: markhuge/301
func handleCLI() (proto, domain string, port, health int) {
	args := minimist.Parse()

	if args.MayBool(false, "help", "h", "?") {
		fmt.Println(usage)
		os.Exit(0)
	}

	if args.MayBool(false, "v", "version") {
		fmt.Println(version)
		os.Exit(0)
	}

	port = args.MayInt(8080, "port", "p")
	health = args.AsInt("health")
	domain = args.MayString("127.0.0.1", "domain", "d")
	proto = args.MayString("http", "proto")

	return proto, domain, port, health
}
Esempio n. 3
0
func main() {
	argm := minimist.Parse()
	fmt.Printf("%q\n", os.Args)

	// cmd --help || cmd --h || cmd -?
	if argm.MayBool(false, "help", "h", "?") {
		fmt.Println(usage)
	}

	// cmd -v || cmd --version
	if argm.AsBool("v", "version") {
		fmt.Println("1.0")
	}

	// cmd foo -- ...
	// argm.SubCommand("foo", func(a *ArgMap) {
	// })

	// argm.SubExec("talk", "echo")
}
Esempio n. 4
0
func main() {
	// v2 ONLY uses Gododir/main.go
	godoFiles := []string{"Gododir/main.go", "Gododir/Godofile.go", "tasks/Godofile.go"}
	src := ""
	for _, filename := range godoFiles {
		src = util.FindUp(".", filename)
		if src != "" {
			break
		}
	}

	if src == "" {
		fmt.Printf("\n\n%s not found\n", src)
		os.Exit(1)
	}

	wd, err := os.Getwd()
	if err != nil {
		util.Error("godo", "Could not get working directory: %s\n", err.Error())
	}

	// parent of Gododir/main.go
	absParentDir, err := filepath.Abs(filepath.Dir(filepath.Dir(src)))
	if err != nil {
		util.Error("godo", "Could not get absolute parent of %s: %s\n", src, err.Error())
	}
	if wd != absParentDir {
		relDir, _ := filepath.Rel(wd, src)
		os.Chdir(absParentDir)
		util.Info("godo", "Using %s\n", relDir)
	}

	os.Setenv("GODOFILE", src)
	argm := minimist.Parse()
	isRebuild = argm.AsBool("rebuild")
	isWatch = argm.AsBool("w", "watch")
	isVerbose = argm.AsBool("v", "verbose")
	hasTasks = len(argm.NonFlags()) > 0
	run(src)
}
Esempio n. 5
0
File: runner.go Progetto: THEY/godo
func godo(tasksFunc func(*Project), argv []string) {
	if argv == nil {
		argm = minimist.Parse()
	} else {
		argm = minimist.ParseArgv(argv)
	}

	help = argm.ZeroBool("help", "h", "?")
	verbose = argm.ZeroBool("verbose", "v")
	version = argm.ZeroBool("version", "V")
	watching = argm.ZeroBool("watch", "w")
	deprecatedWarnings = argm.ZeroBool("D")
	contextArgm = minimist.ParseArgv(argm.Unparsed())

	project := NewProject(tasksFunc)

	if help {
		Usage(project.usage())
		os.Exit(0)
	}

	if version {
		fmt.Printf("godo %s\n", Version)
		os.Exit(0)
	}

	// Run each task including their dependencies.
	args := []string{}
	for _, v := range argm.Leftover() {
		args = append(args, fmt.Sprintf("%v", v))
	}

	if len(args) == 0 {
		if project.Tasks["default"] != nil {
			args = append(args, "default")
		} else {
			Usage(project.usage())
			os.Exit(0)
		}
	}

	// quick fix to make cascading watch work on default task
	if len(args) == 1 && args[0] == "default" {
		args = project.Tasks["default"].Dependencies
	}

	for _, name := range args {
		err := project.Run(name)
		if err != nil {
			util.Error("ERR", "%s\n", err.Error())
			os.Exit(1)
		}
	}

	if watching {
		if project.Watch(args, true) {
			waitgroup.Add(1)
			waitExit = true
		} else {
			fmt.Println("Nothing to watch. Use W{} or Watch{} to specify glob patterns")
			os.Exit(0)
		}
	}

	if waitExit {
		waitgroup.Wait()
	}
}
Esempio n. 6
0
// used for testing to switch out exitFn
func godoExit(tasksFunc func(*Project), argv []string, exitFn func(int)) {
	if argv == nil {
		argm = minimist.Parse()
	} else {
		argm = minimist.ParseArgv(argv)
	}

	dump := argm.AsBool("dump")
	help = argm.AsBool("help", "h", "?")
	verbose = argm.AsBool("verbose", "v")
	version = argm.AsBool("version", "V")
	watching = argm.AsBool("watch", "w")
	deprecatedWarnings = argm.AsBool("D")
	contextArgm := minimist.ParseArgv(argm.Unparsed())

	project := NewProject(tasksFunc, exitFn, contextArgm)

	if help {
		Usage(project.usage())
		exitFn(0)
	}

	if version {
		fmt.Printf("godo %s\n", Version)
		exitFn(0)
	}

	if dump {
		project.dump(os.Stdout, "", "  ")
		exitFn(0)
	}

	// env vars are any nonflag key=value pair
	addToOSEnviron(argm.NonFlags())

	// Run each task including their dependencies.
	args := []string{}
	for _, s := range argm.NonFlags() {
		// skip env vars
		if !strings.Contains(s, "=") {
			args = append(args, s)
		}
	}

	if len(args) == 0 {
		if project.Tasks["default"] != nil {
			args = append(args, "default")
		} else {
			Usage(project.usage())
			exitFn(0)
		}
	}

	for _, name := range args {
		err := project.Run(name)
		if err != nil {
			util.Error("ERR", "%s\n", err.Error())
			exitFn(1)
		}
	}

	if watching {
		if project.Watch(args, true) {
			runnerWaitGroup.Add(1)
			waitExit = true
		} else {
			fmt.Println("Nothing to watch. Use Task#Src() to specify watch patterns")
			exitFn(0)
		}
	}

	if waitExit {
		// Ctrl+C handler
		csig := make(chan os.Signal, 1)
		signal.Notify(csig, syscall.SIGQUIT)
		go func() {
			for sig := range csig {
				fmt.Println("SIG caught")
				if sig == syscall.SIGQUIT {
					fmt.Println("SIG caught B")
					project.Exit(0)
					break
				}
			}
		}()

		runnerWaitGroup.Wait()
	}
	exitFn(0)
}