refactor(ParallelRunner): support command execution

Author: pot-code

add/add_react_component.go

@@ -12,30 +12,30 @@ import (
 )
 
 type AddReactComponent struct {
-	recipe *util.GenerationRecipe
-	gen    core.Generator
+	composer *util.TaskComposer
+	runner   core.Generator
 }
 
 var _ core.Executor = AddReactComponent{}
 
 func NewAddReactComponent(name string) *AddReactComponent {
-	recipe := util.NewGenerationRecipe("",
-		&util.GenerationMaterial{
+	composer := util.NewTaskComposer("",
+		&core.FileDesc{
 			Path: fmt.Sprintf("%s.%s", name, "tsx"),
-			Provider: func() []byte {
+			Data: func() []byte {
 				var buf bytes.Buffer
 
 				templates.WriteReactComponent(&buf, name)
 				return buf.Bytes()
 			},
 		},
 	)
-	return &AddReactComponent{recipe: recipe}
+	return &AddReactComponent{composer: composer}
 }
 
 func (atn AddReactComponent) Run() error {
-	log.Debugf("generation tree:\n%s", atn.recipe.GetGenerationTree())
-	gen := atn.recipe.MakeGenerator()
-	atn.gen = gen
-	return errors.Wrap(gen.Run(), "failed to generate react component")
+	log.Debugf("runnereration tree:\n%s", atn.composer.GetGenerationTree())
+	runner := atn.composer.MakeRunner()
+	atn.runner = runner
+	return errors.Wrap(runner.Run(), "failed to runnererate react component")
 }

add/add_react_hook.go

@@ -12,30 +12,30 @@ import (
 )
 
 type AddReactHook struct {
-	recipe *util.GenerationRecipe
-	gen    core.Generator
+	composer *util.TaskComposer
+	runner   core.Generator
 }
 
 var _ core.Executor = AddReactHook{}
 
 func NewAddReactHook(name string) *AddReactHook {
-	recipe := util.NewGenerationRecipe("",
-		&util.GenerationMaterial{
+	composer := util.NewTaskComposer("",
+		&core.FileDesc{
 			Path: fmt.Sprintf("%s.%s", name, "ts"),
-			Provider: func() []byte {
+			Data: func() []byte {
 				var buf bytes.Buffer
 
 				templates.WriteReactHook(&buf, name)
 				return buf.Bytes()
 			},
 		},
 	)
-	return &AddReactHook{recipe: recipe}
+	return &AddReactHook{composer: composer}
 }
 
 func (atn AddReactHook) Run() error {
-	log.Debugf("generation tree:\n%s", atn.recipe.GetGenerationTree())
-	gen := atn.recipe.MakeGenerator()
-	atn.gen = gen
-	return errors.Wrap(gen.Run(), "failed to generate react hook")
+	log.Debugf("runnereration tree:\n%s", atn.composer.GetGenerationTree())
+	runner := atn.composer.MakeRunner()
+	atn.runner = runner
+	return errors.Wrap(runner.Run(), "failed to runnererate react hook")
 }

add/add_typescript_node.go

@@ -11,53 +11,55 @@ import (
 )
 
 type AddTypescriptToNode struct {
-	recipe *util.GenerationRecipe
-	gen    core.Generator
+	composer *util.TaskComposer
+	runner   core.Generator
 }
 
-var _ core.Executor = AddTypescriptToNode{}
+var _ core.Generator = AddTypescriptToNode{}
 
 func NewAddTypescriptToNode() *AddTypescriptToNode {
-	recipe := util.NewGenerationRecipe("",
-		&util.GenerationMaterial{
+	composer := util.NewTaskComposer("",
+		&core.FileDesc{
 			Path: ".eslintrc.js",
-			Provider: func() []byte {
+			Data: func() []byte {
 				var buf bytes.Buffer
 
 				templates.WriteNodeEslintrc(&buf)
 				return buf.Bytes()
 			},
 		},
-		&util.GenerationMaterial{
+		&core.FileDesc{
 			Path: "tsconfig.json",
-			Provider: func() []byte {
+			Data: func() []byte {
 				var buf bytes.Buffer
 
 				templates.WriteNodeTsConfig(&buf)
 				return buf.Bytes()
 			},
 		},
 	)
-	return &AddTypescriptToNode{recipe: recipe}
+	composer.AddCommand(&core.Command{
+		Bin: "npm",
+		Args: []string{"i", "-D",
+			"typescript",
+			"eslint",
+			"@typescript-eslint/eslint-plugin",
+			"eslint-plugin-prettier",
+			"@typescript-eslint/parser",
+			"eslint-config-prettier",
+			"eslint-plugin-import",
+		},
+	})
+	return &AddTypescriptToNode{composer: composer}
 }
 
 func (atn AddTypescriptToNode) Run() error {
-	cmd := core.NewCmdExecutor("npm", "i", "-D",
-		"typescript",
-		"eslint",
-		"@typescript-eslint/eslint-plugin",
-		"eslint-plugin-prettier",
-		"@typescript-eslint/parser",
-		"eslint-config-prettier",
-		"eslint-plugin-import",
-	)
-
-	if err := cmd.Run(); err != nil {
-		return errors.Wrap(err, "failed to install dependencies")
-	}
+	log.Debugf("generation tree:\n%s", atn.composer.GetGenerationTree())
+	runner := atn.composer.MakeRunner()
+	atn.runner = runner
+	return errors.Wrap(runner.Run(), "failed to generate typescript config")
+}
 
-	log.Debugf("generation tree:\n%s", atn.recipe.GetGenerationTree())
-	gen := atn.recipe.MakeGenerator()
-	atn.gen = gen
-	return errors.Wrap(gen.Run(), "failed to generate typescript config")
+func (atn AddTypescriptToNode) Cleanup() error {
+	return atn.runner.Cleanup()
 }

add/add_typescript_react.go

@@ -11,60 +11,62 @@ import (
 )
 
 type AddTypescriptToReact struct {
-	recipe *util.GenerationRecipe
-	gen    core.Generator
+	composer *util.TaskComposer
+	runner   core.Generator
 }
 
-var _ core.Executor = AddTypescriptToReact{}
+var _ core.Generator = AddTypescriptToReact{}
 
 func NewAddTypescriptToReact() *AddTypescriptToReact {
-	recipe := util.NewGenerationRecipe("",
-		&util.GenerationMaterial{
+	composer := util.NewTaskComposer("",
+		&core.FileDesc{
 			Path: ".eslintrc.js",
-			Provider: func() []byte {
+			Data: func() []byte {
 				var buf bytes.Buffer
 
 				templates.WriteReactEslintrc(&buf)
 				return buf.Bytes()
 			},
 		},
-		&util.GenerationMaterial{
+		&core.FileDesc{
 			Path: "tsconfig.json",
-			Provider: func() []byte {
+			Data: func() []byte {
 				var buf bytes.Buffer
 
 				templates.WriteReactTsConfig(&buf)
 				return buf.Bytes()
 			},
 		},
 	)
-	return &AddTypescriptToReact{recipe: recipe}
+	composer.AddCommand(&core.Command{
+		Bin: "npm",
+		Args: []string{"i", "-D",
+			"@typescript-eslint/eslint-plugin",
+			"@typescript-eslint/parser",
+			"eslint",
+			"eslint-config-airbnb",
+			"eslint-config-prettier",
+			"eslint-import-resolver-typescript",
+			"eslint-plugin-import",
+			"eslint-plugin-jsx-a11y",
+			"eslint-plugin-prettier",
+			"eslint-plugin-react",
+			"eslint-plugin-react-hooks",
+			"prettier",
+			"prettier-eslint",
+			"typescript",
+		},
+	})
+	return &AddTypescriptToReact{composer: composer}
 }
 
 func (atr AddTypescriptToReact) Run() error {
-	cmd := core.NewCmdExecutor("npm", "i", "-D",
-		"@typescript-eslint/eslint-plugin",
-		"@typescript-eslint/parser",
-		"eslint",
-		"eslint-config-airbnb",
-		"eslint-config-prettier",
-		"eslint-import-resolver-typescript",
-		"eslint-plugin-import",
-		"eslint-plugin-jsx-a11y",
-		"eslint-plugin-prettier",
-		"eslint-plugin-react",
-		"eslint-plugin-react-hooks",
-		"prettier",
-		"prettier-eslint",
-		"typescript",
-	)
-
-	if err := cmd.Run(); err != nil {
-		return errors.Wrap(err, "failed to install dependencies")
-	}
+	log.Debugf("runnereration tree:\n%s", atr.composer.GetGenerationTree())
+	runner := atr.composer.MakeRunner()
+	atr.runner = runner
+	return errors.Wrap(runner.Run(), "failed to runnererate typescript config")
+}
 
-	log.Debugf("generation tree:\n%s", atr.recipe.GetGenerationTree())
-	gen := atr.recipe.MakeGenerator()
-	atr.gen = gen
-	return errors.Wrap(gen.Run(), "failed to generate typescript config")
+func (atr AddTypescriptToReact) Cleanup() error {
+	return atr.runner.Cleanup()
 }

core/executor.go

@@ -1,6 +1,7 @@
 package core
 
 import (
+	"fmt"
 	"os"
 	"os/exec"
 	"strings"
@@ -9,24 +10,30 @@ import (
 	log "github.com/sirupsen/logrus"
 )
 
+type Command struct {
+	Bin  string
+	Args []string
+}
+
+func (c Command) String() string {
+	return fmt.Sprintf("%s %s", c.Bin, strings.Join(c.Args, " "))
+}
+
 type CmdExecutor struct {
-	name string
-	args []string
+	cmd *Command
 }
 
 var _ Executor = CmdExecutor{}
 
-func NewCmdExecutor(bin string, args ...string) *CmdExecutor {
-	return &CmdExecutor{bin, args}
+func NewCmdExecutor(cmd *Command) *CmdExecutor {
+	return &CmdExecutor{cmd}
 }
 
 func (ce CmdExecutor) Run() error {
-	log.WithFields(log.Fields{
-		"bin":  ce.name,
-		"args": ce.args,
-	}).Debug("execute command")
-	cmd := exec.Command(ce.name, ce.args...)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stdout
-	return errors.Wrapf(cmd.Run(), "failed to execute command '%s %s'", ce.name, strings.Join(ce.args, " "))
+	log.WithField("cmd", ce.cmd).Info("execute command")
+	cmd := ce.cmd
+	proc := exec.Command(cmd.Bin, cmd.Args...)
+	proc.Stdout = os.Stdout
+	proc.Stderr = os.Stdout
+	return errors.Wrapf(proc.Run(), "failed to execute command '%s'", cmd)
 }

core/executor_test.go

@@ -4,26 +4,30 @@ import "testing"
 
 func TestCmdExecutor_Run(t *testing.T) {
 	type fields struct {
-		name string
-		args []string
+		cmd *Command
 	}
 	tests := []struct {
 		name    string
 		fields  fields
 		wantErr bool
 	}{
 		{"", fields{
-			"ls", []string{"-ahl"},
+			cmd: &Command{
+				Bin:  "ls",
+				Args: []string{"-ahl"},
+			},
 		}, false},
 		{"", fields{
-			"lab", []string{"-ahl"},
+			cmd: &Command{
+				Bin:  "lab",
+				Args: []string{"-ahl"},
+			},
 		}, true},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			ce := CmdExecutor{
-				name: tt.fields.name,
-				args: tt.fields.args,
+				cmd: tt.fields.cmd,
 			}
 			if err := ce.Run(); (err != nil) != tt.wantErr {
 				t.Errorf("CmdExecutor.Run() error = %v, wantErr %v", err, tt.wantErr)

core/file_generator.go

@@ -11,6 +11,15 @@ import (
 	log "github.com/sirupsen/logrus"
 )
 
+type FileDesc struct {
+	Path string
+	Data DataProvider
+}
+
+func (fd FileDesc) String() string {
+	return fd.Path
+}
+
 type DataProvider = func() []byte
 
 type FileGenerator struct {
@@ -19,10 +28,10 @@ type FileGenerator struct {
 	cleaned bool
 }
 
-func NewFileGenerator(path string, data DataProvider) Generator {
-	file := strings.TrimPrefix(path, "/")
+func NewFileGenerator(fd *FileDesc) Generator {
+	file := strings.TrimPrefix(fd.Path, "/")
 	log.Trace("registered file: ", file)
-	return &FileGenerator{file, data, false}
+	return &FileGenerator{file, fd.Data, false}
 }
 
 func (gt *FileGenerator) Run() error {