internal: add NewPropfindResponse helper

internal/elements.go

@@ -117,7 +117,7 @@ func (resp *Response) DecodeProp(v interface{}) error {
 		propstat := &resp.Propstats[i]
 		for j := range propstat.Prop.Raw {
 			raw := &propstat.Prop.Raw[j]
-			if start, ok := raw.tok.(xml.StartElement); ok && name == start.Name {
+			if n, ok := raw.XMLName(); ok && name == n {
 				if err := propstat.Status.Err(); err != nil {
 					return err
 				}
@@ -183,16 +183,6 @@ func EncodeProp(values ...interface{}) (*Prop, error) {
 	return &Prop{Raw: l}, nil
 }
 
-func (prop *Prop) XMLNames() []xml.Name {
-	l := make([]xml.Name, 0, len(prop.Raw))
-	for _, raw := range prop.Raw {
-		if start, ok := raw.tok.(xml.StartElement); ok {
-			l = append(l, start.Name)
-		}
-	}
-	return l
-}
-
 // https://tools.ietf.org/html/rfc4918#section-14.20
 type Propfind struct {
 	XMLName  xml.Name  `xml:"DAV: propfind"`
@@ -232,7 +222,7 @@ func NewResourceType(names ...xml.Name) *ResourceType {
 
 func (t *ResourceType) Is(name xml.Name) bool {
 	for _, raw := range t.Raw {
-		if start, ok := raw.tok.(xml.StartElement); ok && name == start.Name {
+		if n, ok := raw.XMLName(); ok && name == n {
 			return true
 		}
 	}

internal/server.go

@@ -13,6 +13,17 @@ type HTTPError struct {
 	Err  error
 }
 
+func HTTPErrorFromError(err error) *HTTPError {
+	if err == nil {
+		return nil
+	}
+	if httpErr, ok := err.(*HTTPError); ok {
+		return httpErr
+	} else {
+		return &HTTPError{http.StatusInternalServerError, err}
+	}
+}
+
 func HTTPErrorf(code int, format string, a ...interface{}) *HTTPError {
 	return &HTTPError{code, fmt.Errorf(format, a...)}
 }
@@ -104,3 +115,68 @@ func (h *Handler) handlePropfind(w http.ResponseWriter, r *http.Request) error {
 	w.Write([]byte(xml.Header))
 	return xml.NewEncoder(w).Encode(&ms)
 }
+
+type PropfindFunc func(raw *RawXMLValue) (interface{}, error)
+
+func NewPropfindResponse(href string, propfind *Propfind, props map[xml.Name]PropfindFunc) (*Response, error) {
+	resp := NewOKResponse(href)
+
+	if propfind.PropName != nil {
+		for xmlName, _ := range props {
+			emptyVal := NewRawXMLElement(xmlName, nil, nil)
+			if err := resp.EncodeProp(http.StatusOK, emptyVal); err != nil {
+				return nil, err
+			}
+		}
+	} else if propfind.AllProp != nil {
+		// TODO: add support for propfind.Include
+		for xmlName, f := range props {
+			emptyVal := NewRawXMLElement(xmlName, nil, nil)
+
+			val, err := f(emptyVal)
+
+			code := http.StatusOK
+			if err != nil {
+				// TODO: don't throw away error message here
+				code = HTTPErrorFromError(err).Code
+				val = emptyVal
+			}
+
+			if err := resp.EncodeProp(code, val); err != nil {
+				return nil, err
+			}
+		}
+	} else if prop := propfind.Prop; prop != nil {
+		for _, raw := range prop.Raw {
+			xmlName, ok := raw.XMLName()
+			if !ok {
+				continue
+			}
+
+			emptyVal := NewRawXMLElement(xmlName, nil, nil)
+
+			var code int
+			var val interface{} = emptyVal
+			f, ok := props[xmlName]
+			if ok {
+				if v, err := f(&raw); err != nil {
+					// TODO: don't throw away error message here
+					code = HTTPErrorFromError(err).Code
+				} else {
+					code = http.StatusOK
+					val = v
+				}
+			} else {
+				code = http.StatusNotFound
+			}
+
+			if err := resp.EncodeProp(code, val); err != nil {
+				return nil, err
+			}
+		}
+	} else {
+		return nil, HTTPErrorf(http.StatusBadRequest, "webdav: propfind request missing propname, allprop or prop element")
+	}
+
+	return resp, nil
+}

internal/xml.go

@@ -89,6 +89,13 @@ func (val *RawXMLValue) Decode(v interface{}) error {
 	return xml.NewTokenDecoder(val.TokenReader()).Decode(&v)
 }
 
+func (val *RawXMLValue) XMLName() (name xml.Name, ok bool) {
+	if start, ok := val.tok.(xml.StartElement); ok {
+		return start.Name, true
+	}
+	return xml.Name{}, false
+}
+
 // TokenReader returns a stream of tokens for the XML value.
 func (val *RawXMLValue) TokenReader() xml.TokenReader {
 	if val.out != nil {