Support PathParams

Author: nobu-k

context.go

@@ -140,14 +140,9 @@ func (c *Context) CLog(callerDepth int) *logrus.Entry {
 	}).WithFields(c.logFields)
 }
 
-func (c *Context) extractOptionStringFromPath(key string, target *string) error {
-	s, ok := c.request.PathParams[key]
-	if !ok {
-		return nil
-	}
-
-	*target = s
-	return nil
+// PathParams returns parameters embedded in the URL.
+func (c *Context) PathParams() *PathParams {
+	return &PathParams{c.request}
 }
 
 func (c *Context) render(status int, v interface{}) {

params.go

@@ -0,0 +1,52 @@
+package jasco
+
+import (
+	"fmt"
+	"github.com/gocraft/web"
+	"strconv"
+)
+
+// PathParams contains parameters embedded in the URL supported by gocraft/web
+type PathParams struct {
+	req *web.Request
+}
+
+// String returns a string value corresponding to key. When the key doesn't
+// exist, it returns defaultValue.
+func (p *PathParams) String(key string, defaultValue string) string {
+	s, ok := p.req.PathParams[key]
+	if !ok {
+		return defaultValue
+	}
+	return s
+}
+
+// RequiredString return a string value corresponding to the key. When the key
+// doesn't exist, it returns an error.
+func (p *PathParams) RequiredString(key string) (string, error) {
+	s, ok := p.req.PathParams[key]
+	if !ok {
+		return "", fmt.Errorf("path parameter '%v' doesn't exist", key)
+	}
+	return s, nil
+}
+
+// Int returns a positive integer value correspoding to the key as uint64. When
+// the key doesn't exist, it returns defaultValue. It returns an error if it
+// cannot parse the path string parameter as an integer or the value is greater
+// than or equal to 2^63.
+func (p *PathParams) Int(key string, defaultValue uint64) (uint64, error) {
+	s, err := p.RequiredString(key)
+	if err != nil {
+		return defaultValue, nil
+	}
+	return strconv.ParseUint(s, 10, 63)
+}
+
+func (p *PathParams) RequiredInt(key string) (uint64, error) {
+	s, err := p.RequiredString(key)
+	if err != nil {
+		return 0, err
+	}
+	return strconv.ParseUint(s, 10, 63)
+}

params_test.go

@@ -0,0 +1,117 @@
+package jasco
+
+import (
+	"github.com/gocraft/web"
+	. "github.com/smartystreets/goconvey/convey"
+	"testing"
+)
+
+func TestPathParams(t *testing.T) {
+	Convey("Given a PathParams", t, func() {
+		p := PathParams{
+			req: &web.Request{
+				PathParams: map[string]string{
+					"str":     "value",
+					"int":     "10",
+					"neg_int": "-10",
+				},
+			},
+		}
+
+		Convey("when getting an optional string value", func() {
+			s := p.String("str", "default")
+
+			Convey("it should return the stored value", func() {
+				So(s, ShouldEqual, "value")
+			})
+		})
+
+		Convey("when getting a nonexistent string value", func() {
+			s := p.String("nonexistent_str", "default")
+
+			Convey("it should return the default value", func() {
+				So(s, ShouldEqual, "default")
+			})
+		})
+
+		Convey("when getting a required string value", func() {
+			s, err := p.RequiredString("str")
+
+			Convey("it should succeed", func() {
+				So(err, ShouldBeNil)
+			})
+
+			Convey("it should return the stored value", func() {
+				So(s, ShouldEqual, "value")
+			})
+		})
+
+		Convey("when getting a required but nonexistent string value", func() {
+			_, err := p.RequiredString("nonexistent_str")
+
+			Convey("it should fail", func() {
+				So(err, ShouldNotBeNil)
+			})
+		})
+
+		Convey("when getting an optional positive integer value", func() {
+			i, err := p.Int("int", 20)
+
+			Convey("it should succeed", func() {
+				So(err, ShouldBeNil)
+			})
+
+			Convey("it should return the stored value", func() {
+				So(i, ShouldEqual, 10)
+			})
+		})
+
+		Convey("when getting a nonexistent positive integer value", func() {
+			i, err := p.Int("nonexistent_int", 20)
+
+			Convey("it should succeed", func() {
+				So(err, ShouldBeNil)
+			})
+
+			Convey("it should return the default value", func() {
+				So(i, ShouldEqual, 20)
+			})
+		})
+
+		Convey("when getting a required positive integer value", func() {
+			i, err := p.RequiredInt("int")
+
+			Convey("it should succeed", func() {
+				So(err, ShouldBeNil)
+			})
+
+			Convey("it should return the stored value", func() {
+				So(i, ShouldEqual, 10)
+			})
+		})
+
+		Convey("when getting a required but nonexistent positive integer value", func() {
+			_, err := p.RequiredInt("nonexistent_int")
+
+			Convey("it should fail", func() {
+				So(err, ShouldNotBeNil)
+			})
+		})
+
+		Convey("when getting a negative integer", func() {
+			_, err := p.Int("neg_int", 20)
+
+			Convey("it should fail", func() {
+				So(err, ShouldNotBeNil)
+			})
+		})
+
+		Convey("when getting a string as an integer", func() {
+			_, err := p.Int("str", 10)
+
+			Convey("it should fail", func() {
+				So(err, ShouldNotBeNil)
+			})
+		})
+	})
+}