Cleaned up older functions to use templating util

Author: bmonkman

cmd/create.go

@@ -7,6 +7,7 @@ import (
 	"sync"
 
 	"github.com/commitdev/commit0/internal/templator"
+	"github.com/commitdev/commit0/internal/util"
 	"github.com/gobuffalo/packr/v2"
 	"github.com/spf13/cobra"
 )
@@ -25,33 +26,10 @@ func Create(projectName string, outDir string, t *templator.Templator) string {
 	} else if err != nil {
 		log.Fatalf("Error creating root: %v ", err)
 	}
-
-	commit0ConfigPath := path.Join(rootDir, "commit0.yml")
-	log.Printf("%s", commit0ConfigPath)
-
 	var wg sync.WaitGroup
-	wg.Add(1)
-	go func() {
-		f, err := os.Create(commit0ConfigPath)
-		if err != nil {
-			log.Printf("Error creating commit0 config: %v", err)
-		}
-
-		t.Commit0.Execute(f, projectName)
-		wg.Done()
-	}()
-
-	wg.Add(1)
-	go func() {
-		gitIgnorePath := path.Join(rootDir, ".gitignore")
-		f, err := os.Create(gitIgnorePath)
-		if err != nil {
-			log.Printf("Error creating commit0 config: %v", err)
-		}
 
-		t.GitIgnore.Execute(f, projectName)
-		wg.Done()
-	}()
+	util.TemplateFileIfDoesNotExist(rootDir, "commit0.yml", t.Commit0, wg, projectName)
+	util.TemplateFileIfDoesNotExist(rootDir, ".gitignore", t.GitIgnore, wg, projectName)
 
 	wg.Wait()
 	return rootDir

cmd/generate.go

@@ -2,7 +2,6 @@ package cmd
 
 import (
 	"log"
-	"os"
 	"sync"
 
 	"github.com/commitdev/commit0/internal/config"
@@ -12,6 +11,7 @@ import (
 	"github.com/commitdev/commit0/internal/generate/proto"
 	"github.com/commitdev/commit0/internal/generate/react"
 	"github.com/commitdev/commit0/internal/templator"
+	"github.com/commitdev/commit0/internal/util"
 	"github.com/gobuffalo/packr/v2"
 	"github.com/spf13/cobra"
 )
@@ -61,16 +61,7 @@ var generateCmd = &cobra.Command{
 			react.Generate(t, cfg, wg)
 		}
 
-		f, err := os.Create("README.md")
-		if err != nil {
-			log.Printf("Error creating commit0 config: %v", err)
-		}
-
-		wg.Add(1)
-		go func() {
-			t.Readme.Execute(f, cfg)
-			wg.Done()
-		}()
+		util.TemplateFileIfDoesNotExist("", "README.md", t.Readme, wg, cfg)
 
 		if cfg.Network.Http.Enabled {
 			http.GenerateHTTPGW(t, cfg, wg)

internal/generate/golang/generate.go

@@ -3,7 +3,7 @@ package golang
 import (
 	"fmt"
 	"log"
-	"os"
+	"path/filepath"
 	"sync"
 
 	"github.com/commitdev/commit0/internal/config"
@@ -12,39 +12,12 @@ import (
 )
 
 func Generate(templator *templator.Templator, config *config.Commit0Config, wg sync.WaitGroup) {
-	GenerateGoMain(templator, config, wg)
-	GenerateGoMod(templator, config, wg)
-	GenerateHealthServer(templator, config, wg)
+	util.TemplateFileIfDoesNotExist("", "main.go", templator.Go.GoMain, wg, config)
+	util.TemplateFileIfDoesNotExist("", "go.mod", templator.Go.GoMod, wg, config)
+	util.TemplateFileIfDoesNotExist("server/health", "health.go", templator.Go.GoHealthServer, wg, config)
 	GenerateServers(templator, config, wg)
 }
 
-func GenerateGoMain(templator *templator.Templator, config *config.Commit0Config, wg sync.WaitGroup) {
-	if _, err := os.Stat("main.go"); os.IsNotExist(err) {
-
-		f, err := os.Create("main.go")
-
-		if err != nil {
-			log.Printf("Error: %v", err)
-		}
-
-		wg.Add(1)
-		go templator.Go.GoMain.Execute(f, config)
-	} else {
-		log.Printf("main.go already exists. skipping.")
-	}
-}
-
-func GenerateGoMod(templator *templator.Templator, config *config.Commit0Config, wg sync.WaitGroup) {
-	f, err := os.Create("go.mod")
-
-	if err != nil {
-		log.Printf("Error: %v", err)
-	}
-
-	wg.Add(1)
-	go templator.Go.GoMod.Execute(f, config)
-}
-
 func GenerateServers(templator *templator.Templator, config *config.Commit0Config, wg sync.WaitGroup) {
 	serverDirPath := "server"
 	err := util.CreateDirIfDoesNotExist(serverDirPath)
@@ -53,56 +26,16 @@ func GenerateServers(templator *templator.Templator, config *config.Commit0Confi
 	}
 
 	for _, s := range config.Services {
-		serverLibPath := fmt.Sprintf("%s/%s", serverDirPath, s.Name)
-		err := os.Mkdir(serverLibPath, os.ModePerm)
-		if os.IsExist(err) {
-			log.Printf("%s server exists skipping.", s.Name)
-			continue
-		}
-		log.Printf("generating %s", s.Name)
-		if err != nil {
-			log.Printf("Error generating server: %v", err)
-		}
-
-		serverFilePath := fmt.Sprintf("%s/%s.go", serverLibPath, s.Name)
-		f, err := os.Create(serverFilePath)
-
-		if err != nil {
-			log.Printf("Error: %v", err)
-		}
+		path := filepath.Join("server", s.Name)
+		file := fmt.Sprintf("%s.go", s.Name)
 
 		data := map[string]string{
 			"ProjectName": config.Name,
 			"ServiceName": s.Name,
 			"GitRepo":     config.GitRepo,
 		}
 
-		wg.Add(1)
-		go templator.Go.GoServer.Execute(f, data)
-	}
-
-}
-
-func GenerateHealthServer(templator *templator.Templator, config *config.Commit0Config, wg sync.WaitGroup) {
-	serverDirPath := "server"
-	err := util.CreateDirIfDoesNotExist(serverDirPath)
-	if err != nil {
-		log.Printf("Error creating server path: %v", err)
-	}
-
-	serverLibPath := fmt.Sprintf("%s/%s", serverDirPath, "health")
-	err = util.CreateDirIfDoesNotExist(serverLibPath)
-	if err != nil {
-		log.Printf("Error generating server: %v", err)
-	}
-
-	serverFilePath := fmt.Sprintf("%s/%s.go", serverLibPath, "health")
-	f, err := os.Create(serverFilePath)
-
-	if err != nil {
-		log.Printf("Error: %v", err)
+		util.TemplateFileIfDoesNotExist(path, file, templator.Go.GoServer, wg, data)
 	}
 
-	wg.Add(1)
-	go templator.Go.GoHealthServer.Execute(f, config)
 }

internal/generate/proto/generate.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"fmt"
 	"log"
-	"os"
 	"os/exec"
 	"sync"
 
@@ -14,76 +13,22 @@ import (
 )
 
 func Generate(templator *templator.Templator, config *config.Commit0Config, wg sync.WaitGroup) {
-	GenerateIDLMakefile(templator, config, wg)
-	GenerateProtoHealth(templator, config, wg)
-	GenerateServiceProtobufFiles(templator, config, wg)
-	GenerateGoModIDL(templator, config, wg)
-	GenerateProtoServiceLibs(config)
-}
-
-func GenerateGoModIDL(templator *templator.Templator, config *config.Commit0Config, wg sync.WaitGroup) {
 	idlPath := fmt.Sprintf("%s-idl", config.Name)
-	idlOutput := fmt.Sprintf("%s/go.mod", idlPath)
-	err := util.CreateDirIfDoesNotExist(idlPath)
-	f, err := os.Create(idlOutput)
+	idlHealthPath := fmt.Sprintf("%s/proto/health", idlPath)
 
-	if err != nil {
-		log.Printf("Error: %v", err)
-	}
-
-	wg.Add(1)
-	go templator.Go.GoModIDL.Execute(f, config)
-}
-
-func GenerateIDLMakefile(templator *templator.Templator, config *config.Commit0Config, wg sync.WaitGroup) {
-	makeFilePath := fmt.Sprintf("%s-idl", config.Name)
-	makeFileOutput := fmt.Sprintf("%s/Makefile", makeFilePath)
-
-	err := util.CreateDirIfDoesNotExist(makeFilePath)
-	if err != nil {
-		log.Printf("Error generating prototool config: %v", err)
-	}
-
-	f, err := os.Create(makeFileOutput)
-	if err != nil {
-		log.Printf("Error: %v", err)
-	}
-
-	wg.Add(1)
-	go templator.MakefileTemplate.Execute(f, config)
-}
-
-func GenerateProtoHealth(templator *templator.Templator, config *config.Commit0Config, wg sync.WaitGroup) {
-	protoHealthPath := fmt.Sprintf("%s-idl/proto/health", config.Name)
-	protoHealthOutput := fmt.Sprintf("%s/health.proto", protoHealthPath)
-
-	err := util.CreateDirIfDoesNotExist(protoHealthPath)
-	if err != nil {
-		log.Printf("Error: %v", err)
-	}
-
-	f, err := os.Create(protoHealthOutput)
-	if err != nil {
-		log.Printf("Error: %v", err)
-	}
+	util.TemplateFileIfDoesNotExist(idlPath, "go.mod", templator.Go.GoModIDL, wg, config)
+	util.TemplateFileIfDoesNotExist(idlPath, "Makefile", templator.MakefileTemplate, wg, config)
+	GenerateServiceProtobufFiles(templator, config, wg)
+	util.TemplateFileIfDoesNotExist(idlHealthPath, "health.proto", templator.ProtoHealthTemplate, wg, config)
 
-	wg.Add(1)
-	go templator.ProtoHealthTemplate.Execute(f, config)
+	GenerateProtoServiceLibs(config)
 }
 
 func GenerateServiceProtobufFiles(templator *templator.Templator, cfg *config.Commit0Config, wg sync.WaitGroup) {
 	protoPath := fmt.Sprintf("%s-idl/proto", cfg.Name)
 	for _, s := range cfg.Services {
 		serviceProtoDir := fmt.Sprintf("%s/%s", protoPath, s.Name)
-		err := os.Mkdir(serviceProtoDir, os.ModePerm)
-		if os.IsExist(err) {
-			log.Printf("%s service proto exists skipping.", s.Name)
-			continue
-		}
-
-		serviceProtoFilePath := fmt.Sprintf("%s/%s.proto", serviceProtoDir, s.Name)
-
-		f, err := os.Create(serviceProtoFilePath)
+		file := fmt.Sprintf("%s.proto", s.Name)
 
 		data := struct {
 			*config.Commit0Config
@@ -93,8 +38,7 @@ func GenerateServiceProtobufFiles(templator *templator.Templator, cfg *config.Co
 			s.Name,
 		}
 
-		wg.Add(1)
-		go templator.ProtoServiceTemplate.Execute(f, data)
+		util.TemplateFileIfDoesNotExist(serviceProtoDir, file, templator.ProtoServiceTemplate, wg, data)
 	}
 }