Added option to disable logging when serving static assets

logger.go

@@ -9,12 +9,14 @@ import (
 // Logger returns a middleware handler that logs the request as it goes in and the response as it goes out.
 func Logger() Handler {
 	return func(res http.ResponseWriter, req *http.Request, c Context, log *log.Logger) {
-		start := time.Now()
-		log.Printf("Started %s %s", req.Method, req.URL.Path)
+		if !c.Written() {
+			start := time.Now()
+			log.Printf("Started %s %s", req.Method, req.URL.Path)
 
-		rw := res.(ResponseWriter)
-		c.Next()
+			rw := res.(ResponseWriter)
+			c.Next()
 
-		log.Printf("Completed %v %s in %v\n", rw.Status(), http.StatusText(rw.Status()), time.Since(start))
+			log.Printf("Completed %v %s in %v\n", rw.Status(), http.StatusText(rw.Status()), time.Since(start))
+		}
 	}
 }

logger_test.go

@@ -29,3 +29,25 @@ func Test_Logger(t *testing.T) {
 	expect(t, recorder.Code, http.StatusNotFound)
 	refute(t, len(buff.String()), 0)
 }
+
+func Test_LoggerWritten(t *testing.T) {
+	buff := bytes.NewBufferString("")
+	recorder := httptest.NewRecorder()
+
+	m := New()
+	// replace log for testing
+	m.Map(log.New(buff, "[martini] ", 0))
+	m.Use(func(res http.ResponseWriter) {
+		res.WriteHeader(http.StatusNotFound)
+	}) // c.Written() should be true now
+	m.Use(Logger())
+
+	req, err := http.NewRequest("GET", "http://localhost:3000/foobar", nil)
+	if err != nil {
+		t.Error(err)
+	}
+
+	m.ServeHTTP(recorder, req)
+	expect(t, recorder.Code, http.StatusNotFound)
+	expect(t, len(buff.String()), 0)
+}

static.go

@@ -7,9 +7,32 @@ import (
 	"strings"
 )
 
+type StaticOptions struct {
+	SkipLogging    bool
+	SkipServeIndex bool
+	IndexFile      string
+}
+
+func prepareStaticOptions(options []StaticOptions) StaticOptions {
+	if len(options) > 0 {
+		// Default index file to serve should be index.html
+		if options[0].IndexFile == "" {
+			options[0].IndexFile = "index.html"
+		}
+		return options[0]
+	}
+	return StaticOptions{
+		SkipLogging:    false,        // Logging is on by default
+		SkipServeIndex: false,        // Try to serve index.html by default
+		IndexFile:      "index.html", // Default index file to serve
+	}
+}
+
 // Static returns a middleware handler that serves static files in the given directory.
-func Static(directory string) Handler {
+func Static(directory string, staticOpt ...StaticOptions) Handler {
 	dir := http.Dir(directory)
+	opt := prepareStaticOptions(staticOpt)
+
 	return func(res http.ResponseWriter, req *http.Request, log *log.Logger) {
 		file := req.URL.Path
 		f, err := dir.Open(file)
@@ -24,29 +47,33 @@ func Static(directory string) Handler {
 			return
 		}
 
-		// Try to serve index.html
-		if fi.IsDir() {
+		if !opt.SkipServeIndex {
+			// Try to serve index.html
+			if fi.IsDir() {
 
-			// redirect if missing trailing slash
-			if !strings.HasSuffix(file, "/") {
-				http.Redirect(res, req, file+"/", http.StatusFound)
-				return
-			}
+				// redirect if missing trailing slash
+				if !strings.HasSuffix(file, "/") {
+					http.Redirect(res, req, file+"/", http.StatusFound)
+					return
+				}
 
-			file = path.Join(file, "index.html")
-			f, err = dir.Open(file)
-			if err != nil {
-				return
-			}
-			defer f.Close()
+				file = path.Join(file, opt.IndexFile)
+				f, err = dir.Open(file)
+				if err != nil {
+					return
+				}
+				defer f.Close()
 
-			fi, err = f.Stat()
-			if err != nil || fi.IsDir() {
-				return
+				fi, err = f.Stat()
+				if err != nil || fi.IsDir() {
+					return
+				}
 			}
 		}
 
-		log.Println("[Static] Serving " + file)
+		if !opt.SkipLogging {
+			log.Println("[Static] Serving " + file)
+		}
 		http.ServeContent(res, req, file, fi.ModTime(), f)
 	}
 }

static_test.go

@@ -1,6 +1,9 @@
 package martini
 
 import (
+	"bytes"
+	"github.com/codegangsta/inject"
+	"log"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -53,3 +56,69 @@ func Test_Static_BadDir(t *testing.T) {
 	m.ServeHTTP(response, req)
 	refute(t, response.Code, http.StatusOK)
 }
+
+func Test_Static_Options_Logging(t *testing.T) {
+	response := httptest.NewRecorder()
+
+	var buffer bytes.Buffer
+	m := &Martini{inject.New(), []Handler{}, func() {}, log.New(&buffer, "[martini] ", 0)}
+	m.Map(m.logger)
+	m.Map(defaultReturnHandler())
+
+	opt := StaticOptions{}
+	m.Use(Static(".", opt))
+
+	req, err := http.NewRequest("GET", "http://localhost:3000/martini.go", nil)
+	if err != nil {
+		t.Error(err)
+	}
+
+	m.ServeHTTP(response, req)
+	expect(t, response.Code, http.StatusOK)
+	expect(t, buffer.String(), "[martini] [Static] Serving /martini.go\n")
+
+	// Now without logging
+	m.Handlers()
+	buffer.Reset()
+
+	// This should disable logging
+	opt.SkipLogging = true
+	m.Use(Static(".", opt))
+
+	m.ServeHTTP(response, req)
+	expect(t, response.Code, http.StatusOK)
+	expect(t, buffer.String(), "")
+}
+
+func Test_Static_Options_ServeIndex(t *testing.T) {
+	response := httptest.NewRecorder()
+
+	var buffer bytes.Buffer
+	m := &Martini{inject.New(), []Handler{}, func() {}, log.New(&buffer, "[martini] ", 0)}
+	m.Map(m.logger)
+	m.Map(defaultReturnHandler())
+
+	opt := StaticOptions{IndexFile: "martini.go"} // Define martini.go as index file
+	m.Use(Static(".", opt))
+
+	req, err := http.NewRequest("GET", "http://localhost:3000/", nil)
+	if err != nil {
+		t.Error(err)
+	}
+
+	m.ServeHTTP(response, req)
+	expect(t, response.Code, http.StatusOK)
+	expect(t, buffer.String(), "[martini] [Static] Serving /martini.go\n")
+
+	// Now without index serving
+	m.Handlers()
+	buffer.Reset()
+
+	// This should make Static() stop serving index.html (or martini.go in this case)
+	opt.SkipServeIndex = true
+	m.Use(Static(".", opt))
+
+	m.ServeHTTP(response, req)
+	expect(t, response.Code, http.StatusOK)
+	expect(t, buffer.String(), "[martini] [Static] Serving /\n")
+}