qst has grown up, it's now at heyLu/qst.

already?! that was fast...

go/.gitignore

.go
qst
examples/hello
examples/hello_web
.go

go/README.md

## qst - run things quickly (and easily)
`qst` has already grown up, it now lives [in it's own place](https://github.com/heyLu/qst).
You can get it using `go get github.com/heyLu/qst`.
intended to be run in unfamilar environments, you pass it a file or a
directory and it tries to detect what it is and how to run it.
- run `qst` or `qst -h` to see options and support project types
- `qst hello_world.go`: compiles and runs `hello_world.go`, rerunning
	after it exits or the file is saved
	quite fun for small things, just throw some code in a file, have `qst`
	watch and restart when appropriate.
- `qst -phase=test ...` runs the tests for projects that support it
### Building it yourself
	# set up $GOPATH as desired
	$ export GOPATH=$PWD/.go         # choose whatever you want
	$ go build qst
	...
	$ ./qst -h
	Usage: qst <file>
	...
	$ ./qst examples/hello_web.rb
	...
	^C
	$ ./qst examples/hello_web.go
	...
Try changing something in the files, it's fun. :)
### Ideas/todo
- watch many files (select by globbing)
- sometimes restarts twice after one save?
- more project types
- tests (how? lots of shellscripts could do it, but would be very
	cumbersome. current "architecture" doesn't allow mocking.)
run `qst .` to run anything.

go/detect/detect.go

// Guess project "type" from the files present.
package detect
import (
	"errors"
	"path"
	"../fileutil"
)
type Project struct {
	Id       string
	Commands Commands
	Detect   Matcher
}
type Matcher func(string) bool
type Commands map[string]string
var ProjectTypes = []*Project{
	&Project{"c/default", Commands{"run": "gcc -o $(basename {file} .c) {file} && ./$(basename {file} .c)"},
		matchPattern("*.c")},
	&Project{"clojure/leiningen", Commands{"build": "lein uberjar", "run": "lein run", "test": "lein test"},
		matchFile("project.clj")},
	&Project{"coffeescript/default", Commands{"run": "coffee {file}"}, matchPattern("*.coffee")},
	&Project{"docker/fig", Commands{"build": "fig build", "run": "fig up"}, matchFile("fig.yml")},
	&Project{"docker/default", Commands{"build": "docker build ."}, matchFile("Dockerfile")},
	&Project{"executable", Commands{"run": "{file}"}, executableDefault},
	&Project{"go/default", Commands{"build": "go build {file}", "run": "go build $(basename {file}) && ./$(basename {file} .go)",
		"test": "go test"}, matchPattern("*.go")},
	&Project{"haskell/cabal", Commands{"build": "cabal build", "run": "cabal run", "test": "cabal test"},
		matchPattern("*.cabal")},
	&Project{"haskell/default", Commands{"run": "runhaskell {file}"}, haskellDefault},
	&Project{"idris/default", Commands{"run": "idris -o $(basename {file} .idr) {file} && ./$(basename {file} .idr)"},
		matchPattern("*.idr")},
	&Project{"java/maven", Commands{"build": "mvn compile", "test": "mvn compile test"}, matchFile("pom.xml")},
	&Project{"javascript/npm", Commands{"build": "npm install", "run": "npm start", "test": "npm test"},
		matchFile("package.json")},
	&Project{"javascript/meteor", Commands{"run": "meteor"}, matchFile(".meteor/.id")},
	&Project{"javascript/default", Commands{"run": "node {file}"}, matchPattern("*.js")},
	&Project{"julia/default", Commands{"run": "julia {file}"}, matchPattern("*.jl")},
	&Project{"python/django", Commands{"build": "python manage.py syncdb", "run": "python manage.py runserver",
		"test": "python manage.py test"}, matchFile("manage.py")},
	&Project{"python/default", Commands{"run": "python {file}"}, matchPattern("*.py")},
	&Project{"ruby/rails", Commands{"build": "bundle exec rake db:migrate", "run": "rails server",
		"test": "bundle exec rake test"}, matchFile("bin/rails")},
	&Project{"ruby/rake", Commands{"run": "rake", "test": "rake test"}, matchFile("Rakefile")},
	&Project{"ruby/default", Commands{"run": "ruby {file}"}, matchPattern("*.rb")},
	&Project{"rust/cargo", Commands{"build": "cargo build", "run": "cargo run", "test": "cargo test"},
		matchFile("Cargo.toml")},
	&Project{"rust/default", Commands{"run": "rustc {file} && ./$(basename {file} .rs)"}, matchPattern("*.rs")},
	&Project{"cmake", Commands{"build": "mkdir .build && cd .build && cmake .. && make"}, matchFile("CMakeLists.txt")},
	&Project{"make", Commands{"run": "make", "test": "make test"}, matchFile("Makefile")},
	&Project{"procfile", Commands{"run": "$(sed -n 's/^web: //p' Procfile)"}, matchFile("Procfile")},
}
func Detect(file string) (*Project, error) {
	for _, project := range ProjectTypes {
		if project.Detect(file) {
			return project, nil
		}
	}
	return nil, errors.New("no project type matches")
}
func DetectAll(file string) []*Project {
	projects := make([]*Project, 0, len(ProjectTypes))
	for _, project := range ProjectTypes {
		if project.Detect(file) {
			n := len(projects)
			projects = projects[0 : n+1]
			projects[n] = project
		}
	}
	return projects
}
func GetById(id string) *Project {
	for _, project := range ProjectTypes {
		if project.Id == id {
			return project
		}
	}
	return nil
}
func matchingFileOrDir(file string, pattern string) bool {
	if fileutil.IsFile(file) {
		_, f := path.Split(file)
		isMatch, _ := path.Match(pattern, f)
		return isMatch
	} else {
		return fileutil.MatchExists(path.Join(path.Dir(file), pattern))
	}
}
func hasFile(fileOrDir string, file string) bool {
	return fileutil.IsFile(fileutil.Join(fileOrDir, file))
}
func matchPattern(ext string) Matcher {
	return func(file string) bool {
		return matchingFileOrDir(file, ext)
	}
}
func matchFile(fileName string) Matcher {
	return func(file string) bool {
		return hasFile(file, fileName)
	}
}
func executableDefault(file string) bool {
	return fileutil.IsExecutable(file)
}
func haskellDefault(file string) bool {
	return matchingFileOrDir(file, "*.hs") || matchingFileOrDir(file, "*.lhs")
}

go/examples/hello.c

#include <stdio.h>
int main(int argc, char **argv) {
	printf("Hello, World!\n");
	return 0;
}

go/examples/hello.coffee

console.log "Hello, World!"

go/examples/hello.go

package main
import "fmt"
func main() {
	fmt.Println("Hello, World!")
}

go/examples/hello.hs

main = putStrLn "Hello, World!"

go/examples/hello.idr

main : IO ()
main = putStrLn "Hello, World!"

go/examples/hello.jl

println("Hello, World!")

go/examples/hello.rb

puts "Hello, World!"

go/examples/hello.rs

fn main() {
	println!("Hello, World!")
}

go/examples/hello_web.go

package main
import "fmt"
import "net/http"
func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
		name := req.URL.Path[1:]
		if name == "" {
			name = "World"
		}
		w.Write([]byte(fmt.Sprintf("Hello, %s!", name)))
	})
	fmt.Println("Running on :8080")
	http.ListenAndServe(":8080", nil)
}

