Use godep

Godeps/_workspace/src/github.com/calmh/ini/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2013 Jakob Borg
+
+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.

Godeps/_workspace/src/github.com/calmh/ini/README.md

@@ -0,0 +1,39 @@
+ini [![Build Status](https://drone.io/github.com/calmh/ini/status.png)](https://drone.io/github.com/calmh/ini/latest)
+===
+
+Yet another .INI file parser / writer. Created because the existing ones
+were either not general enough (allowing easy access to all parts of the
+original file) or made annoying assumptions about the format. And
+probably equal parts NIH. You might want to just write your own instead
+of using this one, you know that's where you'll end up in the end
+anyhow.
+
+Documentation
+-------------
+
+http://godoc.org/github.com/calmh/ini
+
+Example
+-------
+
+```go
+fd, _ := os.Open("foo.ini")
+cfg := ini.Parse(fd)
+fd.Close()
+
+val := cfg.Get("general", "foo")
+cfg.Set("general", "bar", "baz")
+
+fd, _ = os.Create("bar.ini")
+err := cfg.Write(fd)
+if err != nil {
+	// ...
+}
+err = fd.Close()
+
+```
+
+License
+-------
+
+MIT

Godeps/_workspace/src/github.com/calmh/ini/ini.go

@@ -0,0 +1,220 @@
+// Package ini provides trivial parsing of .INI format files.
+package ini
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// Config is a parsed INI format file.
+type Config struct {
+	sections []section
+	comments []string
+}
+
+type section struct {
+	name     string
+	comments []string
+	options  []option
+}
+
+type option struct {
+	name, value string
+}
+
+var (
+	iniSectionRe = regexp.MustCompile(`^\[(.+)\]$`)
+	iniOptionRe  = regexp.MustCompile(`^([^\s=]+)\s*=\s*(.+?)$`)
+)
+
+// Sections returns the list of sections in the file.
+func (c *Config) Sections() []string {
+	var sections []string
+	for _, sect := range c.sections {
+		sections = append(sections, sect.name)
+	}
+	return sections
+}
+
+// Options returns the list of options in a given section.
+func (c *Config) Options(section string) []string {
+	var options []string
+	for _, sect := range c.sections {
+		if sect.name == section {
+			for _, opt := range sect.options {
+				options = append(options, opt.name)
+			}
+			break
+		}
+	}
+	return options
+}
+
+// OptionMap returns the map option => value for a given section.
+func (c *Config) OptionMap(section string) map[string]string {
+	options := make(map[string]string)
+	for _, sect := range c.sections {
+		if sect.name == section {
+			for _, opt := range sect.options {
+				options[opt.name] = opt.value
+			}
+			break
+		}
+	}
+	return options
+}
+
+// Comments returns the list of comments in a given section.
+// For the empty string, returns the file comments.
+func (c *Config) Comments(section string) []string {
+	if section == "" {
+		return c.comments
+	}
+	for _, sect := range c.sections {
+		if sect.name == section {
+			return sect.comments
+		}
+	}
+	return nil
+}
+
+// AddComments appends the comment to the list of comments for the section.
+func (c *Config) AddComment(sect, comment string) {
+	if sect == "" {
+		c.comments = append(c.comments, comment)
+		return
+	}
+
+	for i, s := range c.sections {
+		if s.name == sect {
+			c.sections[i].comments = append(s.comments, comment)
+			return
+		}
+	}
+
+	c.sections = append(c.sections, section{
+		name:     sect,
+		comments: []string{comment},
+	})
+}
+
+// Parse reads the given io.Reader and returns a parsed Config object.
+func Parse(stream io.Reader) Config {
+	var cfg Config
+	var curSection string
+
+	scanner := bufio.NewScanner(bufio.NewReader(stream))
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if strings.HasPrefix(line, "#") || strings.HasPrefix(line, ";") {
+			comment := strings.TrimLeft(line, ";# ")
+			cfg.AddComment(curSection, comment)
+		} else if len(line) > 0 {
+			if m := iniSectionRe.FindStringSubmatch(line); len(m) > 0 {
+				curSection = m[1]
+			} else if m := iniOptionRe.FindStringSubmatch(line); len(m) > 0 {
+				key := m[1]
+				val := m[2]
+				if !strings.Contains(val, "\"") {
+					// If val does not contain any quote characers, we can make it
+					// a quoted string and safely let strconv.Unquote sort out any
+					// escapes
+					val = "\"" + val + "\""
+				}
+				if val[0] == '"' {
+					val, _ = strconv.Unquote(val)
+				}
+
+				cfg.Set(curSection, key, val)
+			}
+		}
+	}
+	return cfg
+}
+
+// Write writes the sections and options to the io.Writer in INI format.
+func (c *Config) Write(out io.Writer) error {
+	for _, cmt := range c.comments {
+		fmt.Fprintln(out, "; "+cmt)
+	}
+	if len(c.comments) > 0 {
+		fmt.Fprintln(out)
+	}
+
+	for _, sect := range c.sections {
+		fmt.Fprintf(out, "[%s]\n", sect.name)
+		for _, cmt := range sect.comments {
+			fmt.Fprintln(out, "; "+cmt)
+		}
+		for _, opt := range sect.options {
+			val := opt.value
+			if len(val) == 0 {
+				continue
+			}
+
+			// Quote the string if it begins or ends with space
+			needsQuoting := val[0] == ' ' || val[len(val)-1] == ' '
+
+			if !needsQuoting {
+				// Quote the string if it contains any unprintable characters
+				for _, r := range val {
+					if !strconv.IsPrint(r) {
+						needsQuoting = true
+						break
+					}
+				}
+			}
+
+			if needsQuoting {
+				val = strconv.Quote(val)
+			}
+
+			fmt.Fprintf(out, "%s=%s\n", opt.name, val)
+		}
+		fmt.Fprintln(out)
+	}
+	return nil
+}
+
+// Get gets the value from the specified section and key name, or the empty
+// string if either the section or the key is missing.
+func (c *Config) Get(section, key string) string {
+	for _, sect := range c.sections {
+		if sect.name == section {
+			for _, opt := range sect.options {
+				if opt.name == key {
+					return opt.value
+				}
+			}
+			return ""
+		}
+	}
+	return ""
+}
+
+// Set sets a value for an option in a section. If the option exists, it's
+// value will be overwritten. If the option does not exist, it will be added.
+// If the section does not exist, it will be added and the option added to it.
+func (c *Config) Set(sectionName, key, value string) {
+	for i, sect := range c.sections {
+		if sect.name == sectionName {
+			for j, opt := range sect.options {
+				if opt.name == key {
+					c.sections[i].options[j].value = value
+					return
+				}
+			}
+			c.sections[i].options = append(sect.options, option{key, value})
+			return
+		}
+	}
+
+	c.sections = append(c.sections, section{
+		name:    sectionName,
+		options: []option{{key, value}},
+	})
+}

Godeps/_workspace/src/github.com/calmh/ini/ini_test.go

@@ -0,0 +1,178 @@
+package ini_test
+
+import (
+	"bytes"
+	"github.com/calmh/ini"
+	"strings"
+	"testing"
+)
+
+func TestParseValues(t *testing.T) {
+	strs := []string{
+		`[general]`,
+		`k1=v1`,
+		`k2 = v2`,
+		` k3 = v3 `,
+		`k4=" quoted spaces "`,
+		`k5 = " quoted spaces " `,
+		`k6 = with\nnewline`,
+		`k7 = "with\nnewline"`,
+		`k8 = a "quoted" word`,
+		`k9 = "a \"quoted\" word"`,
+	}
+	buf := bytes.NewBufferString(strings.Join(strs, "\n"))
+	cfg := ini.Parse(buf)
+
+	correct := map[string]string{
+		"k1": "v1",
+		"k2": "v2",
+		"k3": "v3",
+		"k4": " quoted spaces ",
+		"k5": " quoted spaces ",
+		"k6": "with\nnewline",
+		"k7": "with\nnewline",
+		"k8": "a \"quoted\" word",
+		"k9": "a \"quoted\" word",
+	}
+
+	for k, v := range correct {
+		if v2 := cfg.Get("general", k); v2 != v {
+			t.Errorf("Incorrect general.%s, %q != %q", k, v2, v)
+		}
+	}
+
+	if v := cfg.Get("general", "nonexistant"); v != "" {
+		t.Errorf("Unexpected non-empty value %q", v)
+	}
+}
+
+func TestParseComments(t *testing.T) {
+	strs := []string{
+		";file comment 1",   // No leading space
+		"; file comment 2 ", // Trailing space
+		";  file comment 3", // Multiple leading spaces
+		"[general]",
+		"; b general comment 1", // Comments in unsorted order
+		"somekey = somevalue",
+		"; a general comment 2",
+		"[other]",
+		"; other comment 1", // Comments in section with no values
+		"; other comment 2",
+		"[other2]",
+		"; other2 comment 1",
+		"; other2 comment 2", // Comments on last section
+		"somekey = somevalue",
+	}
+	buf := bytes.NewBufferString(strings.Join(strs, "\n"))
+
+	correct := map[string][]string{
+		"":        []string{"file comment 1", "file comment 2", "file comment 3"},
+		"general": []string{"b general comment 1", "a general comment 2"},
+		"other":   []string{"other comment 1", "other comment 2"},
+		"other2":  []string{"other2 comment 1", "other2 comment 2"},
+	}
+
+	cfg := ini.Parse(buf)
+
+	for section, comments := range correct {
+		cmts := cfg.Comments(section)
+		if len(cmts) != len(comments) {
+			t.Errorf("Incorrect number of comments for section %q: %d != %d", section, len(cmts), len(comments))
+		} else {
+			for i := range comments {
+				if cmts[i] != comments[i] {
+					t.Errorf("Incorrect comment: %q != %q", cmts[i], comments[i])
+				}
+			}
+		}
+	}
+}
+
+func TestWrite(t *testing.T) {
+	cfg := ini.Config{}
+	cfg.Set("general", "k1", "v1")
+	cfg.Set("general", "k2", "foo bar")
+	cfg.Set("general", "k3", " foo bar ")
+	cfg.Set("general", "k4", "foo\nbar")
+
+	var out bytes.Buffer
+	cfg.Write(&out)
+
+	correct := `[general]
+k1=v1
+k2=foo bar
+k3=" foo bar "
+k4="foo\nbar"
+
+`
+	if s := out.String(); s != correct {
+		t.Errorf("Incorrect written .INI:\n%s\ncorrect:\n%s", s, correct)
+	}
+}
+
+func TestSet(t *testing.T) {
+	buf := bytes.NewBufferString("[general]\nfoo=bar\nfoo2=bar2\n")
+	cfg := ini.Parse(buf)
+
+	cfg.Set("general", "foo", "baz")  // Overwrite existing
+	cfg.Set("general", "baz", "quux") // Create new value
+	cfg.Set("other", "baz2", "quux2") // Create new section + value
+
+	var out bytes.Buffer
+	cfg.Write(&out)
+
+	correct := `[general]
+foo=baz
+foo2=bar2
+baz=quux
+
+[other]
+baz2=quux2
+
+`
+
+	if s := out.String(); s != correct {
+		t.Errorf("Incorrect INI after set:\n%s", s)
+	}
+}
+
+func TestSetManyEquals(t *testing.T) {
+	buf := bytes.NewBufferString("[general]\nfoo=bar==\nfoo2=bar2==\n")
+	cfg := ini.Parse(buf)
+
+	cfg.Set("general", "foo", "baz==")
+
+	var out bytes.Buffer
+	cfg.Write(&out)
+
+	correct := `[general]
+foo=baz==
+foo2=bar2==
+
+`
+
+	if s := out.String(); s != correct {
+		t.Errorf("Incorrect INI after set:\n%s", s)
+	}
+}
+
+func TestRewriteDuplicate(t *testing.T) {
+	buf := bytes.NewBufferString("[general]\nfoo=bar==\nfoo=bar2==\n")
+	cfg := ini.Parse(buf)
+
+	if v := cfg.Get("general", "foo"); v != "bar2==" {
+		t.Errorf("incorrect get %q", v)
+	}
+
+	var out bytes.Buffer
+	cfg.Write(&out)
+
+	correct := `[general]
+foo=bar2==
+
+`
+
+	if s := out.String(); s != correct {
+		t.Errorf("Incorrect INI after set:\n%s", s)
+	}
+}

Godeps/_workspace/src/github.com/codegangsta/inject/.gitignore

@@ -0,0 +1,2 @@
+inject
+inject.test

Godeps/_workspace/src/github.com/codegangsta/inject/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Jeremy Saenz
+
+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.

Godeps/_workspace/src/github.com/codegangsta/inject/README.md

@@ -0,0 +1,4 @@
+inject
+======
+
+Dependency injection for go

Godeps/_workspace/src/github.com/codegangsta/inject/inject.go

@@ -0,0 +1,122 @@
+package inject
+
+import (
+	"fmt"
+	"reflect"
+)
+
+type Injector interface {
+	Applicator
+	Invoker
+	TypeMapper
+	SetParent(Injector)
+}
+
+type Applicator interface {
+	Apply(interface{}) error
+}
+
+type Invoker interface {
+	Invoke(interface{}) ([]reflect.Value, error)
+}
+
+type TypeMapper interface {
+	Map(interface{}) TypeMapper
+	MapTo(interface{}, interface{}) TypeMapper
+	Get(reflect.Type) reflect.Value
+}
+
+type injector struct {
+	values map[reflect.Type]reflect.Value
+	parent Injector
+}
+
+func InterfaceOf(value interface{}) reflect.Type {
+	t := reflect.TypeOf(value)
+
+	for t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+
+	if t.Kind() != reflect.Interface {
+		panic("Called inject.InterfaceOf with a value that is not a pointer to an interface. (*MyInterface)(nil)")
+	}
+
+	return t
+}
+
+func New() Injector {
+	return &injector{
+		values: make(map[reflect.Type]reflect.Value),
+	}
+}
+
+func (inj *injector) Invoke(f interface{}) ([]reflect.Value, error) {
+	t := reflect.TypeOf(f)
+
+	var in = make([]reflect.Value, t.NumIn())
+	for i := 0; i < t.NumIn(); i++ {
+		argType := t.In(i)
+		val := inj.Get(argType)
+		if !val.IsValid() {
+			return nil, fmt.Errorf("Value not found for type %v", argType)
+		}
+
+		in[i] = val
+	}
+
+	return reflect.ValueOf(f).Call(in), nil
+}
+
+func (inj *injector) Apply(val interface{}) error {
+	v := reflect.ValueOf(val)
+
+	for v.Kind() == reflect.Ptr {
+		v = v.Elem()
+	}
+
+	if v.Kind() != reflect.Struct {
+		return nil
+	}
+
+	t := v.Type()
+
+	for i := 0; i < v.NumField(); i++ {
+		f := v.Field(i)
+		structField := t.Field(i)
+		if f.CanSet() && structField.Tag == "inject" {
+			ft := f.Type()
+			v := inj.Get(ft)
+			if !v.IsValid() {
+				return fmt.Errorf("Value not found for type %v", ft)
+			}
+
+			f.Set(v)
+		}
+
+	}
+
+	return nil
+}
+
+func (i *injector) Map(val interface{}) TypeMapper {
+	i.values[reflect.TypeOf(val)] = reflect.ValueOf(val)
+	return i
+}
+
+func (i *injector) MapTo(val interface{}, ifacePtr interface{}) TypeMapper {
+	i.values[InterfaceOf(ifacePtr)] = reflect.ValueOf(val)
+	return i
+}
+
+func (i *injector) Get(t reflect.Type) reflect.Value {
+	val := i.values[t]
+	if !val.IsValid() && i.parent != nil {
+		val = i.parent.Get(t)
+	}
+	return val
+}
+
+func (i *injector) SetParent(parent Injector) {
+	i.parent = parent
+}

Godeps/_workspace/src/github.com/codegangsta/inject/inject_test.go

@@ -0,0 +1,112 @@
+package inject_test
+
+import (
+	"github.com/codegangsta/inject"
+	"reflect"
+	"testing"
+)
+
+type SpecialString interface {
+}
+
+type TestStruct struct {
+	Dep1 string        `inject`
+	Dep2 SpecialString `inject`
+	Dep3 string
+}
+
+/* Test Helpers */
+func expect(t *testing.T, a interface{}, b interface{}) {
+	if a != b {
+		t.Errorf("Expected %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
+	}
+}
+
+func refute(t *testing.T, a interface{}, b interface{}) {
+	if a == b {
+		t.Errorf("Did not expect %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
+	}
+}
+
+func Test_InjectorInvoke(t *testing.T) {
+	injector := inject.New()
+	expect(t, injector == nil, false)
+
+	dep := "some dependency"
+	injector.Map(dep)
+	dep2 := "another dep"
+	injector.MapTo(dep2, (*SpecialString)(nil))
+
+	_, err := injector.Invoke(func(d1 string, d2 SpecialString) {
+		expect(t, d1, dep)
+		expect(t, d2, dep2)
+	})
+
+	expect(t, err, nil)
+}
+
+func Test_InjectorInvokeReturnValues(t *testing.T) {
+	injector := inject.New()
+	expect(t, injector == nil, false)
+
+	dep := "some dependency"
+	injector.Map(dep)
+	dep2 := "another dep"
+	injector.MapTo(dep2, (*SpecialString)(nil))
+
+	result, err := injector.Invoke(func(d1 string, d2 SpecialString) string {
+		expect(t, d1, dep)
+		expect(t, d2, dep2)
+		return "Hello world"
+	})
+
+	expect(t, result[0].String(), "Hello world")
+	expect(t, err, nil)
+}
+
+func Test_InjectorApply(t *testing.T) {
+	injector := inject.New()
+
+	injector.Map("a dep").MapTo("another dep", (*SpecialString)(nil))
+
+	s := TestStruct{}
+	err := injector.Apply(&s)
+	expect(t, err, nil)
+
+	expect(t, s.Dep1, "a dep")
+	expect(t, s.Dep2, "another dep")
+}
+
+func Test_InterfaceOf(t *testing.T) {
+	iType := inject.InterfaceOf((*SpecialString)(nil))
+	expect(t, iType.Kind(), reflect.Interface)
+
+	iType = inject.InterfaceOf((**SpecialString)(nil))
+	expect(t, iType.Kind(), reflect.Interface)
+
+	// Expecting nil
+	defer func() {
+		rec := recover()
+		refute(t, rec, nil)
+	}()
+	iType = inject.InterfaceOf((*testing.T)(nil))
+}
+
+func Test_InjectorGet(t *testing.T) {
+	injector := inject.New()
+
+	injector.Map("some dependency")
+
+	expect(t, injector.Get(reflect.TypeOf("string")).IsValid(), true)
+	expect(t, injector.Get(reflect.TypeOf(11)).IsValid(), false)
+}
+
+func Test_InjectorSetParent(t *testing.T) {
+	injector := inject.New()
+	injector.MapTo("another dep", (*SpecialString)(nil))
+
+	injector2 := inject.New()
+	injector2.SetParent(injector)
+
+	expect(t, injector2.Get(inject.InterfaceOf((*SpecialString)(nil))).IsValid(), true)
+}

Godeps/_workspace/src/github.com/codegangsta/martini/.gitignore

@@ -0,0 +1,23 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test

Godeps/_workspace/src/github.com/codegangsta/martini/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Jeremy Saenz
+
+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.

Godeps/_workspace/src/github.com/codegangsta/martini/README.md

@@ -0,0 +1,303 @@
+# Martini [![Build Status](https://drone.io/github.com/codegangsta/martini/status.png)](https://drone.io/github.com/codegangsta/martini/latest) [![GoDoc](https://godoc.org/github.com/codegangsta/martini?status.png)](http://godoc.org/github.com/codegangsta/martini)
+
+Martini is a powerful package for quickly writing modular web applications/services in Golang.
+
+## Getting Started
+
+After installing Go and setting up your [GOPATH](http://golang.org/doc/code.html#GOPATH), create your first `.go` file. We'll call it `server.go`.
+
+~~~ go
+package main
+
+import "github.com/codegangsta/martini"
+
+func main() {
+  m := martini.Classic()
+  m.Get("/", func() string {
+    return "Hello world!"
+  })
+  m.Run()
+}
+~~~
+
+Then install the Martini package (**go 1.1** and greater is required):
+~~~
+go get github.com/codegangsta/martini
+~~~
+
+Then run your server:
+~~~
+go run server.go
+~~~
+
+You will now have a Martini webserver running on `localhost:3000`.
+
+## Getting Help
+
+Join the [Mailing list](https://groups.google.com/forum/#!forum/martini-go)
+
+Watch the [Demo Video](http://martini.codegangsta.io/#demo)
+
+## Features
+* Extremely simple to use.
+* Non-intrusive design.
+* Play nice with other Golang packages.
+* Awesome path matching and routing.
+* Modular design - Easy to add functionality, easy to rip stuff out.
+* Lots of good handlers/middlewares to use.
+* Great 'out of the box' feature set.
+* **Fully compatible with the [http.HandlerFunc](http://godoc.org/net/http#HandlerFunc) interface.**
+
+## More Middleware
+For more middleware and functionality, check out the [martini-contrib](http://github.com/codegangsta/martini-contrib) repository.
+
+## Table of Contents
+* [Classic Martini](#classic-martini)
+  * [Handlers](#handlers)
+  * [Routing](#routing)
+  * [Services](#services)
+  * [Serving Static Files](#serving-static-files)
+* [Middleware Handlers](#middleware-handlers)
+  * [Next()](#next)
+* [FAQ](#faq)
+
+## Classic Martini
+To get up and running quickly, [martini.Classic()](http://godoc.org/github.com/codegangsta/martini#Classic) provides some reasonable defaults that work well for most web applications:
+~~~ go
+  m := martini.Classic()
+  // ... middleware and routing goes here
+  m.Run()
+~~~
+
+Below is some of the functionality [martini.Classic()](http://godoc.org/github.com/codegangsta/martini#Classic) pulls in automatically:
+  * Request/Response Logging - [martini.Logger](http://godoc.org/github.com/codegangsta/martini#Logger)
+  * Panic Recovery - [martini.Recovery](http://godoc.org/github.com/codegangsta/martini#Recovery)
+  * Static File serving - [martini.Static](http://godoc.org/github.com/codegangsta/martini#Static)
+  * Routing - [martini.Router](http://godoc.org/github.com/codegangsta/martini#Router)
+
+### Handlers
+Handlers are the heart and soul of Martini. A handler is basically any kind of callable function:
+~~~ go
+m.Get("/", func() {
+  println("hello world")
+})
+~~~
+
+#### Return Values
+If a handler returns something, Martini will write the result to the current [http.ResponseWriter](http://godoc.org/net/http#ResponseWriter) as a string:
+~~~ go
+m.Get("/", func() string {
+  return "hello world" // HTTP 200 : "hello world"
+})
+~~~
+
+You can also optionally return a status code:
+~~~ go
+m.Get("/", func() (int, string) {
+  return 418, "i'm a teapot" // HTTP 418 : "i'm a teapot"
+})
+~~~
+
+#### Service Injection
+Handlers are invoked via reflection. Martini makes use of *Dependency Injection* to resolve dependencies in a Handlers argument list. **This makes Martini completely  compatible with golang's `http.HandlerFunc` interface.** 
+
+If you add an argument to your Handler, Martini will search it's list of services and attempt to resolve the dependency via type assertion:
+~~~ go
+m.Get("/", func(res http.ResponseWriter, req *http.Request) { // res and req are injected by Martini
+  res.WriteHeader(200) // HTTP 200
+})
+~~~
+
+The following services are included with [martini.Classic()](http://godoc.org/github.com/codegangsta/martini#Classic):
+  * [*log.Logger](http://godoc.org/log#Logger) - Global logger for Martini.
+  * [martini.Context](http://godoc.org/github.com/codegangsta/martini#Context) - http request context.
+  * [martini.Params](http://godoc.org/github.com/codegangsta/martini#Params) - `map[string]string` of named params found by route matching.
+  * [martini.Routes](http://godoc.org/github.com/codegangsta/martini#Routes) - Route helper service.
+  * [http.ResponseWriter](http://godoc.org/net/http/#ResponseWriter) - http Response writer interface.
+  * [*http.Request](http://godoc.org/net/http/#Request) - http Request.
+
+### Routing
+In Martini, a route is an HTTP method paired with a URL-matching pattern.
+Each route can take one or more handler methods:
+~~~ go
+m.Get("/", func() {
+  // show something
+})
+
+m.Patch("/", func() {
+  // update something
+})
+
+m.Post("/", func() {
+  // create something
+})
+
+m.Put("/", func() {
+  // replace something
+})
+
+m.Delete("/", func() {
+  // destroy something
+})
+
+m.Options("/", func() {
+  // http options
+})
+
+m.NotFound(func() {
+  // handle 404
+})
+~~~
+
+Routes are matched in the order they are defined. The first route that
+matches the request is invoked.
+
+Route patterns may include named parameters, accessible via the [martini.Params](http://godoc.org/github.com/codegangsta/martini#Params) service:
+~~~ go
+m.Get("/hello/:name", func(params martini.Params) string {
+  return "Hello " + params["name"]
+})
+~~~
+
+Routes can be matched with regular expressions and globs as well:
+~~~ go
+m.Get("/hello/**", func(params martini.Params) string {
+  return "Hello " + params["_1"]
+})
+~~~
+
+Route handlers can be stacked on top of each other, which is useful for things like authentication and authorization:
+~~~ go
+m.Get("/secret", authorize, func() {
+  // this will execute as long as authorize doesn't write a response
+})
+~~~
+
+### Services
+Services are objects that are available to be injected into a Handler's argument list. You can map a service on a *Global* or *Request* level.
+
+#### Global Mapping
+A Martini instance implements the inject.Injector interface, so mapping a service is easy:
+~~~ go
+db := &MyDatabase{}
+m := martini.Classic()
+m.Map(db) // the service will be available to all handlers as *MyDatabase
+// ...
+m.Run()
+~~~
+
+#### Request-Level Mapping
+Mapping on the request level can be done in a handler via [martini.Context](http://godoc.org/github.com/codegangsta/martini#Context):
+~~~ go
+func MyCustomLoggerHandler(c martini.Context, req *http.Request) {
+  logger := &MyCustomLogger{req}
+  c.Map(logger) // mapped as *MyCustomLogger
+}
+~~~
+
+#### Mapping values to Interfaces
+One of the most powerful parts about services is the ability to map a service to an interface. For instance, if you wanted to override the [http.ResponseWriter](http://godoc.org/net/http#ResponseWriter) with an object that wrapped it and performed extra operations, you can write the following handler:
+~~~ go
+func WrapResponseWriter(res http.ResponseWriter, c martini.Context) {
+  rw := NewSpecialResponseWriter(res)
+  c.MapTo(rw, (*http.ResponseWriter)(nil)) // override ResponseWriter with our wrapper ResponseWriter
+}
+~~~
+
+### Serving Static Files
+A [martini.Classic()](http://godoc.org/github.com/codegangsta/martini#Classic) instance automatically serves static files from the "public" directory in the root of your server.
+You can serve from more directories by adding more [martini.Static](http://godoc.org/github.com/codegangsta/martini#Static) handlers.
+~~~ go
+m.Use(martini.Static("assets")) // serve from the "assets" directory as well
+~~~
+
+## Middleware Handlers
+Middleware Handlers sit between the incoming http request and the router. In essence they are no different than any other Handler in Martini. You can add a middleware handler to the stack like so:
+~~~ go
+m.Use(func() {
+  // do some middleware stuff
+})
+~~~
+
+You can have full control over the middleware stack with the `Handlers` function:
+~~~ go
+m.Handlers(
+  Middleware1,
+  Middleware2,
+  Middleware3,
+)
+~~~
+
+Middleware Handlers work really well for things like logging, authorization, authentication, sessions, gzipping, error pages and any other operations that must happen before or after an http request:
+~~~ go
+// validate an api key
+m.Use(func(res http.ResponseWriter, req *http.Request) {
+  if req.Header.Get("X-API-KEY") != "secret123" {
+    res.WriteHeader(http.StatusUnauthorized)
+  }
+})
+~~~
+
+### Next()
+[Context.Next()](http://godoc.org/github.com/codegangsta/martini#Context) is an optional function that Middleware Handlers can call to yield the until after the other Handlers have been executed. This works really well for any operations that must happen after an http request:
+~~~ go
+// log before and after a request
+m.Use(func(c martini.Context, log *log.Logger){
+  log.Println("before a request")
+
+  c.Next()
+  
+  log.Println("after a request")
+})
+~~~
+
+## FAQ
+
+### Where do I find middleware X?
+
+Start by looking in the [martini-contrib](http://github.com/codegangsta/martini-contrib) package. If it is not there feel free to put up a Pull Request for one.
+
+* [auth](https://github.com/codegangsta/martini-contrib/tree/master/auth) - Handlers for authentication.
+* [form](https://github.com/codegangsta/martini-contrib/tree/master/form) - Handler for parsing and mapping form fields.
+* [gzip](https://github.com/codegangsta/martini-contrib/tree/master/gzip) - Handler for adding gzip compress to requests
+* [render](https://github.com/codegangsta/martini-contrib/tree/master/render) - Handler that provides a service for easily rendering JSON and HTML templates.
+* [acceptlang](https://github.com/codegangsta/martini-contrib/tree/master/acceptlang) - Handler for parsing the `Accept-Language` HTTP header.
+
+### How do I integrate with existing servers?
+
+A Martini instance implements `http.Handler`, so it can easily be used to serve subtrees 
+on existing Go servers. For example this is a working Martini app for Google App Engine:
+
+~~~ go
+package hello
+
+import (
+  "net/http"
+  "github.com/codegangsta/martini"
+)
+
+func init() {
+  m := martini.Classic()
+  m.Get("/", func() string {
+    return "Hello world!"
+  })
+  http.Handle("/", m)
+}
+~~~
+
+### How do I change the port/host?
+
+Martini's `Run` function looks for the PORT environment variable and uses that. Otherwise Martini will default to port 3000.
+To have more flexibility over port and host, use the `http.ListenAndServe` function instead.
+
+~~~ go
+  m := martini.Classic()
+  // ...
+  http.ListenAndServe(":8080", m)
+~~~
+
+## Contributing
+Martini is meant to be kept tiny and clean. Most contributions should end up in the [martini-contrib](http://github.com/codegangsta/martini-contrib) repository. If you do have a contribution for the core of Martini feel free to put up a Pull Request.
+
+## About
+Martini is obsessively designed by none other than the [Code Gangsta](http://codegangsta.io/)

Godeps/_workspace/src/github.com/codegangsta/martini/env.go

@@ -0,0 +1,21 @@
+package martini
+
+import (
+	"os"
+)
+
+const (
+	Dev  string = "development"
+	Prod string = "production"
+	Test string = "test"
+)
+
+// Env is the environment that Martini is executing in. The MARTINI_ENV is read on initialization to set this variable.
+var Env string = Dev
+
+func init() {
+	e := os.Getenv("MARTINI_ENV")
+	if len(e) > 0 {
+		Env = e
+	}
+}

Godeps/_workspace/src/github.com/codegangsta/martini/go_version.go

@@ -0,0 +1,3 @@
+// +build !go1.1
+
+"martini requires go 1.1 or greater to build"

Godeps/_workspace/src/github.com/codegangsta/martini/logger.go

@@ -0,0 +1,22 @@
+package martini
+
+import (
+	"log"
+	"net/http"
+	"time"
+)
+
+// 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)
+
+		rw := NewResponseWriter(res)
+		c.MapTo(rw, (*http.ResponseWriter)(nil))
+
+		c.Next()
+
+		log.Printf("Completed %v %s in %v\n", rw.Status(), http.StatusText(rw.Status()), time.Since(start))
+	}
+}

Godeps/_workspace/src/github.com/codegangsta/martini/logger_test.go

@@ -0,0 +1,31 @@
+package martini
+
+import (
+	"bytes"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func Test_Logger(t *testing.T) {
+	buff := bytes.NewBufferString("")
+	recorder := httptest.NewRecorder()
+
+	m := New()
+	// replace log for testing
+	m.Map(log.New(buff, "[martini] ", 0))
+	m.Use(Logger())
+	m.Use(func(res http.ResponseWriter) {
+		res.WriteHeader(http.StatusNotFound)
+	})
+
+	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)
+	refute(t, len(buff.String()), 0)
+}

Godeps/_workspace/src/github.com/codegangsta/martini/martini.go

@@ -0,0 +1,155 @@
+// Package martini is a powerful package for quickly writing modular web applications/services in Golang.
+//
+// For a full guide visit http://github.com/codegangsta/martini
+//
+//  package main
+//
+//  import "github.com/codegangsta/martini"
+//
+//  func main() {
+//    m := martini.Classic()
+//
+//    m.Get("/", func() string {
+//      return "Hello world!"
+//    })
+//
+//    m.Run()
+//  }
+package martini
+
+import (
+	"github.com/codegangsta/inject"
+	"log"
+	"net/http"
+	"os"
+	"reflect"
+)
+
+// Martini represents the top level web application. inject.Injector methods can be invoked to map services on a global level.
+type Martini struct {
+	inject.Injector
+	handlers []Handler
+	action   Handler
+	logger   *log.Logger
+}
+
+// New creates a bare bones Martini instance. Use this method if you want to have full control over the middleware that is used.
+func New() *Martini {
+	m := &Martini{inject.New(), []Handler{}, func() {}, log.New(os.Stdout, "[martini] ", 0)}
+	m.Map(m.logger)
+	return m
+}
+
+// Use adds a middleware Handler to the stack. Will panic if the handler is not a callable func. Middleware Handlers are invoked in the order that they are added.
+func (m *Martini) Use(handler Handler) {
+	validateHandler(handler)
+
+	m.handlers = append(m.handlers, handler)
+}
+
+// ServeHTTP is the HTTP Entry point for a Martini instance. Useful if you want to control your own HTTP server.
+func (m *Martini) ServeHTTP(res http.ResponseWriter, req *http.Request) {
+	m.createContext(res, req).run()
+}
+
+// Action sets the handler that will be called after all the middleware has been invoked. This is set to martini.Router in a martini.Classic().
+func (m *Martini) Action(handler Handler) {
+	validateHandler(handler)
+	m.action = handler
+}
+
+// Run the http server. Listening on os.GetEnv("PORT") or 3000 by default.
+func (m *Martini) Run() {
+	port := os.Getenv("PORT")
+	if len(port) == 0 {
+		port = "3000"
+	}
+
+	m.logger.Println("listening on port " + port)
+	m.logger.Fatalln(http.ListenAndServe(":"+port, m))
+}
+
+// Handlers sets the entire middleware stack with the given Handlers. This will clear any current middleware handlers.
+// Will panic if any of the handlers is not a callable function
+func (m *Martini) Handlers(handlers ...Handler) {
+	m.handlers = make([]Handler, 0)
+	for _, handler := range handlers {
+		m.Use(handler)
+	}
+}
+
+func (m *Martini) createContext(res http.ResponseWriter, req *http.Request) *context {
+	c := &context{inject.New(), append(m.handlers, m.action), NewResponseWriter(res), 0}
+	c.SetParent(m)
+	c.MapTo(c, (*Context)(nil))
+	c.MapTo(c.rw, (*http.ResponseWriter)(nil))
+	c.Map(req)
+	return c
+}
+
+// ClassicMartini represents a Martini with some reasonable defaults. Embeds the router functions for convenience.
+type ClassicMartini struct {
+	*Martini
+	Router
+}
+
+// Classic creates a classic Martini with some basic default middleware - martini.Logger, martini.Recovery, and martini.Static.
+func Classic() *ClassicMartini {
+	r := NewRouter()
+	m := New()
+	m.Use(Logger())
+	m.Use(Recovery())
+	m.Use(Static("public"))
+	m.Action(r.Handle)
+	return &ClassicMartini{m, r}
+}
+
+// Handler can be any callable function. Martini attempts to inject services into the handler's argument list.
+// Martini will panic if an argument could not be fullfilled via dependency injection.
+type Handler interface{}
+
+func validateHandler(handler Handler) {
+	if reflect.TypeOf(handler).Kind() != reflect.Func {
+		panic("martini handler must be a callable func")
+	}
+}
+
+// Context represents a request context. Services can be mapped on the request level from this interface.
+type Context interface {
+	inject.Injector
+	// Next is an optional function that Middleware Handlers can call to yield the until after
+	// the other Handlers have been executed. This works really well for any operations that must
+	// happen after an http request
+	Next()
+	written() bool
+}
+
+type context struct {
+	inject.Injector
+	handlers []Handler
+	rw       ResponseWriter
+	index    int
+}
+
+func (c *context) Next() {
+	c.index += 1
+	c.run()
+}
+
+func (c *context) written() bool {
+	return c.rw.Written()
+}
+
+func (c *context) run() {
+	for c.index < len(c.handlers) {
+		_, err := c.Invoke(c.handlers[c.index])
+		if err != nil {
+			panic(err)
+		}
+		c.index += 1
+
+		if c.rw.Written() {
+			return
+		}
+	}
+}

Godeps/_workspace/src/github.com/codegangsta/martini/martini_test.go

@@ -0,0 +1,105 @@
+package martini
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"testing"
+)
+
+/* Test Helpers */
+func expect(t *testing.T, a interface{}, b interface{}) {
+	if a != b {
+		t.Errorf("Expected %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
+	}
+}
+
+func refute(t *testing.T, a interface{}, b interface{}) {
+	if a == b {
+		t.Errorf("Did not expect %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
+	}
+}
+
+func Test_New(t *testing.T) {
+	m := New()
+	refute(t, m, nil)
+}
+
+func Test_Martini_ServeHTTP(t *testing.T) {
+	result := ""
+	response := httptest.NewRecorder()
+
+	m := New()
+	m.Use(func(c Context) {
+		result += "foo"
+		c.Next()
+		result += "ban"
+	})
+	m.Use(func(c Context) {
+		result += "bar"
+		c.Next()
+		result += "baz"
+	})
+	m.Action(func(res http.ResponseWriter, req *http.Request) {
+		result += "bat"
+		res.WriteHeader(http.StatusBadRequest)
+	})
+
+	m.ServeHTTP(response, (*http.Request)(nil))
+
+	expect(t, result, "foobarbatbazban")
+	expect(t, response.Code, http.StatusBadRequest)
+}
+
+func Test_Martini_Handlers(t *testing.T) {
+	result := ""
+	response := httptest.NewRecorder()
+
+	batman := func(c Context) {
+		result += "batman!"
+	}
+
+	m := New()
+	m.Use(func(c Context) {
+		result += "foo"
+		c.Next()
+		result += "ban"
+	})
+	m.Handlers(
+		batman,
+		batman,
+		batman,
+	)
+	m.Action(func(res http.ResponseWriter, req *http.Request) {
+		result += "bat"
+		res.WriteHeader(http.StatusBadRequest)
+	})
+
+	m.ServeHTTP(response, (*http.Request)(nil))
+
+	expect(t, result, "batman!batman!batman!bat")
+	expect(t, response.Code, http.StatusBadRequest)
+}
+
+func Test_Martini_EarlyWrite(t *testing.T) {
+	result := ""
+	response := httptest.NewRecorder()
+
+	m := New()
+	m.Use(func(res http.ResponseWriter) {
+		result += "foobar"
+		res.Write([]byte("Hello world"))
+	})
+	m.Use(func() {
+		result += "bat"
+	})
+	m.Action(func(res http.ResponseWriter) {
+		result += "baz"
+		res.WriteHeader(http.StatusBadRequest)
+	})
+
+	m.ServeHTTP(response, (*http.Request)(nil))
+
+	expect(t, result, "foobar")
+	expect(t, response.Code, http.StatusOK)
+}

Godeps/_workspace/src/github.com/codegangsta/martini/recovery.go

@@ -0,0 +1,21 @@
+package martini
+
+import (
+	"log"
+	"net/http"
+	"runtime/debug"
+)
+
+// Recovery returns a middleware that recovers from any panics and writes a 500 if there was one.
+func Recovery() Handler {
+	return func(res http.ResponseWriter, c Context, logger *log.Logger) {
+		defer func() {
+			if err := recover(); err != nil {
+				res.WriteHeader(http.StatusInternalServerError)
+				logger.Printf("PANIC: %s\n%s", err, debug.Stack())
+			}
+		}()
+
+		c.Next()
+	}
+}

Godeps/_workspace/src/github.com/codegangsta/martini/recovery_test.go

@@ -0,0 +1,26 @@
+package martini
+
+import (
+	"bytes"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func Test_Recovery(t *testing.T) {
+	buff := bytes.NewBufferString("")
+	recorder := httptest.NewRecorder()
+
+	m := New()
+	// replace log for testing
+	m.Map(log.New(buff, "[martini] ", 0))
+	m.Use(Recovery())
+	m.Use(func(res http.ResponseWriter, req *http.Request) {
+		panic("here is a panic!")
+	})
+	m.ServeHTTP(recorder, (*http.Request)(nil))
+	expect(t, recorder.Code, http.StatusInternalServerError)
+	refute(t, len(buff.String()), 0)
+
+}

Godeps/_workspace/src/github.com/codegangsta/martini/response_writer.go

@@ -0,0 +1,67 @@
+package martini
+
+import (
+	"bufio"
+	"fmt"
+	"net"
+	"net/http"
+)
+
+// ResponseWriter is a wrapper around http.ResponseWriter that provides extra information about
+// the response. It is recommended that middleware handlers use this construct to wrap a responsewriter
+// if the functionality calls for it.
+type ResponseWriter interface {
+	http.ResponseWriter
+	// Status returns the status code of the response or 0 if the response has not been written.
+	Status() int
+	// Written returns whether or not the ResponseWriter has been written.
+	Written() bool
+	// Size returns the size of the response body.
+	Size() int
+}
+
+// NewResponseWriter creates a ResponseWriter that wraps an http.ResponseWriter
+func NewResponseWriter(rw http.ResponseWriter) ResponseWriter {
+	return &responseWriter{rw, 0, 0}
+}
+
+type responseWriter struct {
+	http.ResponseWriter
+	status int
+	size   int
+}
+
+func (rw *responseWriter) WriteHeader(s int) {
+	rw.ResponseWriter.WriteHeader(s)
+	rw.status = s
+}
+
+func (rw *responseWriter) Write(b []byte) (int, error) {
+	if !rw.Written() {
+		// The status will be StatusOK if WriteHeader has not been called yet
+		rw.status = http.StatusOK
+	}
+	size, err := rw.ResponseWriter.Write(b)
+	rw.size += size
+	return size, err
+}
+
+func (rw *responseWriter) Status() int {
+	return rw.status
+}
+
+func (rw *responseWriter) Size() int {
+	return rw.size
+}
+
+func (rw *responseWriter) Written() bool {
+	return rw.status != 0
+}
+
+func (rw *responseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	hijacker, ok := rw.ResponseWriter.(http.Hijacker)
+	if !ok {
+		return nil, nil, fmt.Errorf("ResponseWriter doesn't support Hijacker interface")
+	}
+	return hijacker.Hijack()
+}

Godeps/_workspace/src/github.com/codegangsta/martini/response_writer_test.go

@@ -0,0 +1,76 @@
+package martini
+
+import (
+	"bufio"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+type hijackableResponse struct {
+	Hijacked bool
+}
+
+func newHijackableResponse() *hijackableResponse {
+	return &hijackableResponse{}
+}
+
+func (h *hijackableResponse) Header() http.Header           { return nil }
+func (h *hijackableResponse) Write(buf []byte) (int, error) { return 0, nil }
+func (h *hijackableResponse) WriteHeader(code int)          {}
+func (h *hijackableResponse) Flush()                        {}
+func (h *hijackableResponse) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	h.Hijacked = true
+	return nil, nil, nil
+}
+
+func Test_ResponseWriter_WritingString(t *testing.T) {
+	rec := httptest.NewRecorder()
+	rw := NewResponseWriter(rec)
+
+	rw.Write([]byte("Hello world"))
+
+	expect(t, rec.Code, rw.Status())
+	expect(t, rec.Body.String(), "Hello world")
+	expect(t, rw.Status(), http.StatusOK)
+	expect(t, rw.Size(), 11)
+	expect(t, rw.Written(), true)
+}
+
+func Test_ResponseWriter_WritingStrings(t *testing.T) {
+	rec := httptest.NewRecorder()
+	rw := NewResponseWriter(rec)
+
+	rw.Write([]byte("Hello world"))
+	rw.Write([]byte("foo bar bat baz"))
+
+	expect(t, rec.Code, rw.Status())
+	expect(t, rec.Body.String(), "Hello worldfoo bar bat baz")
+	expect(t, rw.Status(), http.StatusOK)
+	expect(t, rw.Size(), 26)
+}
+
+func Test_ResponseWriter_WritingHeader(t *testing.T) {
+	rec := httptest.NewRecorder()
+	rw := NewResponseWriter(rec)
+
+	rw.WriteHeader(http.StatusNotFound)
+
+	expect(t, rec.Code, rw.Status())
+	expect(t, rec.Body.String(), "")
+	expect(t, rw.Status(), http.StatusNotFound)
+	expect(t, rw.Size(), 0)
+}
+
+func Test_ResponseWriter_Hijack(t *testing.T) {
+	hijackable := newHijackableResponse()
+	rw := NewResponseWriter(hijackable)
+	hijacker, ok := rw.(http.Hijacker)
+	expect(t, ok, true)
+	_, _, err := hijacker.Hijack()
+	if err != nil {
+		t.Error(err)
+	}
+	expect(t, hijackable.Hijacked, true)
+}

Godeps/_workspace/src/github.com/codegangsta/martini/router.go

@@ -0,0 +1,255 @@
+package martini
+
+import (
+	"fmt"
+	"github.com/codegangsta/inject"
+	"net/http"
+	"reflect"
+	"regexp"
+	"strconv"
+)
+
+// Params is a map of name/value pairs for named routes. An instance of martini.Params is available to be injected into any route handler.
+type Params map[string]string
+
+// Router is Martini's de-facto routing interface. Supports HTTP verbs, stacked handlers, and dependency injection.
+type Router interface {
+	// Get adds a route for a HTTP GET request to the specified matching pattern.
+	Get(string, ...Handler) Route
+	// Patch adds a route for a HTTP PATCH request to the specified matching pattern.
+	Patch(string, ...Handler) Route
+	// Post adds a route for a HTTP POST request to the specified matching pattern.
+	Post(string, ...Handler) Route
+	// Put adds a route for a HTTP PUT request to the specified matching pattern.
+	Put(string, ...Handler) Route
+	// Delete adds a route for a HTTP DELETE request to the specified matching pattern.
+	Delete(string, ...Handler) Route
+	// Options adds a route for a HTTP OPTIONS request to the specified matching pattern.
+	Options(string, ...Handler) Route
+	// Any adds a route for any HTTP method request to the specified matching pattern.
+	Any(string, ...Handler) Route
+
+	// NotFound sets the handler that is called when a no route matches a request. Throws a basic 404 by default.
+	NotFound(Handler)
+
+	// Handle is the entry point for routing. This is used as a martini.Handler
+	Handle(http.ResponseWriter, *http.Request, Context)
+}
+
+type router struct {
+	routes   []*route
+	notFound Handler
+}
+
+// NewRouter creates a new Router instance.
+func NewRouter() Router {
+	return &router{notFound: http.NotFound}
+}
+
+func (r *router) Get(pattern string, h ...Handler) Route {
+	return r.addRoute("GET", pattern, h)
+}
+
+func (r *router) Patch(pattern string, h ...Handler) Route {
+	return r.addRoute("PATCH", pattern, h)
+}
+
+func (r *router) Post(pattern string, h ...Handler) Route {
+	return r.addRoute("POST", pattern, h)
+}
+
+func (r *router) Put(pattern string, h ...Handler) Route {
+	return r.addRoute("PUT", pattern, h)
+}
+
+func (r *router) Delete(pattern string, h ...Handler) Route {
+	return r.addRoute("DELETE", pattern, h)
+}
+
+func (r *router) Options(pattern string, h ...Handler) Route {
+	return r.addRoute("OPTIONS", pattern, h)
+}
+
+func (r *router) Any(pattern string, h ...Handler) Route {
+	return r.addRoute("*", pattern, h)
+}
+
+func (r *router) Handle(res http.ResponseWriter, req *http.Request, context Context) {
+	for _, route := range r.routes {
+		ok, vals := route.Match(req.Method, req.URL.Path)
+		if ok {
+			params := Params(vals)
+			context.Map(params)
+			r := routes{}
+			context.MapTo(r, (*Routes)(nil))
+			_, err := context.Invoke(route.Handle)
+			if err != nil {
+				panic(err)
+			}
+			return
+		}
+	}
+
+	// no routes exist, 404
+	_, err := context.Invoke(r.notFound)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (r *router) NotFound(handler Handler) {
+	r.notFound = handler
+}
+
+func (r *router) addRoute(method string, pattern string, handlers []Handler) *route {
+	route := newRoute(method, pattern, handlers)
+	route.Validate()
+	r.routes = append(r.routes, route)
+	return route
+}
+
+// Route is an interface representing a Route in Martini's routing layer.
+type Route interface {
+	// URLWith returns a rendering of the Route's url with the given string params.
+	URLWith([]string) string
+}
+
+type route struct {
+	method   string
+	regex    *regexp.Regexp
+	handlers []Handler
+	pattern  string
+}
+
+func newRoute(method string, pattern string, handlers []Handler) *route {
+	route := route{method, nil, handlers, pattern}
+	r := regexp.MustCompile(`:[^/#?()\.\\]+`)
+	pattern = r.ReplaceAllStringFunc(pattern, func(m string) string {
+		return fmt.Sprintf(`(?P<%s>[^/#?]+)`, m[1:])
+	})
+	r2 := regexp.MustCompile(`\*\*`)
+	var index int
+	pattern = r2.ReplaceAllStringFunc(pattern, func(m string) string {
+		index++
+		return fmt.Sprintf(`(?P<_%d>[^#?]*)`, index)
+	})
+	pattern += `\/?`
+	route.regex = regexp.MustCompile(pattern)
+	return &route
+}
+
+func (r route) Match(method string, path string) (bool, map[string]string) {
+	// add Any method matching support
+	if r.method != "*" && method != r.method {
+		return false, nil
+	}
+
+	matches := r.regex.FindStringSubmatch(path)
+	if len(matches) > 0 && matches[0] == path {
+		params := make(map[string]string)
+		for i, name := range r.regex.SubexpNames() {
+			if len(name) > 0 {
+				params[name] = matches[i]
+			}
+		}
+		return true, params
+	}
+	return false, nil
+}
+
+func (r *route) Validate() {
+	for _, handler := range r.handlers {
+		validateHandler(handler)
+	}
+}
+
+func (r *route) Handle(c Context, res http.ResponseWriter) {
+	context := &routeContext{c, 0, r.handlers}
+	c.MapTo(context, (*Context)(nil))
+	context.run()
+}
+
+// URLWith returns the url pattern replacing the parameters for its values
+func (r *route) URLWith(args []string) string {
+	if len(args) > 0 {
+		reg := regexp.MustCompile(`:[^/#?()\.\\]+`)
+		argCount := len(args)
+		i := 0
+		url := reg.ReplaceAllStringFunc(r.pattern, func(m string) string {
+			var val interface{}
+			if i < argCount {
+				val = args[i]
+			} else {
+				val = m
+			}
+			i += 1
+			return fmt.Sprintf(`%v`, val)
+		})
+
+		return url
+	}
+	return r.pattern
+}
+
+// Routes is a helper service for Martini's routing layer.
+type Routes interface {
+	// URLFor returns a rendered URL for the given route. Optional params can be passed to fulfill named parameters in the route.
+	URLFor(route Route, params ...interface{}) string
+}
+
+type routes struct{}
+
+// URLFor returns the url for the given route name.
+func (r routes) URLFor(route Route, params ...interface{}) string {
+	var args []string
+	for _, param := range params {
+		switch v := param.(type) {
+		case int:
+			args = append(args, strconv.FormatInt(int64(v), 10))
+		case string:
+			args = append(args, v)
+		default:
+			if v != nil {
+				panic("Arguments passed to UrlFor must be integers or strings")
+			}
+		}
+	}
+
+	return route.URLWith(args)
+}
+
+type routeContext struct {
+	Context
+	index    int
+	handlers []Handler
+}
+
+func (r *routeContext) Next() {
+	r.index += 1
+	r.run()
+}
+
+func (r *routeContext) run() {
+	for r.index < len(r.handlers) {
+		handler := r.handlers[r.index]
+		vals, err := r.Invoke(handler)
+		if err != nil {
+			panic(err)
+		}
+		r.index += 1
+
+		// if the handler returned something, write it to
+		// the http response
+		rv := r.Get(inject.InterfaceOf((*http.ResponseWriter)(nil)))
+		res := rv.Interface().(http.ResponseWriter)
+		if len(vals) > 1 && vals[0].Kind() == reflect.Int {
+			res.WriteHeader(int(vals[0].Int()))
+			res.Write([]byte(vals[1].String()))
+		} else if len(vals) > 0 {
+			res.Write([]byte(vals[0].String()))
+		}
+		if r.written() {
+			return
+		}
+	}
+}

Godeps/_workspace/src/github.com/codegangsta/martini/router_test.go

@@ -0,0 +1,277 @@
+package martini
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func Test_Routing(t *testing.T) {
+	router := NewRouter()
+	recorder := httptest.NewRecorder()
+
+	req, err := http.NewRequest("GET", "http://localhost:3000/foo", nil)
+	if err != nil {
+		t.Error(err)
+	}
+	context := New().createContext(recorder, req)
+
+	req2, err := http.NewRequest("POST", "http://localhost:3000/bar/bat", nil)
+	if err != nil {
+		t.Error(err)
+	}
+	context2 := New().createContext(recorder, req2)
+
+	req3, err := http.NewRequest("DELETE", "http://localhost:3000/baz", nil)
+	if err != nil {
+		t.Error(err)
+	}
+	context3 := New().createContext(recorder, req3)
+
+	req4, err := http.NewRequest("PATCH", "http://localhost:3000/bar/foo", nil)
+	if err != nil {
+		t.Error(err)
+	}
+	context4 := New().createContext(recorder, req4)
+
+	req5, err := http.NewRequest("GET", "http://localhost:3000/fez/this/should/match", nil)
+	if err != nil {
+		t.Error(err)
+	}
+	context5 := New().createContext(recorder, req5)
+
+	req6, err := http.NewRequest("PUT", "http://localhost:3000/pop/blah/blah/blah/bap/foo/", nil)
+	if err != nil {
+		t.Error(err)
+	}
+	context6 := New().createContext(recorder, req6)
+
+	req7, err := http.NewRequest("DELETE", "http://localhost:3000/wap//pow", nil)
+	if err != nil {
+		t.Error(err)
+	}
+	context7 := New().createContext(recorder, req6)
+
+	result := ""
+	router.Get("/foo", func(req *http.Request) {
+		result += "foo"
+	})
+	router.Patch("/bar/:id", func(params Params) {
+		expect(t, params["id"], "foo")
+		result += "barfoo"
+	})
+	router.Post("/bar/:id", func(params Params) {
+		expect(t, params["id"], "bat")
+		result += "barbat"
+	})
+	router.Put("/fizzbuzz", func() {
+		result += "fizzbuzz"
+	})
+	router.Delete("/bazzer", func(c Context) {
+		result += "baz"
+	})
+	router.Get("/fez/**", func(params Params) {
+		expect(t, params["_1"], "this/should/match")
+		result += "fez"
+	})
+	router.Put("/pop/**/bap/:id/**", func(params Params) {
+		expect(t, params["id"], "foo")
+		expect(t, params["_1"], "blah/blah/blah")
+		expect(t, params["_2"], "")
+		result += "popbap"
+	})
+	router.Delete("/wap/**/pow", func(params Params) {
+		expect(t, params["_1"], "")
+		result += "wappow"
+	})
+
+	router.Handle(recorder, req, context)
+	router.Handle(recorder, req2, context2)
+	router.Handle(recorder, req3, context3)
+	router.Handle(recorder, req4, context4)
+	router.Handle(recorder, req5, context5)
+	router.Handle(recorder, req6, context6)
+	router.Handle(recorder, req7, context7)
+	expect(t, result, "foobarbatbarfoofezpopbapwappow")
+	expect(t, recorder.Code, http.StatusNotFound)
+	expect(t, recorder.Body.String(), "404 page not found\n")
+}
+
+func Test_RouterHandlerStatusCode(t *testing.T) {
+	router := NewRouter()
+	router.Get("/foo", func() string {
+		return "foo"
+	})
+	router.Get("/bar", func() (int, string) {
+		return http.StatusForbidden, "bar"
+	})
+	router.Get("/baz", func() (string, string) {
+		return "baz", "BAZ!"
+	})
+
+	// code should be 200 if none is returned from the handler
+	recorder := httptest.NewRecorder()
+	req, err := http.NewRequest("GET", "http://localhost:3000/foo", nil)
+	if err != nil {
+		t.Error(err)
+	}
+	context := New().createContext(recorder, req)
+	router.Handle(recorder, req, context)
+	expect(t, recorder.Code, http.StatusOK)
+	expect(t, recorder.Body.String(), "foo")
+
+	// if a status code is returned, it should be used
+	recorder = httptest.NewRecorder()
+	req, err = http.NewRequest("GET", "http://localhost:3000/bar", nil)
+	if err != nil {
+		t.Error(err)
+	}
+	context = New().createContext(recorder, req)
+	router.Handle(recorder, req, context)
+	expect(t, recorder.Code, http.StatusForbidden)
+	expect(t, recorder.Body.String(), "bar")
+
+	// shouldn't use the first returned value as a status code if not an integer
+	recorder = httptest.NewRecorder()
+	req, err = http.NewRequest("GET", "http://localhost:3000/baz", nil)
+	if err != nil {
+		t.Error(err)
+	}
+	context = New().createContext(recorder, req)
+	router.Handle(recorder, req, context)
+	expect(t, recorder.Code, http.StatusOK)
+	expect(t, recorder.Body.String(), "baz")
+}
+
+func Test_RouterHandlerStacking(t *testing.T) {
+	router := NewRouter()
+	recorder := httptest.NewRecorder()
+
+	req, err := http.NewRequest("GET", "http://localhost:3000/foo", nil)
+	if err != nil {
+		t.Error(err)
+	}
+	context := New().createContext(recorder, req)
+
+	result := ""
+
+	f1 := func() {
+		result += "foo"
+	}
+
+	f2 := func(c Context) {
+		result += "bar"
+		c.Next()
+		result += "bing"
+	}
+
+	f3 := func() string {
+		result += "bat"
+		return "Hello world"
+	}
+
+	f4 := func() {
+		result += "baz"
+	}
+
+	router.Get("/foo", f1, f2, f3, f4)
+
+	router.Handle(recorder, req, context)
+	expect(t, result, "foobarbatbing")
+	expect(t, recorder.Body.String(), "Hello world")
+}
+
+var routeTests = []struct {
+	// in
+	method string
+	path   string
+
+	// out
+	ok     bool
+	params map[string]string
+}{
+	{"GET", "/foo/123/bat/321", true, map[string]string{"bar": "123", "baz": "321"}},
+	{"POST", "/foo/123/bat/321", false, map[string]string{}},
+	{"GET", "/foo/hello/bat/world", true, map[string]string{"bar": "hello", "baz": "world"}},
+	{"GET", "foo/hello/bat/world", false, map[string]string{}},
+	{"GET", "/foo/123/bat/321/", true, map[string]string{"bar": "123", "baz": "321"}},
+	{"GET", "/foo/123/bat/321//", false, map[string]string{}},
+	{"GET", "/foo/123//bat/321/", false, map[string]string{}},
+}
+
+func Test_RouteMatching(t *testing.T) {
+	route := newRoute("GET", "/foo/:bar/bat/:baz", nil)
+	for _, tt := range routeTests {
+		ok, params := route.Match(tt.method, tt.path)
+		if ok != tt.ok || params["bar"] != tt.params["bar"] || params["baz"] != tt.params["baz"] {
+			t.Errorf("expected: (%v, %v) got: (%v, %v)", tt.ok, tt.params, ok, params)
+		}
+	}
+}
+
+func Test_NotFound(t *testing.T) {
+	router := NewRouter()
+	recorder := httptest.NewRecorder()
+
+	req, _ := http.NewRequest("GET", "http://localhost:3000/foo", nil)
+	context := New().createContext(recorder, req)
+
+	router.NotFound(func(res http.ResponseWriter) {
+		http.Error(res, "Nope", http.StatusNotFound)
+	})
+
+	router.Handle(recorder, req, context)
+	expect(t, recorder.Code, http.StatusNotFound)
+	expect(t, recorder.Body.String(), "Nope\n")
+}
+
+func Test_Any(t *testing.T) {
+	router := NewRouter()
+	router.Any("/foo", func(res http.ResponseWriter) {
+		http.Error(res, "Nope", http.StatusNotFound)
+	})
+
+	recorder := httptest.NewRecorder()
+	req, _ := http.NewRequest("GET", "http://localhost:3000/foo", nil)
+	context := New().createContext(recorder, req)
+	router.Handle(recorder, req, context)
+
+	expect(t, recorder.Code, http.StatusNotFound)
+	expect(t, recorder.Body.String(), "Nope\n")
+
+	recorder = httptest.NewRecorder()
+	req, _ = http.NewRequest("PUT", "http://localhost:3000/foo", nil)
+	context = New().createContext(recorder, req)
+	router.Handle(recorder, req, context)
+
+	expect(t, recorder.Code, http.StatusNotFound)
+	expect(t, recorder.Body.String(), "Nope\n")
+}
+
+func Test_URLFor(t *testing.T) {
+	router := NewRouter()
+	var barIDNameRoute, fooRoute, barRoute Route
+
+	fooRoute = router.Get("/foo", func() {
+		// Nothing
+	})
+
+	barRoute = router.Post("/bar/:id", func(params Params) {
+		// Nothing
+	})
+
+	barIDNameRoute = router.Get("/bar/:id/:name", func(params Params, routes Routes) {
+		expect(t, routes.URLFor(fooRoute, nil), "/foo")
+		expect(t, routes.URLFor(barRoute, 5), "/bar/5")
+		expect(t, routes.URLFor(barIDNameRoute, 5, "john"), "/bar/5/john")
+	})
+
+	// code should be 200 if none is returned from the handler
+	recorder := httptest.NewRecorder()
+	req, err := http.NewRequest("GET", "http://localhost:3000/bar/foo/bar", nil)
+	if err != nil {
+		t.Error(err)
+	}
+	context := New().createContext(recorder, req)
+	router.Handle(recorder, req, context)
+}

Godeps/_workspace/src/github.com/codegangsta/martini/static.go

@@ -0,0 +1,52 @@
+package martini
+
+import (
+	"log"
+	"net/http"
+	"path"
+	"strings"
+)
+
+// Static returns a middleware handler that serves static files in the given directory.
+func Static(directory string) Handler {
+	dir := http.Dir(directory)
+	return func(res http.ResponseWriter, req *http.Request, log *log.Logger) {
+		file := req.URL.Path
+		f, err := dir.Open(file)
+		if err != nil {
+			// discard the error?
+			return
+		}
+		defer f.Close()
+
+		fi, err := f.Stat()
+		if err != nil {
+			return
+		}
+
+		// 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
+			}
+
+			file = path.Join(file, "index.html")
+			f, err = dir.Open(file)
+			if err != nil {
+				return
+			}
+			defer f.Close()
+
+			fi, err = f.Stat()
+			if err != nil || fi.IsDir() {
+				return
+			}
+		}
+
+		log.Println("[Static] Serving " + file)
+		http.ServeContent(res, req, file, fi.ModTime(), f)
+	}
+}