* Remove dependency on container/vector

hoisie · hoisie · commit d811c30d50d1 · 2011-10-24T13:08:04.000-04:00
* Fix multipart POST requests
diff --git a/request.go b/request.go
@@ -1,7 +1,6 @@
 package web
 
 import (
-    "container/vector"
     "fmt"
     "http"
     "io"
@@ -68,7 +67,6 @@ func newRequest(hr *http.Request, hc http.ResponseWriter) *Request {
 
     req := Request{
         Method:     hr.Method,
-        RawURL:     hr.RawURL,
         URL:        hr.URL,
         Proto:      hr.Proto,
         ProtoMajor: hr.ProtoMajor,
@@ -140,7 +138,6 @@ func newRequestCgi(headers http.Header, body io.Reader) *Request {
 }
 
 func parseForm(m map[string][]string, query string) (err os.Error) {
-    data := make(map[string]*vector.StringVector)
     for _, kv := range strings.Split(query, "&") {
         kvPair := strings.SplitN(kv, "=", 2)
 
@@ -154,16 +151,11 @@ func parseForm(m map[string][]string, query string) (err os.Error) {
             err = e
         }
 
-        vec, ok := data[key]
+        vec, ok := m[key]
         if !ok {
-            vec = new(vector.StringVector)
-            data[key] = vec
+            vec = []string{}
         }
-        vec.Push(value)
-    }
-
-    for k, vec := range data {
-        m[k] = vec.Copy()
+        m[key] = append(vec, value)
     }
 
     return
@@ -203,22 +195,27 @@ func (r *Request) parseParams() (err os.Error) {
             r.Params = map[string]string{}
             json.Unmarshal(b, r.Params)
         case "multipart/form-data":
-            _, params := mime.ParseMediaType(ct)
+            _, params, err := mime.ParseMediaType(ct)
+            if err != nil {
+                return err
+            }
             boundary, ok := params["boundary"]
             if !ok {
                 return os.NewError("Missing Boundary")
             }
+
             reader := multipart.NewReader(r.Body, boundary)
             r.Files = make(map[string]filedata)
             for {
                 part, err := reader.NextPart()
+                if part == nil && err == os.EOF {
+                    break
+                }
+
                 if err != nil {
                     return err
                 }
 
-                if part == nil {
-                    break
-                }
                 //read the data
                 data, _ := ioutil.ReadAll(part)
                 //check for the 'filename' param
@@ -227,15 +224,18 @@ func (r *Request) parseParams() (err os.Error) {
                     continue
                 }
                 name := part.FormName()
-                d, params := mime.ParseMediaType(v)
+                d, params, err := mime.ParseMediaType(v)
+                if err != nil {
+                    return err
+                }
                 if d != "form-data" {
                     continue
                 }
                 if params["filename"] != "" {
                     r.Files[name] = filedata{params["filename"], data}
                 } else {
-                    var params vector.StringVector = r.FullParams[name]
-                    params.Push(string(data))
+                    var params []string = r.FullParams[name]
+                    params = append(params, string(data))
                     r.FullParams[name] = params
                 }
 
@@ -244,6 +244,7 @@ func (r *Request) parseParams() (err os.Error) {
             return &badStringError{"unknown Content-Type", ct}
         }
     }
+
     if queryParams != "" {
         err = parseForm(r.FullParams, queryParams)
         if err != nil {
diff --git a/web.go b/web.go
@@ -2,7 +2,6 @@ package web
 
 import (
     "bytes"
-    "container/vector"
     "crypto/hmac"
     "encoding/base64"
     "fmt"
@@ -201,10 +200,10 @@ func (s *Server) addRoute(r string, method string, handler interface{}) {
     }
 
     if fv, ok := handler.(reflect.Value); ok {
-        s.routes.Push(route{r, cr, method, fv})
+        s.routes = append(s.routes, route{r, cr, method, fv})
     } else {
         fv := reflect.ValueOf(handler)
-        s.routes.Push(route{r, cr, method, fv})
+        s.routes = append(s.routes, route{r, cr, method, fv})
     }
 }
 
@@ -326,8 +325,8 @@ func (s *Server) routeHandler(req *Request, c conn) {
         return
     }
 
-    for i := 0; i < s.routes.Len(); i++ {
-        route := s.routes.At(i).(route)
+    for i := 0; i < len(s.routes); i++ {
+        route := s.routes[i]
         cr := route.cr
         //if the methods don't match, skip this handler (except HEAD can be used in place of GET)
         if req.Method != route.method && !(req.Method == "HEAD" && route.method == "GET") {
@@ -343,21 +342,16 @@ func (s *Server) routeHandler(req *Request, c conn) {
             continue
         }
 
-        var args vector.Vector
+        var args []reflect.Value
         handlerType := route.handler.Type()
         if requiresContext(handlerType) {
-            args.Push(reflect.ValueOf(&ctx))
+            args = append(args, reflect.ValueOf(&ctx))
         }
         for _, arg := range match[1:] {
-            args.Push(reflect.ValueOf(arg))
+            args = append(args, reflect.ValueOf(arg))
         }
 
-        valArgs := make([]reflect.Value, args.Len())
-        for i := 0; i < args.Len(); i++ {
-            valArgs[i] = args.At(i).(reflect.Value)
-        }
-
-        ret, err := s.safelyCall(route.handler, valArgs)
+        ret, err := s.safelyCall(route.handler, args)
         if err != nil {
             //fmt.Printf("%v\n", err)
             //there was an error or panic while calling the handler
@@ -406,7 +400,7 @@ var mainServer = Server{
 
 type Server struct {
     Config *ServerConfig
-    routes vector.Vector
+    routes []route
     Logger *log.Logger
     //save the listener so it can be closed
     l      net.Listener
