Initial commit

Author: vardius

.gitignore

@@ -0,0 +1,4 @@
+.idea
+.DS_Store
+tags
+coverage.out

.hound.yml

@@ -0,0 +1,2 @@
+go:
+  enabled: true

.travis.yml

@@ -0,0 +1,16 @@
+language: go
+go:
+  - 1.4
+  - 1.5
+  - 1.6
+  - tip	
+before_install:
+  - go get github.com/modocache/gover
+  - go get github.com/axw/gocov/gocov
+  - go get github.com/mattn/goveralls
+  - go get golang.org/x/tools/cmd/cover
+script:
+  - go test -v -cover -race -coverprofile=coverage.out
+  - $HOME/gopath/bin/gover
+after_script:
+  - goveralls -coverprofile=coverage.out -service=travis-ci -repotoken='SRBCsblTmbxSlR6cR6APELIJUWMlN47CA'

LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Carlos Alexandro Becker
+
+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.

README.md

@@ -0,0 +1,27 @@
+Vardius - goapi
+================
+[![Build Status](https://travis-ci.org/Vardius/goapi.svg?branch=master)](https://travis-ci.org/Vardius/goapi) [![](https://godoc.org/github.com/vardius/goapi?status.svg)](http://godoc.org/github.com/vardius/goapi) [![Coverage Status](https://coveralls.io/repos/github/Vardius/goapi/badge.svg?branch=master)](https://coveralls.io/github/Vardius/goapi?branch=master)
+
+The fastest Go API micro framwework, HTTP request router, multiplexer, mux.
+
+ABOUT
+==================================================
+Contributors:
+
+* [Rafał Lorenz](http://rafallorenz.com)
+
+Want to contribute ? Feel free to send pull requests!
+
+Have problems, bugs, feature ideas?
+We are using the github [issue tracker](https://github.com/vardius/goapi/issues) to manage them.
+
+HOW TO USE
+==================================================
+
+
+License
+-------
+
+This package is released under the MIT license. See the complete license in the package:
+
+[LICENSE](LICENSE.md)

middleware.go

@@ -0,0 +1,28 @@
+package goapi
+
+import (
+	"net/http"
+	"sort"
+)
+
+type (
+	middlewares []*middleware
+	middleware  struct {
+		path     string
+		priority int
+		handler  MiddlewareFunc
+	}
+	Error interface {
+		error
+		Status() int
+	}
+	MiddlewareFunc func(*http.Request) Error
+)
+
+func (m middlewares) Len() int           { return len(m) }
+func (m middlewares) Swap(i, j int)      { m[i], m[j] = m[j], m[i] }
+func (m middlewares) Less(i, j int) bool { return m[i].priority < m[j].priority }
+
+func sortByPriority(m middlewares) {
+	sort.Sort(middlewares(m))
+}

middleware_test.go

@@ -0,0 +1,18 @@
+package goapi
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPriority(t *testing.T) {
+	var m middlewares
+	m = append(m, &middleware{priority: 1}, &middleware{priority: 4}, &middleware{priority: 0}, &middleware{priority: 10})
+	sortByPriority(m)
+
+	assert.Equal(t, 0, m[0].priority)
+	assert.Equal(t, 1, m[1].priority)
+	assert.Equal(t, 4, m[2].priority)
+	assert.Equal(t, 10, m[3].priority)
+}

router.go

@@ -0,0 +1,81 @@
+package goapi
+
+import (
+	"net/http"
+	"regexp"
+	"strings"
+	"sync"
+)
+
+type (
+	tree  map[string]*route
+	route struct {
+		path       string
+		nodes      tree
+		nodesMu    sync.RWMutex
+		handler    http.HandlerFunc
+		middleware middlewares
+		regexp     *regexp.Regexp
+		isEndPoint bool
+	}
+)
+
+func (r *route) getRoute(paths []string) *route {
+	if len(paths) > 0 && paths[0] != "" {
+		r.nodesMu.RLock()
+		defer r.nodesMu.RUnlock()
+		if route := r.nodes[paths[0]]; route != nil {
+			return route.getRoute(paths[1:])
+		} else {
+			for path, route := range r.nodes {
+				if len(path) > 0 && path[:1] == ":" {
+					if route.regexp == nil {
+						return route.getRoute(paths[1:])
+					} else if route.regexp.MatchString(paths[0]) {
+						return route.getRoute(paths[1:])
+					}
+				}
+			}
+		}
+	} else if len(paths) == 0 && r.isEndPoint {
+		return r
+	}
+	return nil
+}
+
+func (r *route) addRoute(paths []string, f http.HandlerFunc) {
+	if len(paths) > 0 && paths[0] != "" {
+		r.nodesMu.Lock()
+		defer r.nodesMu.Unlock()
+		if r.nodes[paths[0]] == nil {
+			r.nodes[paths[0]] = newRoute(paths[0])
+		}
+		r.nodes[paths[0]].addRoute(paths[1:], f)
+	} else {
+		r.setEndPoint(f)
+	}
+}
+
+func (r *route) setEndPoint(f http.HandlerFunc) {
+	if len(r.path) > 0 && r.path[:1] == ":" {
+		if parts := strings.Split(r.path, ":"); len(parts) == 3 {
+			r.setRegexp(parts[2])
+		}
+	}
+	r.isEndPoint = true
+	r.handler = f
+}
+
+func (r *route) setRegexp(exp string) {
+	reg, err := regexp.Compile(exp)
+	if err == nil {
+		r.regexp = reg
+	}
+}
+
+func newRoute(path string) *route {
+	return &route{
+		path:  path,
+		nodes: make(tree),
+	}
+}

router_test.go

@@ -0,0 +1,139 @@
+package goapi
+
+import (
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetRootRoute(t *testing.T) {
+	r := newRoute("/")
+	paths := strings.Split(strings.Trim("/", "/"), "/")
+	r.addRoute(paths, func(w http.ResponseWriter, req *http.Request) {})
+
+	r.getRoute(paths)
+
+	assert.Nil(t, r.getRoute([]string{""}))
+	assert.Nil(t, r.getRoute([]string{"x"}))
+	assert.Nil(t, r.getRoute([]string{"", "x"}))
+	assert.Nil(t, r.getRoute([]string{"x", "y"}))
+	assert.NotNil(t, r.getRoute([]string{}))
+}
+
+func TestGetStrictRoute(t *testing.T) {
+	r := newRoute("/")
+	paths := strings.Split(strings.Trim("/x", "/"), "/")
+	r.addRoute(paths, func(w http.ResponseWriter, req *http.Request) {})
+
+	r.getRoute(paths)
+
+	assert.Nil(t, r.getRoute([]string{}))
+	assert.Nil(t, r.getRoute([]string{""}))
+	assert.Nil(t, r.getRoute([]string{"", "x"}))
+	assert.Nil(t, r.getRoute([]string{"x", "y"}))
+	assert.NotNil(t, r.getRoute([]string{"x"}))
+}
+
+func TestGetParamRoute(t *testing.T) {
+	r := newRoute("/")
+	paths := strings.Split(strings.Trim("/:x", "/"), "/")
+	r.addRoute(paths, func(w http.ResponseWriter, req *http.Request) {})
+
+	r.getRoute(paths)
+
+	assert.Nil(t, r.getRoute([]string{}))
+	assert.Nil(t, r.getRoute([]string{""}))
+	assert.Nil(t, r.getRoute([]string{"", "x"}))
+	assert.Nil(t, r.getRoute([]string{"x", "y"}))
+	assert.NotNil(t, r.getRoute([]string{"x"}))
+	assert.NotNil(t, r.getRoute([]string{"y"}))
+}
+
+func TestGetRegexRoute(t *testing.T) {
+	r := newRoute("/")
+	paths := strings.Split(strings.Trim("/:x:r([a-z]+)go", "/"), "/")
+	r.addRoute(paths, func(w http.ResponseWriter, req *http.Request) {})
+
+	r.getRoute(paths)
+
+	assert.Nil(t, r.getRoute([]string{}))
+	assert.Nil(t, r.getRoute([]string{""}))
+	assert.Nil(t, r.getRoute([]string{"", "x"}))
+	assert.Nil(t, r.getRoute([]string{"x", "y"}))
+	assert.Nil(t, r.getRoute([]string{"x"}))
+	assert.Nil(t, r.getRoute([]string{"y"}))
+	assert.Nil(t, r.getRoute([]string{"rego", "y"}))
+	assert.NotNil(t, r.getRoute([]string{"rego"}))
+}
+
+func TestAddRootRoute(t *testing.T) {
+	r := newRoute("/")
+	paths := strings.Split(strings.Trim("/", "/"), "/")
+	r.addRoute(paths, func(w http.ResponseWriter, req *http.Request) {})
+
+	assert.Equal(t, true, r.isEndPoint)
+	assert.Equal(t, tree{}, r.nodes)
+}
+
+func TestAddEmptyRootRoute(t *testing.T) {
+	r := newRoute("")
+	paths := strings.Split(strings.Trim("/", "/"), "/")
+	r.addRoute(paths, func(w http.ResponseWriter, req *http.Request) {})
+
+	assert.Equal(t, true, r.isEndPoint)
+	assert.Equal(t, tree{}, r.nodes)
+}
+
+func TestAddEmptyRootRouteTwo(t *testing.T) {
+	r := newRoute("")
+	paths := strings.Split(strings.Trim("", "/"), "/")
+	r.addRoute(paths, func(w http.ResponseWriter, req *http.Request) {})
+
+	assert.Equal(t, true, r.isEndPoint)
+	assert.Equal(t, tree{}, r.nodes)
+}
+
+func TestAddRoute(t *testing.T) {
+	r := newRoute("/")
+	paths := strings.Split(strings.Trim("/example", "/"), "/")
+	r.addRoute(paths, func(w http.ResponseWriter, req *http.Request) {})
+
+	assert.Equal(t, false, r.isEndPoint)
+	if assert.NotNil(t, r.nodes["example"]) {
+		assert.Equal(t, true, r.nodes["example"].isEndPoint)
+		assert.Equal(t, "example", r.nodes["example"].path)
+		assert.Nil(t, r.nodes["example"].regexp)
+	}
+}
+
+func TestAddParamRoute(t *testing.T) {
+	r := newRoute("/")
+	paths := strings.Split(strings.Trim("/:example", "/"), "/")
+	r.addRoute(paths, func(w http.ResponseWriter, req *http.Request) {})
+
+	assert.Equal(t, false, r.isEndPoint)
+	if assert.NotNil(t, r.nodes[":example"]) {
+		assert.Equal(t, true, r.nodes[":example"].isEndPoint)
+		assert.Equal(t, ":example", r.nodes[":example"].path)
+		assert.Nil(t, r.nodes[":example"].regexp)
+	}
+}
+
+func TestAddRegexpRoute(t *testing.T) {
+	r := newRoute("/")
+	paths := strings.Split(strings.Trim("/:example:r([a-z]+)go", "/"), "/")
+	r.addRoute(paths, func(w http.ResponseWriter, req *http.Request) {})
+
+	assert.Equal(t, false, r.isEndPoint)
+
+	route := r.nodes[":example:r([a-z]+)go"]
+	if assert.NotNil(t, route) {
+		assert.Equal(t, true, route.isEndPoint)
+		assert.Equal(t, ":example:r([a-z]+)go", route.path)
+		if assert.NotNil(t, route.regexp) {
+			assert.Equal(t, true, route.regexp.MatchString("rego"))
+		}
+	}
+}