//
// Keep in sync with cmd/dist/quoted.go
func Split(s string) ([]string, error) {
	// Split fields allowing '' or "" around elements.
	// Quotes further inside the string do not count.
	var f []string
	for len(s) > 0 {
		for len(s) > 0 && isSpaceByte(s[0]) {
			s = s[1:]
		}
		if len(s) == 0 {
			break
		}
		// Accepted quoted string. No unescaping inside.
		if s[0] == '"' || s[0] == '\'' {
			quote := s[0]
			s = s[1:]

			s = s[1:]
		}
		if len(s) == 0 {
			break
		}
		// Accepted quoted string. No unescaping inside.
		if s[0] == '"' || s[0] == '\'' {
			quote := s[0]
			s = s[1:]
			i := 0
			for i < len(s) && s[i] != quote {
				i++
			}
			if i >= len(s) {
				return nil, fmt.Errorf("unterminated %c string", quote)
			}
			f = append(f, s[:i])
			s = s[i+1:]
			continue
		}
		i := 0

	f.Add([]byte(`unescaped space`))
	f.Add([]byte(`escaped\ space`))
	f.Add([]byte(`"unterminated quote`))
	f.Add([]byte(`'unterminated quote`))
	f.Add([]byte(`unterminated escape\`))
	f.Add([]byte(`"quote with unterminated escape\`))
	f.Add([]byte(`'quoted "double quotes"'`))
	f.Add([]byte(`"quoted 'single quotes'"`))
	f.Add([]byte(`"\$0"`))
	f.Add([]byte(`"\$\0"`))
	f.Add([]byte(`"\$"`))
	f.Add([]byte(`"\$ "`))

-- input --
Doubled single quotes like `` and '' turn into Unicode double quotes,
but single quotes ` and ' do not.
Misplaced markdown fences ``` do not either.
-- gofmt --
Doubled single quotes like “ and ” turn into Unicode double quotes,
but single quotes ` and ' do not.
Misplaced markdown fences ``` do not either.
-- text --
Doubled single quotes like “ and ” turn into Unicode double quotes, but single

}

// fieldNeedsQuotes reports whether our field must be enclosed in quotes.
// Fields with a Comma, fields with a quote or newline, and
// fields which start with a space must be enclosed in quotes.
// We used to quote empty strings, but we do not anymore (as of Go 1.4).
// The two representations should be equivalent, but Postgres distinguishes
// quoted vs non-quoted empty string during database imports, and it has

package markdown

import (
	"bytes"
)

type Quote struct {
	Position
	Blocks []Block
}

func (b *Quote) PrintHTML(buf *bytes.Buffer) {
	buf.WriteString("<blockquote>\n")
	for _, c := range b.Blocks {
		c.PrintHTML(buf)
	}
	buf.WriteString("</blockquote>\n")
}

func (b *Quote) printMarkdown(buf *bytes.Buffer, s mdState) {
	s.prefix += "> "

        sourceIncludes.systemIncludes.collect { it.value } == [ "system1", "system2" ]
        sourceIncludes.macroIncludes.collect { it.value } == [ "macro1", "macro2" ]
    }

    def "order of includes is preserved" () {
        expect:
        sourceIncludes.all.collect { it.value } == ["quoted1", "system1", "quoted2", "macro1", "system2", "macro2" ]
    }

// limitations under the License.

package shellescape

import (
	"regexp"
	"strings"
)

var unsafeValue = regexp.MustCompile(`[^\\w@%+=:,./-]`)

func Quote(s string) string {
	// ported from https://github.com/chrissimpkins/shellescape/blob/master/lib/shellescape/main.py
	if len(s) == 0 {
		return "''"
	}

	if unsafeValue.MatchString(s) {

	// Output:
	// "", invalid syntax
	// "\"double-quoted string\"", <nil>
	// "`or backquoted`", <nil>
	// "'☺'", <nil>
}

func ExampleUnquote() {
	s, err := strconv.Unquote("You can't unquote a string without quotes")
	fmt.Printf("%q, %v\n", s, err)
	s, err = strconv.Unquote("\"The string must be either double-quoted\"")
	fmt.Printf("%q, %v\n", s, err)
	s, err = strconv.Unquote("`or backquoted.`")

        '"quoted"'                         | 'quoted'
        '"with space"'                     | 'with space'
        '"with\\\\"quote\\\\"internal"'    | 'with"quote"internal'
        '"with \\\\"quote\\\\" and space"' | 'with "quote" and space'
    }

    @ToBeFixedForConfigurationCache
    def "compiler and linker args can contain quotes and spaces"() {
        given: