project-manager

main.go (4399B)

---

 // Command project-manager is a tool to manage projects.
 // Usage:
 //
 //	project-manager [flags]
 //
 // The flags are:
 //
 //	-config string
 //	    Path to config file (default "~/.config/ybkimm/project-manager.json")
 //
 // Configuration example:
 //
 //	{ "project-directory": "/path/to/projects", "active-directory": "/path/to/active/projects" }
 package main
 
 import (
 	"flag"
 	"fmt"
 	"os"
 	"path/filepath"
 	"syscall"
 	"unsafe"
 
 	tea "github.com/charmbracelet/bubbletea"
 	"golang.org/x/sys/unix"
 )
 
 var (
 	flagConfig = flag.String(
 		"config",
 		"~/.config/ybkimm/project-manager.json",
 		"Path to config file",
 	)
 )
 
 func main() {
 	flag.Parse()
 
 	configPath, err := expandPath(*flagConfig)
 	if err != nil {
 		panic(err)
 	}
 
 	config, err := loadConfig(configPath)
 	if err != nil {
 		panic(err)
 	}
 
 	projects, err := GetProjects(config)
 	if err != nil {
 		panic(err)
 	}
 
 	p := tea.NewProgram(newAppModel(projects))
 
 	m, err := run(p)
 	if err != nil {
 		panic(err)
 	}
 
 	if m.shouldSave {
 		fmt.Println("Saving changes...")
 		if err := saveChanges(config, m); err != nil {
 			panic(err)
 		}
 		fmt.Println("Done.")
 	}
 
 	if len(m.selectedAction) > 0 && m.selectedProject != nil {
 		projectPath := filepath.Join(config.ProjectDirectory, m.selectedProject.Name)
 		action := fmt.Sprintf(m.selectedAction, projectPath)
 
 		err := executeAction(action)
 		if err != nil {
 			panic(err)
 		}
 	}
 }
 
 func run(p *tea.Program) (appModel, error) {
 	m, err := p.Run()
 	if err != nil {
 		return appModel{}, err
 	}
 
 	return m.(appModel), nil
 }
 
 func saveChanges(config *Config, m appModel) error {
 	for _, project := range m.projects {
 		if project.IsActive {
 			if err := activateProject(config, project); err != nil {
 				return err
 			}
 		} else {
 			if err := deactivateProject(config, project); err != nil {
 				return err
 			}
 		}
 	}
 
 	return nil
 }
 
 func getPaths(config *Config, project string) (projectPath, activePath, archivePath string) {
 	projectPath = filepath.Join(config.ProjectDirectory, project)
 	activePath = filepath.Join(config.ActiveDirectory, project)
 	archivePath = filepath.Join(config.ArchivedDirectory, project)
 
 	return
 }
 
 func activateProject(config *Config, project *Project) error {
 	projectPath, activePath, archivePath := getPaths(config, project.Name)
 
 	err := removeSymlink(archivePath)
 	if err != nil {
 		return err
 	}
 
 	return createSymlink(projectPath, activePath)
 }
 
 func deactivateProject(config *Config, project *Project) error {
 	projectPath, activePath, archivePath := getPaths(config, project.Name)
 
 	err := removeSymlink(activePath)
 	if err != nil {
 		return err
 	}
 
 	return createSymlink(projectPath, archivePath)
 }
 
 // createSymlink creates symlink.
 // if symlink is already exists, ignore.
 func createSymlink(src, dst string) error {
 	if _, err := os.Stat(dst); os.IsNotExist(err) {
 		fmt.Println("Creating symlink:", src, "->", dst)
 		return os.Symlink(src, dst)
 	} else if err != nil {
 		return err
 	}
 
 	return nil
 }
 
 // removeSymlink removes symlink.
 // if symlink is not exists, ignore.
 // if path is not symlink, it warns and returns nil.
 func removeSymlink(path string) error {
 	stat, err := os.Lstat(path)
 	if os.IsNotExist(err) {
 		return nil
 	} else if err != nil {
 		return err
 	}
 
 	isSymlink := stat.Mode()&os.ModeSymlink != 0
 	if isSymlink {
 		fmt.Println("Removing symlink:", path)
 		return os.Remove(path)
 	}
 
 	fmt.Println("Warning: Not symlink:", path)
 	return nil
 }
 
 func executeAction(action string) error {
 	fmt.Println("Executing action:", action)
 
 	// Get the current terminal settings.
 	termios, err := unix.IoctlGetTermios(syscall.Stdin, unix.TIOCGETA)
 	if err != nil {
 		return err
 	}
 
 	// Set the new terminal settings to be the same as the current settings.
 	newTermios := *termios
 
 	// Enable canonical mode, which sets the terminal to send complete lines of input
 	// to the shell process.
 	newTermios.Lflag |= syscall.ICANON
 
 	// Disable echo mode, which stops the terminal from echoing input characters.
 	newTermios.Lflag &^= syscall.ECHO
 
 	// Set the new terminal settings.
 	_, _, errno := syscall.Syscall(
 		syscall.SYS_IOCTL,
 		uintptr(syscall.Stdin),
 		uintptr(syscall.TIOCSETA),
 		uintptr(unsafe.Pointer(&newTermios)),
 	)
 	if errno != 0 {
 		return errno
 	}
 
 	// Replace the current process with the shell process.
 	err = syscall.Exec("/bin/sh", []string{"/bin/sh", "-c", action}, os.Environ())
 	if err != nil {
 		return err
 	}
 
 	return nil
 }