exec.Cmd.Output returns only the Stdout of the executed process, thus the actual error message was being lost. In cases where the subprocess return a exec.ExitError use exec.ExitError.Stderr as the ouput.

It should've been possible to use exec.Cmd.CombinedOutput that returns both Stdout and Stderr in an unified way, but with this a successful command that also returns something in Stderr will interpolate Stderr in the returned string.

_example/pipe.go has an unnecessary cast from string to runes.

Of course, as long as we never parse the multibyte string, there's no problem. However, if we change the value of line to /usr/bin/ls -la あ* | sort 2>&1 | tee files.log, we get strange results as follows:

[/usr/bin/ls -la あ*]
s
[rt]
2>&1
[]
|
[tee files.log]

Hi, i suggest the ability to replace the os.Getenv function with a generic function - to be more specific adding another field to parser (https://github.com/mattn/go-shellwords/blob/master/shellwords.go#L34):

type Parser struct {
	ParseEnv      bool
        Getenv        func(string) string
	ParseBacktick bool
	Position      int
}

if it is nil, os.Getenv is used (this is for backward compatibility). If it weren't for backward compatibility, I would suggest it replaces the ParseEnv variable entirely.

Would be happy to send out a PR if this makes sense.

Parser didn't detect subshell calls, $(), and tried to parse them as environment variables. This picks up the $( pattern and continues on with parsing, leaving it as is.

Added tests for it as well.

Fixes issues with parsing shell lines with single quotes used to group things (eg. subshell calls). Fix was to set got state to argQuoted as the double quote path used (and which worked for it).

Fixes #48

When i do 'go get github.com/mattn/go-shellwords' on my vps which is Debian Jessie 8 32 bit i get the error eerr.Stderr undefined (type *exec.ExitError has no field or method Stderr)

Docker is using this as vendor package. In docker we can check for checking copyright for all the vendor packages and expects any files in .*LICENSE.*' '.*COPYRIGHT.*' '.*COPYING.*' pattern, currently while validating this package it is printing the warning message.

Please create explicit licence file to avoid any warnings while validation, so create a LICENCE file in parent directory with the MIT licence referred in the README file.

\t or \n must be parsed as special characters TAB and NEWLINE, not considered escaped

closes https://github.com/mattn/go-shellwords/issues/52 reported by https://github.com/docker/compose/issues/8605

Currently, arguments consisting only of escaped characters are merged with the following arguments.

This pull request fixes the issue. Also adds some tests.

Reproducible example

Parse(`foo \& bar`)

Expected result

[]string{"foo", "&", "bar"}

Actual result

[]string{"foo", "&bar"}

Currently

Parse(`foo "" bar ''`)

ignores the empty parameters and gives ["foo","bar"]. This should not be the case since a shell will detect these empty arguments. Furthermore, according to #5 the current behaviour is not correct.

With this PR the Parse result becomes ["foo", "", "bar", ""] as described in #5 and as a shell would have interpreted.

I appreciate this project is old and may not be maintained anymore, but before forking it I thought I'd file my particular feature request in the event that it is still maintained.

It would be great if the Parser had an option to ParseSmartQuotes, which would:

• Treat “ and ” as ".
• Treat ‘ and ’ as '.

That's it. Thanks!

It's not uncommon, in certain scenarios, to use parens inside args.

An example can be seen in the Traefik docs here (click CLI and look at the example), where it's expected that, to set a specific value, the arg --providers.docker.constraints=Label('a.label.name','foo') be used.

With the current implementation of go-shellwords, parsing a string including an arg like that throws an error, even though this is a valid shell-word string.

Fixes #38

While this is probably not a perfect solution, I think it makes a good start as it makes all tests pass on Windows and fixes the most common issue when \ paths are used in the input.

I originally wanted to implement proper escaping for Windows too, but then I realized it would be a little more complex and I thought this is already a progress. 🤷‍♂️

In Windows, backslashes are used at the OS path separator. When I run this code, I get an incorrect result for the value of cmd:

func main() {
	sh := `upx c:\github.com\jftuga\test\test.exe`
	cmd, err := shellwords.Parse(sh)
	if err != nil {
		fmt.Println("err:", err)
		return
	}
	fmt.Println(cmd)
}

This outputs:

[upx c:github.comjftugatesttest.exe]

when it should output:

[upx c:\github.com\jftuga\test\test.exe]

Can this be fixed, please?