parse_curl.go

package main

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"strings"

	"github.com/mattn/go-shellwords"
)

type Headers map[string]string

func (h *Headers) ToString() string {
	headersArr := []string{}
	for k, v := range *h {
		headersArr = append(headersArr, k+": "+v)
	}

	return strings.Join(headersArr, "\n")
}

type Request struct {
	Method string  `json:"method"`
	Url    string  `json:"url"`
	Header Headers `json:"headers"`
	Body   string  `json:"body"`
}

func (r *Request) ToJson(format bool) string {
	buffer := &bytes.Buffer{}
	encoder := json.NewEncoder(buffer)
	encoder.SetEscapeHTML(false)

	if format {
		encoder.SetIndent("", "  ")
	}
	_ = encoder.Encode(r)

	return string(buffer.Bytes())
}

func Parse(curl string) (*Request, bool) {
	if strings.Index(curl, "curl ") != 0 {
		return nil, false
	}

	// https://github.com/mattn/go-shellwords
	// https://github.com/tj/parse-curl.js
	args, err := shellwords.Parse(curl)
	if err != nil {
		return nil, false
	}

	args = rewrite(args)
	request := &Request{Method: "GET", Header: Headers{}}
	state := ""

	for _, arg := range args {
		switch true {
		case isUrl(arg):
			request.Url = arg

		case arg == "-A" || arg == "--user-agent":
			state = "user-agent"

		case arg == "-H" || arg == "--header":
			state = "header"

		case arg == "-d" || arg == "--data" || arg == "--data-ascii" || arg == "--data-raw":
			state = "data"

		case arg == "-u" || arg == "--user":
			state = "user"

		case arg == "-I" || arg == "--head":
			request.Method = "HEAD"

		case arg == "-X" || arg == "--request":
			state = "method"

		case arg == "-b" || arg == "--cookie":
			state = "cookie"

		case len(arg) > 0:
			switch state {
			case "header":
				fields := parseField(arg)
				request.Header[fields[0]] = strings.TrimSpace(fields[1])
				state = ""

			case "user-agent":
				request.Header["User-Agent"] = arg
				state = ""

			case "data":
				if request.Method == "GET" || request.Method == "HEAD" {
					request.Method = "POST"
				}

				if !hasContentType(*request) {
					request.Header["Content-Type"] = "application/x-www-form-urlencoded"
				}

				if len(request.Body) == 0 {
					request.Body = arg
				} else {
					request.Body = request.Body + "&" + arg
				}

				state = ""

			case "user":
				request.Header["Authorization"] = "Basic " + base64.StdEncoding.EncodeToString([]byte(arg))
				state = ""

			case "method":
				request.Method = arg
				state = ""

			case "cookie":
				request.Header["Cookie"] = arg
				state = ""

			default:
				break
			}
		}

	}

	// format json body
	if value, ok := request.Header["Content-Type"]; ok && value == "application/json" {
		decoder := json.NewDecoder(strings.NewReader(request.Body))
		jsonData := make(map[string]interface{})
		if err := decoder.Decode(&jsonData); err == nil {
			buffer := &bytes.Buffer{}
			encoder := json.NewEncoder(buffer)
			encoder.SetEscapeHTML(false)
			if err = encoder.Encode(jsonData); err == nil {
				request.Body = strings.ReplaceAll(buffer.String(), "\n", "")
			}
		}
	}

	return request, true
}

func rewrite(args []string) []string {
	res := make([]string, 0)

	for _, arg := range args {

		arg = strings.TrimSpace(arg)

		if arg == "\n" {
			continue
		}

		if strings.Contains(arg, "\n") {
			arg = strings.ReplaceAll(arg, "\n", "")
		}

		// split request method
		if strings.Index(arg, "-X") == 0 {
			res = append(res, arg[0:2])
			res = append(res, arg[2:])
		} else {
			res = append(res, arg)
		}
	}

	return res
}

func isUrl(url string) bool {
	return strings.HasPrefix(url, "http://") ||
		strings.HasPrefix(url, "https://")
}

func parseField(arg string) []string {
	index := strings.Index(arg, ":")
	return []string{arg[0:index], arg[index+2:]}
}

func hasContentType(request Request) bool {
	if _, ok := request.Header["Content-Type"]; ok {
		return true
	}

	return false
}