How docker-compose parse the `command` string?

I ran the command:

docker-compose -p foo -f - up <<YAML
version: "3.8"
services:
  main:
    image: alpine
    command: echo x && y
YAML

Expected

[+] Running 1/0
 ⠿ Container foo-main-1  Created                                                                                                                                    0.0s
Attaching to foo-main-1
foo-main-1  | x && y
foo-main-1 exited with code 0

Actual

[+] Running 1/0
 ⠿ Container foo-main-1  Created                                                                                                                                    0.0s
Attaching to foo-main-1
foo-main-1  | x
foo-main-1 exited with code 0

I know CMD of Dockerfile supports exec form and shell form and expect docker-compose.yml would behave like Dockerfile, however, looks like docker-compose uses some hacky way to pass the command string.

Question

1. Does docker-compose simply use a regular expression to remove everything after ;, && and |?
2. If not, how does docker-compose process the command string?

I would appreciate if you can also provide the source code reference of which line parsing command string.

https://github.com/docker/compose

My Environment

λ docker -v
Docker version 20.10.22, build 3a2c30b
λ docker-compose -v
Docker Compose version v2.15.1

Docker Compose V2 has been rewritten in Go, and the way it parses 'command' is different from V1. Docker Compose V2 uses Go package 'go-shellwords' to parse the command line, with certain special characters being handled specifically, such as:

\`)(";&|<>

In the case of the string 'echo x && y', the '&' character breaks the Parser() loop and leads to the end of string parsing, resulting in the output terminating in 'echo x'.

Additionally, the shell form 'echo x && y' means 'echo x' and then execute 'y'. This may not be what you intended, so you can explicitly declare the command string as 'echo "x && y"' or '["sh", "-c", "echo x && y"]', depends on your specific needs.

If you're interested in learning more about how command strings are parsed by Docker Compose, you can refer to the source code, specifically:

1. https://github.com/docker/compose/blob/v2/cmd/compose/compose.go#L187

func (o *ProjectOptions) ToProject(services []string, po ...cli.ProjectOptionsFn) (*types.Project, error) {
...
	project, err := cli.ProjectFromOptions(options)
	if err != nil {
...

2. https://github.com/compose-spec/compose-go/blob/master/cli/options.go#L381

func ProjectFromOptions(options *ProjectOptions) (*types.Project, error) {
...
	project, err := loader.Load(types.ConfigDetails{
		ConfigFiles: configs,
		WorkingDir:  workingDir,
		Environment: options.Environment,
	}, options.loadOptions...)
	if err != nil {
		return nil, err
	}

3. https://github.com/compose-spec/compose-go/blob/master/loader/loader.go#L1156

var transformShellCommand TransformerFunc = func(value interface{}) (interface{}, error) {
	if str, ok := value.(string); ok {
		return shellwords.Parse(str)
	}
	return value, nil
}

4. https://github.com/mattn/go-shellwords/blob/master/shellwords.go#L125

func (p *Parser) Parse(line string) ([]string, error) {
	args := []string{}
	buf := ""
	var escaped, doubleQuoted, singleQuoted, backQuote, dollarQuote bool
	backtick := ""
...

You can take a look at shellswords.go to see how command string is parsed by Parse() function.