feat: add methods to serve static files (#29)

Author: mojixcoder

kid.go

@@ -158,6 +158,25 @@ func (k *Kid) ADD(path string, handler HandlerFunc, methods []string, middleware
 	k.router.add(path, handler, methods, middlewares)
 }
 
+// Static registers a new route for serving static files.
+//
+// It uses http.Dir as its file system.
+func (k *Kid) Static(urlPath, staticRoot string, middlewares ...MiddlewareFunc) {
+	k.StaticFS(urlPath, FS{http.Dir(staticRoot)})
+}
+
+// StaticFS registers a new route for serving static files.
+//
+// It uses the given file system to serve static files.
+func (k *Kid) StaticFS(urlPath string, fs http.FileSystem, middlewares ...MiddlewareFunc) {
+	fileServer := newFileServer(urlPath, fs)
+
+	methods := []string{http.MethodGet}
+	path := appendSlash(urlPath) + "{*filePath}"
+
+	k.router.add(path, WrapHandler(fileServer), methods, middlewares)
+}
+
 // ServeHTTP implements the http.HandlerFunc interface.
 func (k *Kid) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	c := k.pool.Get().(*Context)

kid_test.go

@@ -491,3 +491,95 @@ func TestKidRun(t *testing.T) {
 	assert.Equal(t, "application/json", resp.Header.Get("Content-Type"))
 	assert.Equal(t, "{\"message\":\"healthy\"}\n", string(body))
 }
+
+func TestKidStatic(t *testing.T) {
+	k := New()
+
+	k.Static("/static/", "testdata/static")
+
+	testCases := []struct {
+		name               string
+		req                *http.Request
+		res                *httptest.ResponseRecorder
+		expectedStatusCode int
+		expectedContent    string
+	}{
+		{
+			name:               "Serving main.html",
+			req:                httptest.NewRequest(http.MethodGet, "/static/main.html", nil),
+			res:                httptest.NewRecorder(),
+			expectedStatusCode: http.StatusOK,
+			expectedContent:    "main",
+		},
+		{
+			name:               "Serving page.html in pages directory",
+			req:                httptest.NewRequest(http.MethodGet, "/static/pages/page.html", nil),
+			res:                httptest.NewRecorder(),
+			expectedStatusCode: http.StatusOK,
+			expectedContent:    "page",
+		},
+		{
+			name:               "Serving pages/index.html",
+			req:                httptest.NewRequest(http.MethodGet, "/static/pages/", nil),
+			res:                httptest.NewRecorder(),
+			expectedStatusCode: http.StatusOK,
+			expectedContent:    "index",
+		},
+		{
+			name:               "Non-existent",
+			req:                httptest.NewRequest(http.MethodGet, "/static/doesn't-exist.html", nil),
+			res:                httptest.NewRecorder(),
+			expectedStatusCode: http.StatusNotFound,
+			expectedContent:    "404 page not found\n",
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			k.ServeHTTP(testCase.res, testCase.req)
+
+			assert.Equal(t, testCase.expectedStatusCode, testCase.res.Code)
+			assert.Equal(t, testCase.expectedContent, testCase.res.Body.String())
+		})
+	}
+
+}
+
+func TestKidStaticFS(t *testing.T) {
+	k := New()
+
+	k.StaticFS("/static/", http.Dir("testdata/static"))
+
+	testCases := []struct {
+		name               string
+		req                *http.Request
+		res                *httptest.ResponseRecorder
+		expectedStatusCode int
+		expectedContent    string
+	}{
+		{
+			name:               "Serving main.html",
+			req:                httptest.NewRequest(http.MethodGet, "/static/main.html", nil),
+			res:                httptest.NewRecorder(),
+			expectedStatusCode: http.StatusOK,
+			expectedContent:    "main",
+		},
+		{
+			name:               "Serving page.html in pages directory",
+			req:                httptest.NewRequest(http.MethodGet, "/static/pages/page.html", nil),
+			res:                httptest.NewRecorder(),
+			expectedStatusCode: http.StatusOK,
+			expectedContent:    "page",
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			k.ServeHTTP(testCase.res, testCase.req)
+
+			assert.Equal(t, testCase.expectedStatusCode, testCase.res.Code)
+			assert.Equal(t, testCase.expectedContent, testCase.res.Body.String())
+		})
+	}
+
+}

static.go

@@ -0,0 +1,55 @@
+package kid
+
+import (
+	"net/http"
+	"os"
+)
+
+// FS is Kid's http.FileSystem implementation to disable directory listing.
+type FS struct {
+	http.FileSystem
+}
+
+// File is Kid's http.File implementation to disable directory listing.
+type File struct {
+	http.File
+}
+
+// Readdir overrides http.File's default implementation.
+//
+// It disables directory listing.
+func (f File) Readdir(count int) ([]os.FileInfo, error) {
+	return nil, nil
+}
+
+// Open overrides http.FileSystem's default implementation to disable directory listing.
+func (fs FS) Open(name string) (http.File, error) {
+	f, err := fs.FileSystem.Open(name)
+	if err != nil {
+		return nil, err
+	}
+
+	return File{f}, err
+}
+
+// newFileServer returns new file server.
+func newFileServer(urlPath string, fs http.FileSystem) http.Handler {
+	if fs == nil {
+		panic("file system cannot be nil")
+	}
+
+	urlPath = cleanPath(urlPath, false)
+	urlPath = appendSlash(urlPath)
+
+	fileServer := http.StripPrefix(urlPath, http.FileServer(fs))
+
+	return fileServer
+}
+
+// appendSlash appends slash to a path if the path is not end with slash.
+func appendSlash(path string) string {
+	if path[len(path)-1] != '/' {
+		path = path + "/"
+	}
+	return path
+}

static_test.go

@@ -0,0 +1,46 @@
+package kid
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAppendSlash(t *testing.T) {
+	path := "/static"
+	assert.Equal(t, "/static/", appendSlash(path))
+
+	path = path + "/"
+	assert.Equal(t, "/static/", appendSlash(path))
+}
+
+func TestNewFileServer(t *testing.T) {
+	assert.Panics(t, func() {
+		newFileServer("/static/", nil)
+	})
+
+	fileServer := newFileServer("/static/", http.Dir("/var/www"))
+	assert.NotNil(t, fileServer)
+}
+
+func TestFileReaddir(t *testing.T) {
+	var f File
+
+	info, err := f.Readdir(10)
+
+	assert.Nil(t, info)
+	assert.Nil(t, err)
+}
+
+func TestFSOpen(t *testing.T) {
+	fs := FS{http.Dir("testdata/static")}
+
+	f, err := fs.Open("non-existent.js")
+	assert.Error(t, err)
+	assert.Nil(t, f)
+
+	f, err = fs.Open("main.html")
+	assert.NoError(t, err)
+	assert.IsType(t, File{}, f)
+}

testdata/static/main.html

@@ -0,0 +1 @@
+main

testdata/static/pages/index.html

@@ -0,0 +1 @@
+index

testdata/static/pages/page.html

@@ -0,0 +1 @@
+page