fixed issues with flag system

Author: M4urici0GM

.idea/.gitignore

@@ -9,10 +9,10 @@ type ShakaRunnerBuilder struct {
 }
 
 func NewBuilder(binary ...string) *ShakaRunnerBuilder {
-    binaryPath := ""
-    if len(binary) > 0 && binary[0] != "" {
-        binaryPath = binary[0]
-    }
+	binaryPath := ""
+	if len(binary) > 0 && binary[0] != "" {
+		binaryPath = binary[0]
+	}
 
 	return &ShakaRunnerBuilder{
 		runner: NewShakaPackager(binaryPath),
@@ -34,15 +34,15 @@ func (b *ShakaRunnerBuilder) Build() *ShakaPackager {
 	return b.runner
 }
 
-func (s *ShakaPackager) Args() ([]string, string, error) {
+func (s *ShakaPackager) Args() ([]string, []string, error) {
 	streamOptions, err := buildStreamDescriptors(s.StreamOptions...)
 	if err != nil {
-		return nil, "", err
+		return nil, nil, err
 	}
 
 	flags, err := buildFlags(s.Flags)
 	if err != nil {
-		return nil, "", err
+		return nil, nil, err
 	}
 
 	return streamOptions, flags, nil

.idea/gaka.iml

@@ -5,127 +5,127 @@
 package packlit
 
 import (
-	"bufio"
-	"context"
-	"io"
-	"log"
-	"os"
-	"os/exec"
+    "bufio"
+    "context"
+    "io"
+    "log"
+    "os"
+    "os/exec"
 )
 
 type CommandRunner interface {
-	CommandContext(context.Context, string, ...string) *exec.Cmd
+    CommandContext(context.Context, string, ...string) *exec.Cmd
 }
 
 type NativeCommandRunner struct{}
 
 func (n *NativeCommandRunner) CommandContext(ctx context.Context, name string, args ...string) *exec.Cmd {
-	return exec.CommandContext(ctx, name, args...)
+    return exec.CommandContext(ctx, name, args...)
 }
 
 type ShakaExecutor struct {
-	shaka         *ShakaPackager
-	logger        *log.Logger
-	commandRunner CommandRunner
+    shaka         *ShakaPackager
+    logger        *log.Logger
+    commandRunner CommandRunner
 }
 
 // Creates new executor.
 // If logger is nil, it will create a new one with prefix [packlit]
 func NewExecutor(shaka *ShakaPackager, logger ...*log.Logger) *ShakaExecutor {
-	return &ShakaExecutor{
-		shaka:         shaka,
-		logger:        getLogger(logger...),
-		commandRunner: &NativeCommandRunner{},
-	}
+    return &ShakaExecutor{
+        shaka:         shaka,
+        logger:        getLogger(logger...),
+        commandRunner: &NativeCommandRunner{},
+    }
 }
 
 func (e *ShakaExecutor) RunWithContext(ctx context.Context) error {
-	args, err := e.shaka.BuildAndValidate()
-	if err != nil {
-		return err
-	}
+    args, err := e.shaka.BuildAndValidate()
+    if err != nil {
+        return err
+    }
 
-	return e.runShaka(ctx, e.shaka.Binary, args)
+    return e.runShaka(ctx, e.shaka.Binary, args)
 }
 
 func (e *ShakaExecutor) Run() error {
-	return e.RunWithContext(context.Background())
+    return e.RunWithContext(context.Background())
 }
 
 func (e *ShakaExecutor) RunAsync(ctx context.Context) (<-chan error, error) {
-	args, flags, err := e.shaka.Args()
-	if err != nil {
-		return nil, err
-	}
-
-	errorChn := make(chan error)
-
-	go func() {
-		defer close(errorChn)
-
-		select {
-		case <-ctx.Done():
-			errorChn <- ctx.Err()
-			return
-		default:
-            args = append(args, flags)
-			err := e.runShaka(ctx, e.shaka.Binary, args)
-			if err != nil {
-				errorChn <- err
-			}
-		}
-	}()
-
-	return errorChn, nil
+    args, flags, err := e.shaka.Args()
+    if err != nil {
+        return nil, err
+    }
+
+    errorChn := make(chan error)
+
+    go func() {
+        defer close(errorChn)
+
+        select {
+        case <-ctx.Done():
+            errorChn <- ctx.Err()
+            return
+        default:
+            args = append(args, flags...)
+            err := e.runShaka(ctx, e.shaka.Binary, args)
+            if err != nil {
+                errorChn <- err
+            }
+        }
+    }()
+
+    return errorChn, nil
 }
 
 func readLog(reader io.Reader, fn func(string)) error {
-	scanner := bufio.NewScanner(reader)
-	for scanner.Scan() {
-		msg := scanner.Text()
-		fn(msg)
-	}
+    scanner := bufio.NewScanner(reader)
+    for scanner.Scan() {
+        msg := scanner.Text()
+        fn(msg)
+    }
 
-	return scanner.Err()
+    return scanner.Err()
 }
 
 func (e *ShakaExecutor) runShaka(ctx context.Context, binaryPath string, args []string) error {
-	cmd := e.commandRunner.CommandContext(ctx, binaryPath, args...)
-
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		return err
-	}
-
-	stderr, err := cmd.StderrPipe()
-	if err != nil {
-		return err
-	}
-
-	err = cmd.Start()
-	if err != nil {
-		log.Fatalf("failed to start command: %v", err)
-	}
-
-	go func() {
-		_ = readLog(stdout, func(msg string) {
-			log.Printf("[debug] %s", msg)
-		})
-	}()
-
-	go func() {
-		_ = readLog(stderr, func(msg string) {
-			log.Printf("[stderr] %s", msg)
-		})
-	}()
-
-	return cmd.Wait()
+    cmd := e.commandRunner.CommandContext(ctx, binaryPath, args...)
+
+    stdout, err := cmd.StdoutPipe()
+    if err != nil {
+        return err
+    }
+
+    stderr, err := cmd.StderrPipe()
+    if err != nil {
+        return err
+    }
+
+    err = cmd.Start()
+    if err != nil {
+        log.Fatalf("failed to start command: %v", err)
+    }
+
+    go func() {
+        _ = readLog(stdout, func(msg string) {
+            log.Printf("[debug] %s", msg)
+        })
+    }()
+
+    go func() {
+        _ = readLog(stderr, func(msg string) {
+            log.Printf("[stderr] %s", msg)
+        })
+    }()
+
+    return cmd.Wait()
 }
 
 func getLogger(logger ...*log.Logger) *log.Logger {
-	if len(logger) != 0 && logger[0] != nil {
-		return logger[0]
-	}
+    if len(logger) != 0 && logger[0] != nil {
+        return logger[0]
+    }
 
-	return log.New(os.Stdout, "[packlit] ", log.LstdFlags)
+    return log.New(os.Stdout, "[packlit] ", log.LstdFlags)
 }

.idea/inspectionProfiles/Project_Default.xml

@@ -33,7 +33,7 @@ func TestShakaExecutorRun(t *testing.T) {
 	ctx := context.Background()
 
 	mockRunner := &MockCommandRunner{}
-	mockRunner.On("CommandContext", ctx, "mock_binary", []string{"\\ "}).
+	mockRunner.On("CommandContext", ctx, "mock_binary", []string{}).
 		Return(exec.Command("echo", "hello world"))
 
 	shaka := NewShakaPackager("mock_binary")
@@ -48,15 +48,15 @@ func TestShakaExecutorRun(t *testing.T) {
 
 	// then
 	require.NoError(t, err)
-	mockRunner.AssertCalled(t, "CommandContext", ctx, "mock_binary", []string{"\\ "})
+	mockRunner.AssertCalled(t, "CommandContext", ctx, "mock_binary", []string{})
 }
 
 func TestShakaExecutorRunError(t *testing.T) {
 	// given
 	ctx := context.Background()
 
 	mockRunner := &MockCommandRunner{}
-	mockRunner.On("CommandContext", ctx, "shaka-packager", []string{"\\ "}).
+	mockRunner.On("CommandContext", ctx, "shaka-packager", []string{}).
 		Return(exec.Command("false"))
 
 	shaka := NewShakaPackager("shaka-packager")
@@ -80,7 +80,7 @@ func TestShakaExecutorRunAsync(t *testing.T) {
 	ctx := context.Background()
 
 	mockRunner := &MockCommandRunner{}
-	mockRunner.On("CommandContext", ctx, "mock_binary", []string{""}).
+	mockRunner.On("CommandContext", ctx, "mock_binary", []string{}).
 		Return(exec.Command("echo", "hello world"))
 
 	shaka := NewShakaPackager("mock_binary")
@@ -96,14 +96,14 @@ func TestShakaExecutorRunAsync(t *testing.T) {
 	// then
 	require.NoError(t, err)
 	require.NoError(t, <-chn)
-	mockRunner.AssertCalled(t, "CommandContext", ctx, "mock_binary", []string{""})
+	mockRunner.AssertCalled(t, "CommandContext", ctx, "mock_binary", []string{})
 }
 
 func TestShakaExecutorErrorAsync(t *testing.T) {
 	ctx := context.Background()
 
 	mockRunner := &MockCommandRunner{}
-	mockRunner.On("CommandContext", ctx, "shaka-packager", []string{""}).
+	mockRunner.On("CommandContext", ctx, "shaka-packager", []string{}).
 		Return(exec.Command("false"))
 
 	shaka := NewShakaPackager("shaka-packager")
@@ -124,4 +124,4 @@ func TestShakaExecutorErrorAsync(t *testing.T) {
 	require.Contains(t, err.Error(), "exit status 1")
 
 	mockRunner.AssertCalled(t, "CommandContext", ctx, mock.Anything, mock.Anything)
-}
+}