[#200] Rename vcs/cmd package to vcs/shell

Author: mengdaming

src/vcs/git/git_command.go

@@ -25,12 +25,12 @@ package git
 import (
 	"bufio"
 	"bytes"
-	"github.com/murex/tcr/vcs/cmd"
+	"github.com/murex/tcr/vcs/shell"
 	"strings"
 )
 
-func newGitCommand() *cmd.ShellCommand {
-	return cmd.New("git")
+func newGitCommand() *shell.Command {
+	return shell.NewCommand("git")
 }
 
 // IsGitCommandAvailable indicates if git command is available on local machine

src/vcs/p4/p4_command.go

@@ -25,12 +25,12 @@ package p4
 import (
 	"bufio"
 	"bytes"
-	"github.com/murex/tcr/vcs/cmd"
+	"github.com/murex/tcr/vcs/shell"
 	"strings"
 )
 
-func newP4Command(params ...string) *cmd.ShellCommand {
-	return cmd.New("p4", params...)
+func newP4Command(params ...string) *shell.Command {
+	return shell.NewCommand("p4", params...)
 }
 
 // IsP4CommandAvailable indicates if p4 command is available on local machine
@@ -84,11 +84,11 @@ func runP4Command(params ...string) (output []byte, err error) {
 }
 
 // tracePipedP4Command calls p4 command, pipes it to pipedTo command, and reports its output traces
-func tracePipedP4Command(pipedTo *cmd.ShellCommand, params ...string) error {
+func tracePipedP4Command(pipedTo *shell.Command, params ...string) error {
 	return newP4Command().TraceAndPipe(pipedTo, params...)
 }
 
 // runPipedP4Command calls p4 command, pipes it to pipedTo command, and reports its output traces
-func runPipedP4Command(pipedTo *cmd.ShellCommand, params ...string) (output []byte, err error) {
+func runPipedP4Command(pipedTo *shell.Command, params ...string) (output []byte, err error) {
 	return newP4Command().RunAndPipe(pipedTo, params...)
 }

src/vcs/p4/p4_command_test.go

@@ -24,7 +24,7 @@ package p4
 
 import (
 	"github.com/murex/tcr/report"
-	"github.com/murex/tcr/vcs/cmd"
+	"github.com/murex/tcr/vcs/shell"
 	"github.com/stretchr/testify/assert"
 	"os"
 	"strings"
@@ -67,7 +67,7 @@ func Test_trace_p4_command(t *testing.T) {
 func Test_run_piped_p4_command(t *testing.T) {
 	skipWhenInGitHubActions(t)
 	output, err := runPipedP4Command(
-		cmd.New("grep", "Client name"),
+		shell.NewCommand("grep", "Client name"),
 		"info")
 	assert.NoError(t, err)
 	assert.Contains(t, string(output), "Client name:")
@@ -77,7 +77,7 @@ func Test_trace_piped_p4_command(t *testing.T) {
 	skipWhenInGitHubActions(t)
 	sniffer := report.NewSniffer()
 	err := tracePipedP4Command(
-		cmd.New("grep", "Client name"),
+		shell.NewCommand("grep", "Client name"),
 		"info")
 	sniffer.Stop()
 	assert.NoError(t, err)

src/vcs/p4/p4_impl.go

@@ -26,7 +26,7 @@ import (
 	"bytes"
 	"github.com/murex/tcr/report"
 	"github.com/murex/tcr/vcs"
-	"github.com/murex/tcr/vcs/cmd"
+	"github.com/murex/tcr/vcs/shell"
 	"github.com/spf13/afero"
 	"golang.org/x/text/encoding/charmap"
 	"golang.org/x/text/transform"
@@ -41,8 +41,8 @@ type p4Impl struct {
 	filesystem           afero.Fs
 	runP4Function        func(params ...string) (output []byte, err error)
 	traceP4Function      func(params ...string) (err error)
-	runPipedP4Function   func(cmd *cmd.ShellCommand, params ...string) (output []byte, err error)
-	tracePipedP4Function func(cmd *cmd.ShellCommand, params ...string) (err error)
+	runPipedP4Function   func(toCmd *shell.Command, params ...string) (output []byte, err error)
+	tracePipedP4Function func(toCmd *shell.Command, params ...string) (err error)
 }
 
 // New initializes the p4 implementation based on the provided directory from local clone
@@ -127,7 +127,6 @@ type changeList struct {
 }
 
 // Commit commits changes to p4 index.
-// TODO: p4 submit
 func (p *p4Impl) Commit(_ bool, messages ...string) error {
 	cl, err := p.createChangeList(messages...)
 	if err != nil {
@@ -152,8 +151,9 @@ func (*p4Impl) Revert() error {
 }
 
 // Push runs a push operation.
-// TODO: confirm that it does nothing as already submitted to the server through commit?
 func (*p4Impl) Push() error {
+	// Nothing to do in case of p4, as the "p4 submit" done in Commit()
+	// already "pushed" the changes to the server.
 	return nil
 }
 
@@ -220,17 +220,16 @@ func (p *p4Impl) traceP4(args ...string) error {
 
 // runP4 calls p4 command in a separate process and returns its output traces
 // The command is launched from the p4 root directory
-func (p *p4Impl) runP4(args ...string) (output []byte, err error) {
-	return p.runP4Function(append([]string{"-d", p.GetRootDir()}, args...)...)
-}
+//func (p *p4Impl) runP4(args ...string) (output []byte, err error) {
+//	return p.runP4Function(append([]string{"-d", p.GetRootDir()}, args...)...)
+//}
 
 func (p *p4Impl) createChangeList(messages ...string) (*changeList, error) {
 	// Command: p4 --field "Description=<message>" change -o | p4 change -i
-
 	out, err := p.runPipedP4Function(
 		newP4Command("change", "-i"),
 		"-Q", "utf8",
-		"--field", buildDescriptionField(cmd.GetShellAttributes(), messages...),
+		"--field", buildDescriptionField(shell.GetAttributes(), messages...),
 		"change", "-o")
 	if err != nil {
 		return nil, err
@@ -240,7 +239,7 @@ func (p *p4Impl) createChangeList(messages ...string) (*changeList, error) {
 	return &changeList{clNumber}, err
 }
 
-func buildDescriptionField(attr cmd.ShellAttributes, messages ...string) string {
+func buildDescriptionField(attr shell.Attributes, messages ...string) string {
 	var builder strings.Builder
 	_, _ = builder.WriteString("Description=")
 	for _, message := range messages {

src/vcs/cmd/command.go src/vcs/shell/command.go

@@ -20,66 +20,66 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
-package cmd
+package shell
 
 import (
 	"github.com/codeskyblue/go-sh"
 	"github.com/murex/tcr/report"
 	"os/exec"
 )
 
-// ShellCommand is a command that can be launched from a shell
-type ShellCommand struct {
+// Command is a command that can be launched from a shell
+type Command struct {
 	name   string
 	params []string
 }
 
-// New creates a new shell command instance
-func New(name string, params ...string) *ShellCommand {
-	return &ShellCommand{name: name, params: params}
+// NewCommand creates a new shell command instance
+func NewCommand(name string, params ...string) *Command {
+	return &Command{name: name, params: params}
 }
 
 // IsInPath indicates if the command can be found in the path
-func (sc *ShellCommand) IsInPath() bool {
-	_, err := exec.LookPath(sc.name)
+func (c *Command) IsInPath() bool {
+	_, err := exec.LookPath(c.name)
 	return err == nil
 }
 
 // GetFullPath returns the full path for this command
-func (sc *ShellCommand) GetFullPath() string {
-	path, _ := exec.LookPath(sc.name)
+func (c *Command) GetFullPath() string {
+	path, _ := exec.LookPath(c.name)
 	return path
 }
 
 // Run calls the command with the provided parameters in a separate process and returns its output traces combined
-func (sc *ShellCommand) Run(params ...string) (output []byte, err error) {
-	//report.PostWarning("Command: ", sc.name, " ", append(sc.params, params...))
-	return sh.Command(sc.name, append(sc.params, params...)).CombinedOutput()
+func (c *Command) Run(params ...string) (output []byte, err error) {
+	//report.PostWarning("Command: ", c.name, " ", append(c.params, params...))
+	return sh.Command(c.name, append(c.params, params...)).CombinedOutput()
 }
 
 // Trace calls the command with the provided parameters and reports its output traces
-func (sc *ShellCommand) Trace(params ...string) error {
-	output, err := sc.Run(params...)
+func (c *Command) Trace(params ...string) error {
+	output, err := c.Run(params...)
 	if len(output) > 0 {
 		report.PostText(string(output))
 	}
 	return err
 }
 
 // RunAndPipe calls the command with the provided parameters in a separate process
-// and pipes its output to cmd. Returns cmd's output traces combined
-func (sc *ShellCommand) RunAndPipe(cmd *ShellCommand, params ...string) (output []byte, err error) {
-	//report.PostWarning("Command: ", sc.name, " ", append(sc.params, params...), " | ", cmd.name, " ", cmd.params)
+// and pipes its output to cmd. Returns toCmd's output traces combined
+func (c *Command) RunAndPipe(toCmd *Command, params ...string) (output []byte, err error) {
+	//report.PostWarning("Command: ", c.name, " ", append(c.params, params...), " | ", shell.name, " ", shell.params)
 	return sh.NewSession().
-		Command(sc.name, append(sc.params, params...)).
-		Command(cmd.name, cmd.params).
+		Command(c.name, append(c.params, params...)).
+		Command(toCmd.name, toCmd.params).
 		CombinedOutput()
 }
 
 // TraceAndPipe calls the command with the provided parameters in a separate process
-// and pipes its output to cmd. Reports cmd's output traces
-func (sc *ShellCommand) TraceAndPipe(cmd *ShellCommand, params ...string) error {
-	output, err := sc.RunAndPipe(cmd, params...)
+// and pipes its output to cmd. Reports toCmd's output traces
+func (c *Command) TraceAndPipe(toCmd *Command, params ...string) error {
+	output, err := c.RunAndPipe(toCmd, params...)
 	if len(output) > 0 {
 		report.PostText(string(output))
 	}

src/vcs/cmd/command_test.go src/vcs/shell/command_test.go

@@ -20,7 +20,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
-package cmd
+package shell
 
 import (
 	"bytes"
@@ -32,45 +32,45 @@ import (
 )
 
 func Test_is_in_path_for_a_valid_command(t *testing.T) {
-	assert.True(t, New("ls").IsInPath())
+	assert.True(t, NewCommand("ls").IsInPath())
 }
 
 func Test_is_in_path_for_an_invalid_command(t *testing.T) {
-	assert.False(t, New("unknown-command").IsInPath())
+	assert.False(t, NewCommand("unknown-command").IsInPath())
 }
 
 func Test_get_full_path_for_a_valid_command(t *testing.T) {
-	base := filepath.Base(New("ls").GetFullPath())
+	base := filepath.Base(NewCommand("ls").GetFullPath())
 	assert.Equal(t, strings.TrimSuffix(base, ".exe"), "ls")
 }
 
 func Test_get_full_path_for_an_invalid_command(t *testing.T) {
-	assert.Zero(t, New("unknown-command").GetFullPath())
+	assert.Zero(t, NewCommand("unknown-command").GetFullPath())
 }
 
 func Test_run_valid_command_with_initial_parameters(t *testing.T) {
-	output, err := New("echo", "hello world!").Run()
+	output, err := NewCommand("echo", "hello world!").Run()
 	assert.NoError(t, err)
 	trimmed := string(bytes.TrimRight(output, "\r\n"))
 	assert.Equal(t, "hello world!", trimmed)
 }
 
 func Test_run_valid_command_with_additional_parameters(t *testing.T) {
-	output, err := New("echo").Run("hello world!")
+	output, err := NewCommand("echo").Run("hello world!")
 	assert.NoError(t, err)
 	trimmed := string(bytes.TrimRight(output, "\r\n"))
 	assert.Equal(t, "hello world!", trimmed)
 }
 
 func Test_run_invalid_command(t *testing.T) {
-	output, err := New("unknown-command").Run()
+	output, err := NewCommand("unknown-command").Run()
 	assert.Error(t, err)
 	assert.Zero(t, output)
 }
 
 func Test_trace_valid_command_with_initial_parameters(t *testing.T) {
 	sniffer := report.NewSniffer()
-	err := New("echo", "hello world!").Trace()
+	err := NewCommand("echo", "hello world!").Trace()
 	sniffer.Stop()
 	assert.NoError(t, err)
 	assert.Equal(t, 1, sniffer.GetMatchCount())
@@ -80,7 +80,7 @@ func Test_trace_valid_command_with_initial_parameters(t *testing.T) {
 
 func Test_trace_valid_command_with_additional_parameters(t *testing.T) {
 	sniffer := report.NewSniffer()
-	err := New("echo").Trace("hello world!")
+	err := NewCommand("echo").Trace("hello world!")
 	sniffer.Stop()
 	assert.NoError(t, err)
 	assert.Equal(t, 1, sniffer.GetMatchCount())
@@ -90,47 +90,47 @@ func Test_trace_valid_command_with_additional_parameters(t *testing.T) {
 
 func Test_trace_invalid_command(t *testing.T) {
 	sniffer := report.NewSniffer()
-	err := New("unknown-command").Trace()
+	err := NewCommand("unknown-command").Trace()
 	sniffer.Stop()
 	assert.Error(t, err)
 	assert.Equal(t, 0, sniffer.GetMatchCount())
 }
 
 func Test_run_pipe_valid_commands_with_initial_parameters(t *testing.T) {
-	output, err := New("echo", "hello\tworld!").RunAndPipe(
-		New("cut", "-f", "1"))
+	output, err := NewCommand("echo", "hello\tworld!").RunAndPipe(
+		NewCommand("cut", "-f", "1"))
 	assert.NoError(t, err)
 	trimmed := string(bytes.TrimRight(output, "\r\n"))
 	assert.Equal(t, "hello", trimmed)
 }
 
 func Test_run_pipe_valid_commands_with_additional_parameters(t *testing.T) {
-	output, err := New("echo").RunAndPipe(
-		New("cut", "-f", "1"),
+	output, err := NewCommand("echo").RunAndPipe(
+		NewCommand("cut", "-f", "1"),
 		"hello\tworld!")
 	assert.NoError(t, err)
 	trimmed := string(bytes.TrimRight(output, "\r\n"))
 	assert.Equal(t, "hello", trimmed)
 }
 
 func Test_run_pipe_with_first_command_invalid(t *testing.T) {
-	output, err := New("unknown-command").RunAndPipe(
-		New("cut", "-f", "1"))
+	output, err := NewCommand("unknown-command").RunAndPipe(
+		NewCommand("cut", "-f", "1"))
 	assert.Error(t, err)
 	assert.Zero(t, output)
 }
 
 func Test_run_pipe_with_second_command_invalid(t *testing.T) {
-	output, err := New("echo").RunAndPipe(
-		New("unknown-command"))
+	output, err := NewCommand("echo").RunAndPipe(
+		NewCommand("unknown-command"))
 	assert.Error(t, err)
 	assert.Zero(t, output)
 }
 
 func Test_trace_pipe_valid_commands_with_initial_parameters(t *testing.T) {
 	sniffer := report.NewSniffer()
-	err := New("echo", "hello\tworld!").TraceAndPipe(
-		New("cut", "-f", "1"))
+	err := NewCommand("echo", "hello\tworld!").TraceAndPipe(
+		NewCommand("cut", "-f", "1"))
 	sniffer.Stop()
 	assert.NoError(t, err)
 	assert.Equal(t, 1, sniffer.GetMatchCount())
@@ -140,8 +140,8 @@ func Test_trace_pipe_valid_commands_with_initial_parameters(t *testing.T) {
 
 func Test_trace_pipe_valid_commands_with_additional_parameters(t *testing.T) {
 	sniffer := report.NewSniffer()
-	err := New("echo").TraceAndPipe(
-		New("cut", "-f", "1"),
+	err := NewCommand("echo").TraceAndPipe(
+		NewCommand("cut", "-f", "1"),
 		"hello\tworld!")
 	sniffer.Stop()
 	assert.NoError(t, err)
@@ -152,17 +152,17 @@ func Test_trace_pipe_valid_commands_with_additional_parameters(t *testing.T) {
 
 func Test_trace_pipe_with_first_command_invalid(t *testing.T) {
 	sniffer := report.NewSniffer()
-	err := New("unknown-command").TraceAndPipe(
-		New("cut", "-f", "1"))
+	err := NewCommand("unknown-command").TraceAndPipe(
+		NewCommand("cut", "-f", "1"))
 	sniffer.Stop()
 	assert.Error(t, err)
 	assert.Equal(t, 0, sniffer.GetMatchCount())
 }
 
 func Test_trace_pipe_with_second_command_invalid(t *testing.T) {
 	sniffer := report.NewSniffer()
-	err := New("echo").TraceAndPipe(
-		New("unknown-command"))
+	err := NewCommand("echo").TraceAndPipe(
+		NewCommand("unknown-command"))
 	sniffer.Stop()
 	assert.Error(t, err)
 	assert.Equal(t, 0, sniffer.GetMatchCount())