initial support for path param

Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>

util.go

@@ -0,0 +1,124 @@
+package http
+
+import (
+	"fmt"
+	"net/http"
+	"reflect"
+	"strings"
+	"sync"
+
+	rutil "github.com/unistack-org/micro/v3/util/reflect"
+	util "github.com/unistack-org/micro/v3/util/router"
+)
+
+var (
+	templateCache = make(map[string]util.Template)
+	mu            sync.RWMutex
+)
+
+func newPathRequest(path string, method string, body string, msg interface{}) (string, interface{}, error) {
+	// parse via https://github.com/googleapis/googleapis/blob/master/google/api/http.proto definition
+	tpl, err := newTemplate(path)
+	if err != nil {
+		return "", nil, err
+	}
+
+	if len(tpl.Fields) == 0 {
+		return path, msg, nil
+	}
+
+	fieldsmap := make(map[string]string, len(tpl.Fields))
+	for _, v := range tpl.Fields {
+		fieldsmap[v] = ""
+	}
+
+	nmsg, err := rutil.Zero(msg)
+	if err != nil {
+		return "", nil, err
+	}
+
+	// we cant switch on message and use proto helpers, to avoid dependency to protobuf
+	tmsg := reflect.ValueOf(msg)
+	if tmsg.Kind() == reflect.Ptr {
+		tmsg = tmsg.Elem()
+	}
+
+	tnmsg := reflect.ValueOf(nmsg)
+	if tnmsg.Kind() == reflect.Ptr {
+		tnmsg = tnmsg.Elem()
+	}
+
+	values := make(map[string]string)
+	// copy cycle
+	for i := 0; i < tmsg.NumField(); i++ {
+		val := tmsg.Field(i)
+		if val.IsZero() {
+			continue
+		}
+		fld := tmsg.Type().Field(i)
+		lfield := strings.ToLower(fld.Name)
+		if _, ok := fieldsmap[lfield]; ok {
+			fieldsmap[lfield] = fmt.Sprintf("%v", val.Interface())
+		} else if body == "*" || body == lfield && method != http.MethodGet {
+			tnmsg.Field(i).Set(val)
+		} else if method == http.MethodGet {
+			values[lfield] = fmt.Sprintf("%v", val.Interface())
+		}
+	}
+
+	// check not filled stuff
+	for k, v := range fieldsmap {
+		if v == "" {
+			return "", nil, fmt.Errorf("path param %s not filled %s", k, v)
+		}
+	}
+
+	var b strings.Builder
+	for _, fld := range tpl.Pool {
+		_, _ = b.WriteRune('/')
+		if v, ok := fieldsmap[fld]; ok {
+			_, _ = b.WriteString(v)
+		} else {
+			_, _ = b.WriteString(fld)
+		}
+	}
+
+	if method == http.MethodGet {
+		idx := 0
+		for k, v := range values {
+			if idx == 0 {
+				_, _ = b.WriteRune('?')
+			} else {
+				_, _ = b.WriteRune('&')
+			}
+			_, _ = b.WriteString(k)
+			_, _ = b.WriteRune('=')
+			_, _ = b.WriteString(v)
+			idx++
+		}
+	}
+
+	return b.String(), nmsg, nil
+}
+
+func newTemplate(path string) (util.Template, error) {
+	mu.RLock()
+	tpl, ok := templateCache[path]
+	if ok {
+		mu.RUnlock()
+		return tpl, nil
+	}
+	mu.RUnlock()
+
+	rule, err := util.Parse(path)
+	if err != nil {
+		return tpl, err
+	}
+
+	tpl = rule.Compile()
+	mu.Lock()
+	templateCache[path] = tpl
+	mu.Unlock()
+
+	return tpl, nil
+}