Merge pull request #34 from nxtcoder17/feat/support-run-targets-with-env

Feat/support run targets with env

[Github PR](#34)

Author: nxtcoder17

Runfile.yml

@@ -27,6 +27,8 @@ tasks:
     env:
       pattern:
         default: ""
+      only_failing:
+        default: false
     watch:
       enable: true
       dir:
@@ -35,11 +37,13 @@ tasks:
         - .go
     cmd:
       - |+
-        if [ -z "$pattern" ]; then
-          go test -json ./parser/... | gotestfmt
-        else
-          go test -json ./parser/... -run "$pattern" | gotestfmt
-        fi
+        pattern_args=""
+        [ -n "$pattern" ] && pattern_args="-run '$pattern'"
+
+        testfmt_args=""
+        [ "$only_failing" = "true" ] && testfmt_args="--hide successful-tests"
+
+        go test -json ./parser/... $pattern_args | gotestfmt $testfmt_args
 
   test:only-failing:
     cmd:

cmd/run/completions/run.fish

@@ -1,35 +1,14 @@
 # run fish shell completion
 set PROGNAME run
 
-function __runfile_list_targets --description 'fetches all runnable tasks'
-    for i in (commandline -opc)
-        if contains -- $i help h
-            return 1
-        end
-    end
-
-    $PROGNAME --list 2>&1 | read -lz rawOutput
-
-    # RETURN on non-zero exit code (in case of errors)
-    if test $status -ne 0
-      return
-    end
-
-    set -l output (echo $rawOutput | string split0)
-
-    if test $output
-      if test "$DEBUG" = "true"
-        echo "$output" > /tmp/test.txt
-      end
-      echo $output
-    end
-
-    return 0
+# list_targets fetches all targets, with all flags provided on the cli
+function list_targets
+  eval $PROGNAME --list
+  # eval (commandline -b) --list
 end
 
-complete -c $PROGNAME -d "runs target with given name" -xa "(__runfile_list_targets)"
+complete -c $PROGNAME -d "runs named task" -xa '(list_targets)'
+complete -c $PROGNAME -l help -s h -d 'show help'
+complete -c $PROGNAME -l list -s l -d 'list all tasks'
 complete -c $PROGNAME -rF -l file -s f -d 'runs targets from this runfile' 
-# complete -c $PROGNAME -n '__runfile_list_targets' -f -l help -s h -d 'show help'
-# complete -c $PROGNAME -n '__runfile_list_targets' -f -l help -s h -d 'show help'
-# complete -r -c $PROGNAME  -n '__runfile_list_targets' -a 'help h' -d 'Shows a list of commands or help for one command'
 

cmd/run/main.go

@@ -82,7 +82,7 @@ func main() {
 			&cli.BoolFlag{
 				Name:    "list",
 				Value:   false,
-				Aliases: []string{"ls"},
+				Aliases: []string{"l"},
 			},
 
 			&cli.BoolFlag{
@@ -112,13 +112,15 @@ func main() {
 		Commands: []*cli.Command{
 			{
 				Name:    "shell:completion",
+				Usage:   "<bash|zsh|fish|ps>",
 				Suggest: true,
 				Action: func(ctx context.Context, c *cli.Command) error {
-					if c.NArg() != 2 {
+					fmt.Printf("args: (%d)\n", c.NArg())
+					if c.NArg() != 1 {
 						return fmt.Errorf("needs argument one of [bash,zsh,fish,ps]")
 					}
 
-					switch c.Args().Slice()[1] {
+					switch c.Args().First() {
 					case "fish":
 						fmt.Fprint(c.Writer, shellCompletionFISH)
 					case "bash":

errors/errors.go

@@ -46,7 +46,10 @@ func (e *Error) resolveTaskName() string {
 
 // Error implements error.
 func (e *Error) Error() string {
-	return e.err.Error()
+	if e.err != nil {
+		return e.err.Error()
+	}
+	return ""
 	// return fmt.Sprintf("%v {%#v}", e.err, e.kv)
 }
 

parser/parse-command.go

@@ -8,7 +8,7 @@ import (
 	"github.com/nxtcoder17/runfile/types"
 )
 
-func parseCommand(prf *types.ParsedRunfile, command any) (*types.ParsedCommandJson, error) {
+func parseCommand(ctx types.Context, prf *types.ParsedRunfile, taskEnv map[string]string, command any) (*types.ParsedCommandJson, error) {
 	ferr := func(err error) error {
 		return errors.ErrTaskInvalidCommand.Wrap(err).KV("command", command)
 	}
@@ -30,14 +30,25 @@ func parseCommand(prf *types.ParsedRunfile, command any) (*types.ParsedCommandJs
 				return nil, ferr(err)
 			}
 
+			parsedEnv, err := parseEnvVars(ctx, cj.Env, evaluationParams{
+				Env: taskEnv,
+			})
+			if err != nil {
+				return nil, ferr(err)
+			}
+
 			pcj := types.ParsedCommandJson{
-				Env: cj.Env,
+				Env: parsedEnv,
 			}
 
 			switch {
 			case cj.Run != nil:
 				{
 					pcj.Run = cj.Run
+					if _, ok := prf.Tasks[*cj.Run]; !ok {
+						err := errors.ErrTaskNotFound.Wrap(fmt.Errorf("run target, not found")).KV("command", command, "run-target", cj.Run)
+						return nil, err
+					}
 				}
 			case cj.Command != nil:
 				{
@@ -49,10 +60,6 @@ func parseCommand(prf *types.ParsedRunfile, command any) (*types.ParsedCommandJs
 				}
 			}
 
-			if _, ok := prf.Tasks[*cj.Run]; !ok {
-				return nil, errors.ErrTaskNotFound.Wrap(fmt.Errorf("run target, not found")).KV("command", command, "run-target", cj.Run)
-			}
-
 			return &pcj, nil
 		}
 	default:

parser/parse-command_test.go

@@ -1,15 +1,39 @@
 package parser
 
 import (
+	"context"
+	"fmt"
 	"reflect"
 	"testing"
 
+	"github.com/nxtcoder17/go.pkgs/log"
+	fn "github.com/nxtcoder17/runfile/functions"
 	"github.com/nxtcoder17/runfile/types"
 )
 
+func testParseCommandJsonEqual(t *testing.T, got, want *types.ParsedCommandJson) {
+	if got == nil && want != nil || got != nil && want == nil {
+		t.Errorf("parseCommand(),\n[.command] \n\tgot = %v\n\twant = %v", got, want)
+		return
+	}
+
+	// t.Log("first", first, "err", err, "secondErr", secondErr, "condition", secondErr != (err != nil))
+
+	if !reflect.DeepEqual(got.Command, want.Command) {
+		t.Errorf("parseCommand(),\n[.command] \n\tgot = %v\n\twant = %v", fn.DefaultIfNil(got.Command, ""), fn.DefaultIfNil(want.Command, ""))
+		return
+	}
+
+	if fmt.Sprint(got.Env) != fmt.Sprint(want.Env) {
+		t.Errorf("parseCommand(),\n[.env] \n\tgot = %+v\n\twant = %+v", got.Env, want.Env)
+		return
+	}
+}
+
 func Test_parseCommand(t *testing.T) {
 	type args struct {
 		prf     *types.ParsedRunfile
+		taskEnv map[string]string
 		command any
 	}
 	tests := []struct {
@@ -18,18 +42,84 @@ func Test_parseCommand(t *testing.T) {
 		want    *types.ParsedCommandJson
 		wantErr bool
 	}{
-		// TODO: Add test cases.
+		{
+			name: "1. must pass with only command",
+			args: args{
+				prf:     &types.ParsedRunfile{},
+				taskEnv: map[string]string{},
+				command: "echo hi hello",
+			},
+			want: &types.ParsedCommandJson{
+				Command: fn.New("echo hi hello"),
+				Run:     nil,
+				Env:     map[string]string{},
+				If:      nil,
+			},
+			wantErr: false,
+		},
+		{
+			name: "2. must fail with only run command with run target not found",
+			args: args{
+				prf:     &types.ParsedRunfile{},
+				taskEnv: map[string]string{},
+				command: map[string]any{
+					"run": "build",
+				},
+			},
+			want:    nil,
+			wantErr: true,
+		},
+		{
+			name: "3. must pass with run command, and target exists in runfile tasks",
+			args: args{
+				prf: &types.ParsedRunfile{
+					Tasks: map[string]types.Task{
+						"build": {
+							Commands: []any{
+								"echo from build",
+							},
+						},
+					},
+				},
+				taskEnv: map[string]string{},
+				command: map[string]any{
+					"run": "build",
+					"env": map[string]string{
+						"k1": "v1",
+					},
+				},
+			},
+			want: &types.ParsedCommandJson{
+				Command: nil,
+				Run:     fn.New("build"),
+				Env: map[string]string{
+					"k1": "v1",
+				},
+				If: nil,
+			},
+			wantErr: false,
+		},
 	}
-	for _, tt := range tests {
+
+	for i := range tests {
+		tt := tests[i]
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := parseCommand(tt.args.prf, tt.args.command)
-			if (err != nil) != tt.wantErr {
+			ctx := types.Context{
+				Context: context.TODO(),
+				Logger:  log.New(),
+			}
+
+			got, err := parseCommand(ctx, tt.args.prf, tt.args.taskEnv, tt.args.command)
+			if tt.wantErr != (err != nil) {
 				t.Errorf("parseCommand() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("parseCommand() = %v, want %v", got, tt.want)
+
+			if tt.wantErr {
+				return
 			}
+
+			testParseCommandJsonEqual(t, got, tt.want)
 		})
 	}
 }

parser/parse-env.go

@@ -102,18 +102,20 @@ func parseEnvVars(ctx types.Context, ev types.EnvVar, params evaluationParams) (
 			case specials.Sh != nil:
 				{
 					*specials.Sh = strings.TrimSpace(*specials.Sh)
-					value := new(bytes.Buffer)
 					cmd := exec.CommandContext(ctx, "sh", "-c", *specials.Sh)
 					cmd.Env = fn.ToEnviron(params.Env)
-					cmd.Stdout = value
+
+					stdoutB := new(bytes.Buffer)
+					cmd.Stdout = stdoutB
+
 					stderrB := new(bytes.Buffer)
 					cmd.Stderr = stderrB
 					if err := cmd.Run(); err != nil {
 						return nil, errors.ErrEvalEnvVarSh.WithCtx(ctx).WrapStr(stderrB.String()).KV()
 						// return nil, errors.ErrEvalEnvVarSh.WithCtx(ctx).KV(attr...)
 					}
 
-					env[k] = strings.TrimSpace(value.String())
+					env[k] = strings.TrimSpace(stdoutB.String())
 				}
 			default:
 				{

parser/parse-task.go

@@ -102,7 +102,7 @@ func ParseTask(ctx types.Context, prf *types.ParsedRunfile, task types.Task) (*t
 
 	commands := make([]types.ParsedCommandJson, 0, len(task.Commands))
 	for i := range task.Commands {
-		c2, err := parseCommand(prf, task.Commands[i])
+		c2, err := parseCommand(ctx, prf, taskEnv, task.Commands[i])
 		if err != nil {
 			return nil, err
 		}
@@ -116,11 +116,6 @@ func ParseTask(ctx types.Context, prf *types.ParsedRunfile, task types.Task) (*t
 				watch.Dirs[i] = filepath.Join(*task.Dir, watch.Dirs[i])
 			}
 		}
-		// for i := range watch.ExcludeDirs {
-		// 	if !isAbsPath(watch.ExcludeDirs[i]) {
-		// 		watch.ExcludeDirs[i] = filepath.Join(*task.Dir, watch.ExcludeDirs[i])
-		// 	}
-		// }
 	}
 
 	return &types.ParsedTask{