14267892308

Committed 04 Apr 2025 02:41PM UTC coverage: 6.101% (-0.07%) from 6.172%

Build # 14267892308

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #110 from foomo/feature/v0.11.0

feat: v0.11.0

Run Details

3 of 122 new or added lines in 9 files covered. (2.46%)

5 existing lines in 2 files now uncovered.

159 of 2606 relevant lines covered (6.1%)

0.71 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/pkg/shell/shell.go

package shell

import (
        "context"
        "fmt"
        "io"
        "os"
        "os/exec"
        "strings"

        "github.com/foomo/posh/pkg/log"
)

// Shell struct
type Shell struct {
        l      log.Logger
        cmd    *exec.Cmd
        quiet  bool
        debug  bool
        args   []string
        stdin  io.Reader
        stdout io.Writer
        stderr io.Writer
}

// ------------------------------------------------------------------------------------------------
// ~ Constructor
// ------------------------------------------------------------------------------------------------

func New(ctx context.Context, l log.Logger, inputs ...interface{}) *Shell {
        var args []string
        for _, input := range inputs {
                if value, ok := input.(string); ok {
                        args = append(args, value)
                } else if value, ok := input.([]string); ok {
                        args = append(args, value...)
                } else {
                        args = append(args, fmt.Sprintf("%v", args))
                }
        }
        cmd := exec.CommandContext(ctx, "sh", "-c")
        cmd.Env = os.Environ()
        return &Shell{
                l:      l.Named("shell"),
                cmd:    cmd,
                args:   args,
                stdin:  os.Stdin,
                stdout: os.Stdout,
                stderr: os.Stderr,
        }
}

// ------------------------------------------------------------------------------------------------
// ~ Public methods
// ------------------------------------------------------------------------------------------------

func (s *Shell) Args(args ...string) *Shell {
        s.args = append(s.args, args...)
        return s
}

func (s *Shell) Env(env ...string) *Shell {
        s.cmd.Env = append(s.cmd.Env, env...)
        return s
}

func (s *Shell) Dir(dir string) *Shell {
        s.cmd.Dir = dir
        return s
}

func (s *Shell) Quiet() *Shell {
        s.quiet = true
        return s
}

func (s *Shell) Stdin(v io.Reader) *Shell {
        s.stdin = v
        return s
}

func (s *Shell) Stdout(v io.Writer) *Shell {
        s.stdout = v
        return s
}

func (s *Shell) Stderr(v io.Writer) *Shell {
        s.stderr = v
        return s
}

func (s *Shell) Debug() *Shell {
        s.debug = true
        return s
}

func (s *Shell) Run() error {
        args := s.args
        s.cmd.Args = append(s.cmd.Args, strings.Join(args, " "))
        s.cmd.Stdin = s.stdin
        if !s.quiet {
                s.cmd.Stdout = s.stdout
                s.cmd.Stderr = s.stderr
        }
        s.trace()
        return s.cmd.Run()
}

func (s *Shell) Output() ([]byte, error) {
        args := s.args
        s.cmd.Args = append(s.cmd.Args, strings.Join(args, " "))
        if !s.quiet {
                s.cmd.Stdin = s.stdin
                s.cmd.Stderr = s.stderr
        }
        s.trace()
        return s.cmd.Output()
}

func (s *Shell) CombinedOutput() ([]byte, error) {
        args := s.args
        s.cmd.Args = append(s.cmd.Args, strings.Join(args, " "))
        if !s.quiet {
                s.cmd.Stdin = s.stdin
        }
        s.trace()
        return s.cmd.CombinedOutput()
}

func (s *Shell) Wait() error {
        args := s.args
        s.cmd.Args = append(s.cmd.Args, strings.Join(args, " "))
        s.cmd.Stdin = s.stdin
        if !s.quiet {
                s.cmd.Stdout = s.stdout
                s.cmd.Stderr = s.stderr
        }
        s.trace()
        // start the process and wait till it's finished
        if err := s.cmd.Start(); err != nil {
                return err
        } else if err := s.cmd.Wait(); err != nil {
                return err
        }
        return nil
}

// ------------------------------------------------------------------------------------------------
// ~ Private methods
// ------------------------------------------------------------------------------------------------

func (s *Shell) trace() {
        if s.debug {
                s.l.Info(s.cmd.String())
        } else {
                s.l.Tracef(`"Executing:
$ %s

Directory: %s

%s
`,
                        s.cmd.String(),
                        s.cmd.Dir,
                        strings.Join(s.cmd.Environ(), "\n"),
                )
        }
}

