Added namespace support

Author: roshangade

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Roshan Gade
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

api.go

@@ -6,21 +6,24 @@
 package rest
 
 import (
-	"./utils"
 	"errors"
 	"fmt"
+	"github.com/go-rs/rest-api-framework/utils"
 	"net/http"
 	"regexp"
 )
 
+type Handler func(ctx *Context)
+
 /**
  * API - Application
  */
 type API struct {
+	prefix       string
 	routes       []route
 	interceptors []interceptor
 	exceptions   []exception
-	unhandled    func(ctx *Context)
+	unhandled    Handler
 }
 
 /**
@@ -31,28 +34,28 @@ type route struct {
 	pattern string
 	regex   *regexp.Regexp
 	params  []string
-	handle  func(ctx *Context)
+	handle  Handler
 }
 
 /**
  * Request interceptor
  */
 type interceptor struct {
-	handle func(ctx *Context)
+	handle Handler
 }
 
 /**
  * Exception Route
  */
 type exception struct {
 	message string
-	handle  func(ctx *Context)
+	handle  Handler
 }
 
 /**
  * Common Route
  */
-func (api *API) Route(method string, pattern string, handle func(ctx *Context)) {
+func (api *API) Route(method string, pattern string, handle Handler) {
 	regex, params, err := utils.Compile(pattern)
 	if err != nil {
 		fmt.Println("Error in pattern", err)
@@ -98,8 +101,8 @@ func (api API) ServeHTTP(res http.ResponseWriter, req *http.Request) {
 			break
 		}
 
-		if route.method == req.Method && route.regex.Match(urlPath) {
-			ctx.found = true
+		if (route.method == "" || route.method == req.Method) && route.regex.Match(urlPath) {
+			ctx.found = route.method != "" //?
 			ctx.Params = utils.Exec(route.regex, route.params, urlPath)
 			route.handle(&ctx)
 		}
@@ -133,49 +136,53 @@ func (api API) ServeHTTP(res http.ResponseWriter, req *http.Request) {
 	}
 }
 
-func (api *API) Use(handle func(ctx *Context)) {
+func (api *API) Use(handle Handler) {
 	task := interceptor{
 		handle: handle,
 	}
 	api.interceptors = append(api.interceptors, task)
 }
 
-func (api *API) GET(pattern string, handle func(ctx *Context)) {
+func (api *API) All(pattern string, handle Handler) {
+	api.Route("", pattern, handle)
+}
+
+func (api *API) Get(pattern string, handle Handler) {
 	api.Route("GET", pattern, handle)
 }
 
-func (api *API) POST(pattern string, handle func(ctx *Context)) {
+func (api *API) Post(pattern string, handle Handler) {
 	api.Route("POST", pattern, handle)
 }
 
-func (api *API) PUT(pattern string, handle func(ctx *Context)) {
+func (api *API) Put(pattern string, handle Handler) {
 	api.Route("PUT", pattern, handle)
 }
 
-func (api *API) DELETE(pattern string, handle func(ctx *Context)) {
+func (api *API) Delete(pattern string, handle Handler) {
 	api.Route("DELETE", pattern, handle)
 }
 
-func (api *API) OPTIONS(pattern string, handle func(ctx *Context)) {
+func (api *API) Options(pattern string, handle Handler) {
 	api.Route("OPTIONS", pattern, handle)
 }
 
-func (api *API) HEAD(pattern string, handle func(ctx *Context)) {
+func (api *API) Head(pattern string, handle Handler) {
 	api.Route("HEAD", pattern, handle)
 }
 
-func (api *API) PATCH(pattern string, handle func(ctx *Context)) {
+func (api *API) Patch(pattern string, handle Handler) {
 	api.Route("PATCH", pattern, handle)
 }
 
-func (api *API) Exception(err string, handle func(ctx *Context)) {
+func (api *API) Exception(err string, handle Handler) {
 	exp := exception{
 		message: err,
 		handle:  handle,
 	}
 	api.exceptions = append(api.exceptions, exp)
 }
 
-func (api *API) UnhandledException(handle func(ctx *Context)) {
+func (api *API) UnhandledException(handle Handler) {
 	api.unhandled = handle
 }

context.go

@@ -6,7 +6,7 @@
 package rest
 
 import (
-	"./render"
+	"github.com/go-rs/rest-api-framework/render"
 	"net/http"
 )
 
@@ -150,10 +150,13 @@ func (ctx *Context) send(data []byte, err error) {
  * Unhandled Exception
  */
 func (ctx *Context) unhandledException() {
-	err := ctx.GetError().Error()
-	ctx.Status(500)
-	if err == "URL_NOT_FOUND" {
-		ctx.Status(404)
+	err := ctx.GetError()
+	if err != nil {
+		msg := err.Error()
+		ctx.Status(500)
+		if msg == "URL_NOT_FOUND" {
+			ctx.Status(404)
+		}
+		ctx.Write([]byte(msg))
 	}
-	ctx.Write([]byte(err))
 }

examples/server.go

@@ -4,57 +4,34 @@ import (
 	".."
 	"errors"
 	"fmt"
+	"github.com/go-rs/rest-api-framework/examples/user"
 	"net/http"
 )
 
 func main() {
 	var api rest.API
 
+	user.APIs(&api)
+
 	// request interceptor / middleware
-	// method-override
 	// body-parser : json, raw, form-data, etc
 	// security
 	api.Use(func(ctx *rest.Context) {
 		ctx.Set("authtoken", "roshangade")
 	})
 
 	// routes
-	api.GET("/", func(ctx *rest.Context) {
-		ctx.Text("Hello World!")
+	api.Get("/", func(ctx *rest.Context) {
+		ctx.JSON(`{"message": "Hello World!"}`)
 	})
 
-	api.GET("/foo", func(ctx *rest.Context) {
+	api.Get("/foo", func(ctx *rest.Context) {
 		ctx.Throw(errors.New("UNAUTHORIZED"))
 	})
 
-	api.GET("/strut", func(ctx *rest.Context) {
-		type user struct {
-			Name string
-		}
-
-		u := user{
-			Name: "roshan",
-		}
-
-		ctx.JSON(u)
-	})
-
-	api.GET("/json", func(ctx *rest.Context) {
-		ctx.JSON(`{"test": "JSON Response"}`)
-	})
-
-	api.GET("/:bar", func(ctx *rest.Context) {
-		fmt.Println("authtoken", ctx.Get("authtoken"))
-		ctx.JSON(ctx.Params)
-	})
-
 	// error handler
 	api.Exception("UNAUTHORIZED", func(ctx *rest.Context) {
-		ctx.Status(401).Text("You are unauthorized")
-	})
-
-	api.UnhandledException(func(ctx *rest.Context) {
-		fmt.Println("---> ", ctx.GetError())
+		ctx.Status(401).JSON(`{"message": "You are unauthorized"}`)
 	})
 
 	fmt.Println("Starting server.")

examples/user/user.go

@@ -0,0 +1,24 @@
+package user
+
+import (
+	"../.."
+)
+
+func APIs(api *rest.API) {
+
+	var user rest.Namespace
+
+	user.Set("/user", api)
+
+	user.Use(func(ctx *rest.Context) {
+		println("User middleware > /user/*")
+	})
+
+	user.Get("/:uid/profile", func(ctx *rest.Context) {
+		ctx.JSON(`{"user": "profile"}`)
+	})
+
+	user.Get("/:uid", func(ctx *rest.Context) {
+		ctx.JSON(ctx.Params)
+	})
+}

namespace.go

@@ -0,0 +1,64 @@
+/*!
+ * rest-api-framework
+ * Copyright(c) 2019 Roshan Gade
+ * MIT Licensed
+ */
+package rest
+
+/**
+ * Namespace - Application
+ */
+type Namespace struct {
+	prefix string
+	api    *API
+}
+
+//TODO: error handling on unset api
+func (n *Namespace) Set(prefix string, api *API) {
+	n.prefix = prefix
+	n.api = api
+}
+
+func (n *Namespace) Use(handle Handler) {
+	n.api.Route("", n.prefix+"/*", handle)
+}
+
+func (n *Namespace) All(pattern string, handle Handler) {
+	n.api.Route("", n.prefix+pattern, handle)
+}
+
+func (n *Namespace) Get(pattern string, handle Handler) {
+	n.api.Route("GET", n.prefix+pattern, handle)
+}
+
+func (n *Namespace) Post(pattern string, handle Handler) {
+	n.api.Route("POST", n.prefix+pattern, handle)
+}
+
+func (n *Namespace) Put(pattern string, handle Handler) {
+	n.api.Route("PUT", n.prefix+pattern, handle)
+}
+
+func (n *Namespace) Delete(pattern string, handle Handler) {
+	n.api.Route("DELETE", n.prefix+pattern, handle)
+}
+
+func (n *Namespace) Options(pattern string, handle Handler) {
+	n.api.Route("OPTIONS", n.prefix+pattern, handle)
+}
+
+func (n *Namespace) Head(pattern string, handle Handler) {
+	n.api.Route("HEAD", n.prefix+pattern, handle)
+}
+
+func (n *Namespace) Patch(pattern string, handle Handler) {
+	n.api.Route("PATCH", n.prefix+pattern, handle)
+}
+
+func (n *Namespace) Exception(err string, handle Handler) {
+	exp := exception{
+		message: err,
+		handle:  handle,
+	}
+	n.api.exceptions = append(n.api.exceptions, exp)
+}