Merge branch 'remote'

Author: blackmarllborooo

README.md

@@ -31,17 +31,19 @@ to be called. For example `cps my-app`.
 2. Layout of the main file;
 3. File `go.mod` with project name;
 4. Makefile with parameters:
-   1. build: builds the application;
-   2. run: start the app in dev mode;
-   3. test: rub all tests;
-   4. lint: checks your project for design errors;
-5. Creates a local repository
+   1. `build`: builds the application;
+   2. `run`: start the app in dev mode;
+   3. `test`: rub all tests;
+   4. `lint`: checks your project for design errors;
+5. Creates a local repository;
+6. Create a configuration file for `golangci-lint`;
 
 ### What is expected next?
 
 Expected in upcoming updates:
 
-1. Adding configuration for **golangci-lint**
+1. Building the project in PKGBUILD;
+2. Add some flags to select the type of project, some values (eg port for the server) in the terminal;
 
 ### Conclusion
 

cmd/create-project-struct.go

@@ -4,25 +4,29 @@ import (
 	"github.com/blackmarllboro/create-project-struct/internal/app/dir"
 	"github.com/blackmarllboro/create-project-struct/internal/app/file"
 	"github.com/blackmarllboro/create-project-struct/internal/pkg/args"
-	"github.com/blackmarllboro/create-project-struct/internal/pkg/git"
 	"github.com/blackmarllboro/create-project-struct/internal/pkg/log"
+	"github.com/blackmarllboro/create-project-struct/internal/pkg/temp"
+	"github.com/blackmarllboro/create-project-struct/pkg/git"
 
 	l "github.com/charmbracelet/log"
 )
 
 func main() {
 	logger := log.NewLogger(l.New())
+	projName := args.NewArgs()
+	template := temp.NewTemp()
+	newFile := file.NewFile(template)
+	project := dir.NewDirs(newFile, projName)
 
-	projName := args.ProjectName{}
-
-	project := dir.NewDirs(file.NewFile(), projName)
 	if err := project.CreateProject(); err != nil {
 		logger.Error(err)
+		return
 	}
 
 	if err := git.CreateLocalGitRepository(projName); err != nil {
 		logger.Error(err)
+		return
 	}
 
-	logger.Info("the project dir has been successfully created")
+	logger.Info("The project dir has been successfully created")
 }

internal/app/dir/dir.go

@@ -1,13 +1,12 @@
 package dir
 
 import (
-	"errors"
 	"fmt"
-	"github.com/blackmarllboro/create-project-struct/internal/pkg/args"
 	"os"
 	"path"
 
-	"github.com/blackmarllboro/create-project-struct/internal/app/file"
+	fileI "github.com/blackmarllboro/create-project-struct/internal/app/file/interfaces"
+	argsI "github.com/blackmarllboro/create-project-struct/internal/pkg/args/interfaces"
 )
 
 const perm = 0755 // Access rights to create folders
