Clean up templator with a helper function, add readme (not filled in …

cmd/create.go

@@ -32,14 +32,14 @@ func Create(projectName string, outDir string, t *templator.Templator) string {
 	if err != nil {
 		log.Printf("Error creating commit0 config: %v", err)
 	}
-	t.Commit0.Execute(f, projectName)
+	go t.Commit0.Execute(f, projectName)
 
 	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)
+	go t.GitIgnore.Execute(f, projectName)
 
 	return rootDir
 }

cmd/generate.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"log"
+	"os"
 
 	"github.com/commitdev/commit0/internal/config"
 	"github.com/commitdev/commit0/internal/generate/docker"
@@ -51,15 +52,22 @@ var generateCmd = &cobra.Command{
 		case Go:
 			proto.Generate(t, cfg)
 			golang.Generate(t, cfg)
+
 			docker.GenerateGoAppDockerFile(t, cfg)
 			docker.GenerateGoDockerCompose(t, cfg)
 		case React:
 			react.Generate(t, cfg)
 		}
 
+		f, err := os.Create("README.md")
+		if err != nil {
+			log.Printf("Error creating commit0 config: %v", err)
+		}
+		go t.Readme.Execute(f, cfg)
+
 		if cfg.Network.Http.Enabled {
-			http.GenerateHttpGW(t, cfg)
-			docker.GenerateGoHttpGWDockerFile(t, cfg)
+			http.GenerateHTTPGW(t, cfg)
+			docker.GenerateGoHTTPGWDockerFile(t, cfg)
 		}
 	},
 }

internal/generate/docker/generate.go

@@ -10,7 +10,7 @@ func GenerateGoAppDockerFile(templator *templator.Templator, config *config.Comm
 	util.TemplateFileIfDoesNotExist("docker/app", "Dockerfile", templator.Docker.ApplicationDocker, config)
 }
 
-func GenerateGoHttpGWDockerFile(templator *templator.Templator, config *config.Commit0Config) {
+func GenerateGoHTTPGWDockerFile(templator *templator.Templator, config *config.Commit0Config) {
 	util.TemplateFileIfDoesNotExist("docker/http", "Dockerfile", templator.Docker.HttpGatewayDocker, config)
 }
 

internal/generate/golang/generate.go

@@ -26,7 +26,7 @@ func GenerateGoMain(templator *templator.Templator, config *config.Commit0Config
 			log.Printf("Error: %v", err)
 		}
 
-		templator.Go.GoMain.Execute(f, config)
+		go templator.Go.GoMain.Execute(f, config)
 	} else {
 		log.Printf("main.go already exists. skipping.")
 	}
@@ -39,7 +39,7 @@ func GenerateGoMod(templator *templator.Templator, config *config.Commit0Config)
 		log.Printf("Error: %v", err)
 	}
 
-	templator.Go.GoMod.Execute(f, config)
+	go templator.Go.GoMod.Execute(f, config)
 }
 
 func GenerateServers(templator *templator.Templator, config *config.Commit0Config) {
@@ -74,7 +74,7 @@ func GenerateServers(templator *templator.Templator, config *config.Commit0Confi
 			"GitRepo":     config.GitRepo,
 		}
 
-		templator.Go.GoServer.Execute(f, data)
+		go templator.Go.GoServer.Execute(f, data)
 	}
 
 }
@@ -99,5 +99,5 @@ func GenerateHealthServer(templator *templator.Templator, config *config.Commit0
 		log.Printf("Error: %v", err)
 	}
 
-	templator.Go.GoHealthServer.Execute(f, config)
+	go templator.Go.GoHealthServer.Execute(f, config)
 }

internal/generate/http/generate.go

@@ -6,6 +6,6 @@ import (
 	"github.com/commitdev/commit0/internal/util"
 )
 