go/examples/hello_web.rb

require 'webrick'
server = WEBrick::HTTPServer.new :Port => 8080
server.mount_proc '/' do |req, res|
  name = req.path == '/' ? "World" : req.path[1..-1]
  res.body = "Hello, #{name}!"
end
trap 'INT' do server.shutdown end
server.start

go/fileutil/fileutil.go

package fileutil
import (
	"os"
	"path"
	"path/filepath"
)
func IsFile(path string) bool {
	info, err := os.Stat(path)
	if err != nil {
		return false
	}
	return !info.IsDir()
}
func IsDir(path string) bool {
	info, err := os.Stat(path)
	if err != nil {
		return false
	}
	return info.IsDir()
}
func MatchExists(glob string) bool {
	matches, _ := filepath.Glob(glob)
	return len(matches) > 0
}
func Join(fileOrDir string, elem ...string) string {
	dir := fileOrDir
	if IsFile(fileOrDir) {
		dir = path.Dir(fileOrDir)
	}
	return path.Join(dir, path.Join(elem...))
}
func IsExecutable(file string) bool {
	info, err := os.Stat(file)
	if err != nil {
		return false
	}
	isExecutable := info.Mode() & 0111
	return isExecutable != 0 && !info.IsDir()
}
func Dir(file string) string {
	if IsDir(file) {
		return file
	}
	return path.Dir(file)
}

go/qst.go