@@ -24,21 +23,22 @@ const (
 type Dirs struct {
 	projectName  string
 	isCurrentDir bool
-	file         *file.File
-	name         args.GetProjectName
+
+	file fileI.File
+	name argsI.GetProjectName
 }
 
-func NewDirs(f *file.File, p args.ProjectName) *Dirs {
-	return &Dirs{file: f, name: p}
+func NewDirs(file fileI.File, name argsI.GetProjectName) *Dirs {
+	return &Dirs{file: file, name: name}
 }
 
 func (d *Dirs) CreateProject() error {
 	if err := d.createProjectDir(); err != nil {
-		return err
+		return fmt.Errorf("failed to create project directory: %v", err)
 	}
 
 	if err := d.createProjectDirs(); err != nil {
-		return err
+		return fmt.Errorf("failed to create project directories: %v", err)
 	}
 
 	return nil
@@ -49,12 +49,12 @@ func (d *Dirs) createProjectDir() error {
 	d.projectName = path.Base(projectDir)
 	d.isCurrentDir = currentDir
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to get project name, err: %s", err)
 	}
 
 	if !currentDir {
 		if err := os.Mkdir(d.projectName, perm); err != nil {
-			return errors.New("this directory already exists")
+			return fmt.Errorf("failed to create dir, err: %v", err)
 		}
 	}
 
@@ -75,17 +75,17 @@ func (d *Dirs) createProjectDirs() error {
 		}
 
 		if err := os.Mkdir(dir, perm); err != nil {
-			return err
+			return fmt.Errorf("failed to create dir, err: %v", err)
 		}
 
-		// depending on the current directory being created, create files or subdirectories.
-		if err := d.createFilesInSubdirs(currentDir, dir); err != nil {
-			return err
-		}
 	}
 
-	if err := d.file.GenerateFilesInMainDir(d.projectName, d.isCurrentDir); err != nil {
-		return err
+	if err := d.createInternalSubDir(); err != nil {
+		return fmt.Errorf("failed to create internal sub dir, err: %v", err)
+	}
+
+	if err := d.file.GenerateFiles(d.isCurrentDir, d.projectName); err != nil {
+		return fmt.Errorf("failed to generate files, err: %v", err)
 	}
 
 	return nil
@@ -99,32 +99,13 @@ func (d *Dirs) createInternalSubDir() error {
 
 		var createSubDirPath string
 		if !d.isCurrentDir {
-			createSubDirPath = d.projectName + "/" + internalDir + "/" + currentDir
+			createSubDirPath = fmt.Sprintf("%s/%s/%s", d.projectName, internalDir, currentDir)
 		} else {
-			createSubDirPath = internalDir + "/" + currentDir
+			createSubDirPath = fmt.Sprintf("%s/%s", internalDir, currentDir)
 		}
 
 		if err := os.Mkdir(createSubDirPath, perm); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (d *Dirs) createFilesInSubdirs(currentDir, dir string) error {
-	switch currentDir {
-	case cmdDir:
-		if err := d.file.GenerateMainFile(dir + fmt.Sprintf("/%s", d.projectName) + ".go"); err != nil {
-			return err
-		}
-	case internalDir:
-		if err := d.createInternalSubDir(); err != nil {
-			return err
-		}
-	case cfgDir:
-		if err := d.file.GenerateCfgFile(dir); err != nil {
-			return err
+			return fmt.Errorf("failed to create dir, err: %v", err)
 		}
 	}
 

internal/app/file/file.go

@@ -3,131 +3,89 @@ package file
 import (
 	"fmt"
 	"os"
-	"path"
 
 	"github.com/blackmarllboro/create-project-struct/pkg/version"
+
+	"github.com/blackmarllboro/create-project-struct/internal/pkg/temp/interfaces"
 )
 
-type File struct{}
+type File struct {
+	temp interfaces.Template
+}
 
-func NewFile() *File {
-	return &File{}
+func NewFile(temp interfaces.Template) *File {
+	return &File{temp: temp}
 }
 
 func (fl File) createAndWriteFile(dir, content string) error {
 	file, err := os.Create(dir)
 	if err != nil {
 		return err
 	}
+
 	defer func() {
 		err = file.Close()
 	}()
+
 	if err != nil {
 		return err
 	}
 
 	if _, err := file.WriteString(content); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (fl File) GenerateMainFile(dir string) error {
-	const content = `
-package main
-
-import "fmt"
-
-func main() {
-	fmt.Println("Hello!")
-}
-`
-
-	if err := fl.createAndWriteFile(dir, content); err != nil {
-		return err
+		return fmt.Errorf("failed to write file, err: %v", err)
 	}
 
 	return nil
 }
 
-func (fl File) GenerateCfgFile(dir string) error {
-	if err := fl.createAndWriteFile(dir+"/config.yaml", ""); err != nil {
-		return err
+func (fl File) getFileContent(fileName, projectName, goVersion string) string {
+	switch fileName {
+	case fmt.Sprintf("%s.go", projectName):
+		return fl.temp.GetMain()
+	case "golangci.yml":
+		return fl.temp.GetLintConfig()
+	case "Makefile":
+		return fl.temp.GetMakefile(projectName)
+	case "go.mod":
+		return fl.temp.GetGoMod(projectName, goVersion)
+	default:
+		return ""
 	}
-
-	return nil
 }
 
-func (fl File) generateGoModFile(dir string, isCurrentDir bool) error {
+func (fl File) GenerateFiles(isCurrentDir bool, projectName string) error {
 	goVersion, err := version.GoVersion()
 	if err != nil {
-		return err
-	}
-
-	projectName := path.Base(dir)
-
-	content := fmt.Sprintf("module %s\n\n%s", projectName, goVersion)
-
-	var creatingFile string
-	if isCurrentDir {
-		creatingFile = "go.mod"
-	} else {
-		creatingFile = projectName + "/go.mod"
+		return fmt.Errorf("failed to get go version, err: %v", err)
 	}
 
-	if err := fl.createAndWriteFile(creatingFile, content); err != nil {
-		return err
+	mainGoFile := fmt.Sprintf("%s.go", projectName)
+	fileNames := []string{
+		mainGoFile,
+		"golangci.yml",
+		"Makefile",
+		"go.mod",
+		"config.yml",
 	}
 
-	return nil
-}
-
-func (fl File) generateMakefile(projectName string, isCurrentDir bool) error {
+	dirPrefix := "./"
 	if !isCurrentDir {
-		projectName = path.Base(projectName)
-	}
-
-	content := fmt.Sprintf(
-		"PROJECT_NAME = %s\n"+
-			"PROJECT_PATH = cmd/$(PROJECT_NAME).go\n\n"+
-			".PHONY:run\nrun:\n\tgo run $(PROJECT_PATH)\n\n"+
-			".PHONY:build\nbuild:\n\tgo build -o bin/$(PROGRAM_NAME) $(PROJECT_PATH)\n\n"+
-			".PHONY:test\ntest:\n\tgo test ./...\n\n"+
-			".PHONY:lint\nlint:\n\tgolangci-lint run",
-		projectName,
-	)
-
-	var creatingFile string
-	if isCurrentDir {
-		creatingFile = "Makefile"
-	} else {
-		creatingFile = projectName + "/Makefile"
-	}
-
-	if err := fl.createAndWriteFile(creatingFile, content); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (fl File) GenerateFilesInMainDir(projectName string, isCurrentDir bool) error {
-	currentDir, err := os.Getwd()
-	if err != nil {
-		return err
+		dirPrefix = fmt.Sprintf("%s/", projectName)
 	}
 
-	if !isCurrentDir {
-		currentDir += fmt.Sprintf("/%s", projectName)
-	}
+	for _, fileName := range fileNames {
+		filePath := dirPrefix + fileName
 
-	if err := fl.generateGoModFile(currentDir, isCurrentDir); err != nil {
-		return err
-	}
+		switch fileName {
+		case mainGoFile:
+			filePath = fmt.Sprintf("%s/cmd/%s", dirPrefix, fileName)
+		case "config.yml":
+			filePath = fmt.Sprintf("%s/config/%s", dirPrefix, fileName)
+		}
 
-	if err := fl.generateMakefile(currentDir, isCurrentDir); err != nil {
-		return err
+		if err := fl.createAndWriteFile(filePath, fl.getFileContent(fileName, projectName, goVersion)); err != nil {
+			return fmt.Errorf("failed to write file data, err: %v", err)
+		}
 	}
 
 	return nil

internal/app/file/interfaces/file.go

@@ -0,0 +1,5 @@
+package interfaces
+
+type File interface {
+	GenerateFiles(isCurrentDir bool, projectName string) error
+}

internal/pkg/args/args.go

@@ -2,16 +2,21 @@ package args
 
 import (
 	"errors"
+	"fmt"
 	"os"
 )
 
-type ProjectName struct{}
+type Args struct{}
+
+func NewArgs() *Args {
+	return &Args{}
+}
 
 // GetProjectName function for getting the project name. The name is specified
 // via a command line argument. Set the argument "." to create a project in the
 // current directory. Boolean value returns true if the application is created in
 // the current directory.
-func (p ProjectName) GetProjectName() (string, bool, error) {
+func (p Args) GetProjectName() (string, bool, error) {
 	if len(os.Args) < 2 {
 		return "", false, errors.New("the project name has not been transferred")
 	}
@@ -21,7 +26,7 @@ func (p ProjectName) GetProjectName() (string, bool, error) {
 	if projectName == "." {
 		pwd, err := os.Getwd()
 		if err != nil {
-			return "", false, err
+			return "", false, fmt.Errorf("failed to get the current directory, err: %s", err)
 		}
 
 		return pwd, true, nil