-func GenerateHttpGW(templator *templator.Templator, config *config.Commit0Config) {
-	util.TemplateFileAndOverwrite("http", "main.go", templator.Go.GoHttpGW, config)
+func GenerateHTTPGW(templator *templator.Templator, config *config.Commit0Config) {
+	util.TemplateFileAndOverwrite("http", "main.go", templator.Go.GoHTTPGW, config)
 }

internal/generate/proto/generate.go

@@ -30,7 +30,7 @@ func GenerateGoModIDL(templator *templator.Templator, config *config.Commit0Conf
 		log.Printf("Error: %v", err)
 	}
 
-	templator.Go.GoModIDL.Execute(f, config)
+	go templator.Go.GoModIDL.Execute(f, config)
 }
 
 func GenerateIDLMakefile(templator *templator.Templator, config *config.Commit0Config) {
@@ -46,7 +46,7 @@ func GenerateIDLMakefile(templator *templator.Templator, config *config.Commit0C
 	if err != nil {
 		log.Printf("Error: %v", err)
 	}
-	templator.MakefileTemplate.Execute(f, config)
+	go templator.MakefileTemplate.Execute(f, config)
 }
 
 func GenerateProtoHealth(templator *templator.Templator, config *config.Commit0Config) {
@@ -63,7 +63,7 @@ func GenerateProtoHealth(templator *templator.Templator, config *config.Commit0C
 		log.Printf("Error: %v", err)
 	}
 
-	templator.ProtoHealthTemplate.Execute(f, config)
+	go templator.ProtoHealthTemplate.Execute(f, config)
 }
 
 func GenerateServiceProtobufFiles(templator *templator.Templator, cfg *config.Commit0Config) {
@@ -88,9 +88,8 @@ func GenerateServiceProtobufFiles(templator *templator.Templator, cfg *config.Co
 			s.Name,
 		}
 
-		templator.ProtoServiceTemplate.Execute(f, data)
+		go templator.ProtoServiceTemplate.Execute(f, data)
 	}
-
 }
 
 func GenerateProtoServiceLibs(config *config.Commit0Config) {

internal/templator/templator.go

@@ -11,25 +11,29 @@ import (
 	"github.com/gobuffalo/packr/v2/file"
 )
 
+// DockerTemplator contains the templates relevent to docker
 type DockerTemplator struct {
 	ApplicationDocker *template.Template
 	HttpGatewayDocker *template.Template
 	DockerIgnore      *template.Template
 	DockerCompose     *template.Template
 }
 
+// GoTemplator contains the templates relevant to a go project
 type GoTemplator struct {
 	GoMain         *template.Template
 	GoMod          *template.Template
 	GoModIDL       *template.Template
 	GoServer       *template.Template
 	GoHealthServer *template.Template
-	GoHttpGW       *template.Template
+	GoHTTPGW       *template.Template
 }
 
+// Templator contains all the templates
 type Templator struct {
 	Commit0              *template.Template
 	GitIgnore            *template.Template
+	Readme               *template.Template
 	MakefileTemplate     *template.Template
 	ProtoHealthTemplate  *template.Template
 	ProtoServiceTemplate *template.Template
@@ -39,89 +43,53 @@ type Templator struct {
 }
 
 func NewTemplator(box *packr.Box) *Templator {
-	makeFileTemplateSource, _ := box.FindString("proto/makefile.tmpl")
-	makeFileTemplate, _ := template.New("ProtoToolTemplate").Parse(makeFileTemplateSource)
-
-	protoHealthTemplateSource, _ := box.FindString("proto/health_proto.tmpl")
-	protoHealthTemplate, _ := template.New("ProtoHealthTemplate").Parse(protoHealthTemplateSource)
-
-	protoServiceTemplateSource, _ := box.FindString("proto/service_proto.tmpl")
-	protoServiceTemplate, _ := template.New("ProtoServiceTemplate").Funcs(util.FuncMap).Parse(protoServiceTemplateSource)
-
 	return &Templator{
-		MakefileTemplate:     makeFileTemplate,
-		ProtoHealthTemplate:  protoHealthTemplate,
-		ProtoServiceTemplate: protoServiceTemplate,
+		MakefileTemplate:     NewSingleFileTemplator(box, "proto/makefile.tmpl"),
+		ProtoHealthTemplate:  NewSingleFileTemplator(box, "proto/health_proto.tmpl"),
+		ProtoServiceTemplate: NewSingleFileTemplator(box, "proto/service_proto.tmpl"),
 		Go:                   NewGoTemplator(box),
-		Commit0:              NewCommit0Templator(box),
-		GitIgnore:            NewGitIgnoreTemplator(box),
+		Commit0:              NewSingleFileTemplator(box, "commit0/commit0.tmpl"),
+		GitIgnore:            NewSingleFileTemplator(box, "util/gitignore.tmpl"),
+		Readme:               NewSingleFileTemplator(box, "util/README.tmpl"),
 		Docker:               NewDockerFileTemplator(box),
 		React:                NewDirectoryTemplator(box, "react"),
 	}
 }
 
 func NewGoTemplator(box *packr.Box) *GoTemplator {
-	goServerTemplateSource, _ := box.FindString("golang/server.tmpl")
-	goServerTemplate, _ := template.New("GoServerTemplate").Funcs(util.FuncMap).Parse(goServerTemplateSource)
-
-	goHealthTemplateSource, _ := box.FindString("golang/health_server.tmpl")
-	goHealthServerTemplate, _ := template.New("GoHealthServerTemplate").Parse(goHealthTemplateSource)
-
-	goModTemplateSource, _ := box.FindString("golang/go_mod.tmpl")
-	goModTemplate, _ := template.New("GoModTemplate").Parse(goModTemplateSource)
-
-	goModIDLTemplateSource, _ := box.FindString("golang/go_mod_idl.tmpl")
-	goModIDLTemplate, _ := template.New("GoModTemplate").Parse(goModIDLTemplateSource)
-
-	goMainTemplateSource, _ := box.FindString("golang/main.tmpl")
-	goMainTemplate, _ := template.New("GoMainTemplate").Funcs(util.FuncMap).Parse(goMainTemplateSource)
-
-	goHttpTemplateSource, _ := box.FindString("golang/http_gw.tmpl")
-	goHttpTemplate, _ := template.New("GoHttpGWTemplate").Funcs(util.FuncMap).Parse(goHttpTemplateSource)
-
 	return &GoTemplator{
-		GoMain:         goMainTemplate,
-		GoMod:          goModTemplate,
-		GoModIDL:       goModIDLTemplate,
-		GoServer:       goServerTemplate,
-		GoHealthServer: goHealthServerTemplate,
-		GoHttpGW:       goHttpTemplate,
+		GoMain:         NewSingleFileTemplator(box, "golang/main.tmpl"),
+		GoMod:          NewSingleFileTemplator(box, "golang/go_mod.tmpl"),
+		GoModIDL:       NewSingleFileTemplator(box, "golang/go_mod_idl.tmpl"),
+		GoServer:       NewSingleFileTemplator(box, "golang/server.tmpl"),
+		GoHealthServer: NewSingleFileTemplator(box, "golang/health_server.tmpl"),
+		GoHTTPGW:       NewSingleFileTemplator(box, "golang/http_gw.tmpl"),
 	}
 
 }
 
-func NewCommit0Templator(box *packr.Box) *template.Template {
-	templateSource, _ := box.FindString("commit0/commit0.tmpl")
-	template, _ := template.New("Commit0Template").Funcs(util.FuncMap).Parse(templateSource)
-
-	return template
-}
-
-func NewGitIgnoreTemplator(box *packr.Box) *template.Template {
-	templateSource, _ := box.FindString("util/gitignore.tmpl")
-	template, _ := template.New("GitIgnore").Parse(templateSource)
-	return template
-}
-
 func NewDockerFileTemplator(box *packr.Box) *DockerTemplator {
-	appTemplateSource, _ := box.FindString("docker/dockerfile_app.tmpl")
-	appTemplate, _ := template.New("AppDockerfile").Parse(appTemplateSource)
-
-	httpTemplateSource, _ := box.FindString("docker/dockerfile_http.tmpl")
-	httpTemplate, _ := template.New("HttpDockerfile").Parse(httpTemplateSource)
-
-	ignoreTemplateSource, _ := box.FindString("docker/dockerignore.tmpl")
-	ignoreTemplate, _ := template.New("Dockerignore").Parse(ignoreTemplateSource)
+	return &DockerTemplator{
+		ApplicationDocker: NewSingleFileTemplator(box, "docker/dockerfile_app.tmpl"),
+		HttpGatewayDocker: NewSingleFileTemplator(box, "docker/dockerfile_http.tmpl"),
+		DockerIgnore:      NewSingleFileTemplator(box, "docker/dockerignore.tmpl"),
+		DockerCompose:     NewSingleFileTemplator(box, "docker/dockercompose.tmpl"),
+	}
+}
 
-	composeTemplateSource, _ := box.FindString("docker/dockercompose.tmpl")
-	composeTemplate, _ := template.New("Dockercompose").Parse(composeTemplateSource)
+// NewSingleFileTemplator returns a template struct for a given template file
+func NewSingleFileTemplator(box *packr.Box, file string) *template.Template {
+	source, err := box.FindString(file)
+	if err != nil {
+		panic(err)
+	}
 
-	return &DockerTemplator{
-		ApplicationDocker: appTemplate,
-		HttpGatewayDocker: httpTemplate,
-		DockerIgnore:      ignoreTemplate,
-		DockerCompose:     composeTemplate,
+	t, err := template.New(file).Funcs(util.FuncMap).Parse(source)
+	if err != nil {
+		panic(err)
 	}
+
+	return t
 }
 
 type DirectoryTemplator struct {

templates/util/README.tmpl

@@ -0,0 +1,3 @@
+# {{.Name}}
+
+@TODO : Fill in readme about how to use all the components the user configured