// qst - run things quickly
//
// Given a file or directory, guesses the project type and runs
// it for you. Restarts on changes. Intended for small experiments
// and working with unfamilar build systems.
package main
import (
	"errors"
	"flag"
	"fmt"
	"log"
	"os"
	"os/exec"
	"os/signal"
	"path/filepath"
	"strings"
	"syscall"
	"time"
	"./detect"
	"./fileutil"
)
var delay = flag.Duration("delay", 1*time.Second, "time to wait until restart")
var autoRestart = flag.Bool("autorestart", true, "automatically restart after command exists")
var command = flag.String("command", "", "command to run ({file} will be substituted)")
var projectType = flag.String("type", "", "project type to use (autodetected if not present)")
var phase = flag.String("phase", "run", "which phase to run (build, run or test)")
var justDetect = flag.Bool("detect", false, "detect the project type and exit")
func main() {
	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "Usage: %s <file>\n\n", os.Args[0])
		flag.PrintDefaults()
		fmt.Fprintf(os.Stderr, "\nSupported project types: \n")
		for _, project := range detect.ProjectTypes {
			paddedId := fmt.Sprintf("%s%s", project.Id, strings.Repeat(" ", 30-len(project.Id)))
			fmt.Fprintf(os.Stderr, "\t%s- %v\n", paddedId, project.Commands[*phase])
		}
	}
	flag.Parse()
	args := flag.Args()
	if len(args) < 1 {
		flag.Usage()
		os.Exit(1)
	}
	file := args[0]
	if *justDetect {
		projects := detect.DetectAll(file)
		if len(projects) == 0 {
			log.Fatal("unkown project type")
		}
		for _, project := range projects {
			fmt.Println(project.Id)
		}
		os.Exit(0)
	}
	var cmd string
	if !flagEmpty(command) {
		cmd = *command
	} else {
		project, err := detect.Detect(file)
		if !flagEmpty(projectType) {
			project = detect.GetById(*projectType)
			if project == nil {
				log.Fatalf("unknown type: `%s'", *projectType)
			} else if !project.Detect(file) {
				log.Fatalf("%s doesn't match type %s!", file, *projectType)
			}
		}
		if err != nil {
			log.Fatal("error: ", err)
		}
		log.Printf("detected a %s project", project.Id)
		projectCmd, found := project.Commands[*phase]
		if !found {
			log.Fatalf("%s doesn't support `%s'", project.Id, *phase)
		}
		cmd = projectCmd
	}
	file, _ = filepath.Abs(file)
	cmd = strings.Replace(cmd, "{file}", file, -1)
	if err := os.Chdir(fileutil.Dir(file)); err != nil {
		log.Fatal(err)
	}
	log.Printf("command to run: `%s'", cmd)
	runner := MakeRunner(cmd, *autoRestart)
	go runCmd(file, runner)
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt, os.Kill, syscall.SIGTERM)
	s := <-c
	log.Printf("got signal: %s, exiting...", s)
	runner.Stop()
}
func flagEmpty(stringFlag *string) bool {
	return stringFlag == nil || strings.TrimSpace(*stringFlag) == ""
}
func runCmd(file string, runner *Runner) {
	runner.Start()
	lastMtime := time.Now()
	for {
		info, err := os.Stat(file)
		if os.IsNotExist(err) {
			log.Fatalf("`%s' disappeared, exiting", file)
		}
		mtime := info.ModTime()
		if mtime.After(lastMtime) {
			log.Printf("`%s' changed, trying to restart", file)
			runner.Restart()
		}
		lastMtime = mtime
		time.Sleep(1 * time.Second)
	}
}
type Runner struct {
	cmd         *exec.Cmd
	shellCmd    string
	started     bool
	autoRestart bool
	restarting  bool
}
func MakeRunner(shellCmd string, autoRestart bool) *Runner {
	return &Runner{nil, shellCmd, false, autoRestart, false}
}
func (r *Runner) Start() error {
	if r.started {
		return errors.New("already started, use Restart()")
	}
	r.started = true
	go func() {
		for {
			log.Printf("[runner] starting command")
			r.cmd = exec.Command("sh", "-c", r.shellCmd)
			r.cmd.Stderr = os.Stderr
			r.cmd.Stdout = os.Stdout
			r.cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
			err := r.cmd.Run()
			var result interface{}
			if err != nil {
				result = err
			} else {
				result = r.cmd.ProcessState
			}
			log.Printf("[runner] finished: %s", result)
			time.Sleep(*delay)
			if !r.restarting && !r.autoRestart {
				r.started = false
				break
			}
			r.restarting = false
		}
	}()
	return nil
}
func (r *Runner) Kill() error {
	pgid, err := syscall.Getpgid(r.cmd.Process.Pid)
	if err == nil {
		syscall.Kill(-pgid, syscall.SIGTERM)
	}
	return err
}
func (r *Runner) Restart() error {
	r.restarting = true
	if r.started {
		return r.Kill()
	} else {
		return r.Start()
	}
}
func (r *Runner) Stop() {
	r.autoRestart = false
	r.Kill()
}
func isFile(file string) bool {
	info, err := os.Stat(file)
	return err == nil && !info.IsDir()
}