versioning API: initialize support for grouping

Former-commit-id: 36cf8cd79801e8556f3c7b560f3bd759d9770d67

versioning/group.go

@@ -0,0 +1,175 @@
+package versioning
+
+import (
+	"github.com/kataras/iris/context"
+	"github.com/kataras/iris/core/router"
+)
+
+func RegisterGroups(r router.Party, groups ...*Group) []*router.Route {
+	return Concat(groups...).For(r)
+}
+
+type (
+	vroute struct {
+		method   string
+		path     string
+		versions Map
+	}
+
+	Group struct {
+		version string
+		routes  []vroute
+
+		deprecation DeprecationOptions
+	}
+)
+
+func NewGroup(version string) *Group {
+	return &Group{
+		version: version,
+	}
+}
+
+// Deprecated marks this group and all its versioned routes
+// as deprecated versions of that endpoint.
+// It can be called in the end just before `Concat` or `RegisterGroups`
+// or first by `NewGroup(...).Deprecated(...)`. It returns itself.
+func (g *Group) Deprecated(options DeprecationOptions) *Group {
+	// if `Deprecated` is called in the end.
+	for _, r := range g.routes {
+		r.versions[g.version] = Deprecated(r.versions[g.version], options)
+	}
+
+	// store the options if called before registering any versioned routes.
+	g.deprecation = options
+
+	return g
+}
+
+// Handle registers a versioned route to the group.
+//
+// See `Concat` and `RegisterGroups` for more.
+func (g *Group) Handle(method string, registeredPath string, handler context.Handler) {
+	if g.deprecation.ShouldHandle() { // if `Deprecated` called first.
+		handler = Deprecated(handler, g.deprecation)
+	}
+
+	g.routes = append(g.routes, vroute{
+		method:   method,
+		path:     registeredPath,
+		versions: Map{g.version: handler},
+	})
+}
+
+// None registers an "offline" versioned route
+// see `context#ExecRoute(routeName)` and routing examples.
+func (g *Group) None(path string, handler context.Handler) {
+	g.Handle(router.MethodNone, path, handler)
+}
+
+// Get registers a versioned route for the Get http method.
+func (g *Group) Get(path string, handler context.Handler) {
+	g.Handle("GET", path, handler)
+}
+
+// Post registers a versioned route for the Post http method.
+func (g *Group) Post(path string, handler context.Handler) {
+	g.Handle("POST", path, handler)
+}
+
+// Put registers a versioned route for the Put http method
+func (g *Group) Put(path string, handler context.Handler) {
+	g.Handle("PUT", path, handler)
+}
+
+// Delete registers a versioned route for the Delete http method.
+func (g *Group) Delete(path string, handler context.Handler) {
+	g.Handle("DELETE", path, handler)
+}
+
+// Connect registers a versioned route for the Connect http method.
+func (g *Group) Connect(path string, handler context.Handler) {
+	g.Handle("CONNECT", path, handler)
+}
+
+// Head registers a versioned route for the Head http method.
+func (g *Group) Head(path string, handler context.Handler) {
+	g.Handle("HEAD", path, handler)
+}
+
+// Options registers a versioned route for the Options http method.
+func (g *Group) Options(path string, handler context.Handler) {
+	g.Handle("OPTIONS", path, handler)
+}
+
+// Patch registers a versioned route for the Patch http method.
+func (g *Group) Patch(path string, handler context.Handler) {
+	g.Handle("PATCH", path, handler)
+}
+
+// Trace registers a versioned route for the Trace http method.
+func (g *Group) Trace(path string, handler context.Handler) {
+	g.Handle("TRACE", path, handler)
+}
+
+// Any registers a versioned route for ALL of the http methods
+// (Get,Post,Put,Head,Patch,Options,Connect,Delete).
+func (g *Group) Any(registeredPath string, handler context.Handler) {
+	g.Get(registeredPath, handler)
+	g.Post(registeredPath, handler)
+	g.Put(registeredPath, handler)
+	g.Delete(registeredPath, handler)
+	g.Connect(registeredPath, handler)
+	g.Head(registeredPath, handler)
+	g.Options(registeredPath, handler)
+	g.Patch(registeredPath, handler)
+	g.Trace(registeredPath, handler)
+}
+
+type Groups struct {
+	routes []vroute
+
+	notFoundHandler context.Handler
+}
+
+func Concat(groups ...*Group) *Groups {
+	var total []vroute
+
+	for _, g := range groups {
+	inner:
+		for _, r := range g.routes {
+			for i, tr := range total {
+				if tr.method == r.method && tr.path == r.path {
+					for k, v := range r.versions {
+						total[i].versions[k] = v
+					}
+					continue inner
+				}
+			}
+		}
+
+		total = append(total, g.routes...)
+	}
+
+	return &Groups{total, NotFoundHandler}
+}
+
+func (g *Groups) NotFound(handler context.Handler) *Groups {
+	g.notFoundHandler = handler
+	return g
+}
+
+func (g *Groups) For(r router.Party) (totalRoutesRegistered []*router.Route) {
+	for _, vr := range g.routes {
+		if g.notFoundHandler != nil {
+			vr.versions[NotFound] = g.notFoundHandler
+		}
+
+		// fmt.Printf("Method: %s | Path: %s | Versions: %#+v\n", vr.method, vr.path, vr.versions)
+		route := r.Handle(vr.method, vr.path,
+			NewMatcher(vr.versions))
+		totalRoutesRegistered = append(totalRoutesRegistered, route)
+	}
+
+	return
+}