Snapshot

cmd/jn/main.go

@@ -12,7 +12,7 @@ func main() {
 	args := os.Args[1:]
 	entry := internal.NewEntry()
 	template := internal.NewTemplate()
-	templateExists, _ := internal.Exists(template.FullPath)
+	templateExists, _ := template.Exists()
 
 	if len(args) > 0 && args[0] == "journal" {
 		cmd := exec.Command("open", entry.RootPath)
@@ -21,70 +21,42 @@ func main() {
 	}
 
 	if len(args) > 0 && args[0] == "template" {
-		openTemplateCmd := exec.Command("open", template.FullPath)
-
 		if templateExists {
-			internal.RunCmd(openTemplateCmd)
+			template.Launch()
 			return
 		} else {
-			createEntry(template.RootPath, template.FullPath)
-			internal.RunCmd(openTemplateCmd)
+			_, err := template.Create()
+			if err != nil {
+				log.Fatal("Could not create template: ", err)
+			}
+			template.Launch()
 			return
 		}
 	}
 
-	openEntryCmd := exec.Command("open", entry.FullPath)
-	entryExists, _ := internal.Exists(entry.FullPath)
-
-	if entryExists {
-		internal.RunCmd(openEntryCmd)
-		return
-	}
-
-	if templateExists {
-		createEntryFromTemplate(entry.FolderPath, entry.FullPath, template.FullPath)
-	} else {
-		createEntry(entry.FolderPath, entry.FullPath)
-	}
-
-	internal.RunCmd(openEntryCmd)
-}
-
-func createEntry(folderPath string, entryPath string) {
-	err := os.MkdirAll(folderPath, 0700)
+	entryExists, err := entry.Exists()
 	if err != nil {
-		log.Fatal("Could not create new folder", err)
+		log.Fatal("Could not determine if entry exists: ", err)
 	}
 
-	_, err = os.Create(entryPath)
-	if err != nil {
-		log.Fatal("Could not create new entry", err)
-	}
-}
-
-func createEntryFromTemplate(folderPath string, entryPath string, templatePath string) {
-	err := os.MkdirAll(folderPath, 0700)
-	if err != nil {
-		log.Fatal("Could not create new folder", err)
+	if entryExists {
+		entry.Launch()
+		return
 	}
 
-	templateContent, err := os.ReadFile(templatePath)
+	_, err = entry.Create()
 	if err != nil {
-		log.Fatal("Could not read template", err)
+		log.Fatal("Could not create entry: ", err)
 	}
 
-	file, err := os.Create(entryPath)
-	if err != nil {
-		log.Fatal("Could not create new entry", err)
-	}
+	if templateExists {
+		templateContent, err := template.Read()
 
-	_, err = file.Write(templateContent)
-	if err != nil {
-		log.Fatal("Could not write template to new entry", err)
+		err = entry.Write(templateContent)
+		if err != nil {
+			log.Fatal("Could not write template contents to entry: ", err)
+		}
 	}
 
-	err = file.Close()
-	if err != nil {
-		log.Fatal("Could not close new entry", err)
-	}
+	entry.Launch()
 }

internal/entry.go

@@ -2,6 +2,8 @@ package internal
 
 import (
 	"fmt"
+	"os"
+	"os/exec"
 	"path"
 	"time"
 )
@@ -30,3 +32,42 @@ func NewEntry() Entry {
 		FullPath:      path.Join(folderPath, entryName),
 	}
 }
+
+func (e *Entry) Create() (*os.File, error) {
+	err := os.MkdirAll(e.FolderPath, 0700)
+	if err != nil {
+		return nil, err
+	}
+
+	file, err := os.Create(e.FullPath)
+	if err != nil {
+		return nil, err
+	}
+
+	return file, nil
+}
+
+func (e *Entry) Write(content []byte) error {
+	file, err := os.Open(e.FullPath)
+
+	_, err = file.Write(content)
+	if err != nil {
+		return err
+	}
+
+	err = file.Close()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (e *Entry) Launch() {
+	cmd := exec.Command("open", e.FullPath)
+	RunCmd(cmd)
+}
+
+func (e *Entry) Exists() (bool, error) {
+	return Exists(e.FullPath)
+}

internal/template.go

@@ -1,10 +1,15 @@
 package internal
 
-import "path"
+import (
+	"os"
+	"os/exec"
+	"path"
+)
 
 type Template struct {
 	FileExtension string
 	RootPath      string
+	FolderPath    string
 	FullPath      string
 }
 
@@ -16,6 +21,34 @@ func NewTemplate() Template {
 	return Template{
 		FileExtension: fileExtension,
 		RootPath:      rootPath,
+		FolderPath:    path.Join(rootPath, "journal"),
 		FullPath:      fullPath,
 	}
 }
+
+func (t *Template) Create() (*os.File, error) {
+	err := os.MkdirAll(t.FolderPath, 0700)
+	if err != nil {
+		return nil, err
+	}
+
+	file, err := os.Create(t.FullPath)
+	if err != nil {
+		return nil, err
+	}
+
+	return file, nil
+}
+
+func (t *Template) Read() ([]byte, error) {
+	return os.ReadFile(t.FullPath)
+}
+
+func (t *Template) Launch() {
+	cmd := exec.Command("open", t.FullPath)
+	RunCmd(cmd)
+}
+
+func (t *Template) Exists() (bool, error) {
+	return Exists(t.FullPath)
+}