feat: refactoring

Author: tyzerrr

cmd/sessionizer.go

@@ -3,6 +3,7 @@ package cmd
 import (
 	"context"
 	"errors"
+	"fmt"
 	"os"
 	"os/signal"
 
@@ -40,8 +41,15 @@ func newCmd() *cli.Command {
 
 func run(ctx context.Context, cmd *cli.Command) error {
 	pathResolver := handler.NewPathResolver()
-	configParser := handler.NewConfigParser(pathResolver)
-	sh := handler.NewSessionHandler(configParser, pathResolver)
+	config, err := handler.NewConfigParser(pathResolver).ReadConfig()
+	if err != nil {
+		return fmt.Errorf("failed to run tmux-sessionizer because failed to read configration files: %w", err)
+	}
+	projectNameFullPathMap, projectExpressionNameMap, err := pathResolver.BuildProjectInfo(config)
+	if err != nil {
+		return fmt.Errorf("failed to build project information from .tmux-sessionizer config files: %w", err)
+	}
+	sh := handler.NewSessionHandler(config, pathResolver, projectNameFullPathMap, projectExpressionNameMap)
 	return runWithHandler(sh, ctx, cmd)
 }
 

handler/config_parser.go

@@ -2,6 +2,7 @@ package handler
 
 import (
 	"bufio"
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -33,15 +34,17 @@ func NewConfigParser(pr *PathResolver) *ConfigParser {
 	}
 }
 
-func (c *ConfigParser) ReadConfig() *Config {
+func (c *ConfigParser) ReadConfig() (*Config, error) {
 	var configFiles = []string{"./.tmux-sessionizer", "~/.tmux-sessionizer"}
 	for _, cf := range configFiles {
 		config, err := c.ParseConfig(cf)
 		if err == nil {
-			return config
+			return config, nil
+		} else {
+			return nil, err
 		}
 	}
-	return nil
+	return nil, errors.New("failed to read both config files, ${pwd}/.tmux-sessionizer, ${HOME}/.tmux-sessionizer")
 }
 
 func (c *ConfigParser) ParseConfig(configFile string) (*Config, error) {

handler/handler.go

@@ -15,56 +15,48 @@ import (
 	"github.com/manifoldco/promptui"
 )
 
-type ISessionHandler interface {
-	NewSession(ctx context.Context) error
-	GrabExistingSession(ctx context.Context) error
-	CreateNewProjectSession(ctx context.Context) error
-	DeleteProjectSession(ctx context.Context) error
-}
-
 type SessionHandler struct {
-	c IConfigParser
-	p IPathResolver
+	config                   *Config
+	pathResolver             *PathResolver
+	projectNameFullPathMap   map[string]string
+	projectExpressionNameMap map[string]string
 }
 
-func NewSessionHandler(configParser IConfigParser, pathResolver IPathResolver) ISessionHandler {
+func NewSessionHandler(config *Config, pathResolver *PathResolver,
+	projectNameFullPathMap, projectExpressionNameMap map[string]string) ISessionHandler {
 	return &SessionHandler{
-		c: configParser,
-		p: pathResolver,
+		config:                   config,
+		pathResolver:             pathResolver,
+		projectNameFullPathMap:   projectNameFullPathMap,
+		projectExpressionNameMap: projectExpressionNameMap,
 	}
 }
 
 func (sh *SessionHandler) NewSession(ctx context.Context) error {
-	config := sh.c.ReadConfig()
-	if config == nil {
-		return errors.New("failed to create new project from projects")
-	}
 	/*build fzf input and build hashmap to retrieve filepath from entry's name.*/
 	var input bytes.Buffer
-	projectNameFullPathMap, projectExpressionNameMap := make(map[string]string, 0), make(map[string]string, 0)
-	for _, project := range config.Projects {
-		replaced, err := sh.p.ReplaceHomeDir(project.filepath)
+	for _, project := range sh.config.Projects {
+		replaced, err := sh.pathResolver.ReplaceHomeDir(project.filepath)
 		if err != nil {
 			return errors.New("failed to replace home directory to ~")
 		}
 		input.WriteString(replaced + "\n")
-		projectNameFullPathMap[project.name] = project.filepath
-		projectExpressionNameMap[replaced] = project.name
 	}
 	fzfOut, err := sh.toFzf(input)
 	if err != nil {
 		return fmt.Errorf("failed to create new project from projects: %w", err)
 	}
-	sessionName := projectExpressionNameMap[strings.Trim(fzfOut.String(), "\n")]
+
+	sessionName := sh.projectExpressionNameMap[strings.Trim(fzfOut.String(), "\n")]
 	if sh.isInSession() {
-		return sh.switchToNewClient(sessionName, projectNameFullPathMap[sessionName])
+		return sh.switchToNewClient(sessionName, sh.projectNameFullPathMap[sessionName])
 	}
 	if sh.sessionExists(sessionName) {
 		return sh.attach(sessionName)
 	}
 	if err := sh.newTmuxCmd(
 		"tmux", "new-session", "-s",
-		sessionName, "-c", projectNameFullPathMap[sessionName]).Run(); err != nil {
+		sessionName, "-c", sh.projectNameFullPathMap[sessionName]).Run(); err != nil {
 		return fmt.Errorf("failed to create new session %w: ", err)
 	}
 	return nil
@@ -106,7 +98,7 @@ func (sh *SessionHandler) CreateNewProjectSession(ctx context.Context) error {
 		if err != nil {
 			return fmt.Errorf("faield to get new project information interactively: %w", err)
 		}
-		newProjectPath, err := sh.p.ExpandPath(filepath.Join(parentDir, fmt.Sprintf("%v/", newProjectName)))
+		newProjectPath, err := sh.pathResolver.ExpandPath(filepath.Join(parentDir, fmt.Sprintf("%v/", newProjectName)))
 		if err != nil {
 			return fmt.Errorf("failed to expand path: %w", err)
 		}
@@ -212,7 +204,7 @@ func (sh *SessionHandler) buildParentDirSet() (map[string]struct{}, error) {
 	var configFiles = []string{"./.tmux-sessionizer", "~/.tmux-sessionizer"}
 	parentDirSet := make(map[string]struct{}, 0)
 	for _, configFile := range configFiles {
-		path, err := sh.p.ExpandPath(configFile)
+		path, err := sh.pathResolver.ExpandPath(configFile)
 		if err != nil {
 			return nil, fmt.Errorf("failed to expand path: %w", err)
 		}

handler/interface.go

@@ -1,5 +1,7 @@
 package handler
 
+import "context"
+
 type IConfigParser interface {
 	ReadConfig() *Config
 	ParseConfig(configFile string) (*Config, error)
@@ -9,3 +11,10 @@ type IPathResolver interface {
 	ExpandPath(path string) (string, error)
 	ReplaceHomeDir(fullpath string) (string, error)
 }
+
+type ISessionHandler interface {
+	NewSession(ctx context.Context) error
+	GrabExistingSession(ctx context.Context) error
+	CreateNewProjectSession(ctx context.Context) error
+	DeleteProjectSession(ctx context.Context) error
+}

handler/path_resolver.go

@@ -1,6 +1,8 @@
 package handler
 
 import (
+	"bytes"
+	"errors"
 	"os"
 	"path/filepath"
 	"strings"
@@ -30,3 +32,18 @@ func (p *PathResolver) ReplaceHomeDir(fullpath string) (string, error) {
 	}
 	return strings.Replace(fullpath, home, "~", 1), nil
 }
+
+func (p *PathResolver) BuildProjectInfo(config *Config) (map[string]string, map[string]string, error) {
+	var input bytes.Buffer
+	projectNameFullPathMap, projectExpressionNameMap := make(map[string]string, 0), make(map[string]string, 0)
+	for _, project := range config.Projects {
+		replaced, err := p.ReplaceHomeDir(project.filepath)
+		if err != nil {
+			return nil, nil, errors.New("failed to replace home directory to ~")
+		}
+		input.WriteString(replaced + "\n")
+		projectNameFullPathMap[project.name] = project.filepath
+		projectExpressionNameMap[replaced] = project.name
+	}
+	return projectNameFullPathMap, projectExpressionNameMap, nil
+}