1	package shell
2
3	import (
4	"context"
5	"fmt"
6	"io"
7	"os"
8	"os/exec"
9	"strings"
10
11	"github.com/foomo/posh/pkg/log"
12	)
13
14	// Shell struct
15	type Shell struct {
16	l log.Logger
17	cmd *exec.Cmd
18	quiet bool
19	debug bool
20	args []string
21	stdin io.Reader
22	stdout io.Writer
23	stderr io.Writer
24	}
25
26	// ------------------------------------------------------------------------------------------------
27	// ~ Constructor
28	// ------------------------------------------------------------------------------------------------
29
30	func New(ctx context.Context, l log.Logger, inputs ...interface{}) *Shell {	×
31	var args []string	×
32	for _, input := range inputs {	×
33	if value, ok := input.(string); ok {	×
34	args = append(args, value)	×
35	} else if value, ok := input.([]string); ok {	×
36	args = append(args, value...)	×
37	} else {	×
38	args = append(args, fmt.Sprintf("%v", args))	×
39	}	×
40	}
41	cmd := exec.CommandContext(ctx, "sh", "-c")	×
42	cmd.Env = os.Environ()	×
43	return &Shell{	×
44	l: l.Named("shell"),	×
45	cmd: cmd,	×
46	args: args,	×
47	stdin: os.Stdin,	×
48	stdout: os.Stdout,	×
49	stderr: os.Stderr,	×
50	}	×
51	}
52
53	// ------------------------------------------------------------------------------------------------
54	// ~ Public methods
55	// ------------------------------------------------------------------------------------------------
56
57	func (s Shell) Args(args ...string) Shell {	×
58	s.args = append(s.args, args...)	×
59	return s	×
60	}	×
61
62	func (s Shell) Env(env ...string) Shell {	×
63	s.cmd.Env = append(s.cmd.Env, env...)	×
64	return s	×
65	}	×
66
67	func (s Shell) Dir(dir string) Shell {	×
68	s.cmd.Dir = dir	×
69	return s	×
70	}	×
71
72	func (s Shell) Quiet() Shell {	×
73	s.quiet = true	×
74	return s	×
75	}	×
76
77	func (s Shell) Stdin(v io.Reader) Shell {	×
78	s.stdin = v	×
79	return s	×
80	}	×
81
82	func (s Shell) Stdout(v io.Writer) Shell {	×
83	s.stdout = v	×
84	return s	×
85	}	×
86
87	func (s Shell) Stderr(v io.Writer) Shell {	×
88	s.stderr = v	×
89	return s	×
90	}	×
91
NEW 92	func (s Shell) Debug() Shell {	×
NEW 93	s.debug = true	×
NEW 94	return s	×
NEW 95	}	×
96
97	func (s *Shell) Run() error {	×
98	args := s.args	×
99	s.cmd.Args = append(s.cmd.Args, strings.Join(args, " "))	×
100	s.cmd.Stdin = s.stdin	×
101	if !s.quiet {	×
102	s.cmd.Stdout = s.stdout	×
103	s.cmd.Stderr = s.stderr	×
104	}	×
105	s.trace()	×
106	return s.cmd.Run()	×
107	}
108
109	func (s *Shell) Output() ([]byte, error) {	×
110	args := s.args	×
111	s.cmd.Args = append(s.cmd.Args, strings.Join(args, " "))	×
112	if !s.quiet {	×
113	s.cmd.Stdin = s.stdin	×
114	s.cmd.Stderr = s.stderr	×
115	}	×
116	s.trace()	×
117	return s.cmd.Output()	×
118	}
119
120	func (s *Shell) CombinedOutput() ([]byte, error) {	×
121	args := s.args	×
122	s.cmd.Args = append(s.cmd.Args, strings.Join(args, " "))	×
123	if !s.quiet {	×
124	s.cmd.Stdin = s.stdin	×
125	}	×
126	s.trace()	×
127	return s.cmd.CombinedOutput()	×
128	}
129
130	func (s *Shell) Wait() error {	×
131	args := s.args	×
132	s.cmd.Args = append(s.cmd.Args, strings.Join(args, " "))	×
133	s.cmd.Stdin = s.stdin	×
134	if !s.quiet {	×
135	s.cmd.Stdout = s.stdout	×
136	s.cmd.Stderr = s.stderr	×
137	}	×
138	s.trace()	×
139	// start the process and wait till it's finished	×
140	if err := s.cmd.Start(); err != nil {	×
141	return err	×
142	} else if err := s.cmd.Wait(); err != nil {	×
143	return err	×
144	}	×
145	return nil	×
146	}
147
148	// ------------------------------------------------------------------------------------------------
149	// ~ Private methods
150	// ------------------------------------------------------------------------------------------------
151
152	func (s *Shell) trace() {	×
NEW 153	if s.debug {	×
NEW 154	s.l.Info(s.cmd.String())	×
NEW 155	} else {	×
NEW 156	s.l.Tracef(`"Executing:	×
157	$ %s	×
158		×
159	Directory: %s	×
160		×
161	%s	×
162	`,	×
NEW 163	s.cmd.String(),	×
NEW 164	s.cmd.Dir,	×
NEW 165	strings.Join(s.cmd.Environ(), "\n"),	×
NEW 166	)	×
NEW 167	}	×
168	}

foomo / posh / 14267892308

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous