Initial commit

Author: Arthur White

.gitignore

@@ -0,0 +1,22 @@
+_cgo_defun.c
+_cgo_export.*
+_cgo_gotypes.go
+_obj
+_test
+_testmain.go
+._*
+.AppleDouble
+.DS_Store
+.LSOverride
+[568vq].out
+*.[568vq]
+*.a
+*.cgo1.go
+*.cgo2.c
+*.exe
+*.o
+*.prof
+*.so
+*.test
+ehthumbs.db
+Thumbs.db

.travis.yml

@@ -0,0 +1,14 @@
+language: go
+
+go:
+  - tip
+
+env:
+  - CGO_ENABLED=0
+
+before_install:
+  - go get github.com/mattn/goveralls
+  - go get golang.org/x/tools/cmd/cover
+
+script:
+  - $HOME/gopath/bin/goveralls -service=travis-ci

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 WHITE
+
+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,39 @@
+# [![gowww](https://avatars.githubusercontent.com/u/18078923?s=20)](https://github.com/gowww) static [![GoDoc](https://godoc.org/github.com/gowww/static?status.svg)](https://godoc.org/github.com/gowww/static) [![Build](https://travis-ci.org/gowww/static.svg?branch=master)](https://travis-ci.org/gowww/static) [![Coverage](https://coveralls.io/repos/github/gowww/static/badge.svg?branch=master)](https://coveralls.io/github/gowww/static?branch=master) [![Go Report](https://goreportcard.com/badge/github.com/gowww/static)](https://goreportcard.com/report/github.com/gowww/static) ![Status Stable](https://img.shields.io/badge/status-stable-brightgreen.svg)
+
+Package [static](https://godoc.org/github.com/gowww/static) provides a handler for static file serving with cache control and automatic fingerprinting.
+
+## Installing
+
+1. Get package:
+
+	```Shell
+	go get -u github.com/gowww/static
+	```
+
+2. Import it in your code:
+
+	```Go
+	import "github.com/gowww/static"
+	```
+
+## Usage
+
+Use [Handle](https://godoc.org/github.com/gowww/static#Handle) with the URL path prefix and the source directory to get a [Handler](https://godoc.org/github.com/gowww/static#Handler) that will serve your static files:
+
+```Go
+staticHandler := static.Handle("/static/", "static")
+
+http.Handle("/static/", staticHandler)
+```
+
+Use [Handler.Hash](https://godoc.org/github.com/gowww/static#Handler.Hash) to append the file fingerprint to a file name (if the file can be opened, obviously):
+
+```Go
+staticHandler.Hash("scripts/main.js")
+```
+
+## References
+
+- [Strategies for cache-busting CSS — CSS Tricks](https://css-tricks.com/strategies-for-cache-busting-css/)
+- [Fingerprinting images to improve page load speed — Imgix](https://docs.imgix.com/best-practices/fingerprinting-images-improve-page-load-speed)
+- [Revving filenames: don’t use querystring](http://www.stevesouders.com/blog/2008/08/23/revving-filenames-dont-use-querystring/)

cache.go

@@ -0,0 +1,30 @@
+package static
+
+import (
+	"sync"
+	"time"
+)
+
+var hashCacheData = &hashCache{store: make(map[string]*cacheFileInfo)}
+
+type hashCache struct {
+	sync.RWMutex
+	store map[string]*cacheFileInfo
+}
+
+type cacheFileInfo struct {
+	Hash    string
+	ModTime time.Time
+}
+
+func (c *hashCache) Get(path string) *cacheFileInfo {
+	c.RLock()
+	defer c.RUnlock()
+	return c.store[path]
+}
+
+func (c *hashCache) Set(path, hash string, mod time.Time) {
+	c.Lock()
+	defer c.Unlock()
+	c.store[path] = &cacheFileInfo{hash, mod}
+}

example_test.go

@@ -0,0 +1,34 @@
+package static_test
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/gowww/static"
+)
+
+func Example() {
+	staticHandler := static.Handle("/static/", "static")
+
+	http.Handle("/static/", staticHandler)
+
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintf(w, "Cacheable asset: %s", staticHandler.Hash("main.js"))
+	})
+
+	http.ListenAndServe(":8080", nil)
+}
+
+func ExampleHandler_Hash() {
+	staticHandler := static.Handle("/static/", ".")
+
+	// File exists: hash will be appended to the file name.
+	fmt.Println(staticHandler.Hash("LICENSE"))
+
+	// File doesn't exist: the file name will contain no hash.
+	fmt.Println(staticHandler.Hash("unknown"))
+
+	// Output:
+	// /static/LICENSE.edbc4f9728a8e311b55e081b27e3caff
+	// /static/unknown
+}

handler.go

@@ -0,0 +1,86 @@
+// Package static provides a handler for static file serving with cache control and automatic fingerprinting.
+package static
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// A Handler serves files and provides helpers.
+type Handler interface {
+	http.Handler
+	Hash(string) string
+}
+
+type handler struct {
+	next   http.Handler
+	prefix string
+	dir    string
+}
+
+// Handle returns a handler for static file serving.
+func Handle(prefix, dir string) Handler {
+	if !strings.HasPrefix(prefix, "/") || !strings.HasSuffix(prefix, "/") {
+		panic(fmt.Errorf("static: prefix %q must begin and end with %q", prefix, "/"))
+	}
+	// TODO: Cache all file hashes from dir recursively in a goroutine.
+	return &handler{
+		next:   http.FileServer(http.Dir(dir)),
+		prefix: prefix,
+		dir:    dir,
+	}
+}
+
+func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	r.URL.Path = strings.TrimPrefix(r.URL.Path, h.prefix)
+	prefix, reqHash, ext := hashSplitFilepath(r.URL.Path)
+	if reqHash == "" { // No hash: serve file as wanted.
+		h.next.ServeHTTP(w, r)
+		return
+	}
+	realHash, err := fileHash(filepath.Join(h.dir, prefix+ext))
+	if err != nil { // Cannot open file to get real hash.
+		msg, code := toHTTPError(err)
+		http.Error(w, msg, code)
+		return
+	}
+	if reqHash != realHash { // Hash has changed: redirect to new one.
+		http.Redirect(w, r, h.prefix+prefix+"."+realHash+ext, http.StatusMovedPermanently)
+		return
+	}
+	r.URL.Path = prefix + ext
+	w.Header().Set("Cache-Control", "public, max-age=31536000")
+	w.Header().Set("ETag", `"`+realHash+`"`)
+	h.next.ServeHTTP(w, r)
+}
+
+// Hash returns the URL path from a prefix and a file path.
+// If the file was successfully opened, the file hash is appended to the file name.
+// dir is the directory where the file is to be found.
+func (h *handler) Hash(path string) string {
+	path = strings.TrimPrefix(path, "/") // Avoid double "/" as h.prefix already ends with one.
+	hash, err := fileHash(filepath.Join(h.dir, path))
+	if err != nil {
+		return h.prefix + path
+	}
+	extDotIdx := extDotIndex(path)
+	if extDotIdx == -1 {
+		return h.prefix + path + "." + hash
+	}
+	return h.prefix + path[:extDotIdx] + "." + hash + path[extDotIdx:]
+}
+
+// toHTTPError is copied from net/http/fs.go.
+func toHTTPError(err error) (msg string, httpStatus int) {
+	if os.IsNotExist(err) {
+		return "404 page not found", http.StatusNotFound
+	}
+	if os.IsPermission(err) {
+		return "403 Forbidden", http.StatusForbidden
+	}
+	// Default:
+	return "500 Internal Server Error", http.StatusInternalServerError
+}

hash.go

@@ -0,0 +1,101 @@
+/*
+Considered hashed filename schemes:
+	Example                         Problem
+	main-extra.min.js?v=h45h57r1n6  Query string may be ignored by shitty caches.
+	main-extra.min.js/h45h57r1n6    Cannot detect content type by extension and sort by file name.
+	main-extra.min.js.h45h57r1n6    Cannot detect content type by extension.
+	h45h57r1n6-main-extra.min.js    Cannot sort by file name.
+	main-extra-h45h57r1n6.min.js    Cannot sort by complete file name.
+	main-extra.min-h45h57r1n6.js    Ugly.
+	main-extra.min.h45h57r1n6.js    -
+*/
+
+package static
+
+import (
+	"os"
+
+	"github.com/gowww/crypto"
+)
+
+// isHash tells if s represents a hash.
+func isHash(s string) bool {
+	if len(s) != 32 {
+		return false
+	}
+	for i := 0; i < len(s); i++ {
+		b := s[i]
+		if b < '0' || b > '9' && b < 'a' || b > 'z' {
+			return false
+		}
+	}
+	return true
+}
+
+// hashSplitFilepath returns the part before the hash, the hash, and the filename extension (with dot).
+func hashSplitFilepath(path string) (prefix, hash, ext string) {
+	prefix = path
+	if prefix[len(prefix)-1] == '/' { // Path ends with slash: no hash.
+		return
+	}
+	extSep := extDotIndex(prefix)
+	if extSep == -1 { // No dot in last part: no hash or extension.
+		return
+	}
+	ext = prefix[extSep:]    // Put extension (with dot) in its return variable.
+	prefix = prefix[:extSep] // Strip extension from prefix.
+	hashSep := extDotIndex(prefix)
+	if hashSep == -1 { // A single dot in base: see if extension is in fact a hash.
+		extWithoutDot := ext[1:]
+		if isHash(extWithoutDot) {
+			hash, ext = extWithoutDot, ""
+		}
+		return
+	}
+	preHash := prefix[hashSep+1:] // Last filename part (without dot) could be a hash.
+	if isHash(preHash) {
+		hash = preHash            // Put hash in its return variable.
+		prefix = prefix[:hashSep] // Strip hash from prefix.
+	}
+	return
+}
+
+func fileHash(path string) (string, error) {
+	cfi := hashCacheData.Get(path)
+	if cfi != nil { // Check modification time to validate cached hash.
+		fi, err := os.Stat(path)
+		if err != nil {
+			return "", err
+		}
+		if !fi.ModTime().After(cfi.ModTime) {
+			return cfi.Hash, nil
+		}
+	}
+
+	f, err := os.Open(path)
+	if err != nil {
+		return "", err
+	}
+	defer f.Close()
+	hash, err := crypto.HashMD5(f)
+	if err != nil {
+		return "", err
+	}
+	stat, err := f.Stat()
+	if err != nil {
+		return "", err
+	}
+	hashCacheData.Set(path, hash, stat.ModTime())
+	return hash, nil
+}
+
+// extDotIndex returns the last dot index in the last path part.
+// It none, -1 is returned.
+func extDotIndex(path string) int {
+	for i := len(path) - 1; i >= 0 && path[i] != '/'; i-- {
+		if path[i] == '.' {
+			return i
+		}
+	}
+	return -1
+}