main.go

package main

import (
	"bytes"
	"flag"
	"fmt"
	"os"
	"os/exec"
	"path"
	"path/filepath"
	"regexp"
	"runtime"
	"strconv"
	"strings"

	"github.com/DAddYE/igo/cmd"
)

type Cmd int

const (
	INVALID Cmd = iota
	COMPILE
	PARSE
	BUILD
	RUN
	TEST
)

var commands = []string{
	COMPILE: "compile",
	PARSE:   "parse",
	BUILD:   "build",
	RUN:     "run",
	TEST:    "test",
}

func usage() {
	fmt.Fprintf(os.Stderr, "usage: igo ["+strings.Join(commands[1:], "|")+"] [flags] [path ...]\n")
	flag.PrintDefaults()
	os.Exit(2)
}

func toCmd(c string) Cmd {
	for i, command := range commands {
		if c == command {
			return Cmd(i)
		}
	}
	return Cmd(0)
}

func abs(i int) int {
	switch {
	case i < 0:
		return -i
	default:
		return i
	}
}

func parseError(err []byte) {
	const regex = `^(.*):(\d+):(\d+)?\s*(.*)`
	re := regexp.MustCompile(regex)

	// Iterate over each error message.
	for _, line := range bytes.Split(err, []byte{'\n'}) {

		// if the error message is kind of:
		//		./path/name.go:line:col error message
		//
		match := re.FindAllStringSubmatch(string(line), 4)
		if len(match) == 1 {
			file, _ := filepath.Rel("./", match[0][1]) // TODO: check this under chdir
			line, _ := strconv.Atoi(match[0][2])
			col, _ := strconv.Atoi(match[0][3])
			message := match[0][4]
			igoFile := strings.TrimSuffix(file, ".go") + ".igo"
			if pos := cmd.IgoPositions[igoFile]; pos != nil {
				var cols []int
				for in, out := range *pos {
					if out.Line == line {
						cols = append(cols, in.Column)
					}
				}
				if len(cols) > 0 {
					closest := abs(cols[0] - col)
					for _, c := range cols {
						if cd := abs(c - col); cd < closest {
							closest = cd
						}
					}
					fmt.Printf("%s:%d:%d %s\n", igoFile, line, closest, message)
				} else {
					fmt.Printf("%s:%d:%d %s\n", igoFile, line, col, message)
				}
			}
		}
	}
}

func main() {
	flag.Usage = usage
	flag.Parse()

	var (
		command  Cmd
		paths    []string
		exitCode = 0
	)

	for i := 0; i < flag.NArg(); i++ {
		s := flag.Arg(i)
		if cmd := toCmd(s); cmd > 0 {
			command = cmd
		} else {
			// Could be a path
			paths = append(paths, s)
		}
	}

	switch command {
	case PARSE:
		exitCode = cmd.To(cmd.IGO, paths)
	case COMPILE:
		os.Chdir(*cmd.DestDir)
		exitCode = cmd.To(cmd.GO, paths)
	case BUILD, RUN, TEST:
		os.Chdir(*cmd.DestDir)
		exitCode = cmd.To(cmd.GO, paths)
		if exitCode == 0 {
			gocmd := path.Join(runtime.GOROOT(), "bin", "go")
			out, err := exec.Command(gocmd, commands[command]).CombinedOutput()
			if err != nil {
				parseError(out)
				exitCode = 1
			}
		}
	default:
		fmt.Fprintln(os.Stderr, "Invalid command")
		usage()
	}
	os.Exit(exitCode)
}