Move the logging to a separate logger so we can do a tui.

builder/build.go

@@ -1,9 +1,7 @@
 package builder
 
 import (
-  "fmt"
   "os/exec"
-  "log"
   "io"
   "os"
   "time"
@@ -16,6 +14,7 @@ import (
   "strconv"
   "lcthw.dev/go/ttarpit/config"
   "lcthw.dev/go/ttarpit/data"
+  . "lcthw.dev/go/ttarpit/debug"
 )
 
 type ErrorHandler func (data.ErrInfo) 
@@ -63,7 +62,7 @@ func (build *Builder) ParseErrInfo(line string, reg *regexp.Regexp) (data.ErrInf
 
 
 func (build *Builder) LaunchLogger(in io.Reader, out io.Writer, err error) {
-  if err != nil { log.Fatal(err) }
+  if err != nil { Log.Fatal(err) }
 
   go func() {
     scan := bufio.NewScanner(in)
@@ -89,7 +88,7 @@ func (build *Builder) LaunchProcess(proc *config.Process) {
     proc.ExecCmd.Err = nil
   }
 
-  fmt.Println("STARTING", proc.Command)
+  Log.Println("STARTING", proc.Command)
 
   stderr, err := proc.ExecCmd.StderrPipe();
   build.LaunchLogger(stderr, os.Stdout, err)
@@ -99,13 +98,13 @@ func (build *Builder) LaunchProcess(proc *config.Process) {
 
   err = proc.ExecCmd.Start()
   if err != nil {
-    log.Fatalf("FAIL %s %s err=%v", proc.Command, proc.Args, err)
+    Log.Fatalf("FAIL %s %s err=%v", proc.Command, proc.Args, err)
   }
 
-  fmt.Println("WAITING for", proc.Command)
+  Log.Println("WAITING for", proc.Command)
 
   proc.ExecCmd.Wait()
-  fmt.Println("PROCESS", proc.Command, "EXITED")
+  Log.Println("PROCESS", proc.Command, "EXITED")
 }
 
 func (build *Builder) MatchesPath(fp string) bool {
@@ -139,18 +138,18 @@ func (build *Builder) RunBuild() {
   if build.BeginBuild() {
     defer build.EndBuild() 
 
-    fmt.Println("CONFIG:", build.settings.ConfigPath)
-    fmt.Println("COMMANDs:", build.settings.Processes)
+    Log.Println("CONFIG:", build.settings.ConfigPath)
+    Log.Println("COMMANDs:", build.settings.Processes)
 
     for name, proc := range build.settings.Processes {
-      fmt.Println("PROCESS:", name)
+      Log.Println("PROCESS:", name)
 
       build.LaunchProcess(&proc)
     }
 
     time.Sleep(1000 * time.Millisecond)
   } else {
-    fmt.Println("!!!! BUILD SKIP, already running")
+    Log.Println("!!!! BUILD SKIP, already running")
   }
 }
 
@@ -158,15 +157,15 @@ func (build *Builder) AddWatchDir(watcher *fsnotify.Watcher, name string) error
   return filepath.WalkDir(name,
   func(path string, d fs.DirEntry, err error) error {
     if err != nil {
-      log.Printf("WATCH ERROR! walking=%s path=%s: err=%v", name, path, err)
+      Log.Printf("WATCH ERROR! walking=%s path=%s: err=%v", name, path, err)
       return err
     }
 
     if d.IsDir() {
-      log.Println("WATCHING: ", path)
+      Log.Println("WATCHING: ", path)
       err = watcher.Add(path)
       if err != nil {
-        log.Printf("failed to watch %s", path)
+        Log.Printf("failed to watch %s", path)
         return err
       }
     }
@@ -178,7 +177,7 @@ func (build *Builder) AddWatchDir(watcher *fsnotify.Watcher, name string) error
 func (build *Builder) WatchDir() {
   watcher, err := fsnotify.NewWatcher()
   if err != nil {
-    log.Fatal("Failed to start fsnotify", err)
+    Log.Fatal("Failed to start fsnotify", err)
   }
   defer watcher.Close()
 
@@ -191,7 +190,7 @@ func (build *Builder) WatchDir() {
         }
 
         if event.Has(fsnotify.Create) {
-          log.Println("---> CREATE", event.Name)
+          Log.Println("---> CREATE", event.Name)
           build.AddWatchDir(watcher, event.Name)
         } else if event.Has(fsnotify.Write) {
           // check if match then do thing
@@ -199,13 +198,13 @@ func (build *Builder) WatchDir() {
             go build.RunBuild()
           }
         } else {
-          log.Println("event:", event)
+          Log.Println("event:", event)
         }
       case err, ok := <-watcher.Errors:
         if !ok {
           return
         }
-        log.Println("error: ", err)
+        Log.Println("error: ", err)
       }
     }
   }()
@@ -213,7 +212,7 @@ func (build *Builder) WatchDir() {
   err = build.AddWatchDir(watcher, ".")
 
   if err != nil {
-    log.Fatal(err, "Failed to watch .")
+    Log.Fatal(err, "Failed to watch .")
   }
 
   <-make(chan struct{})

debug/logging.go

@@ -0,0 +1,14 @@
+package debug
+
+import (
+  "log"
+  "os"
+)
+
+var Log *log.Logger
+
+func Init() {
+  out, err := os.Create("debug.log")
+  if err != nil { log.Fatal(err) }
+  Log = log.New(out, "", log.LstdFlags)
+}

game/engine.go

@@ -1,9 +1,9 @@
 package game
 
 import (
-  "fmt"
   "lcthw.dev/go/ttarpit/config"
   "lcthw.dev/go/ttarpit/data"
+  . "lcthw.dev/go/ttarpit/debug"
 )
 
 type Game struct {
@@ -23,18 +23,18 @@ func New(settings config.Config) *Game {
 }
 
 func (game *Game) TakeHit(errinfo data.ErrInfo) {
-  fmt.Println("!!!!!!!!!!!!!!!!!", errinfo)
+  Log.Println("!!!!!!!!!!!!!!!!!", errinfo)
   game.Errors++
   game.HP--
 
-  fmt.Println("============== PROCESS EXIT")
-  fmt.Printf("==== HP: %d  Errors: %d =====\n",
+  Log.Println("============== PROCESS EXIT")
+  Log.Printf("==== HP: %d  Errors: %d =====\n",
     game.HP, game.Errors)
 
   if game.HP <= 0 {
-    fmt.Println("!!!!!! YOU DIED !!!!!!!")
+    Log.Println("!!!!!! YOU DIED !!!!!!!")
     game.HP = game.settings.StartingHP
   }
 
-  fmt.Println("===========================")
+  Log.Println("===========================")
 }

main.go

@@ -5,9 +5,12 @@ import (
   "lcthw.dev/go/ttarpit/config"
   "lcthw.dev/go/ttarpit/game"
   "lcthw.dev/go/ttarpit/data"
+  "lcthw.dev/go/ttarpit/debug"
 )
 
 func main() {
+  debug.Init()
+
   settings := config.Load()
 
   game := game.New(settings)