Merge branch 'master' of /home/torkel/dev/go/src/github.com/torkelo/backend

Conflicts:
	.gitignore
	LICENSE.md
	README.md

.bra.toml

@@ -0,0 +1,17 @@
+[run]
+init_cmds = [
+  ["go", "build", "-o", "./bin/grafana"],
+	["./bin/grafana", "web"]
+]
+watch_all = true
+watch_dirs = [
+	"$WORKDIR/pkg",
+	"$WORKDIR/grafana/src/views",
+	"$WORKDIR/conf",
+]
+watch_exts = [".go", ".ini"]
+build_delay = 1500
+cmds = [
+  ["go", "build", "-o", "./bin/grafana"],
+	["./bin/grafana", "web"]
+]

.gitignore

@@ -12,3 +12,11 @@ src/css/*.min.css
 *.sublime-workspace
 *.swp
 .idea/
+
+data/sessions
+data/*.db
+data/log
+/bin/*
+/grafana-pro
+
+grafana.custom.ini

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "grafana"]
+	path = grafana
+	url = git@github.com:torkelo/grafana-private.git

Godeps/Godeps.json

@@ -0,0 +1,79 @@
+{
+	"ImportPath": "github.com/torkelo/grafana-pro",
+	"GoVersion": "go1.3",
+	"Packages": [
+		"./pkg/..."
+	],
+	"Deps": [
+		{
+			"ImportPath": "github.com/Unknwon/com",
+			"Rev": "d9bcf409c8a368d06c9b347705c381e7c12d54df"
+		},
+		{
+			"ImportPath": "github.com/Unknwon/macaron",
+			"Rev": "da7cbddc50b9d33e076fb1eabff13b55c3b85fc5"
+		},
+		{
+			"ImportPath": "github.com/codegangsta/cli",
+			"Comment": "1.2.0-38-g9908e96",
+			"Rev": "9908e96513e5a94de37004098a3974a567f18111"
+		},
+		{
+			"ImportPath": "github.com/go-sql-driver/mysql",
+			"Comment": "v1.2-26-g9543750",
+			"Rev": "9543750295406ef070f7de8ae9c43ccddd44e15e"
+		},
+		{
+			"ImportPath": "github.com/go-xorm/core",
+			"Rev": "a949e067ced1cb6e6ef5c38b6f28b074fa718f1e"
+		},
+		{
+			"ImportPath": "github.com/go-xorm/xorm",
+			"Comment": "v0.4.1-19-g5c23849",
+			"Rev": "5c23849a66f4593e68909bb6c1fa30651b5b0541"
+		},
+		{
+			"ImportPath": "github.com/jtolds/gls",
+			"Rev": "f1ac7f4f24f50328e6bc838ca4437d1612a0243c"
+		},
+		{
+			"ImportPath": "github.com/lib/pq",
+			"Comment": "go1.0-cutoff-13-g19eeca3",
+			"Rev": "19eeca3e30d2577b1761db471ec130810e67f532"
+		},
+		{
+			"ImportPath": "github.com/macaron-contrib/binding",
+			"Rev": "0fbe4b9707e6eb556ef843e5471592f55ce0a5e7"
+		},
+		{
+			"ImportPath": "github.com/macaron-contrib/session",
+			"Rev": "65b8817c40cb5bdce08673a15fd2a648c2ba0e16"
+		},
+		{
+			"ImportPath": "github.com/mattn/go-sqlite3",
+			"Rev": "d10e2c8f62100097910367dee90a9bd89d426a44"
+		},
+		{
+			"ImportPath": "github.com/smartystreets/goconvey/convey",
+			"Comment": "1.5.0-356-gfbc0a1c",
+			"Rev": "fbc0a1c888f9f96263f9a559d1769905245f1123"
+		},
+		{
+			"ImportPath": "github.com/streadway/amqp",
+			"Rev": "150b7f24d6ad507e6026c13d85ce1f1391ac7400"
+		},
+		{
+			"ImportPath": "golang.org/x/net/context",
+			"Rev": "972f0c5fbe4ae29e666c3f78c3ed42ae7a448b0a"
+		},
+		{
+			"ImportPath": "golang.org/x/oauth2",
+			"Rev": "e5909d4679a1926c774c712b343f10b8298687a3"
+		},
+		{
+			"ImportPath": "gopkg.in/ini.v1",
+			"Comment": "v0-10-g28ad8c4",
+			"Rev": "28ad8c408ba20e5c86b06d64cd2cc9248f640a83"
+		}
+	]
+}

Godeps/Readme

@@ -0,0 +1,5 @@
+This directory tree is generated automatically by godep.
+
+Please do not edit.
+
+See https://github.com/tools/godep for more information.

Godeps/_workspace/.gitignore

@@ -0,0 +1,2 @@
+/pkg
+/bin

Godeps/_workspace/src/github.com/Unknwon/com/.gitignore

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

Godeps/_workspace/src/github.com/Unknwon/com/LICENSE

@@ -0,0 +1,191 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Godeps/_workspace/src/github.com/Unknwon/com/README.md

@@ -0,0 +1,24 @@
+Common functions
+===
+
+[![Build Status](https://drone.io/github.com/Unknwon/com/status.png)](https://drone.io/github.com/Unknwon/com/latest) [![Go Walker](http://gowalker.org/api/v1/badge)](http://gowalker.org/github.com/Unknwon/com)
+
+This is an open source project for commonly used functions for the Go programming language.
+
+This package need >= **go 1.2**
+
+Code Convention: based on [Go Code Convention](https://github.com/Unknwon/go-code-convention).
+
+## Contribute
+
+Your contribute is welcome, but you have to check following steps after you added some functions and commit them:
+
+1. Make sure you wrote user-friendly comments for **all functions** .
+2. Make sure you wrote test cases with any possible condition for **all functions** in file `*_test.go`.
+3. Make sure you wrote benchmarks for **all functions** in file `*_test.go`.
+4. Make sure you wrote useful examples for **all functions** in file `example_test.go`.
+5. Make sure you ran `go test -bench="."` and got **PASS** .
+
+## Performance
+
+See results on [drone.io](https://drone.io/github.com/Unknwon/com/latest) by `go test -bench="."`.

Godeps/_workspace/src/github.com/Unknwon/com/cmd.go

@@ -0,0 +1,161 @@
+// +build go1.2
+
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+// Package com is an open source project for commonly used functions for the Go programming language.
+package com
+
+import (
+	"bytes"
+	"fmt"
+	"os/exec"
+	"runtime"
+	"strings"
+)
+
+// ExecCmdDirBytes executes system command in given directory
+// and return stdout, stderr in bytes type, along with possible error.
+func ExecCmdDirBytes(dir, cmdName string, args ...string) ([]byte, []byte, error) {
+	bufOut := new(bytes.Buffer)
+	bufErr := new(bytes.Buffer)
+
+	cmd := exec.Command(cmdName, args...)
+	cmd.Dir = dir
+	cmd.Stdout = bufOut
+	cmd.Stderr = bufErr
+
+	err := cmd.Run()
+	return bufOut.Bytes(), bufErr.Bytes(), err
+}
+
+// ExecCmdBytes executes system command
+// and return stdout, stderr in bytes type, along with possible error.
+func ExecCmdBytes(cmdName string, args ...string) ([]byte, []byte, error) {
+	return ExecCmdDirBytes("", cmdName, args...)
+}
+
+// ExecCmdDir executes system command in given directory
+// and return stdout, stderr in string type, along with possible error.
+func ExecCmdDir(dir, cmdName string, args ...string) (string, string, error) {
+	bufOut, bufErr, err := ExecCmdDirBytes(dir, cmdName, args...)
+	return string(bufOut), string(bufErr), err
+}
+
+// ExecCmd executes system command
+// and return stdout, stderr in string type, along with possible error.
+func ExecCmd(cmdName string, args ...string) (string, string, error) {
+	return ExecCmdDir("", cmdName, args...)
+}
+
+// _________        .__                 .____
+// \_   ___ \  ____ |  |   ___________  |    |    ____   ____
+// /    \  \/ /  _ \|  |  /  _ \_  __ \ |    |   /  _ \ / ___\
+// \     \___(  <_> )  |_(  <_> )  | \/ |    |__(  <_> ) /_/  >
+//  \______  /\____/|____/\____/|__|    |_______ \____/\___  /
+//         \/                                   \/    /_____/
+
+// Color number constants.
+const (
+	Gray = uint8(iota + 90)
+	Red
+	Green
+	Yellow
+	Blue
+	Magenta
+	//NRed      = uint8(31) // Normal
+	EndColor = "\033[0m"
+)
+
+// getColorLevel returns colored level string by given level.
+func getColorLevel(level string) string {
+	level = strings.ToUpper(level)
+	switch level {
+	case "TRAC":
+		return fmt.Sprintf("\033[%dm%s\033[0m", Blue, level)
+	case "ERRO":
+		return fmt.Sprintf("\033[%dm%s\033[0m", Red, level)
+	case "WARN":
+		return fmt.Sprintf("\033[%dm%s\033[0m", Magenta, level)
+	case "SUCC":
+		return fmt.Sprintf("\033[%dm%s\033[0m", Green, level)
+	default:
+		return level
+	}
+}
+
+// ColorLogS colors log and return colored content.
+// Log format: <level> <content [highlight][path]> [ error ].
+// Level: TRAC -> blue; ERRO -> red; WARN -> Magenta; SUCC -> green; others -> default.
+// Content: default; path: yellow; error -> red.
+// Level has to be surrounded by "[" and "]".
+// Highlights have to be surrounded by "# " and " #"(space), "#" will be deleted.
+// Paths have to be surrounded by "( " and " )"(space).
+// Errors have to be surrounded by "[ " and " ]"(space).
+// Note: it hasn't support windows yet, contribute is welcome.
+func ColorLogS(format string, a ...interface{}) string {
+	log := fmt.Sprintf(format, a...)
+
+	var clog string
+
+	if runtime.GOOS != "windows" {
+		// Level.
+		i := strings.Index(log, "]")
+		if log[0] == '[' && i > -1 {
+			clog += "[" + getColorLevel(log[1:i]) + "]"
+		}
+
+		log = log[i+1:]
+
+		// Error.
+		log = strings.Replace(log, "[ ", fmt.Sprintf("[\033[%dm", Red), -1)
+		log = strings.Replace(log, " ]", EndColor+"]", -1)
+
+		// Path.
+		log = strings.Replace(log, "( ", fmt.Sprintf("(\033[%dm", Yellow), -1)
+		log = strings.Replace(log, " )", EndColor+")", -1)
+
+		// Highlights.
+		log = strings.Replace(log, "# ", fmt.Sprintf("\033[%dm", Gray), -1)
+		log = strings.Replace(log, " #", EndColor, -1)
+
+	} else {
+		// Level.
+		i := strings.Index(log, "]")
+		if log[0] == '[' && i > -1 {
+			clog += "[" + log[1:i] + "]"
+		}
+
+		log = log[i+1:]
+
+		// Error.
+		log = strings.Replace(log, "[ ", "[", -1)
+		log = strings.Replace(log, " ]", "]", -1)
+
+		// Path.
+		log = strings.Replace(log, "( ", "(", -1)
+		log = strings.Replace(log, " )", ")", -1)
+
+		// Highlights.
+		log = strings.Replace(log, "# ", "", -1)
+		log = strings.Replace(log, " #", "", -1)
+	}
+	return clog + log
+}
+
+// ColorLog prints colored log to stdout.
+// See color rules in function 'ColorLogS'.
+func ColorLog(format string, a ...interface{}) {
+	fmt.Print(ColorLogS(format, a...))
+}

Godeps/_workspace/src/github.com/Unknwon/com/cmd_test.go

@@ -0,0 +1,140 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestColorLogS(t *testing.T) {
+	if runtime.GOOS != "windows" {
+		// Trace + path.
+		cls := ColorLogS("[TRAC] Trace level test with path( %s )", "/path/to/somethere")
+		clsR := fmt.Sprintf(
+			"[\033[%dmTRAC%s] Trace level test with path(\033[%dm%s%s)",
+			Blue, EndColor, Yellow, "/path/to/somethere", EndColor)
+		if cls != clsR {
+			t.Errorf("ColorLogS:\n Expect => %s\n Got => %s\n", clsR, cls)
+		}
+
+		// Error + error.
+		cls = ColorLogS("[ERRO] Error level test with error[ %s ]", "test error")
+		clsR = fmt.Sprintf(
+			"[\033[%dmERRO%s] Error level test with error[\033[%dm%s%s]",
+			Red, EndColor, Red, "test error", EndColor)
+		if cls != clsR {
+			t.Errorf("ColorLogS:\n Expect => %s\n Got => %s\n", clsR, cls)
+		}
+
+		// Warning + highlight.
+		cls = ColorLogS("[WARN] Warnning level test with highlight # %s #", "special offer!")
+		clsR = fmt.Sprintf(
+			"[\033[%dmWARN%s] Warnning level test with highlight \033[%dm%s%s",
+			Magenta, EndColor, Gray, "special offer!", EndColor)
+		if cls != clsR {
+			t.Errorf("ColorLogS:\n Expect => %s\n Got => %s\n", clsR, cls)
+		}
+
+		// Success.
+		cls = ColorLogS("[SUCC] Success level test")
+		clsR = fmt.Sprintf(
+			"[\033[%dmSUCC%s] Success level test",
+			Green, EndColor)
+		if cls != clsR {
+			t.Errorf("ColorLogS:\n Expect => %s\n Got => %s\n", clsR, cls)
+		}
+
+		// Default.
+		cls = ColorLogS("[INFO] Default level test")
+		clsR = fmt.Sprintf(
+			"[INFO] Default level test")
+		if cls != clsR {
+			t.Errorf("ColorLogS:\n Expect => %s\n Got => %s\n", clsR, cls)
+		}
+	} else {
+		// Trace + path.
+		cls := ColorLogS("[TRAC] Trace level test with path( %s )", "/path/to/somethere")
+		clsR := fmt.Sprintf(
+			"[TRAC] Trace level test with path(%s)",
+			"/path/to/somethere")
+		if cls != clsR {
+			t.Errorf("ColorLogS:\n Expect => %s\n Got => %s\n", clsR, cls)
+		}
+
+		// Error + error.
+		cls = ColorLogS("[ERRO] Error level test with error[ %s ]", "test error")
+		clsR = fmt.Sprintf(
+			"[ERRO] Error level test with error[%s]",
+			"test error")
+		if cls != clsR {
+			t.Errorf("ColorLogS:\n Expect => %s\n Got => %s\n", clsR, cls)
+		}
+
+		// Warning + highlight.
+		cls = ColorLogS("[WARN] Warnning level test with highlight # %s #", "special offer!")
+		clsR = fmt.Sprintf(
+			"[WARN] Warnning level test with highlight %s",
+			"special offer!")
+		if cls != clsR {
+			t.Errorf("ColorLogS:\n Expect => %s\n Got => %s\n", clsR, cls)
+		}
+
+		// Success.
+		cls = ColorLogS("[SUCC] Success level test")
+		clsR = fmt.Sprintf(
+			"[SUCC] Success level test")
+		if cls != clsR {
+			t.Errorf("ColorLogS:\n Expect => %s\n Got => %s\n", clsR, cls)
+		}
+
+		// Default.
+		cls = ColorLogS("[INFO] Default level test")
+		clsR = fmt.Sprintf(
+			"[INFO] Default level test")
+		if cls != clsR {
+			t.Errorf("ColorLogS:\n Expect => %s\n Got => %s\n", clsR, cls)
+		}
+	}
+}
+
+func TestExecCmd(t *testing.T) {
+	stdout, stderr, err := ExecCmd("go", "help", "get")
+	if err != nil {
+		t.Errorf("ExecCmd:\n Expect => %v\n Got => %v\n", nil, err)
+	} else if len(stderr) != 0 {
+		t.Errorf("ExecCmd:\n Expect => %s\n Got => %s\n", "", stderr)
+	} else if !strings.HasPrefix(stdout, "usage: go get") {
+		t.Errorf("ExecCmd:\n Expect => %s\n Got => %s\n", "usage: go get", stdout)
+	}
+}
+
+func BenchmarkColorLogS(b *testing.B) {
+	log := fmt.Sprintf(
+		"[WARN] This is a tesing log that should be colored, path( %s ),"+
+			" highlight # %s #, error [ %s ].",
+		"path to somewhere", "highlighted content", "tesing error")
+	for i := 0; i < b.N; i++ {
+		ColorLogS(log)
+	}
+}
+
+func BenchmarkExecCmd(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		ExecCmd("go", "help", "get")
+	}
+}

Godeps/_workspace/src/github.com/Unknwon/com/convert.go

@@ -0,0 +1,157 @@
+// Copyright 2014 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"fmt"
+	"strconv"
+)
+
+// Convert string to specify type.
+type StrTo string
+
+func (f StrTo) Exist() bool {
+	return string(f) != string(0x1E)
+}
+
+func (f StrTo) Uint8() (uint8, error) {
+	v, err := strconv.ParseUint(f.String(), 10, 8)
+	return uint8(v), err
+}
+
+func (f StrTo) Int() (int, error) {
+	v, err := strconv.ParseInt(f.String(), 10, 32)
+	return int(v), err
+}
+
+func (f StrTo) Int64() (int64, error) {
+	v, err := strconv.ParseInt(f.String(), 10, 64)
+	return int64(v), err
+}
+
+func (f StrTo) MustUint8() uint8 {
+	v, _ := f.Uint8()
+	return v
+}
+
+func (f StrTo) MustInt() int {
+	v, _ := f.Int()
+	return v
+}
+
+func (f StrTo) MustInt64() int64 {
+	v, _ := f.Int64()
+	return v
+}
+
+func (f StrTo) String() string {
+	if f.Exist() {
+		return string(f)
+	}
+	return ""
+}
+
+// Convert any type to string.
+func ToStr(value interface{}, args ...int) (s string) {
+	switch v := value.(type) {
+	case bool:
+		s = strconv.FormatBool(v)
+	case float32:
+		s = strconv.FormatFloat(float64(v), 'f', argInt(args).Get(0, -1), argInt(args).Get(1, 32))
+	case float64:
+		s = strconv.FormatFloat(v, 'f', argInt(args).Get(0, -1), argInt(args).Get(1, 64))
+	case int:
+		s = strconv.FormatInt(int64(v), argInt(args).Get(0, 10))
+	case int8:
+		s = strconv.FormatInt(int64(v), argInt(args).Get(0, 10))
+	case int16:
+		s = strconv.FormatInt(int64(v), argInt(args).Get(0, 10))
+	case int32:
+		s = strconv.FormatInt(int64(v), argInt(args).Get(0, 10))
+	case int64:
+		s = strconv.FormatInt(v, argInt(args).Get(0, 10))
+	case uint:
+		s = strconv.FormatUint(uint64(v), argInt(args).Get(0, 10))
+	case uint8:
+		s = strconv.FormatUint(uint64(v), argInt(args).Get(0, 10))
+	case uint16:
+		s = strconv.FormatUint(uint64(v), argInt(args).Get(0, 10))
+	case uint32:
+		s = strconv.FormatUint(uint64(v), argInt(args).Get(0, 10))
+	case uint64:
+		s = strconv.FormatUint(v, argInt(args).Get(0, 10))
+	case string:
+		s = v
+	case []byte:
+		s = string(v)
+	default:
+		s = fmt.Sprintf("%v", v)
+	}
+	return s
+}
+
+type argInt []int
+
+func (a argInt) Get(i int, args ...int) (r int) {
+	if i >= 0 && i < len(a) {
+		r = a[i]
+	} else if len(args) > 0 {
+		r = args[0]
+	}
+	return
+}
+
+// HexStr2int converts hex format string to decimal number.
+func HexStr2int(hexStr string) (int, error) {
+	num := 0
+	length := len(hexStr)
+	for i := 0; i < length; i++ {
+		char := hexStr[length-i-1]
+		factor := -1
+
+		switch {
+		case char >= '0' && char <= '9':
+			factor = int(char) - '0'
+		case char >= 'a' && char <= 'f':
+			factor = int(char) - 'a' + 10
+		default:
+			return -1, fmt.Errorf("invalid hex: %s", string(char))
+		}
+
+		num += factor * PowInt(16, i)
+	}
+	return num, nil
+}
+
+// Int2HexStr converts decimal number to hex format string.
+func Int2HexStr(num int) (hex string) {
+	if num == 0 {
+		return "0"
+	}
+
+	for num > 0 {
+		r := num % 16
+
+		c := "?"
+		if r >= 0 && r <= 9 {
+			c = string(r + '0')
+		} else {
+			c = string(r + 'a' - 10)
+		}
+		hex = c + hex
+		num = num / 16
+	}
+	return hex
+}

Godeps/_workspace/src/github.com/Unknwon/com/convert_test.go

@@ -0,0 +1,56 @@
+// Copyright 2014 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestHexStr2int(t *testing.T) {
+	Convey("Convert hex format string to decimal", t, func() {
+		hexDecs := map[string]int{
+			"1":   1,
+			"002": 2,
+			"011": 17,
+			"0a1": 161,
+			"35e": 862,
+		}
+
+		for hex, dec := range hexDecs {
+			val, err := HexStr2int(hex)
+			So(err, ShouldBeNil)
+			So(val, ShouldEqual, dec)
+		}
+	})
+}
+
+func TestInt2HexStr(t *testing.T) {
+	Convey("Convert decimal to hex format string", t, func() {
+		decHexs := map[int]string{
+			1:   "1",
+			2:   "2",
+			17:  "11",
+			161: "a1",
+			862: "35e",
+		}
+
+		for dec, hex := range decHexs {
+			val := Int2HexStr(dec)
+			So(val, ShouldEqual, hex)
+		}
+	})
+}

Godeps/_workspace/src/github.com/Unknwon/com/dir.go

@@ -0,0 +1,173 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path"
+	"strings"
+)
+
+// IsDir returns true if given path is a directory,
+// or returns false when it's a file or does not exist.
+func IsDir(dir string) bool {
+	f, e := os.Stat(dir)
+	if e != nil {
+		return false
+	}
+	return f.IsDir()
+}
+
+func statDir(dirPath, recPath string, includeDir, isDirOnly bool) ([]string, error) {
+	dir, err := os.Open(dirPath)
+	if err != nil {
+		return nil, err
+	}
+	defer dir.Close()
+
+	fis, err := dir.Readdir(0)
+	if err != nil {
+		return nil, err
+	}
+
+	statList := make([]string, 0)
+	for _, fi := range fis {
+		if strings.Contains(fi.Name(), ".DS_Store") {
+			continue
+		}
+
+		relPath := path.Join(recPath, fi.Name())
+		curPath := path.Join(dirPath, fi.Name())
+		if fi.IsDir() {
+			if includeDir {
+				statList = append(statList, relPath+"/")
+			}
+			s, err := statDir(curPath, relPath, includeDir, isDirOnly)
+			if err != nil {
+				return nil, err
+			}
+			statList = append(statList, s...)
+		} else if !isDirOnly {
+			statList = append(statList, relPath)
+		}
+	}
+	return statList, nil
+}
+
+// StatDir gathers information of given directory by depth-first.
+// It returns slice of file list and includes subdirectories if enabled;
+// it returns error and nil slice when error occurs in underlying functions,
+// or given path is not a directory or does not exist.
+//
+// Slice does not include given path itself.
+// If subdirectories is enabled, they will have suffix '/'.
+func StatDir(rootPath string, includeDir ...bool) ([]string, error) {
+	if !IsDir(rootPath) {
+		return nil, errors.New("not a directory or does not exist: " + rootPath)
+	}
+
+	isIncludeDir := false
+	if len(includeDir) >= 1 {
+		isIncludeDir = includeDir[0]
+	}
+	return statDir(rootPath, "", isIncludeDir, false)
+}
+
+// GetAllSubDirs returns all subdirectories of given root path.
+// Slice does not include given path itself.
+func GetAllSubDirs(rootPath string) ([]string, error) {
+	if !IsDir(rootPath) {
+		return nil, errors.New("not a directory or does not exist: " + rootPath)
+	}
+	return statDir(rootPath, "", true, true)
+}
+
+// GetFileListBySuffix returns an ordered list of file paths.
+// It recognize if given path is a file, and don't do recursive find.
+func GetFileListBySuffix(dirPath, suffix string) ([]string, error) {
+	if !IsExist(dirPath) {
+		return nil, fmt.Errorf("given path does not exist: %s", dirPath)
+	} else if IsFile(dirPath) {
+		return []string{dirPath}, nil
+	}
+
+	// Given path is a directory.
+	dir, err := os.Open(dirPath)
+	if err != nil {
+		return nil, err
+	}
+
+	fis, err := dir.Readdir(0)
+	if err != nil {
+		return nil, err
+	}
+
+	files := make([]string, 0, len(fis))
+	for _, fi := range fis {
+		if strings.HasSuffix(fi.Name(), suffix) {
+			files = append(files, path.Join(dirPath, fi.Name()))
+		}
+	}
+
+	return files, nil
+}
+
+// CopyDir copy files recursively from source to target directory.
+//
+// The filter accepts a function that process the path info.
+// and should return true for need to filter.
+//
+// It returns error when error occurs in underlying functions.
+func CopyDir(srcPath, destPath string, filters ...func(filePath string) bool) error {
+	// Check if target directory exists.
+	if IsExist(destPath) {
+		return errors.New("file or directory alreay exists: " + destPath)
+	}
+
+	err := os.MkdirAll(destPath, os.ModePerm)
+	if err != nil {
+		return err
+	}
+
+	// Gather directory info.
+	infos, err := StatDir(srcPath, true)
+	if err != nil {
+		return err
+	}
+
+	var filter func(filePath string) bool
+	if len(filters) > 0 {
+		filter = filters[0]
+	}
+
+	for _, info := range infos {
+		if filter != nil && filter(info) {
+			continue
+		}
+
+		curPath := path.Join(destPath, info)
+		if strings.HasSuffix(info, "/") {
+			err = os.MkdirAll(curPath, os.ModePerm)
+		} else {
+			err = Copy(path.Join(srcPath, info), curPath)
+		}
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

Godeps/_workspace/src/github.com/Unknwon/com/dir_test.go

@@ -0,0 +1,58 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"os"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestIsDir(t *testing.T) {
+	Convey("Check if given path is a directory", t, func() {
+		Convey("Pass a file name", func() {
+			So(IsDir("file.go"), ShouldEqual, false)
+		})
+		Convey("Pass a directory name", func() {
+			So(IsDir("testdata"), ShouldEqual, true)
+		})
+		Convey("Pass a invalid path", func() {
+			So(IsDir("foo"), ShouldEqual, false)
+		})
+	})
+}
+
+func TestCopyDir(t *testing.T) {
+	Convey("Items of two slices should be same", t, func() {
+		s1, err := StatDir("testdata", true)
+		So(err, ShouldEqual, nil)
+
+		err = CopyDir("testdata", "testdata2")
+		So(err, ShouldEqual, nil)
+
+		s2, err := StatDir("testdata2", true)
+		os.RemoveAll("testdata2")
+		So(err, ShouldEqual, nil)
+
+		So(CompareSliceStr(s1, s2), ShouldEqual, true)
+	})
+}
+
+func BenchmarkIsDir(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		IsDir("file.go")
+	}
+}

Godeps/_workspace/src/github.com/Unknwon/com/example_test.go

@@ -0,0 +1,299 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com_test
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/Unknwon/com"
+)
+
+// ------------------------------
+// cmd.go
+// ------------------------------
+
+func ExampleColorLogS() {
+	coloredLog := com.ColorLogS(fmt.Sprintf(
+		"[WARN] This is a tesing log that should be colored, path( %s ),"+
+			" highlight # %s #, error [ %s ].",
+		"path to somewhere", "highlighted content", "tesing error"))
+	fmt.Println(coloredLog)
+}
+
+func ExampleColorLog() {
+	com.ColorLog(fmt.Sprintf(
+		"[WARN] This is a tesing log that should be colored, path( %s ),"+
+			" highlight # %s #, error [ %s ].",
+		"path to somewhere", "highlighted content", "tesing error"))
+}
+
+func ExampleExecCmd() {
+	stdout, stderr, err := com.ExecCmd("go", "help", "get")
+	fmt.Println(stdout, stderr, err)
+}
+
+// ------------- END ------------
+
+// ------------------------------
+// html.go
+// ------------------------------
+
+func ExampleHtml2JS() {
+	htm := "<div id=\"button\" class=\"btn\">Click me</div>\n\r"
+	js := string(com.Html2JS([]byte(htm)))
+	fmt.Println(js)
+	// Output: <div id=\"button\" class=\"btn\">Click me</div>\n
+}
+
+// ------------- END ------------
+
+// ------------------------------
+// path.go
+// ------------------------------
+
+func ExampleGetGOPATHs() {
+	gps := com.GetGOPATHs()
+	fmt.Println(gps)
+}
+
+func ExampleGetSrcPath() {
+	srcPath, err := com.GetSrcPath("github.com/Unknwon/com")
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	fmt.Println(srcPath)
+}
+
+func ExampleHomeDir() {
+	hd, err := com.HomeDir()
+	fmt.Println(hd, err)
+}
+
+// ------------- END ------------
+
+// ------------------------------
+// file.go
+// ------------------------------
+
+func ExampleIsFile() {
+	if com.IsFile("file.go") {
+		fmt.Println("file.go exists")
+		return
+	}
+	fmt.Println("file.go is not a file or does not exist")
+}
+
+func ExampleIsExist() {
+	if com.IsExist("file.go") {
+		fmt.Println("file.go exists")
+		return
+	}
+	fmt.Println("file.go does not exist")
+}
+
+// ------------- END ------------
+
+// ------------------------------
+// dir.go
+// ------------------------------
+
+func ExampleIsDir() {
+	if com.IsDir("files") {
+		fmt.Println("directory 'files' exists")
+		return
+	}
+	fmt.Println("'files' is not a directory or does not exist")
+}
+
+// ------------- END ------------
+
+// ------------------------------
+// string.go
+// ------------------------------
+
+func ExampleIsLetter() {
+	fmt.Println(com.IsLetter('1'))
+	fmt.Println(com.IsLetter('['))
+	fmt.Println(com.IsLetter('a'))
+	fmt.Println(com.IsLetter('Z'))
+	// Output:
+	// false
+	// false
+	// true
+	// true
+}
+
+func ExampleExpand() {
+	match := map[string]string{
+		"domain":    "gowalker.org",
+		"subdomain": "github.com",
+	}
+	s := "http://{domain}/{subdomain}/{0}/{1}"
+	fmt.Println(com.Expand(s, match, "Unknwon", "gowalker"))
+	// Output: http://gowalker.org/github.com/Unknwon/gowalker
+}
+
+// ------------- END ------------
+
+// ------------------------------
+// http.go
+// ------------------------------
+
+func ExampleHttpGet() ([]byte, error) {
+	rc, err := com.HttpGet(&http.Client{}, "http://gowalker.org", nil)
+	if err != nil {
+		return nil, err
+	}
+	p, err := ioutil.ReadAll(rc)
+	rc.Close()
+	return p, err
+}
+
+func ExampleHttpGetBytes() ([]byte, error) {
+	p, err := com.HttpGetBytes(&http.Client{}, "http://gowalker.org", nil)
+	return p, err
+}
+
+func ExampleHttpGetJSON() interface{} {
+	j := com.HttpGetJSON(&http.Client{}, "http://gowalker.org", nil)
+	return j
+}
+
+type rawFile struct {
+	name   string
+	rawURL string
+	data   []byte
+}
+
+func (rf *rawFile) Name() string {
+	return rf.name
+}
+
+func (rf *rawFile) RawUrl() string {
+	return rf.rawURL
+}
+
+func (rf *rawFile) Data() []byte {
+	return rf.data
+}
+
+func (rf *rawFile) SetData(p []byte) {
+	rf.data = p
+}
+
+func ExampleFetchFiles() {
+	// Code that should be outside of your function body.
+	// type rawFile struct {
+	// name   string
+	// 	rawURL string
+	// 	data   []byte
+	// }
+
+	// func (rf *rawFile) Name() string {
+	// 	return rf.name
+	// }
+
+	// func (rf *rawFile) RawUrl() string {
+	// 	return rf.rawURL
+	// }
+
+	// func (rf *rawFile) Data() []byte {
+	// 	return rf.data
+	// }
+
+	// func (rf *rawFile) SetData(p []byte) {
+	// 	rf.data = p
+	// }
+
+	files := []com.RawFile{
+		&rawFile{rawURL: "http://example.com"},
+		&rawFile{rawURL: "http://example.com/foo"},
+	}
+	err := com.FetchFiles(&http.Client{}, files, nil)
+	fmt.Println(err, len(files[0].Data()), len(files[1].Data()))
+}
+
+func ExampleFetchFilesCurl() {
+	// Code that should be outside of your function body.
+	// type rawFile struct {
+	// name   string
+	// 	rawURL string
+	// 	data   []byte
+	// }
+
+	// func (rf *rawFile) Name() string {
+	// 	return rf.name
+	// }
+
+	// func (rf *rawFile) RawUrl() string {
+	// 	return rf.rawURL
+	// }
+
+	// func (rf *rawFile) Data() []byte {
+	// 	return rf.data
+	// }
+
+	// func (rf *rawFile) SetData(p []byte) {
+	// 	rf.data = p
+	// }
+
+	files := []com.RawFile{
+		&rawFile{rawURL: "http://example.com"},
+		&rawFile{rawURL: "http://example.com/foo"},
+	}
+	err := com.FetchFilesCurl(files)
+	fmt.Println(err, len(files[0].Data()), len(files[1].Data()))
+}
+
+// ------------- END ------------
+
+// ------------------------------
+// regex.go
+// ------------------------------
+
+func ExampleIsEmail() {
+	fmt.Println(com.IsEmail("test@example.com"))
+	fmt.Println(com.IsEmail("@example.com"))
+	// Output:
+	// true
+	// false
+}
+
+func ExampleIsUrl() {
+	fmt.Println(com.IsUrl("http://example.com"))
+	fmt.Println(com.IsUrl("http//example.com"))
+	// Output:
+	// true
+	// false
+}
+
+// ------------- END ------------
+
+// ------------------------------
+// slice.go
+// ------------------------------
+
+func ExampleAppendStr() {
+	s := []string{"a"}
+	s = com.AppendStr(s, "a")
+	s = com.AppendStr(s, "b")
+	fmt.Println(s)
+	// Output: [a b]
+}
+
+// ------------- END ------------

Godeps/_workspace/src/github.com/Unknwon/com/file.go

@@ -0,0 +1,145 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"math"
+	"os"
+	"path"
+)
+
+// Storage unit constants.
+const (
+	Byte  = 1
+	KByte = Byte * 1024
+	MByte = KByte * 1024
+	GByte = MByte * 1024
+	TByte = GByte * 1024
+	PByte = TByte * 1024
+	EByte = PByte * 1024
+)
+
+func logn(n, b float64) float64 {
+	return math.Log(n) / math.Log(b)
+}
+
+func humanateBytes(s uint64, base float64, sizes []string) string {
+	if s < 10 {
+		return fmt.Sprintf("%dB", s)
+	}
+	e := math.Floor(logn(float64(s), base))
+	suffix := sizes[int(e)]
+	val := float64(s) / math.Pow(base, math.Floor(e))
+	f := "%.0f"
+	if val < 10 {
+		f = "%.1f"
+	}
+
+	return fmt.Sprintf(f+"%s", val, suffix)
+}
+
+// HumaneFileSize calculates the file size and generate user-friendly string.
+func HumaneFileSize(s uint64) string {
+	sizes := []string{"B", "KB", "MB", "GB", "TB", "PB", "EB"}
+	return humanateBytes(s, 1024, sizes)
+}
+
+// FileMTime returns file modified time and possible error.
+func FileMTime(file string) (int64, error) {
+	f, err := os.Stat(file)
+	if err != nil {
+		return 0, err
+	}
+	return f.ModTime().Unix(), nil
+}
+
+// FileSize returns file size in bytes and possible error.
+func FileSize(file string) (int64, error) {
+	f, err := os.Stat(file)
+	if err != nil {
+		return 0, err
+	}
+	return f.Size(), nil
+}
+
+// Copy copies file from source to target path.
+func Copy(src, dest string) error {
+	// Gather file information to set back later.
+	si, err := os.Lstat(src)
+	if err != nil {
+		return err
+	}
+
+	// Handle symbolic link.
+	if si.Mode()&os.ModeSymlink != 0 {
+		target, err := os.Readlink(src)
+		if err != nil {
+			return err
+		}
+		// NOTE: os.Chmod and os.Chtimes don't recoganize symbolic link,
+		// which will lead "no such file or directory" error.
+		return os.Symlink(target, dest)
+	}
+
+	sr, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer sr.Close()
+
+	dw, err := os.Create(dest)
+	if err != nil {
+		return err
+	}
+	defer dw.Close()
+
+	if _, err = io.Copy(dw, sr); err != nil {
+		return err
+	}
+
+	// Set back file information.
+	if err = os.Chtimes(dest, si.ModTime(), si.ModTime()); err != nil {
+		return err
+	}
+	return os.Chmod(dest, si.Mode())
+}
+
+// WriteFile writes data to a file named by filename.
+// If the file does not exist, WriteFile creates it
+// and its upper level paths.
+func WriteFile(filename string, data []byte) error {
+	os.MkdirAll(path.Dir(filename), os.ModePerm)
+	return ioutil.WriteFile(filename, data, 0655)
+}
+
+// IsFile returns true if given path is a file,
+// or returns false when it's a directory or does not exist.
+func IsFile(filePath string) bool {
+	f, e := os.Stat(filePath)
+	if e != nil {
+		return false
+	}
+	return !f.IsDir()
+}
+
+// IsExist checks whether a file or directory exists.
+// It returns false when the file or directory does not exist.
+func IsExist(path string) bool {
+	_, err := os.Stat(path)
+	return err == nil || os.IsExist(err)
+}

Godeps/_workspace/src/github.com/Unknwon/com/file_test.go

@@ -0,0 +1,61 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestIsFile(t *testing.T) {
+	if !IsFile("file.go") {
+		t.Errorf("IsExist:\n Expect => %v\n Got => %v\n", true, false)
+	}
+
+	if IsFile("testdata") {
+		t.Errorf("IsExist:\n Expect => %v\n Got => %v\n", false, true)
+	}
+
+	if IsFile("files.go") {
+		t.Errorf("IsExist:\n Expect => %v\n Got => %v\n", false, true)
+	}
+}
+
+func TestIsExist(t *testing.T) {
+	Convey("Check if file or directory exists", t, func() {
+		Convey("Pass a file name that exists", func() {
+			So(IsExist("file.go"), ShouldEqual, true)
+		})
+		Convey("Pass a directory name that exists", func() {
+			So(IsExist("testdata"), ShouldEqual, true)
+		})
+		Convey("Pass a directory name that does not exist", func() {
+			So(IsExist(".hg"), ShouldEqual, false)
+		})
+	})
+}
+
+func BenchmarkIsFile(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		IsFile("file.go")
+	}
+}
+
+func BenchmarkIsExist(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		IsExist("file.go")
+	}
+}

Godeps/_workspace/src/github.com/Unknwon/com/html.go

@@ -0,0 +1,60 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"html"
+	"regexp"
+	"strings"
+)
+
+// Html2JS converts []byte type of HTML content into JS format.
+func Html2JS(data []byte) []byte {
+	s := string(data)
+	s = strings.Replace(s, `\`, `\\`, -1)
+	s = strings.Replace(s, "\n", `\n`, -1)
+	s = strings.Replace(s, "\r", "", -1)
+	s = strings.Replace(s, "\"", `\"`, -1)
+	s = strings.Replace(s, "<table>", "&lt;table>", -1)
+	return []byte(s)
+}
+
+// encode html chars to string
+func HtmlEncode(str string) string {
+	return html.EscapeString(str)
+}
+
+// decode string to html chars
+func HtmlDecode(str string) string {
+	return html.UnescapeString(str)
+}
+
+// strip tags in html string
+func StripTags(src string) string {
+	//去除style,script,html tag
+	re := regexp.MustCompile(`(?s)<(?:style|script)[^<>]*>.*?</(?:style|script)>|</?[a-z][a-z0-9]*[^<>]*>|<!--.*?-->`)
+	src = re.ReplaceAllString(src, "")
+
+	//trim all spaces(2+) into \n
+	re = regexp.MustCompile(`\s{2,}`)
+	src = re.ReplaceAllString(src, "\n")
+
+	return strings.TrimSpace(src)
+}
+
+// change \n to <br/>
+func Nl2br(str string) string {
+	return strings.Replace(str, "\n", "<br/>", -1)
+}

Godeps/_workspace/src/github.com/Unknwon/com/html_test.go

@@ -0,0 +1,35 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"testing"
+)
+
+func TestHtml2JS(t *testing.T) {
+	htm := "<div id=\"button\" class=\"btn\">Click me</div>\n\r"
+	js := string(Html2JS([]byte(htm)))
+	jsR := `<div id=\"button\" class=\"btn\">Click me</div>\n`
+	if js != jsR {
+		t.Errorf("Html2JS:\n Expect => %s\n Got => %s\n", jsR, js)
+	}
+}
+
+func BenchmarkHtml2JS(b *testing.B) {
+	htm := "<div id=\"button\" class=\"btn\">Click me</div>\n\r"
+	for i := 0; i < b.N; i++ {
+		Html2JS([]byte(htm))
+	}
+}

Godeps/_workspace/src/github.com/Unknwon/com/http.go

@@ -0,0 +1,201 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"path"
+)
+
+type NotFoundError struct {
+	Message string
+}
+
+func (e NotFoundError) Error() string {
+	return e.Message
+}
+
+type RemoteError struct {
+	Host string
+	Err  error
+}
+
+func (e *RemoteError) Error() string {
+	return e.Err.Error()
+}
+
+var UserAgent = "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1541.0 Safari/537.36"
+
+// HttpCall makes HTTP method call.
+func HttpCall(client *http.Client, method, url string, header http.Header, body io.Reader) (io.ReadCloser, error) {
+	req, err := http.NewRequest(method, url, body)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("User-Agent", UserAgent)
+	for k, vs := range header {
+		req.Header[k] = vs
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode == 200 {
+		return resp.Body, nil
+	}
+	resp.Body.Close()
+	if resp.StatusCode == 404 { // 403 can be rate limit error.  || resp.StatusCode == 403 {
+		err = fmt.Errorf("resource not found: %s", url)
+	} else {
+		err = fmt.Errorf("%s %s -> %d", method, url, resp.StatusCode)
+	}
+	return nil, err
+}
+
+// HttpGet gets the specified resource.
+// ErrNotFound is returned if the server responds with status 404.
+func HttpGet(client *http.Client, url string, header http.Header) (io.ReadCloser, error) {
+	return HttpCall(client, "GET", url, header, nil)
+}
+
+// HttpPost posts the specified resource.
+// ErrNotFound is returned if the server responds with status 404.
+func HttpPost(client *http.Client, url string, header http.Header, body []byte) (io.ReadCloser, error) {
+	return HttpCall(client, "POST", url, header, bytes.NewBuffer(body))
+}
+
+// HttpGetToFile gets the specified resource and writes to file.
+// ErrNotFound is returned if the server responds with status 404.
+func HttpGetToFile(client *http.Client, url string, header http.Header, fileName string) error {
+	rc, err := HttpGet(client, url, header)
+	if err != nil {
+		return err
+	}
+	defer rc.Close()
+
+	os.MkdirAll(path.Dir(fileName), os.ModePerm)
+	f, err := os.Create(fileName)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	_, err = io.Copy(f, rc)
+	return err
+}
+
+// HttpGetBytes gets the specified resource. ErrNotFound is returned if the server
+// responds with status 404.
+func HttpGetBytes(client *http.Client, url string, header http.Header) ([]byte, error) {
+	rc, err := HttpGet(client, url, header)
+	if err != nil {
+		return nil, err
+	}
+	defer rc.Close()
+	return ioutil.ReadAll(rc)
+}
+
+// HttpGetJSON gets the specified resource and mapping to struct.
+// ErrNotFound is returned if the server responds with status 404.
+func HttpGetJSON(client *http.Client, url string, v interface{}) error {
+	rc, err := HttpGet(client, url, nil)
+	if err != nil {
+		return err
+	}
+	defer rc.Close()
+	err = json.NewDecoder(rc).Decode(v)
+	if _, ok := err.(*json.SyntaxError); ok {
+		return fmt.Errorf("JSON syntax error at %s", url)
+	}
+	return nil
+}
+
+// HttpPostJSON posts the specified resource with struct values,
+// and maps results to struct.
+// ErrNotFound is returned if the server responds with status 404.
+func HttpPostJSON(client *http.Client, url string, body, v interface{}) error {
+	data, err := json.Marshal(body)
+	if err != nil {
+		return err
+	}
+	rc, err := HttpPost(client, url, http.Header{"content-type": []string{"application/json"}}, data)
+	if err != nil {
+		return err
+	}
+	defer rc.Close()
+	err = json.NewDecoder(rc).Decode(v)
+	if _, ok := err.(*json.SyntaxError); ok {
+		return fmt.Errorf("JSON syntax error at %s", url)
+	}
+	return nil
+}
+
+// A RawFile describes a file that can be downloaded.
+type RawFile interface {
+	Name() string
+	RawUrl() string
+	Data() []byte
+	SetData([]byte)
+}
+
+// FetchFiles fetches files specified by the rawURL field in parallel.
+func FetchFiles(client *http.Client, files []RawFile, header http.Header) error {
+	ch := make(chan error, len(files))
+	for i := range files {
+		go func(i int) {
+			p, err := HttpGetBytes(client, files[i].RawUrl(), nil)
+			if err != nil {
+				ch <- err
+				return
+			}
+			files[i].SetData(p)
+			ch <- nil
+		}(i)
+	}
+	for _ = range files {
+		if err := <-ch; err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// FetchFiles uses command `curl` to fetch files specified by the rawURL field in parallel.
+func FetchFilesCurl(files []RawFile, curlOptions ...string) error {
+	ch := make(chan error, len(files))
+	for i := range files {
+		go func(i int) {
+			stdout, _, err := ExecCmd("curl", append(curlOptions, files[i].RawUrl())...)
+			if err != nil {
+				ch <- err
+				return
+			}
+
+			files[i].SetData([]byte(stdout))
+			ch <- nil
+		}(i)
+	}
+	for _ = range files {
+		if err := <-ch; err != nil {
+			return err
+		}
+	}
+	return nil
+}

Godeps/_workspace/src/github.com/Unknwon/com/http_test.go

@@ -0,0 +1,111 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+var examplePrefix = `<!doctype html>
+<html>
+<head>
+    <title>Example Domain</title>
+`
+
+func TestHttpGet(t *testing.T) {
+	// 200.
+	rc, err := HttpGet(&http.Client{}, "http://example.com", nil)
+	if err != nil {
+		t.Fatalf("HttpGet:\n Expect => %v\n Got => %s\n", nil, err)
+	}
+	p, err := ioutil.ReadAll(rc)
+	if err != nil {
+		t.Errorf("HttpGet:\n Expect => %v\n Got => %s\n", nil, err)
+	}
+	s := string(p)
+	if !strings.HasPrefix(s, examplePrefix) {
+		t.Errorf("HttpGet:\n Expect => %s\n Got => %s\n", examplePrefix, s)
+	}
+}
+
+func TestHttpGetBytes(t *testing.T) {
+	p, err := HttpGetBytes(&http.Client{}, "http://example.com", nil)
+	if err != nil {
+		t.Errorf("HttpGetBytes:\n Expect => %v\n Got => %s\n", nil, err)
+	}
+	s := string(p)
+	if !strings.HasPrefix(s, examplePrefix) {
+		t.Errorf("HttpGet:\n Expect => %s\n Got => %s\n", examplePrefix, s)
+	}
+}
+
+func TestHttpGetJSON(t *testing.T) {
+
+}
+
+type rawFile struct {
+	name   string
+	rawURL string
+	data   []byte
+}
+
+func (rf *rawFile) Name() string {
+	return rf.name
+}
+
+func (rf *rawFile) RawUrl() string {
+	return rf.rawURL
+}
+
+func (rf *rawFile) Data() []byte {
+	return rf.data
+}
+
+func (rf *rawFile) SetData(p []byte) {
+	rf.data = p
+}
+
+func TestFetchFiles(t *testing.T) {
+	files := []RawFile{
+		&rawFile{rawURL: "http://example.com"},
+		&rawFile{rawURL: "http://example.com"},
+	}
+	err := FetchFiles(&http.Client{}, files, nil)
+	if err != nil {
+		t.Errorf("FetchFiles:\n Expect => %v\n Got => %s\n", nil, err)
+	} else if len(files[0].Data()) != 1270 {
+		t.Errorf("FetchFiles:\n Expect => %d\n Got => %d\n", 1270, len(files[0].Data()))
+	} else if len(files[1].Data()) != 1270 {
+		t.Errorf("FetchFiles:\n Expect => %d\n Got => %d\n", 1270, len(files[1].Data()))
+	}
+}
+
+func TestFetchFilesCurl(t *testing.T) {
+	files := []RawFile{
+		&rawFile{rawURL: "http://example.com"},
+		&rawFile{rawURL: "http://example.com"},
+	}
+	err := FetchFilesCurl(files)
+	if err != nil {
+		t.Errorf("FetchFilesCurl:\n Expect => %v\n Got => %s\n", nil, err)
+	} else if len(files[0].Data()) != 1270 {
+		t.Errorf("FetchFilesCurl:\n Expect => %d\n Got => %d\n", 1270, len(files[0].Data()))
+	} else if len(files[1].Data()) != 1270 {
+		t.Errorf("FetchFilesCurl:\n Expect => %d\n Got => %d\n", 1270, len(files[1].Data()))
+	}
+}

Godeps/_workspace/src/github.com/Unknwon/com/math.go

@@ -0,0 +1,24 @@
+// Copyright 2014 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+// PowInt is int type of math.Pow function.
+func PowInt(x int, y int) int {
+	num := 1
+	for i := 0; i < y; i++ {
+		num *= x
+	}
+	return num
+}

Godeps/_workspace/src/github.com/Unknwon/com/path.go

@@ -0,0 +1,80 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+)
+
+// GetGOPATHs returns all paths in GOPATH variable.
+func GetGOPATHs() []string {
+	gopath := os.Getenv("GOPATH")
+	var paths []string
+	if runtime.GOOS == "windows" {
+		gopath = strings.Replace(gopath, "\\", "/", -1)
+		paths = strings.Split(gopath, ";")
+	} else {
+		paths = strings.Split(gopath, ":")
+	}
+	return paths
+}
+
+// GetSrcPath returns app. source code path.
+// It only works when you have src. folder in GOPATH,
+// it returns error not able to locate source folder path.
+func GetSrcPath(importPath string) (appPath string, err error) {
+	paths := GetGOPATHs()
+	for _, p := range paths {
+		if IsExist(p + "/src/" + importPath + "/") {
+			appPath = p + "/src/" + importPath + "/"
+			break
+		}
+	}
+
+	if len(appPath) == 0 {
+		return "", errors.New("Unable to locate source folder path")
+	}
+
+	appPath = filepath.Dir(appPath) + "/"
+	if runtime.GOOS == "windows" {
+		// Replace all '\' to '/'.
+		appPath = strings.Replace(appPath, "\\", "/", -1)
+	}
+
+	return appPath, nil
+}
+
+// HomeDir returns path of '~'(in Linux) on Windows,
+// it returns error when the variable does not exist.
+func HomeDir() (home string, err error) {
+	if runtime.GOOS == "windows" {
+		home = os.Getenv("HOMEDRIVE") + os.Getenv("HOMEPATH")
+		if home == "" {
+			home = os.Getenv("USERPROFILE")
+		}
+	} else {
+		home = os.Getenv("HOME")
+	}
+
+	if len(home) == 0 {
+		return "", errors.New("Cannot specify home directory because it's empty")
+	}
+
+	return home, nil
+}

Godeps/_workspace/src/github.com/Unknwon/com/path_test.go

@@ -0,0 +1,67 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"os"
+	"runtime"
+	"testing"
+)
+
+func TestGetGOPATHs(t *testing.T) {
+	var gpsR []string
+
+	if runtime.GOOS != "windows" {
+		gpsR = []string{"path/to/gopath1", "path/to/gopath2", "path/to/gopath3"}
+		os.Setenv("GOPATH", "path/to/gopath1:path/to/gopath2:path/to/gopath3")
+	} else {
+		gpsR = []string{"path/to/gopath1", "path/to/gopath2", "path/to/gopath3"}
+		os.Setenv("GOPATH", "path\\to\\gopath1;path\\to\\gopath2;path\\to\\gopath3")
+	}
+
+	gps := GetGOPATHs()
+	if !CompareSliceStr(gps, gpsR) {
+		t.Errorf("GetGOPATHs:\n Expect => %s\n Got => %s\n", gpsR, gps)
+	}
+}
+
+func TestGetSrcPath(t *testing.T) {
+
+}
+
+func TestHomeDir(t *testing.T) {
+	_, err := HomeDir()
+	if err != nil {
+		t.Errorf("HomeDir:\n Expect => %v\n Got => %s\n", nil, err)
+	}
+}
+
+func BenchmarkGetGOPATHs(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		GetGOPATHs()
+	}
+}
+
+func BenchmarkGetSrcPath(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		GetSrcPath("github.com/Unknwon/com")
+	}
+}
+
+func BenchmarkHomeDir(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		HomeDir()
+	}
+}

Godeps/_workspace/src/github.com/Unknwon/com/regex.go

@@ -0,0 +1,56 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import "regexp"
+
+const (
+	regex_email_pattern        = `(?i)[A-Z0-9._%+-]+@(?:[A-Z0-9-]+\.)+[A-Z]{2,6}`
+	regex_strict_email_pattern = `(?i)[A-Z0-9!#$%&'*+/=?^_{|}~-]+` +
+		`(?:\.[A-Z0-9!#$%&'*+/=?^_{|}~-]+)*` +
+		`@(?:[A-Z0-9](?:[A-Z0-9-]*[A-Z0-9])?\.)+` +
+		`[A-Z0-9](?:[A-Z0-9-]*[A-Z0-9])?`
+	regex_url_pattern = `(ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?`
+)
+
+var (
+	regex_email        *regexp.Regexp
+	regex_strict_email *regexp.Regexp
+	regex_url          *regexp.Regexp
+)
+
+func init() {
+	regex_email = regexp.MustCompile(regex_email_pattern)
+	regex_strict_email = regexp.MustCompile(regex_strict_email_pattern)
+	regex_url = regexp.MustCompile(regex_url_pattern)
+}
+
+// validate string is an email address, if not return false
+// basically validation can match 99% cases
+func IsEmail(email string) bool {
+	return regex_email.MatchString(email)
+}
+
+// validate string is an email address, if not return false
+// this validation omits RFC 2822
+func IsEmailRFC(email string) bool {
+	return regex_strict_email.MatchString(email)
+}
+
+// validate string is a url link, if not return false
+// simple validation can match 99% cases
+func IsUrl(url string) bool {
+	return regex_url.MatchString(url)
+}

Godeps/_workspace/src/github.com/Unknwon/com/regex_test.go

@@ -0,0 +1,70 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"testing"
+)
+
+func TestIsEmail(t *testing.T) {
+	emails := map[string]bool{
+		`test@example.com`:             true,
+		`single-character@b.org`:       true,
+		`uncommon_address@test.museum`: true,
+		`local@sld.UPPER`:              true,
+		`@missing.org`:                 false,
+		`missing@.com`:                 false,
+		`missing@qq.`:                  false,
+		`wrong-ip@127.1.1.1.26`:        false,
+	}
+	for e, r := range emails {
+		b := IsEmail(e)
+		if b != r {
+			t.Errorf("IsEmail:\n Expect => %v\n Got => %v\n", r, b)
+		}
+	}
+}
+
+func TestIsUrl(t *testing.T) {
+	urls := map[string]bool{
+		"http://www.example.com":                     true,
+		"http://example.com":                         true,
+		"http://example.com?user=test&password=test": true,
+		"http://example.com?user=test#login":         true,
+		"ftp://example.com":                          true,
+		"https://example.com":                        true,
+		"htp://example.com":                          false,
+		"http//example.com":                          false,
+		"http://example":                             true,
+	}
+	for u, r := range urls {
+		b := IsUrl(u)
+		if b != r {
+			t.Errorf("IsUrl:\n Expect => %v\n Got => %v\n", r, b)
+		}
+	}
+}
+
+func BenchmarkIsEmail(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		IsEmail("test@example.com")
+	}
+}
+
+func BenchmarkIsUrl(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		IsEmail("http://example.com")
+	}
+}

Godeps/_workspace/src/github.com/Unknwon/com/slice.go

@@ -0,0 +1,87 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"strings"
+)
+
+// AppendStr appends string to slice with no duplicates.
+func AppendStr(strs []string, str string) []string {
+	for _, s := range strs {
+		if s == str {
+			return strs
+		}
+	}
+	return append(strs, str)
+}
+
+// CompareSliceStr compares two 'string' type slices.
+// It returns true if elements and order are both the same.
+func CompareSliceStr(s1, s2 []string) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+
+	for i := range s1 {
+		if s1[i] != s2[i] {
+			return false
+		}
+	}
+
+	return true
+}
+
+// CompareSliceStr compares two 'string' type slices.
+// It returns true if elements are the same, and ignores the order.
+func CompareSliceStrU(s1, s2 []string) bool {
+	if len(s1) != len(s2) {
+		return false
+	}
+
+	for i := range s1 {
+		for j := len(s2) - 1; j >= 0; j-- {
+			if s1[i] == s2[j] {
+				s2 = append(s2[:j], s2[j+1:]...)
+				break
+			}
+		}
+	}
+	if len(s2) > 0 {
+		return false
+	}
+	return true
+}
+
+// IsSliceContainsStr returns true if the string exists in given slice, ignore case.
+func IsSliceContainsStr(sl []string, str string) bool {
+	str = strings.ToLower(str)
+	for _, s := range sl {
+		if strings.ToLower(s) == str {
+			return true
+		}
+	}
+	return false
+}
+
+// IsSliceContainsInt64 returns true if the int64 exists in given slice.
+func IsSliceContainsInt64(sl []int64, i int64) bool {
+	for _, s := range sl {
+		if s == i {
+			return true
+		}
+	}
+	return false
+}

Godeps/_workspace/src/github.com/Unknwon/com/slice_test.go

@@ -0,0 +1,99 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestAppendStr(t *testing.T) {
+	Convey("Append a string to a slice with no duplicates", t, func() {
+		s := []string{"a"}
+
+		Convey("Append a string that does not exist in slice", func() {
+			s = AppendStr(s, "b")
+			So(len(s), ShouldEqual, 2)
+		})
+
+		Convey("Append a string that does exist in slice", func() {
+			s = AppendStr(s, "b")
+			So(len(s), ShouldEqual, 2)
+		})
+	})
+}
+
+func TestCompareSliceStr(t *testing.T) {
+	Convey("Compares two 'string' type slices with elements and order", t, func() {
+		Convey("Compare two slices that do have same elements and order", func() {
+			So(CompareSliceStr(
+				[]string{"1", "2", "3"}, []string{"1", "2", "3"}), ShouldBeTrue)
+		})
+
+		Convey("Compare two slices that do have same elements but does not have same order", func() {
+			So(!CompareSliceStr(
+				[]string{"2", "1", "3"}, []string{"1", "2", "3"}), ShouldBeTrue)
+		})
+
+		Convey("Compare two slices that have different number of elements", func() {
+			So(!CompareSliceStr(
+				[]string{"2", "1"}, []string{"1", "2", "3"}), ShouldBeTrue)
+		})
+	})
+}
+
+func TestCompareSliceStrU(t *testing.T) {
+	Convey("Compare two 'string' type slices with elements and ignore the order", t, func() {
+		Convey("Compare two slices that do have same elements and order", func() {
+			So(CompareSliceStrU(
+				[]string{"1", "2", "3"}, []string{"1", "2", "3"}), ShouldBeTrue)
+		})
+
+		Convey("Compare two slices that do have same elements but does not have same order", func() {
+			So(CompareSliceStrU(
+				[]string{"2", "1", "3"}, []string{"1", "2", "3"}), ShouldBeTrue)
+		})
+
+		Convey("Compare two slices that have different number of elements", func() {
+			So(!CompareSliceStrU(
+				[]string{"2", "1"}, []string{"1", "2", "3"}), ShouldBeTrue)
+		})
+	})
+}
+
+func BenchmarkAppendStr(b *testing.B) {
+	s := []string{"a"}
+	for i := 0; i < b.N; i++ {
+		s = AppendStr(s, fmt.Sprint(b.N%3))
+	}
+}
+
+func BenchmarkCompareSliceStr(b *testing.B) {
+	s1 := []string{"1", "2", "3"}
+	s2 := []string{"1", "2", "3"}
+	for i := 0; i < b.N; i++ {
+		CompareSliceStr(s1, s2)
+	}
+}
+
+func BenchmarkCompareSliceStrU(b *testing.B) {
+	s1 := []string{"1", "4", "2", "3"}
+	s2 := []string{"1", "2", "3", "4"}
+	for i := 0; i < b.N; i++ {
+		CompareSliceStrU(s1, s2)
+	}
+}

Godeps/_workspace/src/github.com/Unknwon/com/string.go

@@ -0,0 +1,140 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"encoding/base64"
+	"errors"
+	"io"
+	r "math/rand"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// AESEncrypt encrypts text and given key with AES.
+func AESEncrypt(key, text []byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	b := base64.StdEncoding.EncodeToString(text)
+	ciphertext := make([]byte, aes.BlockSize+len(b))
+	iv := ciphertext[:aes.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		return nil, err
+	}
+	cfb := cipher.NewCFBEncrypter(block, iv)
+	cfb.XORKeyStream(ciphertext[aes.BlockSize:], []byte(b))
+	return ciphertext, nil
+}
+
+// AESDecrypt decrypts text and given key with AES.
+func AESDecrypt(key, text []byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	if len(text) < aes.BlockSize {
+		return nil, errors.New("ciphertext too short")
+	}
+	iv := text[:aes.BlockSize]
+	text = text[aes.BlockSize:]
+	cfb := cipher.NewCFBDecrypter(block, iv)
+	cfb.XORKeyStream(text, text)
+	data, err := base64.StdEncoding.DecodeString(string(text))
+	if err != nil {
+		return nil, err
+	}
+	return data, nil
+}
+
+// IsLetter returns true if the 'l' is an English letter.
+func IsLetter(l uint8) bool {
+	n := (l | 0x20) - 'a'
+	if n >= 0 && n < 26 {
+		return true
+	}
+	return false
+}
+
+// Expand replaces {k} in template with match[k] or subs[atoi(k)] if k is not in match.
+func Expand(template string, match map[string]string, subs ...string) string {
+	var p []byte
+	var i int
+	for {
+		i = strings.Index(template, "{")
+		if i < 0 {
+			break
+		}
+		p = append(p, template[:i]...)
+		template = template[i+1:]
+		i = strings.Index(template, "}")
+		if s, ok := match[template[:i]]; ok {
+			p = append(p, s...)
+		} else {
+			j, _ := strconv.Atoi(template[:i])
+			if j >= len(subs) {
+				p = append(p, []byte("Missing")...)
+			} else {
+				p = append(p, subs[j]...)
+			}
+		}
+		template = template[i+1:]
+	}
+	p = append(p, template...)
+	return string(p)
+}
+
+// Reverse s string, support unicode
+func Reverse(s string) string {
+	n := len(s)
+	runes := make([]rune, n)
+	for _, rune := range s {
+		n--
+		runes[n] = rune
+	}
+	return string(runes[n:])
+}
+
+// RandomCreateBytes generate random []byte by specify chars.
+func RandomCreateBytes(n int, alphabets ...byte) []byte {
+	const alphanum = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+	var bytes = make([]byte, n)
+	var randby bool
+	if num, err := rand.Read(bytes); num != n || err != nil {
+		r.Seed(time.Now().UnixNano())
+		randby = true
+	}
+	for i, b := range bytes {
+		if len(alphabets) == 0 {
+			if randby {
+				bytes[i] = alphanum[r.Intn(len(alphanum))]
+			} else {
+				bytes[i] = alphanum[b%byte(len(alphanum))]
+			}
+		} else {
+			if randby {
+				bytes[i] = alphabets[r.Intn(len(alphabets))]
+			} else {
+				bytes[i] = alphabets[b%byte(len(alphabets))]
+			}
+		}
+	}
+	return bytes
+}

Godeps/_workspace/src/github.com/Unknwon/com/string_test.go

@@ -0,0 +1,82 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"testing"
+)
+
+func TestIsLetter(t *testing.T) {
+	if IsLetter('1') {
+		t.Errorf("IsLetter:\n Expect => %v\n Got => %v\n", false, true)
+	}
+
+	if IsLetter('[') {
+		t.Errorf("IsLetter:\n Expect => %v\n Got => %v\n", false, true)
+	}
+
+	if !IsLetter('a') {
+		t.Errorf("IsLetter:\n Expect => %v\n Got => %v\n", true, false)
+	}
+
+	if !IsLetter('Z') {
+		t.Errorf("IsLetter:\n Expect => %v\n Got => %v\n", true, false)
+	}
+}
+
+func TestExpand(t *testing.T) {
+	match := map[string]string{
+		"domain":    "gowalker.org",
+		"subdomain": "github.com",
+	}
+	s := "http://{domain}/{subdomain}/{0}/{1}"
+	sR := "http://gowalker.org/github.com/Unknwon/gowalker"
+	if Expand(s, match, "Unknwon", "gowalker") != sR {
+		t.Errorf("Expand:\n Expect => %s\n Got => %s\n", sR, s)
+	}
+}
+
+func TestReverse(t *testing.T) {
+	if Reverse("abcdefg") != "gfedcba" {
+		t.Errorf("Reverse:\n Except => %s\n Got =>%s\n", "gfedcba", Reverse("abcdefg"))
+	}
+	if Reverse("上善若水厚德载物") != "物载德厚水若善上" {
+		t.Errorf("Reverse:\n Except => %s\n Got =>%s\n", "物载德厚水若善上", Reverse("上善若水厚德载物"))
+	}
+}
+
+func BenchmarkIsLetter(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		IsLetter('a')
+	}
+}
+
+func BenchmarkExpand(b *testing.B) {
+	match := map[string]string{
+		"domain":    "gowalker.org",
+		"subdomain": "github.com",
+	}
+	s := "http://{domain}/{subdomain}/{0}/{1}"
+	for i := 0; i < b.N; i++ {
+		Expand(s, match, "Unknwon", "gowalker")
+	}
+}
+
+func BenchmarkReverse(b *testing.B) {
+	s := "abscef中文"
+	for i := 0; i < b.N; i++ {
+		Reverse(s)
+	}
+}

Godeps/_workspace/src/github.com/Unknwon/com/testdata/SaveFile.txt

@@ -0,0 +1 @@
+TestSaveFile

Godeps/_workspace/src/github.com/Unknwon/com/testdata/SaveFileS.txt

@@ -0,0 +1 @@
+TestSaveFileS

Godeps/_workspace/src/github.com/Unknwon/com/testdata/statDir/SaveFile.txt

@@ -0,0 +1 @@
+TestSaveFile

Godeps/_workspace/src/github.com/Unknwon/com/testdata/statDir/SaveFileS.txt

@@ -0,0 +1 @@
+TestSaveFileS

Godeps/_workspace/src/github.com/Unknwon/com/testdata/statDir/secondLevel/SaveFile.txt

@@ -0,0 +1 @@
+TestSaveFile

Godeps/_workspace/src/github.com/Unknwon/com/testdata/statDir/secondLevel/SaveFileS.txt

@@ -0,0 +1 @@
+TestSaveFileS

Godeps/_workspace/src/github.com/Unknwon/com/time.go

@@ -0,0 +1,115 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Format unix time int64 to string
+func Date(ti int64, format string) string {
+	t := time.Unix(int64(ti), 0)
+	return DateT(t, format)
+}
+
+// Format unix time string to string
+func DateS(ts string, format string) string {
+	i, _ := strconv.ParseInt(ts, 10, 64)
+	return Date(i, format)
+}
+
+// Format time.Time struct to string
+// MM - month - 01
+// M - month - 1, single bit
+// DD - day - 02
+// D - day 2
+// YYYY - year - 2006
+// YY - year - 06
+// HH - 24 hours - 03
+// H - 24 hours - 3
+// hh - 12 hours - 03
+// h - 12 hours - 3
+// mm - minute - 04
+// m - minute - 4
+// ss - second - 05
+// s - second = 5
+func DateT(t time.Time, format string) string {
+	res := strings.Replace(format, "MM", t.Format("01"), -1)
+	res = strings.Replace(res, "M", t.Format("1"), -1)
+	res = strings.Replace(res, "DD", t.Format("02"), -1)
+	res = strings.Replace(res, "D", t.Format("2"), -1)
+	res = strings.Replace(res, "YYYY", t.Format("2006"), -1)
+	res = strings.Replace(res, "YY", t.Format("06"), -1)
+	res = strings.Replace(res, "HH", fmt.Sprintf("%02d", t.Hour()), -1)
+	res = strings.Replace(res, "H", fmt.Sprintf("%d", t.Hour()), -1)
+	res = strings.Replace(res, "hh", t.Format("03"), -1)
+	res = strings.Replace(res, "h", t.Format("3"), -1)
+	res = strings.Replace(res, "mm", t.Format("04"), -1)
+	res = strings.Replace(res, "m", t.Format("4"), -1)
+	res = strings.Replace(res, "ss", t.Format("05"), -1)
+	res = strings.Replace(res, "s", t.Format("5"), -1)
+	return res
+}
+
+// DateFormat pattern rules.
+var datePatterns = []string{
+	// year
+	"Y", "2006", // A full numeric representation of a year, 4 digits   Examples: 1999 or 2003
+	"y", "06", //A two digit representation of a year   Examples: 99 or 03
+
+	// month
+	"m", "01", // Numeric representation of a month, with leading zeros 01 through 12
+	"n", "1", // Numeric representation of a month, without leading zeros   1 through 12
+	"M", "Jan", // A short textual representation of a month, three letters Jan through Dec
+	"F", "January", // A full textual representation of a month, such as January or March   January through December
+
+	// day
+	"d", "02", // Day of the month, 2 digits with leading zeros 01 to 31
+	"j", "2", // Day of the month without leading zeros 1 to 31
+
+	// week
+	"D", "Mon", // A textual representation of a day, three letters Mon through Sun
+	"l", "Monday", // A full textual representation of the day of the week  Sunday through Saturday
+
+	// time
+	"g", "3", // 12-hour format of an hour without leading zeros    1 through 12
+	"G", "15", // 24-hour format of an hour without leading zeros   0 through 23
+	"h", "03", // 12-hour format of an hour with leading zeros  01 through 12
+	"H", "15", // 24-hour format of an hour with leading zeros  00 through 23
+
+	"a", "pm", // Lowercase Ante meridiem and Post meridiem am or pm
+	"A", "PM", // Uppercase Ante meridiem and Post meridiem AM or PM
+
+	"i", "04", // Minutes with leading zeros    00 to 59
+	"s", "05", // Seconds, with leading zeros   00 through 59
+
+	// time zone
+	"T", "MST",
+	"P", "-07:00",
+	"O", "-0700",
+
+	// RFC 2822
+	"r", time.RFC1123Z,
+}
+
+// Parse Date use PHP time format.
+func DateParse(dateString, format string) (time.Time, error) {
+	replacer := strings.NewReplacer(datePatterns...)
+	format = replacer.Replace(format)
+	return time.ParseInLocation(format, dateString, time.Local)
+}

Godeps/_workspace/src/github.com/Unknwon/com/url.go

@@ -0,0 +1,41 @@
+// Copyright 2013 com authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package com
+
+import (
+	"encoding/base64"
+	"net/url"
+)
+
+// url encode string, is + not %20
+func UrlEncode(str string) string {
+	return url.QueryEscape(str)
+}
+
+// url decode string
+func UrlDecode(str string) (string, error) {
+	return url.QueryUnescape(str)
+}
+
+// base64 encode
+func Base64Encode(str string) string {
+	return base64.StdEncoding.EncodeToString([]byte(str))
+}
+
+// base64 decode
+func Base64Decode(str string) (string, error) {
+	s, e := base64.StdEncoding.DecodeString(str)
+	return string(s), e
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/.gitignore

@@ -0,0 +1,2 @@
+macaron.sublime-project
+macaron.sublime-workspace

Godeps/_workspace/src/github.com/Unknwon/macaron/LICENSE

@@ -0,0 +1,191 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Godeps/_workspace/src/github.com/Unknwon/macaron/README.md

@@ -0,0 +1,91 @@
+Macaron [![Build Status](https://drone.io/github.com/Unknwon/macaron/status.png)](https://drone.io/github.com/Unknwon/macaron/latest) [![](http://gocover.io/_badge/github.com/Unknwon/macaron)](http://gocover.io/github.com/Unknwon/macaron)
+=======================
+
+![Macaron Logo](macaronlogo.png)
+
+Package macaron is a high productive and modular design web framework in Go.
+
+##### Current version: 0.5.0
+
+## Getting Started
+
+To install Macaron:
+
+	go get github.com/Unknwon/macaron
+
+The very basic usage of Macaron:
+
+```go
+package main
+
+import "github.com/Unknwon/macaron"
+
+func main() {
+	m := macaron.Classic()
+	m.Get("/", func() string {
+		return "Hello world!"
+	})
+	m.Run()
+}
+```
+
+## Features
+
+- Powerful routing with suburl.
+- Flexible routes combinations.
+- Unlimited nested group routers.
+- Directly integrate with existing services.
+- Dynamically change template files at runtime.
+- Allow to use in-memory template and static files.
+- Easy to plugin/unplugin features with modular design.
+- Handy dependency injection powered by [inject](https://github.com/codegangsta/inject).
+- Better router layer and less reflection make faster speed.
+
+## Middlewares 
+
+Middlewares allow you easily plugin/unplugin features for your Macaron applications.
+
+There are already many [middlewares](https://github.com/macaron-contrib) to simplify your work:
+
+- gzip - Gzip compression to all requests
+- render - Go template engine
+- static - Serves static files
+- [binding](https://github.com/macaron-contrib/binding) - Request data binding and validation
+- [i18n](https://github.com/macaron-contrib/i18n) - Internationalization and Localization
+- [cache](https://github.com/macaron-contrib/cache) - Cache manager
+- [session](https://github.com/macaron-contrib/session) - Session manager
+- [csrf](https://github.com/macaron-contrib/csrf) - Generates and validates csrf tokens
+- [captcha](https://github.com/macaron-contrib/captcha) - Captcha service
+- [pongo2](https://github.com/macaron-contrib/pongo2) - Pongo2 template engine support
+- [sockets](https://github.com/macaron-contrib/sockets) - WebSockets channels binding
+- [bindata](https://github.com/macaron-contrib/bindata) - Embed binary data as static and template files
+- [toolbox](https://github.com/macaron-contrib/toolbox) - Health check, pprof, profile and statistic services
+- [oauth2](https://github.com/macaron-contrib/oauth2) - OAuth 2.0 backend
+- [switcher](https://github.com/macaron-contrib/switcher) - Multiple-site support
+- [method](https://github.com/macaron-contrib/method) - HTTP method override
+- [permissions2](https://github.com/xyproto/permissions2) - Cookies, users and permissions
+- [renders](https://github.com/macaron-contrib/renders) - Beego-like render engine(Macaron has built-in template engine, this is another option)
+
+## Use Cases
+
+- [Gogs](https://github.com/gogits/gogs): Go Git Service
+- [Gogs Web](https://github.com/gogits/gogsweb): Gogs official website
+- [Switch](https://github.com/gpmgo/switch): Gopm registry
+- [YouGam](http://yougam.com): Online Forum
+- [Car Girl](http://qcnl.gzsy.com/): Online campaign
+
+## Getting Help
+
+- [API Reference](https://gowalker.org/github.com/Unknwon/macaron)
+- [Documentation](http://macaron.gogs.io)
+- [FAQs](http://macaron.gogs.io/docs/faqs)
+
+## Credits
+
+- Basic design of [Martini](https://github.com/go-martini/martini).
+- Router layer of [beego](https://github.com/astaxie/beego).
+- Logo is modified by [@insionng](https://github.com/insionng) based on [Tribal Dragon](http://xtremeyamazaki.deviantart.com/art/Tribal-Dragon-27005087).
+
+## License
+
+This project is under Apache v2 License. See the [LICENSE](LICENSE) file for the full license text.

Godeps/_workspace/src/github.com/Unknwon/macaron/bpool/README.md

@@ -0,0 +1,37 @@
+# bpool [![GoDoc](https://godoc.org/github.com/oxtoacart/bpool?status.png)](https://godoc.org/github.com/oxtoacart/bpool)
+
+Package bpool implements leaky pools of byte arrays and Buffers as bounded channels. It is based on the leaky buffer example from the Effective Go documentation: http://golang.org/doc/effective_go.html#leaky_buffer
+
+## Install
+
+`go get github.com/oxtoacart/bpool`
+
+## Documentation
+
+See [godoc.org](http://godoc.org/github.com/oxtoacart/bpool) or use `godoc github.com/oxtoacart/bpool`
+
+## Example
+
+```go
+
+var bufpool *bpol.BufferPool
+
+func main() {
+
+    bufpool = bpool.NewBufferPool(48)
+
+}
+
+func someFunction() error {
+
+     // Get a buffer from the pool
+     buf := bufpool.Get()
+     ...
+     ...
+     ...
+     // Return the buffer to the pool
+     bufpool.Put(buf)
+     
+     return nil
+}
+```

Godeps/_workspace/src/github.com/Unknwon/macaron/bpool/bufferpool.go

@@ -0,0 +1,45 @@
+package bpool
+
+import (
+	"bytes"
+)
+
+/*
+BufferPool implements a pool of bytes.Buffers in the form of a bounded
+channel.
+*/
+type BufferPool struct {
+	c chan *bytes.Buffer
+}
+
+/*
+NewBufferPool creates a new BufferPool bounded to the given size.
+*/
+func NewBufferPool(size int) (bp *BufferPool) {
+	return &BufferPool{
+		c: make(chan *bytes.Buffer, size),
+	}
+}
+
+/*
+Get gets a Buffer from the BufferPool, or creates a new one if none are available
+in the pool.
+*/
+func (bp *BufferPool) Get() (b *bytes.Buffer) {
+	select {
+	case b = <-bp.c:
+	// reuse existing buffer
+	default:
+		// create new buffer
+		b = bytes.NewBuffer([]byte{})
+	}
+	return
+}
+
+/*
+Put returns the given Buffer to the BufferPool.
+*/
+func (bp *BufferPool) Put(b *bytes.Buffer) {
+	b.Reset()
+	bp.c <- b
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/context.go

@@ -0,0 +1,421 @@
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+	"html/template"
+	"io"
+	"io/ioutil"
+	"mime/multipart"
+	"net/http"
+	"net/url"
+	"path"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"time"
+
+	"github.com/Unknwon/com"
+
+	"github.com/Unknwon/macaron/inject"
+)
+
+// Locale reprents a localization interface.
+type Locale interface {
+	Language() string
+	Tr(string, ...interface{}) string
+}
+
+// RequestBody represents a request body.
+type RequestBody struct {
+	reader io.ReadCloser
+}
+
+// Bytes reads and returns content of request body in bytes.
+func (rb *RequestBody) Bytes() ([]byte, error) {
+	return ioutil.ReadAll(rb.reader)
+}
+
+// String reads and returns content of request body in string.
+func (rb *RequestBody) String() (string, error) {
+	data, err := rb.Bytes()
+	return string(data), err
+}
+
+// ReadCloser returns a ReadCloser for request body.
+func (rb *RequestBody) ReadCloser() io.ReadCloser {
+	return rb.reader
+}
+
+// Request represents an HTTP request received by a server or to be sent by a client.
+type Request struct {
+	*http.Request
+}
+
+func (r *Request) Body() *RequestBody {
+	return &RequestBody{r.Request.Body}
+}
+
+// Context represents the runtime context of current request of Macaron instance.
+// It is the integration of most frequently used middlewares and helper methods.
+type Context struct {
+	inject.Injector
+	handlers []Handler
+	action   Handler
+	index    int
+
+	*Router
+	Req    Request
+	Resp   ResponseWriter
+	params Params
+	Render // Not nil only if you use macaran.Render middleware.
+	Locale
+	Data map[string]interface{}
+}
+
+func (c *Context) handler() Handler {
+	if c.index < len(c.handlers) {
+		return c.handlers[c.index]
+	}
+	if c.index == len(c.handlers) {
+		return c.action
+	}
+	panic("invalid index for context handler")
+}
+
+func (c *Context) Next() {
+	c.index += 1
+	c.run()
+}
+
+func (c *Context) Written() bool {
+	return c.Resp.Written()
+}
+
+func (c *Context) run() {
+	for c.index <= len(c.handlers) {
+		vals, err := c.Invoke(c.handler())
+		if err != nil {
+			panic(err)
+		}
+		c.index += 1
+
+		// if the handler returned something, write it to the http response
+		if len(vals) > 0 {
+			ev := c.GetVal(reflect.TypeOf(ReturnHandler(nil)))
+			handleReturn := ev.Interface().(ReturnHandler)
+			handleReturn(c, vals)
+		}
+
+		if c.Written() {
+			return
+		}
+	}
+}
+
+// RemoteAddr returns more real IP address.
+func (ctx *Context) RemoteAddr() string {
+	addr := ctx.Req.Header.Get("X-Real-IP")
+	if len(addr) == 0 {
+		addr = ctx.Req.Header.Get("X-Forwarded-For")
+		if addr == "" {
+			addr = ctx.Req.RemoteAddr
+			if i := strings.LastIndex(addr, ":"); i > -1 {
+				addr = addr[:i]
+			}
+		}
+	}
+	return addr
+}
+
+func (ctx *Context) renderHTML(status int, setName, tplName string, data ...interface{}) {
+	if ctx.Render == nil {
+		panic("renderer middleware hasn't been registered")
+	}
+	if len(data) <= 0 {
+		ctx.Render.HTMLSet(status, setName, tplName, ctx.Data)
+	} else if len(data) == 1 {
+		ctx.Render.HTMLSet(status, setName, tplName, data[0])
+	} else {
+		ctx.Render.HTMLSet(status, setName, tplName, data[0], data[1].(HTMLOptions))
+	}
+}
+
+// HTML calls Render.HTML but allows less arguments.
+func (ctx *Context) HTML(status int, name string, data ...interface{}) {
+	ctx.renderHTML(status, _DEFAULT_TPL_SET_NAME, name, data...)
+}
+
+// HTML calls Render.HTMLSet but allows less arguments.
+func (ctx *Context) HTMLSet(status int, setName, tplName string, data ...interface{}) {
+	ctx.renderHTML(status, setName, tplName, data...)
+}
+
+func (ctx *Context) Redirect(location string, status ...int) {
+	code := http.StatusFound
+	if len(status) == 1 {
+		code = status[0]
+	}
+
+	http.Redirect(ctx.Resp, ctx.Req.Request, location, code)
+}
+
+// Query querys form parameter.
+func (ctx *Context) Query(name string) string {
+	if ctx.Req.Form == nil {
+		ctx.Req.ParseForm()
+	}
+	return ctx.Req.Form.Get(name)
+}
+
+// QueryStrings returns a list of results by given query name.
+func (ctx *Context) QueryStrings(name string) []string {
+	if ctx.Req.Form == nil {
+		ctx.Req.ParseForm()
+	}
+
+	vals, ok := ctx.Req.Form[name]
+	if !ok {
+		return []string{}
+	}
+	return vals
+}
+
+// QueryEscape returns escapred query result.
+func (ctx *Context) QueryEscape(name string) string {
+	return template.HTMLEscapeString(ctx.Query(name))
+}
+
+// QueryInt returns query result in int type.
+func (ctx *Context) QueryInt(name string) int {
+	return com.StrTo(ctx.Query(name)).MustInt()
+}
+
+// QueryInt64 returns query result in int64 type.
+func (ctx *Context) QueryInt64(name string) int64 {
+	return com.StrTo(ctx.Query(name)).MustInt64()
+}
+
+// Params returns value of given param name.
+// e.g. ctx.Params(":uid")
+func (ctx *Context) Params(name string) string {
+	return ctx.params[name]
+}
+
+// SetParams sets value of param with given name.
+func (ctx *Context) SetParams(name, val string) {
+	if !strings.HasPrefix(name, ":") {
+		name = ":" + name
+	}
+	ctx.params[name] = val
+}
+
+// ParamsEscape returns escapred params result.
+// e.g. ctx.ParamsEscape(":uname")
+func (ctx *Context) ParamsEscape(name string) string {
+	return template.HTMLEscapeString(ctx.Params(name))
+}
+
+// ParamsInt returns params result in int type.
+// e.g. ctx.ParamsInt(":uid")
+func (ctx *Context) ParamsInt(name string) int {
+	return com.StrTo(ctx.Params(name)).MustInt()
+}
+
+// ParamsInt64 returns params result in int64 type.
+// e.g. ctx.ParamsInt64(":uid")
+func (ctx *Context) ParamsInt64(name string) int64 {
+	return com.StrTo(ctx.Params(name)).MustInt64()
+}
+
+// GetFile returns information about user upload file by given form field name.
+func (ctx *Context) GetFile(name string) (multipart.File, *multipart.FileHeader, error) {
+	return ctx.Req.FormFile(name)
+}
+
+// SetCookie sets given cookie value to response header.
+func (ctx *Context) SetCookie(name string, value string, others ...interface{}) {
+	cookie := http.Cookie{}
+	cookie.Name = name
+	cookie.Value = url.QueryEscape(value)
+
+	if len(others) > 0 {
+		switch v := others[0].(type) {
+		case int:
+			cookie.MaxAge = v
+		case int64:
+			cookie.MaxAge = int(v)
+		case int32:
+			cookie.MaxAge = int(v)
+		}
+	}
+
+	// default "/"
+	if len(others) > 1 {
+		if v, ok := others[1].(string); ok && len(v) > 0 {
+			cookie.Path = v
+		}
+	} else {
+		cookie.Path = "/"
+	}
+
+	// default empty
+	if len(others) > 2 {
+		if v, ok := others[2].(string); ok && len(v) > 0 {
+			cookie.Domain = v
+		}
+	}
+
+	// default empty
+	if len(others) > 3 {
+		switch v := others[3].(type) {
+		case bool:
+			cookie.Secure = v
+		default:
+			if others[3] != nil {
+				cookie.Secure = true
+			}
+		}
+	}
+
+	// default false. for session cookie default true
+	if len(others) > 4 {
+		if v, ok := others[4].(bool); ok && v {
+			cookie.HttpOnly = true
+		}
+	}
+
+	ctx.Resp.Header().Add("Set-Cookie", cookie.String())
+}
+
+// GetCookie returns given cookie value from request header.
+func (ctx *Context) GetCookie(name string) string {
+	cookie, err := ctx.Req.Cookie(name)
+	if err != nil {
+		return ""
+	}
+	val, _ := url.QueryUnescape(cookie.Value)
+	return val
+}
+
+// GetCookieInt returns cookie result in int type.
+func (ctx *Context) GetCookieInt(name string) int {
+	return com.StrTo(ctx.GetCookie(name)).MustInt()
+}
+
+// GetCookieInt64 returns cookie result in int64 type.
+func (ctx *Context) GetCookieInt64(name string) int64 {
+	return com.StrTo(ctx.GetCookie(name)).MustInt64()
+}
+
+var defaultCookieSecret string
+
+// SetDefaultCookieSecret sets global default secure cookie secret.
+func (m *Macaron) SetDefaultCookieSecret(secret string) {
+	defaultCookieSecret = secret
+}
+
+// SetSecureCookie sets given cookie value to response header with default secret string.
+func (ctx *Context) SetSecureCookie(name, value string, others ...interface{}) {
+	ctx.SetSuperSecureCookie(defaultCookieSecret, name, value, others...)
+}
+
+// GetSecureCookie returns given cookie value from request header with default secret string.
+func (ctx *Context) GetSecureCookie(key string) (string, bool) {
+	return ctx.GetSuperSecureCookie(defaultCookieSecret, key)
+}
+
+// SetSuperSecureCookie sets given cookie value to response header with secret string.
+func (ctx *Context) SetSuperSecureCookie(secret, name, value string, others ...interface{}) {
+	m := md5.Sum([]byte(secret))
+	secret = hex.EncodeToString(m[:])
+	text, err := com.AESEncrypt([]byte(secret), []byte(value))
+	if err != nil {
+		panic("error encrypting cookie: " + err.Error())
+	}
+	ctx.SetCookie(name, hex.EncodeToString(text), others...)
+}
+
+// GetSuperSecureCookie returns given cookie value from request header with secret string.
+func (ctx *Context) GetSuperSecureCookie(secret, key string) (string, bool) {
+	val := ctx.GetCookie(key)
+	if val == "" {
+		return "", false
+	}
+
+	data, err := hex.DecodeString(val)
+	if err != nil {
+		return "", false
+	}
+
+	m := md5.Sum([]byte(secret))
+	secret = hex.EncodeToString(m[:])
+	text, err := com.AESDecrypt([]byte(secret), data)
+	return string(text), err == nil
+}
+
+// ServeContent serves given content to response.
+func (ctx *Context) ServeContent(name string, r io.ReadSeeker, params ...interface{}) {
+	modtime := time.Now()
+	for _, p := range params {
+		switch v := p.(type) {
+		case time.Time:
+			modtime = v
+		}
+	}
+	ctx.Resp.Header().Set("Content-Description", "Raw content")
+	ctx.Resp.Header().Set("Content-Type", "text/plain")
+	ctx.Resp.Header().Set("Expires", "0")
+	ctx.Resp.Header().Set("Cache-Control", "must-revalidate")
+	ctx.Resp.Header().Set("Pragma", "public")
+	http.ServeContent(ctx.Resp, ctx.Req.Request, name, modtime, r)
+}
+
+// ServeFile serves given file to response.
+func (ctx *Context) ServeFile(file string, names ...string) {
+	var name string
+	if len(names) > 0 {
+		name = names[0]
+	} else {
+		name = path.Base(file)
+	}
+	ctx.Resp.Header().Set("Content-Description", "File Transfer")
+	ctx.Resp.Header().Set("Content-Type", "application/octet-stream")
+	ctx.Resp.Header().Set("Content-Disposition", "attachment; filename="+name)
+	ctx.Resp.Header().Set("Content-Transfer-Encoding", "binary")
+	ctx.Resp.Header().Set("Expires", "0")
+	ctx.Resp.Header().Set("Cache-Control", "must-revalidate")
+	ctx.Resp.Header().Set("Pragma", "public")
+	http.ServeFile(ctx.Resp, ctx.Req.Request, file)
+}
+
+// ChangeStaticPath changes static path from old to new one.
+func (ctx *Context) ChangeStaticPath(oldPath, newPath string) {
+	if !filepath.IsAbs(oldPath) {
+		oldPath = filepath.Join(Root, oldPath)
+	}
+	dir := statics.Get(oldPath)
+	if dir != nil {
+		statics.Delete(oldPath)
+
+		if !filepath.IsAbs(newPath) {
+			newPath = filepath.Join(Root, newPath)
+		}
+		*dir = http.Dir(newPath)
+		statics.Set(dir)
+	}
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/context_test.go

@@ -0,0 +1,314 @@
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"bytes"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/Unknwon/com"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_Context(t *testing.T) {
+	Convey("Do advanced encapsulation operations", t, func() {
+		m := Classic()
+		m.Use(Renderers(RenderOptions{
+			Directory: "fixtures/basic",
+		}, "fixtures/basic2"))
+
+		Convey("Get request body", func() {
+			m.Get("/body1", func(ctx *Context) {
+				data, err := ioutil.ReadAll(ctx.Req.Body().ReadCloser())
+				So(err, ShouldBeNil)
+				So(string(data), ShouldEqual, "This is my request body")
+			})
+			m.Get("/body2", func(ctx *Context) {
+				data, err := ctx.Req.Body().Bytes()
+				So(err, ShouldBeNil)
+				So(string(data), ShouldEqual, "This is my request body")
+			})
+			m.Get("/body3", func(ctx *Context) {
+				data, err := ctx.Req.Body().String()
+				So(err, ShouldBeNil)
+				So(data, ShouldEqual, "This is my request body")
+			})
+
+			for i := 1; i <= 3; i++ {
+				resp := httptest.NewRecorder()
+				req, err := http.NewRequest("GET", "/body"+com.ToStr(i), nil)
+				req.Body = ioutil.NopCloser(bytes.NewBufferString("This is my request body"))
+				So(err, ShouldBeNil)
+				m.ServeHTTP(resp, req)
+			}
+		})
+
+		Convey("Get remote IP address", func() {
+			m.Get("/remoteaddr", func(ctx *Context) string {
+				return ctx.RemoteAddr()
+			})
+
+			resp := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", "/remoteaddr", nil)
+			req.RemoteAddr = "127.0.0.1:3333"
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+			So(resp.Body.String(), ShouldEqual, "127.0.0.1")
+		})
+
+		Convey("Render HTML", func() {
+			m.Get("/html", func(ctx *Context) {
+				ctx.HTML(304, "hello", "Unknwon") // 304 for logger test.
+			})
+
+			resp := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", "/html", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+			So(resp.Body.String(), ShouldEqual, "<h1>Hello Unknwon</h1>")
+
+			m.Get("/html2", func(ctx *Context) {
+				ctx.Data["Name"] = "Unknwon"
+				ctx.HTMLSet(200, "basic2", "hello2")
+			})
+
+			resp = httptest.NewRecorder()
+			req, err = http.NewRequest("GET", "/html2", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+			So(resp.Body.String(), ShouldEqual, "<h1>Hello Unknwon</h1>")
+		})
+
+		Convey("Parse from and query", func() {
+			m.Get("/query", func(ctx *Context) string {
+				var buf bytes.Buffer
+				buf.WriteString(ctx.Query("name") + " ")
+				buf.WriteString(ctx.QueryEscape("name") + " ")
+				buf.WriteString(com.ToStr(ctx.QueryInt("int")) + " ")
+				buf.WriteString(com.ToStr(ctx.QueryInt64("int64")) + " ")
+				return buf.String()
+			})
+			m.Get("/query2", func(ctx *Context) string {
+				var buf bytes.Buffer
+				buf.WriteString(strings.Join(ctx.QueryStrings("list"), ",") + " ")
+				buf.WriteString(strings.Join(ctx.QueryStrings("404"), ",") + " ")
+				return buf.String()
+			})
+
+			resp := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", "/query?name=Unknwon&int=12&int64=123", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+			So(resp.Body.String(), ShouldEqual, "Unknwon Unknwon 12 123 ")
+
+			resp = httptest.NewRecorder()
+			req, err = http.NewRequest("GET", "/query2?list=item1&list=item2", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+			So(resp.Body.String(), ShouldEqual, "item1,item2  ")
+		})
+
+		Convey("URL parameter", func() {
+			m.Get("/:name/:int/:int64", func(ctx *Context) string {
+				var buf bytes.Buffer
+				ctx.SetParams(":name", ctx.Params(":name"))
+				buf.WriteString(ctx.Params(":name") + " ")
+				buf.WriteString(ctx.ParamsEscape(":name") + " ")
+				buf.WriteString(com.ToStr(ctx.ParamsInt(":int")) + " ")
+				buf.WriteString(com.ToStr(ctx.ParamsInt64(":int64")) + " ")
+				return buf.String()
+			})
+
+			resp := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", "/user/1/13", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+			So(resp.Body.String(), ShouldEqual, "user user 1 13 ")
+		})
+
+		Convey("Get file", func() {
+			m.Get("/getfile", func(ctx *Context) {
+				ctx.GetFile("hi")
+			})
+
+			resp := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", "/getfile", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+		})
+
+		Convey("Set and get cookie", func() {
+			m.Get("/set", func(ctx *Context) {
+				ctx.SetCookie("user", "Unknwon", 1)
+			})
+
+			resp := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", "/set", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+			So(resp.Header().Get("Set-Cookie"), ShouldEqual, "user=Unknwon; Path=/; Max-Age=1")
+
+			m.Get("/get", func(ctx *Context) string {
+				ctx.GetCookie("404")
+				So(ctx.GetCookieInt("uid"), ShouldEqual, 1)
+				So(ctx.GetCookieInt64("uid"), ShouldEqual, 1)
+				return ctx.GetCookie("user")
+			})
+
+			resp = httptest.NewRecorder()
+			req, err = http.NewRequest("GET", "/get", nil)
+			So(err, ShouldBeNil)
+			req.Header.Set("Cookie", "user=Unknwon; uid=1")
+			m.ServeHTTP(resp, req)
+			So(resp.Body.String(), ShouldEqual, "Unknwon")
+		})
+
+		Convey("Set and get secure cookie", func() {
+			m.SetDefaultCookieSecret("macaron")
+			m.Get("/set", func(ctx *Context) {
+				ctx.SetSecureCookie("user", "Unknwon", 1)
+			})
+
+			resp := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", "/set", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+
+			cookie := resp.Header().Get("Set-Cookie")
+
+			m.Get("/get", func(ctx *Context) string {
+				name, ok := ctx.GetSecureCookie("user")
+				So(ok, ShouldBeTrue)
+				return name
+			})
+
+			resp = httptest.NewRecorder()
+			req, err = http.NewRequest("GET", "/get", nil)
+			So(err, ShouldBeNil)
+			req.Header.Set("Cookie", cookie)
+			m.ServeHTTP(resp, req)
+			So(resp.Body.String(), ShouldEqual, "Unknwon")
+		})
+
+		Convey("Serve files", func() {
+			m.Get("/file", func(ctx *Context) {
+				ctx.ServeFile("fixtures/custom_funcs/index.tmpl")
+			})
+
+			resp := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", "/file", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+			So(resp.Body.String(), ShouldEqual, "{{ myCustomFunc }}")
+
+			m.Get("/file2", func(ctx *Context) {
+				ctx.ServeFile("fixtures/custom_funcs/index.tmpl", "ok.tmpl")
+			})
+
+			resp = httptest.NewRecorder()
+			req, err = http.NewRequest("GET", "/file2", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+			So(resp.Body.String(), ShouldEqual, "{{ myCustomFunc }}")
+		})
+
+		Convey("Serve content", func() {
+			m.Get("/content", func(ctx *Context) {
+				ctx.ServeContent("content1", bytes.NewReader([]byte("Hello world!")))
+			})
+
+			resp := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", "/content", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+			So(resp.Body.String(), ShouldEqual, "Hello world!")
+
+			m.Get("/content2", func(ctx *Context) {
+				ctx.ServeContent("content1", bytes.NewReader([]byte("Hello world!")), time.Now())
+			})
+
+			resp = httptest.NewRecorder()
+			req, err = http.NewRequest("GET", "/content2", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+			So(resp.Body.String(), ShouldEqual, "Hello world!")
+		})
+	})
+}
+
+func Test_Context_Render(t *testing.T) {
+	Convey("Invalid render", t, func() {
+		defer func() {
+			So(recover(), ShouldNotBeNil)
+		}()
+
+		m := New()
+		m.Get("/", func(ctx *Context) {
+			ctx.HTML(200, "hey")
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+	})
+}
+
+func Test_Context_Redirect(t *testing.T) {
+	Convey("Context with default redirect", t, func() {
+		url, err := url.Parse("http://localhost/path/one")
+		So(err, ShouldBeNil)
+		resp := httptest.NewRecorder()
+		req := http.Request{
+			Method: "GET",
+			URL:    url,
+		}
+		ctx := &Context{
+			Req:  Request{&req},
+			Resp: NewResponseWriter(resp),
+			Data: make(map[string]interface{}),
+		}
+		ctx.Redirect("two")
+
+		So(resp.Code, ShouldEqual, http.StatusFound)
+		So(resp.HeaderMap["Location"][0], ShouldEqual, "/path/two")
+	})
+
+	Convey("Context with custom redirect", t, func() {
+		url, err := url.Parse("http://localhost/path/one")
+		So(err, ShouldBeNil)
+		resp := httptest.NewRecorder()
+		req := http.Request{
+			Method: "GET",
+			URL:    url,
+		}
+		ctx := &Context{
+			Req:  Request{&req},
+			Resp: NewResponseWriter(resp),
+			Data: make(map[string]interface{}),
+		}
+		ctx.Redirect("two", 307)
+
+		So(resp.Code, ShouldEqual, http.StatusTemporaryRedirect)
+		So(resp.HeaderMap["Location"][0], ShouldEqual, "/path/two")
+	})
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/fixtures/basic/admin/index.tmpl

@@ -0,0 +1 @@
+<h1>Admin {{.}}</h1>

Godeps/_workspace/src/github.com/Unknwon/macaron/fixtures/basic/another_layout.tmpl

@@ -0,0 +1 @@
+another head{{ yield }}another foot

Godeps/_workspace/src/github.com/Unknwon/macaron/fixtures/basic/content.tmpl

@@ -0,0 +1 @@
+<h1>{{ . }}</h1>

Godeps/_workspace/src/github.com/Unknwon/macaron/fixtures/basic/current_layout.tmpl

@@ -0,0 +1 @@
+{{ current }} head{{ yield }}{{ current }} foot

Godeps/_workspace/src/github.com/Unknwon/macaron/fixtures/basic/delims.tmpl

@@ -0,0 +1 @@
+<h1>Hello {[{.}]}</h1>

Godeps/_workspace/src/github.com/Unknwon/macaron/fixtures/basic/hello.tmpl

@@ -0,0 +1 @@
+<h1>Hello {{.}}</h1>

Godeps/_workspace/src/github.com/Unknwon/macaron/fixtures/basic/hypertext.html

@@ -0,0 +1 @@
+Hypertext!

Godeps/_workspace/src/github.com/Unknwon/macaron/fixtures/basic/layout.tmpl

@@ -0,0 +1 @@
+head{{ yield }}foot

Godeps/_workspace/src/github.com/Unknwon/macaron/fixtures/basic2/hello.tmpl

@@ -0,0 +1 @@
+<h1>What's up, {{.}}</h1>

Godeps/_workspace/src/github.com/Unknwon/macaron/fixtures/basic2/hello2.tmpl

@@ -0,0 +1 @@
+<h1>Hello {{.Name}}</h1>

Godeps/_workspace/src/github.com/Unknwon/macaron/fixtures/custom_funcs/index.tmpl

@@ -0,0 +1 @@
+{{ myCustomFunc }}

Godeps/_workspace/src/github.com/Unknwon/macaron/gzip.go

@@ -0,0 +1,81 @@
+// Copyright 2013 Martini Authors
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"bufio"
+	"compress/gzip"
+	"fmt"
+	"net"
+	"net/http"
+	"strings"
+)
+
+const (
+	HeaderAcceptEncoding  = "Accept-Encoding"
+	HeaderContentEncoding = "Content-Encoding"
+	HeaderContentLength   = "Content-Length"
+	HeaderContentType     = "Content-Type"
+	HeaderVary            = "Vary"
+)
+
+// Gziper returns a Handler that adds gzip compression to all requests.
+// Make sure to include the Gzip middleware above other middleware
+// that alter the response body (like the render middleware).
+func Gziper() Handler {
+	return func(ctx *Context) {
+		if !strings.Contains(ctx.Req.Header.Get(HeaderAcceptEncoding), "gzip") {
+			return
+		}
+
+		headers := ctx.Resp.Header()
+		headers.Set(HeaderContentEncoding, "gzip")
+		headers.Set(HeaderVary, HeaderAcceptEncoding)
+
+		gz := gzip.NewWriter(ctx.Resp)
+		defer gz.Close()
+
+		gzw := gzipResponseWriter{gz, ctx.Resp}
+		ctx.Resp = gzw
+		ctx.MapTo(gzw, (*http.ResponseWriter)(nil))
+
+		ctx.Next()
+
+		// delete content length after we know we have been written to
+		gzw.Header().Del("Content-Length")
+	}
+}
+
+type gzipResponseWriter struct {
+	w *gzip.Writer
+	ResponseWriter
+}
+
+func (grw gzipResponseWriter) Write(p []byte) (int, error) {
+	if len(grw.Header().Get(HeaderContentType)) == 0 {
+		grw.Header().Set(HeaderContentType, http.DetectContentType(p))
+	}
+
+	return grw.w.Write(p)
+}
+
+func (grw gzipResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	hijacker, ok := grw.ResponseWriter.(http.Hijacker)
+	if !ok {
+		return nil, nil, fmt.Errorf("the ResponseWriter doesn't support the Hijacker interface")
+	}
+	return hijacker.Hijack()
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/gzip_test.go

@@ -0,0 +1,65 @@
+// Copyright 2013 Martini Authors
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_Gzip(t *testing.T) {
+	Convey("Gzip response content", t, func() {
+		before := false
+
+		m := New()
+		m.Use(Gziper())
+		m.Use(func(r http.ResponseWriter) {
+			r.(ResponseWriter).Before(func(rw ResponseWriter) {
+				before = true
+			})
+		})
+		m.Get("/", func() string { return "hello wolrd!" })
+
+		// Not yet gzip.
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		_, ok := resp.HeaderMap[HeaderContentEncoding]
+		So(ok, ShouldBeFalse)
+
+		ce := resp.Header().Get(HeaderContentEncoding)
+		So(strings.EqualFold(ce, "gzip"), ShouldBeFalse)
+
+		// Gzip now.
+		resp = httptest.NewRecorder()
+		req.Header.Set(HeaderAcceptEncoding, "gzip")
+		m.ServeHTTP(resp, req)
+
+		_, ok = resp.HeaderMap[HeaderContentEncoding]
+		So(ok, ShouldBeTrue)
+
+		ce = resp.Header().Get(HeaderContentEncoding)
+		So(strings.EqualFold(ce, "gzip"), ShouldBeTrue)
+
+		So(before, ShouldBeTrue)
+	})
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/inject/README.md

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

Godeps/_workspace/src/github.com/Unknwon/macaron/inject/inject.go

@@ -0,0 +1,187 @@
+// Package inject provides utilities for mapping and injecting dependencies in various ways.
+package inject
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// Injector represents an interface for mapping and injecting dependencies into structs
+// and function arguments.
+type Injector interface {
+	Applicator
+	Invoker
+	TypeMapper
+	// SetParent sets the parent of the injector. If the injector cannot find a
+	// dependency in its Type map it will check its parent before returning an
+	// error.
+	SetParent(Injector)
+}
+
+// Applicator represents an interface for mapping dependencies to a struct.
+type Applicator interface {
+	// Maps dependencies in the Type map to each field in the struct
+	// that is tagged with 'inject'. Returns an error if the injection
+	// fails.
+	Apply(interface{}) error
+}
+
+// Invoker represents an interface for calling functions via reflection.
+type Invoker interface {
+	// Invoke attempts to call the interface{} provided as a function,
+	// providing dependencies for function arguments based on Type. Returns
+	// a slice of reflect.Value representing the returned values of the function.
+	// Returns an error if the injection fails.
+	Invoke(interface{}) ([]reflect.Value, error)
+}
+
+// TypeMapper represents an interface for mapping interface{} values based on type.
+type TypeMapper interface {
+	// Maps the interface{} value based on its immediate type from reflect.TypeOf.
+	Map(interface{}) TypeMapper
+	// Maps the interface{} value based on the pointer of an Interface provided.
+	// This is really only useful for mapping a value as an interface, as interfaces
+	// cannot at this time be referenced directly without a pointer.
+	MapTo(interface{}, interface{}) TypeMapper
+	// Provides a possibility to directly insert a mapping based on type and value.
+	// This makes it possible to directly map type arguments not possible to instantiate
+	// with reflect like unidirectional channels.
+	Set(reflect.Type, reflect.Value) TypeMapper
+	// Returns the Value that is mapped to the current type. Returns a zeroed Value if
+	// the Type has not been mapped.
+	GetVal(reflect.Type) reflect.Value
+}
+
+type injector struct {
+	values map[reflect.Type]reflect.Value
+	parent Injector
+}
+
+// InterfaceOf dereferences a pointer to an Interface type.
+// It panics if value is not an pointer to an interface.
+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
+}
+
+// New returns a new Injector.
+func New() Injector {
+	return &injector{
+		values: make(map[reflect.Type]reflect.Value),
+	}
+}
+
+// Invoke attempts to call the interface{} provided as a function,
+// providing dependencies for function arguments based on Type.
+// Returns a slice of reflect.Value representing the returned values of the function.
+// Returns an error if the injection fails.
+// It panics if f is not a function
+func (inj *injector) Invoke(f interface{}) ([]reflect.Value, error) {
+	t := reflect.TypeOf(f)
+
+	var in = make([]reflect.Value, t.NumIn()) //Panic if t is not kind of Func
+	for i := 0; i < t.NumIn(); i++ {
+		argType := t.In(i)
+		val := inj.GetVal(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
+}
+
+// Maps dependencies in the Type map to each field in the struct
+// that is tagged with 'inject'.
+// Returns an error if the injection fails.
+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 // Should not panic here ?
+	}
+
+	t := v.Type()
+
+	for i := 0; i < v.NumField(); i++ {
+		f := v.Field(i)
+		structField := t.Field(i)
+		if f.CanSet() && (structField.Tag == "inject" || structField.Tag.Get("inject") != "") {
+			ft := f.Type()
+			v := inj.GetVal(ft)
+			if !v.IsValid() {
+				return fmt.Errorf("Value not found for type %v", ft)
+			}
+
+			f.Set(v)
+		}
+
+	}
+
+	return nil
+}
+
+// Maps the concrete value of val to its dynamic type using reflect.TypeOf,
+// It returns the TypeMapper registered in.
+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
+}
+
+// Maps the given reflect.Type to the given reflect.Value and returns
+// the Typemapper the mapping has been registered in.
+func (i *injector) Set(typ reflect.Type, val reflect.Value) TypeMapper {
+	i.values[typ] = val
+	return i
+}
+
+func (i *injector) GetVal(t reflect.Type) reflect.Value {
+	val := i.values[t]
+
+	if val.IsValid() {
+		return val
+	}
+
+	// no concrete types found, try to find implementors
+	// if t is an interface
+	if t.Kind() == reflect.Interface {
+		for k, v := range i.values {
+			if k.Implements(t) {
+				val = v
+				break
+			}
+		}
+	}
+
+	// Still no type found, try to look it up on the parent
+	if !val.IsValid() && i.parent != nil {
+		val = i.parent.GetVal(t)
+	}
+
+	return val
+
+}
+
+func (i *injector) SetParent(parent Injector) {
+	i.parent = parent
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/inject/inject.goconvey

@@ -0,0 +1 @@
+ignore

Godeps/_workspace/src/github.com/Unknwon/macaron/inject/inject_test.go

@@ -0,0 +1,174 @@
+// Copyright 2013 Martini Authors
+// Copyright 2014 Unknown
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package inject_test
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/Unknwon/macaron/inject"
+)
+
+type SpecialString interface {
+}
+
+type TestStruct struct {
+	Dep1 string        `inject:"t" json:"-"`
+	Dep2 SpecialString `inject`
+	Dep3 string
+}
+
+type Greeter struct {
+	Name string
+}
+
+func (g *Greeter) String() string {
+	return "Hello, My name is" + g.Name
+}
+
+/* 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))
+	dep3 := make(chan *SpecialString)
+	dep4 := make(chan *SpecialString)
+	typRecv := reflect.ChanOf(reflect.RecvDir, reflect.TypeOf(dep3).Elem())
+	typSend := reflect.ChanOf(reflect.SendDir, reflect.TypeOf(dep4).Elem())
+	injector.Set(typRecv, reflect.ValueOf(dep3))
+	injector.Set(typSend, reflect.ValueOf(dep4))
+
+	_, err := injector.Invoke(func(d1 string, d2 SpecialString, d3 <-chan *SpecialString, d4 chan<- *SpecialString) {
+		expect(t, d1, dep)
+		expect(t, d2, dep2)
+		expect(t, reflect.TypeOf(d3).Elem(), reflect.TypeOf(dep3).Elem())
+		expect(t, reflect.TypeOf(d4).Elem(), reflect.TypeOf(dep4).Elem())
+		expect(t, reflect.TypeOf(d3).ChanDir(), reflect.RecvDir)
+		expect(t, reflect.TypeOf(d4).ChanDir(), reflect.SendDir)
+	})
+
+	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_InjectorSet(t *testing.T) {
+	injector := inject.New()
+	typ := reflect.TypeOf("string")
+	typSend := reflect.ChanOf(reflect.SendDir, typ)
+	typRecv := reflect.ChanOf(reflect.RecvDir, typ)
+
+	// instantiating unidirectional channels is not possible using reflect
+	// http://golang.org/src/pkg/reflect/value.go?s=60463:60504#L2064
+	chanRecv := reflect.MakeChan(reflect.ChanOf(reflect.BothDir, typ), 0)
+	chanSend := reflect.MakeChan(reflect.ChanOf(reflect.BothDir, typ), 0)
+
+	injector.Set(typSend, chanSend)
+	injector.Set(typRecv, chanRecv)
+
+	expect(t, injector.GetVal(typSend).IsValid(), true)
+	expect(t, injector.GetVal(typRecv).IsValid(), true)
+	expect(t, injector.GetVal(chanSend.Type()).IsValid(), false)
+}
+
+func Test_InjectorGet(t *testing.T) {
+	injector := inject.New()
+
+	injector.Map("some dependency")
+
+	expect(t, injector.GetVal(reflect.TypeOf("string")).IsValid(), true)
+	expect(t, injector.GetVal(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.GetVal(inject.InterfaceOf((*SpecialString)(nil))).IsValid(), true)
+}
+
+func TestInjectImplementors(t *testing.T) {
+	injector := inject.New()
+	g := &Greeter{"Jeremy"}
+	injector.Map(g)
+
+	expect(t, injector.GetVal(inject.InterfaceOf((*fmt.Stringer)(nil))).IsValid(), true)
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/logger.go

@@ -0,0 +1,61 @@
+// Copyright 2013 Martini Authors
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"runtime"
+	"time"
+)
+
+var ColorLog = true
+
+func init() {
+	ColorLog = runtime.GOOS != "windows"
+}
+
+// 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(ctx *Context, log *log.Logger) {
+		start := time.Now()
+
+		log.Printf("Started %s %s for %s", ctx.Req.Method, ctx.Req.RequestURI, ctx.RemoteAddr())
+
+		rw := ctx.Resp.(ResponseWriter)
+		ctx.Next()
+
+		content := fmt.Sprintf("Completed %s %v %s in %v", ctx.Req.RequestURI, rw.Status(), http.StatusText(rw.Status()), time.Since(start))
+		if ColorLog {
+			switch rw.Status() {
+			case 200, 201, 202:
+				content = fmt.Sprintf("\033[1;32m%s\033[0m", content)
+			case 301, 302:
+				content = fmt.Sprintf("\033[1;37m%s\033[0m", content)
+			case 304:
+				content = fmt.Sprintf("\033[1;33m%s\033[0m", content)
+			case 401, 403:
+				content = fmt.Sprintf("\033[4;31m%s\033[0m", content)
+			case 404:
+				content = fmt.Sprintf("\033[1;31m%s\033[0m", content)
+			case 500:
+				content = fmt.Sprintf("\033[1;36m%s\033[0m", content)
+			}
+		}
+		log.Println(content)
+	}
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/logger_test.go

@@ -0,0 +1,67 @@
+// Copyright 2013 Martini Authors
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"bytes"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/Unknwon/com"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_Logger(t *testing.T) {
+	Convey("Global logger", t, func() {
+		buf := bytes.NewBufferString("")
+		m := New()
+		m.Map(log.New(buf, "[Macaron] ", 0))
+		m.Use(Logger())
+		m.Use(func(res http.ResponseWriter) {
+			res.WriteHeader(http.StatusNotFound)
+		})
+		m.Get("/", func() {})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "http://localhost:4000/", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Code, ShouldEqual, http.StatusNotFound)
+		So(len(buf.String()), ShouldBeGreaterThan, 0)
+	})
+
+	if !isWindows {
+		Convey("Color console output", t, func() {
+			m := Classic()
+			m.Get("/:code:int", func(ctx *Context) (int, string) {
+				return ctx.ParamsInt(":code"), ""
+			})
+
+			// Just for testing if logger would capture.
+			codes := []int{200, 201, 202, 301, 302, 304, 401, 403, 404, 500}
+			for _, code := range codes {
+				resp := httptest.NewRecorder()
+				req, err := http.NewRequest("GET", "http://localhost:4000/"+com.ToStr(code), nil)
+				So(err, ShouldBeNil)
+				m.ServeHTTP(resp, req)
+				So(resp.Code, ShouldEqual, code)
+			}
+		})
+	}
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/macaron.go

@@ -0,0 +1,273 @@
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+// Package macaron is a high productive and modular design web framework in Go.
+package macaron
+
+import (
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"reflect"
+	"strings"
+
+	"github.com/Unknwon/com"
+	"gopkg.in/ini.v1"
+
+	"github.com/Unknwon/macaron/inject"
+)
+
+const _VERSION = "0.5.0.0116"
+
+func Version() string {
+	return _VERSION
+}
+
+// Handler can be any callable function.
+// Macaron attempts to inject services into the handler's argument list,
+// and panics if an argument could not be fullfilled via dependency injection.
+type Handler interface{}
+
+// validateHandler makes sure a handler is a callable function,
+// and panics if it is not.
+func validateHandler(h Handler) {
+	if reflect.TypeOf(h).Kind() != reflect.Func {
+		panic("Macaron handler must be a callable function")
+	}
+}
+
+// validateHandlers makes sure handlers are callable functions,
+// and panics if any of them is not.
+func validateHandlers(handlers []Handler) {
+	for _, h := range handlers {
+		validateHandler(h)
+	}
+}
+
+// Macaron represents the top level web application.
+// inject.Injector methods can be invoked to map services on a global level.
+type Macaron struct {
+	inject.Injector
+	befores  []BeforeHandler
+	handlers []Handler
+	action   Handler
+
+	urlPrefix string // For suburl support.
+	*Router
+
+	logger *log.Logger
+}
+
+// NewWithLogger creates a bare bones Macaron instance.
+// Use this method if you want to have full control over the middleware that is used.
+// You can specify logger output writer with this function.
+func NewWithLogger(out io.Writer) *Macaron {
+	m := &Macaron{
+		Injector: inject.New(),
+		action:   func() {},
+		Router:   NewRouter(),
+		logger:   log.New(out, "[Macaron] ", 0),
+	}
+	m.Router.m = m
+	m.Map(m.logger)
+	m.Map(defaultReturnHandler())
+	m.notFound = func(resp http.ResponseWriter, req *http.Request) {
+		c := m.createContext(resp, req)
+		c.handlers = append(c.handlers, http.NotFound)
+		c.run()
+	}
+	return m
+}
+
+// New creates a bare bones Macaron instance.
+// Use this method if you want to have full control over the middleware that is used.
+func New() *Macaron {
+	return NewWithLogger(os.Stdout)
+}
+
+// Classic creates a classic Macaron with some basic default middleware:
+// mocaron.Logger, mocaron.Recovery and mocaron.Static.
+func Classic() *Macaron {
+	m := New()
+	m.Use(Logger())
+	m.Use(Recovery())
+	m.Use(Static("public"))
+	return m
+}
+
+// Handlers sets the entire middleware stack with the given Handlers.
+// This will clear any current middleware handlers,
+// and panics if any of the handlers is not a callable function
+func (m *Macaron) Handlers(handlers ...Handler) {
+	m.handlers = make([]Handler, 0)
+	for _, handler := range handlers {
+		m.Use(handler)
+	}
+}
+
+// Action sets the handler that will be called after all the middleware has been invoked.
+// This is set to macaron.Router in a macaron.Classic().
+func (m *Macaron) Action(handler Handler) {
+	validateHandler(handler)
+	m.action = handler
+}
+
+// BeforeHandler represents a handler executes at beginning of every request.
+// Macaron stops future process when it returns true.
+type BeforeHandler func(rw http.ResponseWriter, req *http.Request) bool
+
+func (m *Macaron) Before(handler BeforeHandler) {
+	m.befores = append(m.befores, handler)
+}
+
+// Use adds a middleware Handler to the stack,
+// and panics if the handler is not a callable func.
+// Middleware Handlers are invoked in the order that they are added.
+func (m *Macaron) Use(handler Handler) {
+	validateHandler(handler)
+	m.handlers = append(m.handlers, handler)
+}
+
+func (m *Macaron) createContext(rw http.ResponseWriter, req *http.Request) *Context {
+	c := &Context{
+		Injector: inject.New(),
+		handlers: m.handlers,
+		action:   m.action,
+		index:    0,
+		Router:   m.Router,
+		Req:      Request{req},
+		Resp:     NewResponseWriter(rw),
+		Data:     make(map[string]interface{}),
+	}
+	c.SetParent(m)
+	c.Map(c)
+	c.MapTo(c.Resp, (*http.ResponseWriter)(nil))
+	c.Map(req)
+	return c
+}
+
+// ServeHTTP is the HTTP Entry point for a Macaron instance.
+// Useful if you want to control your own HTTP server.
+// Be aware that none of middleware will run without registering any router.
+func (m *Macaron) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
+	req.URL.Path = strings.TrimPrefix(req.URL.Path, m.urlPrefix)
+	for _, h := range m.befores {
+		if h(rw, req) {
+			return
+		}
+	}
+	m.Router.ServeHTTP(rw, req)
+}
+
+func GetDefaultListenInfo() (string, int) {
+	host := os.Getenv("HOST")
+	if len(host) == 0 {
+		host = "0.0.0.0"
+	}
+	port := com.StrTo(os.Getenv("PORT")).MustInt()
+	if port == 0 {
+		port = 4000
+	}
+	return host, port
+}
+
+// Run the http server. Listening on os.GetEnv("PORT") or 4000 by default.
+func (m *Macaron) Run(args ...interface{}) {
+	host, port := GetDefaultListenInfo()
+	if len(args) == 1 {
+		switch arg := args[0].(type) {
+		case string:
+			host = arg
+		case int:
+			port = arg
+		}
+	} else if len(args) >= 2 {
+		if arg, ok := args[0].(string); ok {
+			host = arg
+		}
+		if arg, ok := args[1].(int); ok {
+			port = arg
+		}
+	}
+
+	addr := host + ":" + com.ToStr(port)
+	logger := m.Injector.GetVal(reflect.TypeOf(m.logger)).Interface().(*log.Logger)
+	logger.Printf("listening on %s (%s)\n", addr, Env)
+	logger.Fatalln(http.ListenAndServe(addr, m))
+}
+
+// SetURLPrefix sets URL prefix of router layer, so that it support suburl.
+func (m *Macaron) SetURLPrefix(prefix string) {
+	m.urlPrefix = prefix
+}
+
+// ____   ____            .__      ___.   .__
+// \   \ /   /____ _______|__|____ \_ |__ |  |   ____   ______
+//  \   Y   /\__  \\_  __ \  \__  \ | __ \|  | _/ __ \ /  ___/
+//   \     /  / __ \|  | \/  |/ __ \| \_\ \  |_\  ___/ \___ \
+//    \___/  (____  /__|  |__(____  /___  /____/\___  >____  >
+//                \/              \/    \/          \/     \/
+
+const (
+	DEV  = "development"
+	PROD = "production"
+	TEST = "test"
+)
+
+var (
+	// Env is the environment that Macaron is executing in.
+	// The MACARON_ENV is read on initialization to set this variable.
+	Env = DEV
+
+	// Path of work directory.
+	Root string
+
+	// Flash applies to current request.
+	FlashNow bool
+
+	// Configuration convention object.
+	cfg *ini.File
+)
+
+func setENV(e string) {
+	if len(e) > 0 {
+		Env = e
+	}
+}
+
+func init() {
+	setENV(os.Getenv("MACARON_ENV"))
+
+	var err error
+	Root, err = os.Getwd()
+	if err != nil {
+		panic("error getting work directory: " + err.Error())
+	}
+}
+
+// SetConfig sets data sources for configuration.
+func SetConfig(source interface{}, others ...interface{}) (_ *ini.File, err error) {
+	cfg, err = ini.Load(source, others...)
+	return Config(), err
+}
+
+// Config returns configuration convention object.
+// It returns an empty object if there is no one available.
+func Config() *ini.File {
+	if cfg == nil {
+		return &ini.File{}
+	}
+	return cfg
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/macaron_test.go

@@ -0,0 +1,218 @@
+// Copyright 2013 Martini Authors
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+	"time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_Version(t *testing.T) {
+	Convey("Get version", t, func() {
+		So(Version(), ShouldEqual, _VERSION)
+	})
+}
+
+func Test_New(t *testing.T) {
+	Convey("Initialize a new instance", t, func() {
+		So(New(), ShouldNotBeNil)
+	})
+
+	Convey("Just test that Run doesn't bomb", t, func() {
+		go New().Run()
+		time.Sleep(1 * time.Second)
+		os.Setenv("PORT", "4001")
+		go New().Run("0.0.0.0")
+		go New().Run(4002)
+		go New().Run("0.0.0.0", 4003)
+	})
+}
+
+func Test_Macaron_Before(t *testing.T) {
+	Convey("Register before handlers", t, func() {
+		m := New()
+		m.Before(func(rw http.ResponseWriter, req *http.Request) bool {
+			return false
+		})
+		m.Before(func(rw http.ResponseWriter, req *http.Request) bool {
+			return true
+		})
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+	})
+}
+
+func Test_Macaron_ServeHTTP(t *testing.T) {
+	Convey("Serve HTTP requests", t, func() {
+		result := ""
+		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.Get("/", func() {})
+		m.Action(func(res http.ResponseWriter, req *http.Request) {
+			result += "bat"
+			res.WriteHeader(http.StatusBadRequest)
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(result, ShouldEqual, "foobarbatbazban")
+		So(resp.Code, ShouldEqual, http.StatusBadRequest)
+	})
+}
+
+func Test_Macaron_Handlers(t *testing.T) {
+	Convey("Add custom handlers", t, func() {
+		result := ""
+		batman := func(c *Context) {
+			result += "batman!"
+		}
+
+		m := New()
+		m.Use(func(c *Context) {
+			result += "foo"
+			c.Next()
+			result += "ban"
+		})
+		m.Handlers(
+			batman,
+			batman,
+			batman,
+		)
+
+		Convey("Add not callable function", func() {
+			defer func() {
+				So(recover(), ShouldNotBeNil)
+			}()
+			m.Use("shit")
+		})
+
+		m.Get("/", func() {})
+		m.Action(func(res http.ResponseWriter, req *http.Request) {
+			result += "bat"
+			res.WriteHeader(http.StatusBadRequest)
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(result, ShouldEqual, "batman!batman!batman!bat")
+		So(resp.Code, ShouldEqual, http.StatusBadRequest)
+	})
+}
+
+func Test_Macaron_EarlyWrite(t *testing.T) {
+	Convey("Write early content to response", t, func() {
+		result := ""
+		m := New()
+		m.Use(func(res http.ResponseWriter) {
+			result += "foobar"
+			res.Write([]byte("Hello world"))
+		})
+		m.Use(func() {
+			result += "bat"
+		})
+		m.Get("/", func() {})
+		m.Action(func(res http.ResponseWriter) {
+			result += "baz"
+			res.WriteHeader(http.StatusBadRequest)
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(result, ShouldEqual, "foobar")
+		So(resp.Code, ShouldEqual, http.StatusOK)
+	})
+}
+
+func Test_Macaron_Written(t *testing.T) {
+	Convey("Written sign", t, func() {
+		resp := httptest.NewRecorder()
+		m := New()
+		m.Handlers(func(res http.ResponseWriter) {
+			res.WriteHeader(http.StatusOK)
+		})
+
+		ctx := m.createContext(resp, &http.Request{Method: "GET"})
+		So(ctx.Written(), ShouldBeFalse)
+
+		ctx.run()
+		So(ctx.Written(), ShouldBeTrue)
+	})
+}
+
+func Test_Macaron_Basic_NoRace(t *testing.T) {
+	Convey("Make sure no race between requests", t, func() {
+		m := New()
+		handlers := []Handler{func() {}, func() {}}
+		// Ensure append will not realloc to trigger the race condition
+		m.handlers = handlers[:1]
+		m.Get("/", func() {})
+		req, _ := http.NewRequest("GET", "/", nil)
+		for i := 0; i < 2; i++ {
+			go func() {
+				resp := httptest.NewRecorder()
+				m.ServeHTTP(resp, req)
+			}()
+		}
+	})
+}
+
+func Test_SetENV(t *testing.T) {
+	Convey("Get and save environment variable", t, func() {
+		tests := []struct {
+			in  string
+			out string
+		}{
+			{"", "development"},
+			{"not_development", "not_development"},
+		}
+
+		for _, test := range tests {
+			setENV(test.in)
+			So(Env, ShouldEqual, test.out)
+		}
+	})
+}
+
+func Test_Config(t *testing.T) {
+	Convey("Set and get configuration object", t, func() {
+		So(Config(), ShouldNotBeNil)
+		cfg, err := SetConfig([]byte(""))
+		So(err, ShouldBeNil)
+		So(cfg, ShouldNotBeNil)
+	})
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/recovery.go

@@ -0,0 +1,163 @@
+// Copyright 2013 Martini Authors
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"runtime"
+
+	"github.com/Unknwon/macaron/inject"
+)
+
+const (
+	panicHtml = `<html>
+<head><title>PANIC: %s</title>
+<meta charset="utf-8" />
+<style type="text/css">
+html, body {
+	font-family: "Roboto", sans-serif;
+	color: #333333;
+	background-color: #ea5343;
+	margin: 0px;
+}
+h1 {
+	color: #d04526;
+	background-color: #ffffff;
+	padding: 20px;
+	border-bottom: 1px dashed #2b3848;
+}
+pre {
+	margin: 20px;
+	padding: 20px;
+	border: 2px solid #2b3848;
+	background-color: #ffffff;
+	white-space: pre-wrap;       /* css-3 */
+	white-space: -moz-pre-wrap;  /* Mozilla, since 1999 */
+	white-space: -pre-wrap;      /* Opera 4-6 */
+	white-space: -o-pre-wrap;    /* Opera 7 */
+	word-wrap: break-word;       /* Internet Explorer 5.5+ */
+}
+</style>
+</head><body>
+<h1>PANIC</h1>
+<pre style="font-weight: bold;">%s</pre>
+<pre>%s</pre>
+</body>
+</html>`
+)
+
+var (
+	dunno     = []byte("???")
+	centerDot = []byte("·")
+	dot       = []byte(".")
+	slash     = []byte("/")
+)
+
+// stack returns a nicely formated stack frame, skipping skip frames
+func stack(skip int) []byte {
+	buf := new(bytes.Buffer) // the returned data
+	// As we loop, we open files and read them. These variables record the currently
+	// loaded file.
+	var lines [][]byte
+	var lastFile string
+	for i := skip; ; i++ { // Skip the expected number of frames
+		pc, file, line, ok := runtime.Caller(i)
+		if !ok {
+			break
+		}
+		// Print this much at least.  If we can't find the source, it won't show.
+		fmt.Fprintf(buf, "%s:%d (0x%x)\n", file, line, pc)
+		if file != lastFile {
+			data, err := ioutil.ReadFile(file)
+			if err != nil {
+				continue
+			}
+			lines = bytes.Split(data, []byte{'\n'})
+			lastFile = file
+		}
+		fmt.Fprintf(buf, "\t%s: %s\n", function(pc), source(lines, line))
+	}
+	return buf.Bytes()
+}
+
+// source returns a space-trimmed slice of the n'th line.
+func source(lines [][]byte, n int) []byte {
+	n-- // in stack trace, lines are 1-indexed but our array is 0-indexed
+	if n < 0 || n >= len(lines) {
+		return dunno
+	}
+	return bytes.TrimSpace(lines[n])
+}
+
+// function returns, if possible, the name of the function containing the PC.
+func function(pc uintptr) []byte {
+	fn := runtime.FuncForPC(pc)
+	if fn == nil {
+		return dunno
+	}
+	name := []byte(fn.Name())
+	// The name includes the path name to the package, which is unnecessary
+	// since the file name is already included.  Plus, it has center dots.
+	// That is, we see
+	//	runtime/debug.*T·ptrmethod
+	// and want
+	//	*T.ptrmethod
+	// Also the package path might contains dot (e.g. code.google.com/...),
+	// so first eliminate the path prefix
+	if lastslash := bytes.LastIndex(name, slash); lastslash >= 0 {
+		name = name[lastslash+1:]
+	}
+	if period := bytes.Index(name, dot); period >= 0 {
+		name = name[period+1:]
+	}
+	name = bytes.Replace(name, centerDot, dot, -1)
+	return name
+}
+
+// Recovery returns a middleware that recovers from any panics and writes a 500 if there was one.
+// While Martini is in development mode, Recovery will also output the panic as HTML.
+func Recovery() Handler {
+	return func(c *Context, log *log.Logger) {
+		defer func() {
+			if err := recover(); err != nil {
+				stack := stack(3)
+				log.Printf("PANIC: %s\n%s", err, stack)
+
+				// Lookup the current responsewriter
+				val := c.GetVal(inject.InterfaceOf((*http.ResponseWriter)(nil)))
+				res := val.Interface().(http.ResponseWriter)
+
+				// respond with panic message while in development mode
+				var body []byte
+				if Env == DEV {
+					res.Header().Set("Content-Type", "text/html")
+					body = []byte(fmt.Sprintf(panicHtml, err, err, stack))
+				}
+
+				res.WriteHeader(http.StatusInternalServerError)
+				if nil != body {
+					res.Write(body)
+				}
+			}
+		}()
+
+		c.Next()
+	}
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/recovery_test.go

@@ -0,0 +1,74 @@
+// Copyright 2013 Martini Authors
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"bytes"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_Recovery(t *testing.T) {
+	Convey("Recovery from panic", t, func() {
+		buf := bytes.NewBufferString("")
+		setENV(DEV)
+
+		m := New()
+		m.Map(log.New(buf, "[Macaron] ", 0))
+		m.Use(func(res http.ResponseWriter, req *http.Request) {
+			res.Header().Set("Content-Type", "unpredictable")
+		})
+		m.Use(Recovery())
+		m.Use(func(res http.ResponseWriter, req *http.Request) {
+			panic("here is a panic!")
+		})
+		m.Get("/", func() {})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Code, ShouldEqual, http.StatusInternalServerError)
+		So(resp.HeaderMap.Get("Content-Type"), ShouldEqual, "text/html")
+		So(buf.String(), ShouldNotBeEmpty)
+	})
+
+	Convey("Revocery panic to another response writer", t, func() {
+		resp := httptest.NewRecorder()
+		resp2 := httptest.NewRecorder()
+		setENV(DEV)
+
+		m := New()
+		m.Use(Recovery())
+		m.Use(func(c *Context) {
+			c.MapTo(resp2, (*http.ResponseWriter)(nil))
+			panic("here is a panic!")
+		})
+		m.Get("/", func() {})
+
+		req, err := http.NewRequest("GET", "/", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp2.Code, ShouldEqual, http.StatusInternalServerError)
+		So(resp2.HeaderMap.Get("Content-Type"), ShouldEqual, "text/html")
+		So(resp2.Body.Len(), ShouldBeGreaterThan, 0)
+	})
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/render.go

@@ -0,0 +1,592 @@
+// Copyright 2013 Martini Authors
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"bytes"
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"html/template"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/Unknwon/com"
+
+	"github.com/Unknwon/macaron/bpool"
+)
+
+const (
+	ContentType    = "Content-Type"
+	ContentLength  = "Content-Length"
+	ContentBinary  = "application/octet-stream"
+	ContentJSON    = "application/json"
+	ContentHTML    = "text/html"
+	CONTENT_PLAIN  = "text/plain"
+	ContentXHTML   = "application/xhtml+xml"
+	ContentXML     = "text/xml"
+	defaultCharset = "UTF-8"
+)
+
+var (
+	// Provides a temporary buffer to execute templates into and catch errors.
+	bufpool = bpool.NewBufferPool(64)
+
+	// Included helper functions for use when rendering html
+	helperFuncs = template.FuncMap{
+		"yield": func() (string, error) {
+			return "", fmt.Errorf("yield called with no layout defined")
+		},
+		"current": func() (string, error) {
+			return "", nil
+		},
+	}
+)
+
+type (
+	// TemplateFile represents a interface of template file that has name and can be read.
+	TemplateFile interface {
+		Name() string
+		Data() []byte
+		Ext() string
+	}
+	// TemplateFileSystem represents a interface of template file system that able to list all files.
+	TemplateFileSystem interface {
+		ListFiles() []TemplateFile
+	}
+
+	// Delims represents a set of Left and Right delimiters for HTML template rendering
+	Delims struct {
+		// Left delimiter, defaults to {{
+		Left string
+		// Right delimiter, defaults to }}
+		Right string
+	}
+
+	// RenderOptions represents a struct for specifying configuration options for the Render middleware.
+	RenderOptions struct {
+		// Directory to load templates. Default is "templates".
+		Directory string
+		// Layout template name. Will not render a layout if "". Default is to "".
+		Layout string
+		// Extensions to parse template files from. Defaults are [".tmpl", ".html"].
+		Extensions []string
+		// Funcs is a slice of FuncMaps to apply to the template upon compilation. This is useful for helper functions. Default is [].
+		Funcs []template.FuncMap
+		// Delims sets the action delimiters to the specified strings in the Delims struct.
+		Delims Delims
+		// Appends the given charset to the Content-Type header. Default is "UTF-8".
+		Charset string
+		// Outputs human readable JSON.
+		IndentJSON bool
+		// Outputs human readable XML.
+		IndentXML bool
+		// Prefixes the JSON output with the given bytes.
+		PrefixJSON []byte
+		// Prefixes the XML output with the given bytes.
+		PrefixXML []byte
+		// Allows changing of output to XHTML instead of HTML. Default is "text/html"
+		HTMLContentType string
+		// TemplateFileSystem is the interface for supporting any implmentation of template file system.
+		TemplateFileSystem
+	}
+
+	// HTMLOptions is a struct for overriding some rendering Options for specific HTML call
+	HTMLOptions struct {
+		// Layout template name. Overrides Options.Layout.
+		Layout string
+	}
+
+	Render interface {
+		http.ResponseWriter
+		RW() http.ResponseWriter
+
+		JSON(int, interface{})
+		JSONString(interface{}) (string, error)
+		RawData(int, []byte)
+		RenderData(int, []byte)
+		HTML(int, string, interface{}, ...HTMLOptions)
+		HTMLSet(int, string, string, interface{}, ...HTMLOptions)
+		HTMLSetString(string, string, interface{}, ...HTMLOptions) (string, error)
+		HTMLString(string, interface{}, ...HTMLOptions) (string, error)
+		HTMLSetBytes(string, string, interface{}, ...HTMLOptions) ([]byte, error)
+		HTMLBytes(string, interface{}, ...HTMLOptions) ([]byte, error)
+		XML(int, interface{})
+		Error(int, ...string)
+		Status(int)
+		SetTemplatePath(string, string)
+		HasTemplateSet(string) bool
+	}
+)
+
+// TplFile implements TemplateFile interface.
+type TplFile struct {
+	name string
+	data []byte
+	ext  string
+}
+
+// NewTplFile cerates new template file with given name and data.
+func NewTplFile(name string, data []byte, ext string) *TplFile {
+	return &TplFile{name, data, ext}
+}
+
+func (f *TplFile) Name() string {
+	return f.name
+}
+
+func (f *TplFile) Data() []byte {
+	return f.data
+}
+
+func (f *TplFile) Ext() string {
+	return f.ext
+}
+
+// TplFileSystem implements TemplateFileSystem interface.
+type TplFileSystem struct {
+	files []TemplateFile
+}
+
+// NewTemplateFileSystem creates new template file system with given options.
+func NewTemplateFileSystem(opt RenderOptions, omitData bool) TplFileSystem {
+	fs := TplFileSystem{}
+	fs.files = make([]TemplateFile, 0, 10)
+
+	if err := filepath.Walk(opt.Directory, func(path string, info os.FileInfo, err error) error {
+		r, err := filepath.Rel(opt.Directory, path)
+		if err != nil {
+			return err
+		}
+
+		ext := GetExt(r)
+
+		for _, extension := range opt.Extensions {
+			if ext == extension {
+				var data []byte
+				if !omitData {
+					data, err = ioutil.ReadFile(path)
+					if err != nil {
+						return err
+					}
+				}
+
+				name := filepath.ToSlash((r[0 : len(r)-len(ext)]))
+				fs.files = append(fs.files, NewTplFile(name, data, ext))
+				break
+			}
+		}
+
+		return nil
+	}); err != nil {
+		panic("NewTemplateFileSystem: " + err.Error())
+	}
+
+	return fs
+}
+
+func (fs TplFileSystem) ListFiles() []TemplateFile {
+	return fs.files
+}
+
+func PrepareCharset(charset string) string {
+	if len(charset) != 0 {
+		return "; charset=" + charset
+	}
+
+	return "; charset=" + defaultCharset
+}
+
+func GetExt(s string) string {
+	index := strings.Index(s, ".")
+	if index == -1 {
+		return ""
+	}
+	return s[index:]
+}
+
+func compile(opt RenderOptions) *template.Template {
+	dir := opt.Directory
+	t := template.New(dir)
+	t.Delims(opt.Delims.Left, opt.Delims.Right)
+	// Parse an initial template in case we don't have any.
+	template.Must(t.Parse("Macaron"))
+
+	if opt.TemplateFileSystem == nil {
+		opt.TemplateFileSystem = NewTemplateFileSystem(opt, false)
+	}
+
+	for _, f := range opt.TemplateFileSystem.ListFiles() {
+		tmpl := t.New(f.Name())
+		for _, funcs := range opt.Funcs {
+			tmpl.Funcs(funcs)
+		}
+		// Bomb out if parse fails. We don't want any silent server starts.
+		template.Must(tmpl.Funcs(helperFuncs).Parse(string(f.Data())))
+	}
+
+	return t
+}
+
+const (
+	_DEFAULT_TPL_SET_NAME = "DEFAULT"
+)
+
+// templateSet represents a template set of type *template.Template.
+type templateSet struct {
+	lock sync.RWMutex
+	sets map[string]*template.Template
+	dirs map[string]string
+}
+
+func newTemplateSet() *templateSet {
+	return &templateSet{
+		sets: make(map[string]*template.Template),
+		dirs: make(map[string]string),
+	}
+}
+
+func (ts *templateSet) Set(name string, opt *RenderOptions) *template.Template {
+	t := compile(*opt)
+
+	ts.lock.Lock()
+	defer ts.lock.Unlock()
+
+	ts.sets[name] = t
+	ts.dirs[name] = opt.Directory
+	return t
+}
+
+func (ts *templateSet) Get(name string) *template.Template {
+	ts.lock.RLock()
+	defer ts.lock.RUnlock()
+
+	return ts.sets[name]
+}
+
+func (ts *templateSet) GetDir(name string) string {
+	ts.lock.RLock()
+	defer ts.lock.RUnlock()
+
+	return ts.dirs[name]
+}
+
+func prepareOptions(options []RenderOptions) RenderOptions {
+	var opt RenderOptions
+	if len(options) > 0 {
+		opt = options[0]
+	}
+
+	// Defaults.
+	if len(opt.Directory) == 0 {
+		opt.Directory = "templates"
+	}
+	if len(opt.Extensions) == 0 {
+		opt.Extensions = []string{".tmpl", ".html"}
+	}
+	if len(opt.HTMLContentType) == 0 {
+		opt.HTMLContentType = ContentHTML
+	}
+
+	return opt
+}
+
+func ParseTplSet(tplSet string) (tplName string, tplDir string) {
+	tplSet = strings.TrimSpace(tplSet)
+	if len(tplSet) == 0 {
+		panic("empty template set argument")
+	}
+	infos := strings.Split(tplSet, ":")
+	if len(infos) == 1 {
+		tplDir = infos[0]
+		tplName = path.Base(tplDir)
+	} else {
+		tplName = infos[0]
+		tplDir = infos[1]
+	}
+
+	if !com.IsDir(tplDir) {
+		panic("template set path does not exist or is not a directory")
+	}
+	return tplName, tplDir
+}
+
+func renderHandler(opt RenderOptions, tplSets []string) Handler {
+	cs := PrepareCharset(opt.Charset)
+	ts := newTemplateSet()
+	ts.Set(_DEFAULT_TPL_SET_NAME, &opt)
+
+	var tmpOpt RenderOptions
+	for _, tplSet := range tplSets {
+		tplName, tplDir := ParseTplSet(tplSet)
+		tmpOpt = opt
+		tmpOpt.Directory = tplDir
+		ts.Set(tplName, &tmpOpt)
+	}
+
+	return func(ctx *Context) {
+		r := &TplRender{
+			ResponseWriter:  ctx.Resp,
+			templateSet:     ts,
+			Opt:             &opt,
+			CompiledCharset: cs,
+		}
+		ctx.Data["TmplLoadTimes"] = func() string {
+			if r.startTime.IsZero() {
+				return ""
+			}
+			return fmt.Sprint(time.Since(r.startTime).Nanoseconds()/1e6) + "ms"
+		}
+
+		ctx.Render = r
+		ctx.MapTo(r, (*Render)(nil))
+	}
+}
+
+// Renderer is a Middleware that maps a macaron.Render service into the Macaron handler chain.
+// An single variadic macaron.RenderOptions struct can be optionally provided to configure
+// HTML rendering. The default directory for templates is "templates" and the default
+// file extension is ".tmpl" and ".html".
+//
+// If MACARON_ENV is set to "" or "development" then templates will be recompiled on every request. For more performance, set the
+// MACARON_ENV environment variable to "production".
+func Renderer(options ...RenderOptions) Handler {
+	return renderHandler(prepareOptions(options), []string{})
+}
+
+func Renderers(options RenderOptions, tplSets ...string) Handler {
+	return renderHandler(prepareOptions([]RenderOptions{options}), tplSets)
+}
+
+type TplRender struct {
+	http.ResponseWriter
+	*templateSet
+	Opt             *RenderOptions
+	CompiledCharset string
+
+	startTime time.Time
+}
+
+func (r *TplRender) RW() http.ResponseWriter {
+	return r.ResponseWriter
+}
+
+func (r *TplRender) JSON(status int, v interface{}) {
+	var result []byte
+	var err error
+	if r.Opt.IndentJSON {
+		result, err = json.MarshalIndent(v, "", "  ")
+	} else {
+		result, err = json.Marshal(v)
+	}
+	if err != nil {
+		http.Error(r, err.Error(), 500)
+		return
+	}
+
+	// json rendered fine, write out the result
+	r.Header().Set(ContentType, ContentJSON+r.CompiledCharset)
+	r.WriteHeader(status)
+	if len(r.Opt.PrefixJSON) > 0 {
+		r.Write(r.Opt.PrefixJSON)
+	}
+	r.Write(result)
+}
+
+func (r *TplRender) JSONString(v interface{}) (string, error) {
+	var result []byte
+	var err error
+	if r.Opt.IndentJSON {
+		result, err = json.MarshalIndent(v, "", "  ")
+	} else {
+		result, err = json.Marshal(v)
+	}
+	if err != nil {
+		return "", err
+	}
+	return string(result), nil
+}
+
+func (r *TplRender) XML(status int, v interface{}) {
+	var result []byte
+	var err error
+	if r.Opt.IndentXML {
+		result, err = xml.MarshalIndent(v, "", "  ")
+	} else {
+		result, err = xml.Marshal(v)
+	}
+	if err != nil {
+		http.Error(r, err.Error(), 500)
+		return
+	}
+
+	// XML rendered fine, write out the result
+	r.Header().Set(ContentType, ContentXML+r.CompiledCharset)
+	r.WriteHeader(status)
+	if len(r.Opt.PrefixXML) > 0 {
+		r.Write(r.Opt.PrefixXML)
+	}
+	r.Write(result)
+}
+
+func (r *TplRender) data(status int, contentType string, v []byte) {
+	if r.Header().Get(ContentType) == "" {
+		r.Header().Set(ContentType, contentType)
+	}
+	r.WriteHeader(status)
+	r.Write(v)
+}
+
+func (r *TplRender) RawData(status int, v []byte) {
+	r.data(status, ContentBinary, v)
+}
+
+func (r *TplRender) RenderData(status int, v []byte) {
+	r.data(status, CONTENT_PLAIN, v)
+}
+
+func (r *TplRender) execute(t *template.Template, name string, data interface{}) (*bytes.Buffer, error) {
+	buf := bufpool.Get()
+	return buf, t.ExecuteTemplate(buf, name, data)
+}
+
+func (r *TplRender) addYield(t *template.Template, tplName string, data interface{}) {
+	funcs := template.FuncMap{
+		"yield": func() (template.HTML, error) {
+			buf, err := r.execute(t, tplName, data)
+			// return safe html here since we are rendering our own template
+			return template.HTML(buf.String()), err
+		},
+		"current": func() (string, error) {
+			return tplName, nil
+		},
+	}
+	t.Funcs(funcs)
+}
+
+func (r *TplRender) renderBytes(setName, tplName string, data interface{}, htmlOpt ...HTMLOptions) (*bytes.Buffer, error) {
+	t := r.templateSet.Get(setName)
+	if Env == DEV {
+		opt := *r.Opt
+		opt.Directory = r.templateSet.GetDir(setName)
+		t = r.templateSet.Set(setName, &opt)
+	}
+	if t == nil {
+		return nil, fmt.Errorf("html/template: template \"%s\" is undefined", tplName)
+	}
+
+	opt := r.prepareHTMLOptions(htmlOpt)
+
+	if len(opt.Layout) > 0 {
+		r.addYield(t, tplName, data)
+		tplName = opt.Layout
+	}
+
+	out, err := r.execute(t, tplName, data)
+	if err != nil {
+		return nil, err
+	}
+
+	return out, nil
+}
+
+func (r *TplRender) renderHTML(status int, setName, tplName string, data interface{}, htmlOpt ...HTMLOptions) {
+	r.startTime = time.Now()
+
+	out, err := r.renderBytes(setName, tplName, data, htmlOpt...)
+	if err != nil {
+		http.Error(r, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	r.Header().Set(ContentType, r.Opt.HTMLContentType+r.CompiledCharset)
+	r.WriteHeader(status)
+
+	io.Copy(r, out)
+	bufpool.Put(out)
+}
+
+func (r *TplRender) HTML(status int, name string, data interface{}, htmlOpt ...HTMLOptions) {
+	r.renderHTML(status, _DEFAULT_TPL_SET_NAME, name, data, htmlOpt...)
+}
+
+func (r *TplRender) HTMLSet(status int, setName, tplName string, data interface{}, htmlOpt ...HTMLOptions) {
+	r.renderHTML(status, setName, tplName, data, htmlOpt...)
+}
+
+func (r *TplRender) HTMLSetBytes(setName, tplName string, data interface{}, htmlOpt ...HTMLOptions) ([]byte, error) {
+	out, err := r.renderBytes(setName, tplName, data, htmlOpt...)
+	if err != nil {
+		return []byte(""), err
+	}
+	return out.Bytes(), nil
+}
+
+func (r *TplRender) HTMLBytes(name string, data interface{}, htmlOpt ...HTMLOptions) ([]byte, error) {
+	return r.HTMLSetBytes(_DEFAULT_TPL_SET_NAME, name, data, htmlOpt...)
+}
+
+func (r *TplRender) HTMLSetString(setName, tplName string, data interface{}, htmlOpt ...HTMLOptions) (string, error) {
+	p, err := r.HTMLSetBytes(setName, tplName, data, htmlOpt...)
+	return string(p), err
+}
+
+func (r *TplRender) HTMLString(name string, data interface{}, htmlOpt ...HTMLOptions) (string, error) {
+	p, err := r.HTMLBytes(name, data, htmlOpt...)
+	return string(p), err
+}
+
+// Error writes the given HTTP status to the current ResponseWriter
+func (r *TplRender) Error(status int, message ...string) {
+	r.WriteHeader(status)
+	if len(message) > 0 {
+		r.Write([]byte(message[0]))
+	}
+}
+
+func (r *TplRender) Status(status int) {
+	r.WriteHeader(status)
+}
+
+func (r *TplRender) prepareHTMLOptions(htmlOpt []HTMLOptions) HTMLOptions {
+	if len(htmlOpt) > 0 {
+		return htmlOpt[0]
+	}
+
+	return HTMLOptions{
+		Layout: r.Opt.Layout,
+	}
+}
+
+func (r *TplRender) SetTemplatePath(setName, dir string) {
+	if len(setName) == 0 {
+		setName = _DEFAULT_TPL_SET_NAME
+	}
+	opt := *r.Opt
+	opt.Directory = dir
+	r.templateSet.Set(setName, &opt)
+}
+
+func (r *TplRender) HasTemplateSet(name string) bool {
+	return r.templateSet.Get(name) != nil
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/render_test.go

@@ -0,0 +1,581 @@
+// Copyright 2013 Martini Authors
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"encoding/xml"
+	"html/template"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+type Greeting struct {
+	One string `json:"one"`
+	Two string `json:"two"`
+}
+
+type GreetingXML struct {
+	XMLName xml.Name `xml:"greeting"`
+	One     string   `xml:"one,attr"`
+	Two     string   `xml:"two,attr"`
+}
+
+func Test_Render_JSON(t *testing.T) {
+	Convey("Render JSON", t, func() {
+		m := Classic()
+		m.Use(Renderer())
+		m.Get("/foobar", func(r Render) {
+			r.JSON(300, Greeting{"hello", "world"})
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusMultipleChoices)
+		So(resp.Header().Get(ContentType), ShouldEqual, ContentJSON+"; charset=UTF-8")
+		So(resp.Body.String(), ShouldEqual, `{"one":"hello","two":"world"}`)
+	})
+
+	Convey("Render JSON with prefix", t, func() {
+		m := Classic()
+		prefix := ")]}',\n"
+		m.Use(Renderer(RenderOptions{
+			PrefixJSON: []byte(prefix),
+		}))
+		m.Get("/foobar", func(r Render) {
+			r.JSON(300, Greeting{"hello", "world"})
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusMultipleChoices)
+		So(resp.Header().Get(ContentType), ShouldEqual, ContentJSON+"; charset=UTF-8")
+		So(resp.Body.String(), ShouldEqual, prefix+`{"one":"hello","two":"world"}`)
+	})
+
+	Convey("Render Indented JSON", t, func() {
+		m := Classic()
+		m.Use(Renderer(RenderOptions{
+			IndentJSON: true,
+		}))
+		m.Get("/foobar", func(r Render) {
+			r.JSON(300, Greeting{"hello", "world"})
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusMultipleChoices)
+		So(resp.Header().Get(ContentType), ShouldEqual, ContentJSON+"; charset=UTF-8")
+		So(resp.Body.String(), ShouldEqual, `{
+  "one": "hello",
+  "two": "world"
+}`)
+	})
+
+	Convey("Render JSON and return string", t, func() {
+		m := Classic()
+		m.Use(Renderer())
+		m.Get("/foobar", func(r Render) {
+			result, err := r.JSONString(Greeting{"hello", "world"})
+			So(err, ShouldBeNil)
+			So(result, ShouldEqual, `{"one":"hello","two":"world"}`)
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+	})
+
+	Convey("Render with charset JSON", t, func() {
+		m := Classic()
+		m.Use(Renderer(RenderOptions{
+			Charset: "foobar",
+		}))
+		m.Get("/foobar", func(r Render) {
+			r.JSON(300, Greeting{"hello", "world"})
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusMultipleChoices)
+		So(resp.Header().Get(ContentType), ShouldEqual, ContentJSON+"; charset=foobar")
+		So(resp.Body.String(), ShouldEqual, `{"one":"hello","two":"world"}`)
+	})
+}
+
+func Test_Render_XML(t *testing.T) {
+	Convey("Render XML", t, func() {
+		m := Classic()
+		m.Use(Renderer())
+		m.Get("/foobar", func(r Render) {
+			r.XML(300, GreetingXML{One: "hello", Two: "world"})
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusMultipleChoices)
+		So(resp.Header().Get(ContentType), ShouldEqual, ContentXML+"; charset=UTF-8")
+		So(resp.Body.String(), ShouldEqual, `<greeting one="hello" two="world"></greeting>`)
+	})
+
+	Convey("Render XML with prefix", t, func() {
+		m := Classic()
+		prefix := ")]}',\n"
+		m.Use(Renderer(RenderOptions{
+			PrefixXML: []byte(prefix),
+		}))
+		m.Get("/foobar", func(r Render) {
+			r.XML(300, GreetingXML{One: "hello", Two: "world"})
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusMultipleChoices)
+		So(resp.Header().Get(ContentType), ShouldEqual, ContentXML+"; charset=UTF-8")
+		So(resp.Body.String(), ShouldEqual, prefix+`<greeting one="hello" two="world"></greeting>`)
+	})
+
+	Convey("Render Indented XML", t, func() {
+		m := Classic()
+		m.Use(Renderer(RenderOptions{
+			IndentXML: true,
+		}))
+		m.Get("/foobar", func(r Render) {
+			r.XML(300, GreetingXML{One: "hello", Two: "world"})
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusMultipleChoices)
+		So(resp.Header().Get(ContentType), ShouldEqual, ContentXML+"; charset=UTF-8")
+		So(resp.Body.String(), ShouldEqual, `<greeting one="hello" two="world"></greeting>`)
+	})
+}
+
+func Test_Render_HTML(t *testing.T) {
+	Convey("Render HTML", t, func() {
+		m := Classic()
+		m.Use(Renderers(RenderOptions{
+			Directory: "fixtures/basic",
+		}, "fixtures/basic2"))
+		m.Get("/foobar", func(r Render) {
+			r.HTML(200, "hello", "jeremy")
+			r.SetTemplatePath("", "fixtures/basic2")
+		})
+		m.Get("/foobar2", func(r Render) {
+			if r.HasTemplateSet("basic2") {
+				r.HTMLSet(200, "basic2", "hello", "jeremy")
+			}
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(resp.Header().Get(ContentType), ShouldEqual, ContentHTML+"; charset=UTF-8")
+		So(resp.Body.String(), ShouldEqual, "<h1>Hello jeremy</h1>")
+
+		resp = httptest.NewRecorder()
+		req, err = http.NewRequest("GET", "/foobar2", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(resp.Header().Get(ContentType), ShouldEqual, ContentHTML+"; charset=UTF-8")
+		So(resp.Body.String(), ShouldEqual, "<h1>What's up, jeremy</h1>")
+
+		Convey("Change render templates path", func() {
+			resp := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", "/foobar", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+
+			So(resp.Code, ShouldEqual, http.StatusOK)
+			So(resp.Header().Get(ContentType), ShouldEqual, ContentHTML+"; charset=UTF-8")
+			So(resp.Body.String(), ShouldEqual, "<h1>What's up, jeremy</h1>")
+		})
+	})
+
+	Convey("Render HTML and return string", t, func() {
+		m := Classic()
+		m.Use(Renderers(RenderOptions{
+			Directory: "fixtures/basic",
+		}, "basic2:fixtures/basic2"))
+		m.Get("/foobar", func(r Render) {
+			result, err := r.HTMLString("hello", "jeremy")
+			So(err, ShouldBeNil)
+			So(result, ShouldEqual, "<h1>Hello jeremy</h1>")
+		})
+		m.Get("/foobar2", func(r Render) {
+			result, err := r.HTMLSetString("basic2", "hello", "jeremy")
+			So(err, ShouldBeNil)
+			So(result, ShouldEqual, "<h1>What's up, jeremy</h1>")
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		resp = httptest.NewRecorder()
+		req, err = http.NewRequest("GET", "/foobar2", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+	})
+
+	Convey("Render with nested HTML", t, func() {
+		m := Classic()
+		m.Use(Renderer(RenderOptions{
+			Directory: "fixtures/basic",
+		}))
+		m.Get("/foobar", func(r Render) {
+			r.HTML(200, "admin/index", "jeremy")
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(resp.Header().Get(ContentType), ShouldEqual, ContentHTML+"; charset=UTF-8")
+		So(resp.Body.String(), ShouldEqual, "<h1>Admin jeremy</h1>")
+	})
+
+	Convey("Render bad HTML", t, func() {
+		m := Classic()
+		m.Use(Renderer(RenderOptions{
+			Directory: "fixtures/basic",
+		}))
+		m.Get("/foobar", func(r Render) {
+			r.HTML(200, "nope", nil)
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusInternalServerError)
+		So(resp.Body.String(), ShouldEqual, "html/template: \"nope\" is undefined\n")
+	})
+
+	Convey("Invalid template set", t, func() {
+		Convey("Empty template set argument", func() {
+			defer func() {
+				So(recover(), ShouldNotBeNil)
+			}()
+			m := Classic()
+			m.Use(Renderers(RenderOptions{
+				Directory: "fixtures/basic",
+			}, ""))
+		})
+
+		Convey("Bad template set path", func() {
+			defer func() {
+				So(recover(), ShouldNotBeNil)
+			}()
+			m := Classic()
+			m.Use(Renderers(RenderOptions{
+				Directory: "fixtures/basic",
+			}, "404"))
+		})
+	})
+}
+
+func Test_Render_XHTML(t *testing.T) {
+	Convey("Render XHTML", t, func() {
+		m := Classic()
+		m.Use(Renderer(RenderOptions{
+			Directory:       "fixtures/basic",
+			HTMLContentType: ContentXHTML,
+		}))
+		m.Get("/foobar", func(r Render) {
+			r.HTML(200, "hello", "jeremy")
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(resp.Header().Get(ContentType), ShouldEqual, ContentXHTML+"; charset=UTF-8")
+		So(resp.Body.String(), ShouldEqual, "<h1>Hello jeremy</h1>")
+	})
+}
+
+func Test_Render_Extensions(t *testing.T) {
+	Convey("Render with extensions", t, func() {
+		m := Classic()
+		m.Use(Renderer(RenderOptions{
+			Directory:  "fixtures/basic",
+			Extensions: []string{".tmpl", ".html"},
+		}))
+		m.Get("/foobar", func(r Render) {
+			r.HTML(200, "hypertext", nil)
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(resp.Header().Get(ContentType), ShouldEqual, ContentHTML+"; charset=UTF-8")
+		So(resp.Body.String(), ShouldEqual, "Hypertext!")
+	})
+}
+
+func Test_Render_Funcs(t *testing.T) {
+	Convey("Render with functions", t, func() {
+		m := Classic()
+		m.Use(Renderer(RenderOptions{
+			Directory: "fixtures/custom_funcs",
+			Funcs: []template.FuncMap{
+				{
+					"myCustomFunc": func() string {
+						return "My custom function"
+					},
+				},
+			},
+		}))
+		m.Get("/foobar", func(r Render) {
+			r.HTML(200, "index", "jeremy")
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Body.String(), ShouldEqual, "My custom function")
+	})
+}
+
+func Test_Render_Layout(t *testing.T) {
+	Convey("Render with layout", t, func() {
+		m := Classic()
+		m.Use(Renderer(RenderOptions{
+			Directory: "fixtures/basic",
+			Layout:    "layout",
+		}))
+		m.Get("/foobar", func(r Render) {
+			r.HTML(200, "content", "jeremy")
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Body.String(), ShouldEqual, "head<h1>jeremy</h1>foot")
+	})
+
+	Convey("Render with current layout", t, func() {
+		m := Classic()
+		m.Use(Renderer(RenderOptions{
+			Directory: "fixtures/basic",
+			Layout:    "current_layout",
+		}))
+		m.Get("/foobar", func(r Render) {
+			r.HTML(200, "content", "jeremy")
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Body.String(), ShouldEqual, "content head<h1>jeremy</h1>content foot")
+	})
+
+	Convey("Render with override layout", t, func() {
+		m := Classic()
+		m.Use(Renderer(RenderOptions{
+			Directory: "fixtures/basic",
+			Layout:    "layout",
+		}))
+		m.Get("/foobar", func(r Render) {
+			r.HTML(200, "content", "jeremy", HTMLOptions{
+				Layout: "another_layout",
+			})
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(resp.Header().Get(ContentType), ShouldEqual, ContentHTML+"; charset=UTF-8")
+		So(resp.Body.String(), ShouldEqual, "another head<h1>jeremy</h1>another foot")
+	})
+}
+
+func Test_Render_Delimiters(t *testing.T) {
+	Convey("Render with delimiters", t, func() {
+		m := Classic()
+		m.Use(Renderer(RenderOptions{
+			Delims:    Delims{"{[{", "}]}"},
+			Directory: "fixtures/basic",
+		}))
+		m.Get("/foobar", func(r Render) {
+			r.HTML(200, "delims", "jeremy")
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(resp.Header().Get(ContentType), ShouldEqual, ContentHTML+"; charset=UTF-8")
+		So(resp.Body.String(), ShouldEqual, "<h1>Hello jeremy</h1>")
+	})
+}
+
+func Test_Render_BinaryData(t *testing.T) {
+	Convey("Render binary data", t, func() {
+		m := Classic()
+		m.Use(Renderer())
+		m.Get("/foobar", func(r Render) {
+			r.RawData(200, []byte("hello there"))
+		})
+		m.Get("/foobar2", func(r Render) {
+			r.RenderData(200, []byte("hello there"))
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(resp.Header().Get(ContentType), ShouldEqual, ContentBinary)
+		So(resp.Body.String(), ShouldEqual, "hello there")
+
+		resp = httptest.NewRecorder()
+		req, err = http.NewRequest("GET", "/foobar2", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(resp.Header().Get(ContentType), ShouldEqual, CONTENT_PLAIN)
+		So(resp.Body.String(), ShouldEqual, "hello there")
+	})
+
+	Convey("Render binary data with mime type", t, func() {
+		m := Classic()
+		m.Use(Renderer())
+		m.Get("/foobar", func(r Render) {
+			r.RW().Header().Set(ContentType, "image/jpeg")
+			r.RawData(200, []byte("..jpeg data.."))
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/foobar", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(resp.Header().Get(ContentType), ShouldEqual, "image/jpeg")
+		So(resp.Body.String(), ShouldEqual, "..jpeg data..")
+	})
+}
+
+func Test_Render_Status(t *testing.T) {
+	Convey("Render with status 204", t, func() {
+		resp := httptest.NewRecorder()
+		r := TplRender{resp, newTemplateSet(), &RenderOptions{}, "", time.Now()}
+		r.Status(204)
+		So(resp.Code, ShouldEqual, http.StatusNoContent)
+	})
+
+	Convey("Render with status 404", t, func() {
+		resp := httptest.NewRecorder()
+		r := TplRender{resp, newTemplateSet(), &RenderOptions{}, "", time.Now()}
+		r.Error(404)
+		So(resp.Code, ShouldEqual, http.StatusNotFound)
+	})
+
+	Convey("Render with status 500", t, func() {
+		resp := httptest.NewRecorder()
+		r := TplRender{resp, newTemplateSet(), &RenderOptions{}, "", time.Now()}
+		r.Error(500)
+		So(resp.Code, ShouldEqual, http.StatusInternalServerError)
+	})
+}
+
+func Test_Render_NoRace(t *testing.T) {
+	Convey("Make sure render has no race", t, func() {
+		m := Classic()
+		m.Use(Renderer(RenderOptions{
+			Directory: "fixtures/basic",
+		}))
+		m.Get("/foobar", func(r Render) {
+			r.HTML(200, "hello", "world")
+		})
+
+		done := make(chan bool)
+		doreq := func() {
+			resp := httptest.NewRecorder()
+			req, _ := http.NewRequest("GET", "/foobar", nil)
+			m.ServeHTTP(resp, req)
+			done <- true
+		}
+		// Run two requests to check there is no race condition
+		go doreq()
+		go doreq()
+		<-done
+		<-done
+	})
+}
+
+func Test_GetExt(t *testing.T) {
+	Convey("Get extension", t, func() {
+		So(GetExt("test"), ShouldBeBlank)
+		So(GetExt("test.tmpl"), ShouldEqual, ".tmpl")
+		So(GetExt("test.go.tmpl"), ShouldEqual, ".go.tmpl")
+	})
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/response_writer.go

@@ -0,0 +1,111 @@
+// Copyright 2013 Martini Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+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
+	http.Flusher
+	// 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
+	// Before allows for a function to be called before the ResponseWriter has been written to. This is
+	// useful for setting headers or any other operations that must happen before a response has been written.
+	Before(BeforeFunc)
+}
+
+// BeforeFunc is a function that is called before the ResponseWriter has been written to.
+type BeforeFunc func(ResponseWriter)
+
+// NewResponseWriter creates a ResponseWriter that wraps an http.ResponseWriter
+func NewResponseWriter(rw http.ResponseWriter) ResponseWriter {
+	return &responseWriter{rw, 0, 0, nil}
+}
+
+type responseWriter struct {
+	http.ResponseWriter
+	status      int
+	size        int
+	beforeFuncs []BeforeFunc
+}
+
+func (rw *responseWriter) WriteHeader(s int) {
+	rw.callBefore()
+	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.WriteHeader(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) Before(before BeforeFunc) {
+	rw.beforeFuncs = append(rw.beforeFuncs, before)
+}
+
+func (rw *responseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	hijacker, ok := rw.ResponseWriter.(http.Hijacker)
+	if !ok {
+		return nil, nil, fmt.Errorf("the ResponseWriter doesn't support the Hijacker interface")
+	}
+	return hijacker.Hijack()
+}
+
+func (rw *responseWriter) CloseNotify() <-chan bool {
+	return rw.ResponseWriter.(http.CloseNotifier).CloseNotify()
+}
+
+func (rw *responseWriter) callBefore() {
+	for i := len(rw.beforeFuncs) - 1; i >= 0; i-- {
+		rw.beforeFuncs[i](rw)
+	}
+}
+
+func (rw *responseWriter) Flush() {
+	flusher, ok := rw.ResponseWriter.(http.Flusher)
+	if ok {
+		flusher.Flush()
+	}
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/response_writer_test.go

@@ -0,0 +1,188 @@
+// Copyright 2013 Martini Authors
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"bufio"
+	"io"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+type closeNotifyingRecorder struct {
+	*httptest.ResponseRecorder
+	closed chan bool
+}
+
+func newCloseNotifyingRecorder() *closeNotifyingRecorder {
+	return &closeNotifyingRecorder{
+		httptest.NewRecorder(),
+		make(chan bool, 1),
+	}
+}
+
+func (c *closeNotifyingRecorder) close() {
+	c.closed <- true
+}
+
+func (c *closeNotifyingRecorder) CloseNotify() <-chan bool {
+	return c.closed
+}
+
+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(t *testing.T) {
+	Convey("Write string to response writer", t, func() {
+		resp := httptest.NewRecorder()
+		rw := NewResponseWriter(resp)
+		rw.Write([]byte("Hello world"))
+
+		So(resp.Code, ShouldEqual, rw.Status())
+		So(resp.Body.String(), ShouldEqual, "Hello world")
+		So(rw.Status(), ShouldEqual, http.StatusOK)
+		So(rw.Size(), ShouldEqual, 11)
+		So(rw.Written(), ShouldBeTrue)
+	})
+
+	Convey("Write strings to response writer", t, func() {
+		resp := httptest.NewRecorder()
+		rw := NewResponseWriter(resp)
+		rw.Write([]byte("Hello world"))
+		rw.Write([]byte("foo bar bat baz"))
+
+		So(resp.Code, ShouldEqual, rw.Status())
+		So(resp.Body.String(), ShouldEqual, "Hello worldfoo bar bat baz")
+		So(rw.Status(), ShouldEqual, http.StatusOK)
+		So(rw.Size(), ShouldEqual, 26)
+		So(rw.Written(), ShouldBeTrue)
+	})
+
+	Convey("Write header to response writer", t, func() {
+		resp := httptest.NewRecorder()
+		rw := NewResponseWriter(resp)
+		rw.WriteHeader(http.StatusNotFound)
+
+		So(resp.Code, ShouldEqual, rw.Status())
+		So(resp.Body.String(), ShouldBeBlank)
+		So(rw.Status(), ShouldEqual, http.StatusNotFound)
+		So(rw.Size(), ShouldEqual, 0)
+	})
+
+	Convey("Write before response write", t, func() {
+		result := ""
+		resp := httptest.NewRecorder()
+		rw := NewResponseWriter(resp)
+		rw.Before(func(ResponseWriter) {
+			result += "foo"
+		})
+		rw.Before(func(ResponseWriter) {
+			result += "bar"
+		})
+		rw.WriteHeader(http.StatusNotFound)
+
+		So(resp.Code, ShouldEqual, rw.Status())
+		So(resp.Body.String(), ShouldBeBlank)
+		So(rw.Status(), ShouldEqual, http.StatusNotFound)
+		So(rw.Size(), ShouldEqual, 0)
+		So(result, ShouldEqual, "barfoo")
+	})
+
+	Convey("Response writer with Hijack", t, func() {
+		hijackable := newHijackableResponse()
+		rw := NewResponseWriter(hijackable)
+		hijacker, ok := rw.(http.Hijacker)
+		So(ok, ShouldBeTrue)
+		_, _, err := hijacker.Hijack()
+		So(err, ShouldBeNil)
+		So(hijackable.Hijacked, ShouldBeTrue)
+	})
+
+	Convey("Response writer with bad Hijack", t, func() {
+		hijackable := new(http.ResponseWriter)
+		rw := NewResponseWriter(*hijackable)
+		hijacker, ok := rw.(http.Hijacker)
+		So(ok, ShouldBeTrue)
+		_, _, err := hijacker.Hijack()
+		So(err, ShouldNotBeNil)
+	})
+
+	Convey("Response writer with close notify", t, func() {
+		resp := newCloseNotifyingRecorder()
+		rw := NewResponseWriter(resp)
+		closed := false
+		notifier := rw.(http.CloseNotifier).CloseNotify()
+		resp.close()
+		select {
+		case <-notifier:
+			closed = true
+		case <-time.After(time.Second):
+		}
+		So(closed, ShouldBeTrue)
+	})
+
+	Convey("Response writer with flusher", t, func() {
+		resp := httptest.NewRecorder()
+		rw := NewResponseWriter(resp)
+		_, ok := rw.(http.Flusher)
+		So(ok, ShouldBeTrue)
+	})
+
+	Convey("Response writer with flusher handler", t, func() {
+		m := Classic()
+		m.Get("/events", func(w http.ResponseWriter, r *http.Request) {
+			f, ok := w.(http.Flusher)
+			So(ok, ShouldBeTrue)
+
+			w.Header().Set("Content-Type", "text/event-stream")
+			w.Header().Set("Cache-Control", "no-cache")
+			w.Header().Set("Connection", "keep-alive")
+
+			for i := 0; i < 2; i++ {
+				time.Sleep(10 * time.Millisecond)
+				io.WriteString(w, "data: Hello\n\n")
+				f.Flush()
+			}
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/events", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(resp.Body.String(), ShouldEqual, "data: Hello\n\ndata: Hello\n\n")
+	})
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/return_handler.go

@@ -0,0 +1,59 @@
+// Copyright 2013 Martini Authors
+// Copyright 2014 Unknown
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"net/http"
+	"reflect"
+
+	"github.com/Unknwon/macaron/inject"
+)
+
+// ReturnHandler is a service that Martini provides that is called
+// when a route handler returns something. The ReturnHandler is
+// responsible for writing to the ResponseWriter based on the values
+// that are passed into this function.
+type ReturnHandler func(*Context, []reflect.Value)
+
+func defaultReturnHandler() ReturnHandler {
+	return func(ctx *Context, vals []reflect.Value) {
+		rv := ctx.GetVal(inject.InterfaceOf((*http.ResponseWriter)(nil)))
+		res := rv.Interface().(http.ResponseWriter)
+		var responseVal reflect.Value
+		if len(vals) > 1 && vals[0].Kind() == reflect.Int {
+			res.WriteHeader(int(vals[0].Int()))
+			responseVal = vals[1]
+		} else if len(vals) > 0 {
+			responseVal = vals[0]
+		}
+		if canDeref(responseVal) {
+			responseVal = responseVal.Elem()
+		}
+		if isByteSlice(responseVal) {
+			res.Write(responseVal.Bytes())
+		} else {
+			res.Write([]byte(responseVal.String()))
+		}
+	}
+}
+
+func isByteSlice(val reflect.Value) bool {
+	return val.Kind() == reflect.Slice && val.Type().Elem().Kind() == reflect.Uint8
+}
+
+func canDeref(val reflect.Value) bool {
+	return val.Kind() == reflect.Interface || val.Kind() == reflect.Ptr
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/return_handler_test.go

@@ -0,0 +1,69 @@
+// Copyright 2014 Unknown
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_Return_Handler(t *testing.T) {
+	Convey("Return with status and body", t, func() {
+		m := Classic()
+		m.Get("/", func() (int, string) {
+			return 418, "i'm a teapot"
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusTeapot)
+		So(resp.Body.String(), ShouldEqual, "i'm a teapot")
+	})
+
+	Convey("Return with pointer", t, func() {
+		m := Classic()
+		m.Get("/", func() *string {
+			str := "hello world"
+			return &str
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Body.String(), ShouldEqual, "hello world")
+	})
+
+	Convey("Return with byte slice", t, func() {
+		m := Classic()
+		m.Get("/", func() []byte {
+			return []byte("hello world")
+		})
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Body.String(), ShouldEqual, "hello world")
+	})
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/router.go

@@ -0,0 +1,300 @@
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"net/http"
+	"strings"
+	"sync"
+
+	"github.com/Unknwon/com"
+)
+
+var (
+	// Known HTTP methods.
+	_HTTP_METHODS = map[string]bool{
+		"GET":     true,
+		"POST":    true,
+		"PUT":     true,
+		"DELETE":  true,
+		"PATCH":   true,
+		"OPTIONS": true,
+		"HEAD":    true,
+	}
+)
+
+// routeMap represents a thread-safe map for route tree.
+type routeMap struct {
+	lock   sync.RWMutex
+	routes map[string]map[string]bool
+}
+
+// NewRouteMap initializes and returns a new routeMap.
+func NewRouteMap() *routeMap {
+	rm := &routeMap{
+		routes: make(map[string]map[string]bool),
+	}
+	for m := range _HTTP_METHODS {
+		rm.routes[m] = make(map[string]bool)
+	}
+	return rm
+}
+
+// isExist returns true if a route has been registered.
+func (rm *routeMap) isExist(method, pattern string) bool {
+	rm.lock.RLock()
+	defer rm.lock.RUnlock()
+
+	return rm.routes[method][pattern]
+}
+
+// add adds new route to route tree map.
+func (rm *routeMap) add(method, pattern string) {
+	rm.lock.Lock()
+	defer rm.lock.Unlock()
+
+	rm.routes[method][pattern] = true
+}
+
+type group struct {
+	pattern  string
+	handlers []Handler
+}
+
+// Router represents a Macaron router layer.
+type Router struct {
+	m       *Macaron
+	routers map[string]*Tree
+	*routeMap
+
+	groups   []group
+	notFound http.HandlerFunc
+}
+
+func NewRouter() *Router {
+	return &Router{
+		routers:  make(map[string]*Tree),
+		routeMap: NewRouteMap(),
+	}
+}
+
+type Params map[string]string
+
+// Handle is a function that can be registered to a route to handle HTTP requests.
+// Like http.HandlerFunc, but has a third parameter for the values of wildcards (variables).
+type Handle func(http.ResponseWriter, *http.Request, Params)
+
+// handle adds new route to the router tree.
+func (r *Router) handle(method, pattern string, handle Handle) {
+	method = strings.ToUpper(method)
+
+	// Prevent duplicate routes.
+	if r.isExist(method, pattern) {
+		return
+	}
+
+	// Validate HTTP methods.
+	if !_HTTP_METHODS[method] && method != "*" {
+		panic("unknown HTTP method: " + method)
+	}
+
+	// Generate methods need register.
+	methods := make(map[string]bool)
+	if method == "*" {
+		for m := range _HTTP_METHODS {
+			methods[m] = true
+		}
+	} else {
+		methods[method] = true
+	}
+
+	// Add to router tree.
+	for m := range methods {
+		if t, ok := r.routers[m]; ok {
+			t.AddRouter(pattern, handle)
+		} else {
+			t := NewTree()
+			t.AddRouter(pattern, handle)
+			r.routers[m] = t
+		}
+		r.add(m, pattern)
+	}
+}
+
+// Handle registers a new request handle with the given pattern, method and handlers.
+func (r *Router) Handle(method string, pattern string, handlers []Handler) {
+	if len(r.groups) > 0 {
+		groupPattern := ""
+		h := make([]Handler, 0)
+		for _, g := range r.groups {
+			groupPattern += g.pattern
+			h = append(h, g.handlers...)
+		}
+
+		pattern = groupPattern + pattern
+		h = append(h, handlers...)
+		handlers = h
+	}
+	validateHandlers(handlers)
+
+	r.handle(method, pattern, func(resp http.ResponseWriter, req *http.Request, params Params) {
+		c := r.m.createContext(resp, req)
+		c.params = params
+		c.handlers = make([]Handler, 0, len(r.m.handlers)+len(handlers))
+		c.handlers = append(c.handlers, r.m.handlers...)
+		c.handlers = append(c.handlers, handlers...)
+		c.run()
+	})
+}
+
+func (r *Router) Group(pattern string, fn func(), h ...Handler) {
+	r.groups = append(r.groups, group{pattern, h})
+	fn()
+	r.groups = r.groups[:len(r.groups)-1]
+}
+
+// Get is a shortcut for r.Handle("GET", pattern, handlers)
+func (r *Router) Get(pattern string, h ...Handler) {
+	r.Handle("GET", pattern, h)
+}
+
+// Patch is a shortcut for r.Handle("PATCH", pattern, handlers)
+func (r *Router) Patch(pattern string, h ...Handler) {
+	r.Handle("PATCH", pattern, h)
+}
+
+// Post is a shortcut for r.Handle("POST", pattern, handlers)
+func (r *Router) Post(pattern string, h ...Handler) {
+	r.Handle("POST", pattern, h)
+}
+
+// Put is a shortcut for r.Handle("PUT", pattern, handlers)
+func (r *Router) Put(pattern string, h ...Handler) {
+	r.Handle("PUT", pattern, h)
+}
+
+// Delete is a shortcut for r.Handle("DELETE", pattern, handlers)
+func (r *Router) Delete(pattern string, h ...Handler) {
+	r.Handle("DELETE", pattern, h)
+}
+
+// Options is a shortcut for r.Handle("OPTIONS", pattern, handlers)
+func (r *Router) Options(pattern string, h ...Handler) {
+	r.Handle("OPTIONS", pattern, h)
+}
+
+// Head is a shortcut for r.Handle("HEAD", pattern, handlers)
+func (r *Router) Head(pattern string, h ...Handler) {
+	r.Handle("HEAD", pattern, h)
+}
+
+// Any is a shortcut for r.Handle("*", pattern, handlers)
+func (r *Router) Any(pattern string, h ...Handler) {
+	r.Handle("*", pattern, h)
+}
+
+// Route is a shortcut for same handlers but different HTTP methods.
+//
+// Example:
+// 		m.Route("/", "GET,POST", h)
+func (r *Router) Route(pattern, methods string, h ...Handler) {
+	for _, m := range strings.Split(methods, ",") {
+		r.Handle(strings.TrimSpace(m), pattern, h)
+	}
+}
+
+// Combo returns a combo router.
+func (r *Router) Combo(pattern string, h ...Handler) *ComboRouter {
+	return &ComboRouter{r, pattern, h, map[string]bool{}}
+}
+
+// Configurable http.HandlerFunc which is called when no matching route is
+// found. If it is not set, http.NotFound is used.
+// Be sure to set 404 response code in your handler.
+func (r *Router) NotFound(handlers ...Handler) {
+	r.notFound = func(rw http.ResponseWriter, req *http.Request) {
+		c := r.m.createContext(rw, req)
+		c.handlers = append(r.m.handlers, handlers...)
+		c.run()
+	}
+}
+
+func (r *Router) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
+	if t, ok := r.routers[req.Method]; ok {
+		h, p := t.Match(req.URL.Path)
+		if h != nil {
+			if splat, ok := p[":splat"]; ok {
+				p["*"] = p[":splat"] // Better name.
+				splatlist := strings.Split(splat, "/")
+				for k, v := range splatlist {
+					p[com.ToStr(k)] = v
+				}
+			}
+			h(rw, req, p)
+			return
+		}
+	}
+
+	r.notFound(rw, req)
+}
+
+// ComboRouter represents a combo router.
+type ComboRouter struct {
+	router   *Router
+	pattern  string
+	handlers []Handler
+	methods  map[string]bool // Registered methods.
+}
+
+func (cr *ComboRouter) checkMethod(name string) {
+	if cr.methods[name] {
+		panic("method '" + name + "' has already been registered")
+	}
+	cr.methods[name] = true
+}
+
+func (cr *ComboRouter) route(fn func(string, ...Handler), method string, h ...Handler) *ComboRouter {
+	cr.checkMethod(method)
+	fn(cr.pattern, append(cr.handlers, h...)...)
+	return cr
+}
+
+func (cr *ComboRouter) Get(h ...Handler) *ComboRouter {
+	return cr.route(cr.router.Get, "GET", h...)
+}
+
+func (cr *ComboRouter) Patch(h ...Handler) *ComboRouter {
+	return cr.route(cr.router.Patch, "PATCH", h...)
+}
+
+func (cr *ComboRouter) Post(h ...Handler) *ComboRouter {
+	return cr.route(cr.router.Post, "POST", h...)
+}
+
+func (cr *ComboRouter) Put(h ...Handler) *ComboRouter {
+	return cr.route(cr.router.Put, "PUT", h...)
+}
+
+func (cr *ComboRouter) Delete(h ...Handler) *ComboRouter {
+	return cr.route(cr.router.Delete, "DELETE", h...)
+}
+
+func (cr *ComboRouter) Options(h ...Handler) *ComboRouter {
+	return cr.route(cr.router.Options, "OPTIONS", h...)
+}
+
+func (cr *ComboRouter) Head(h ...Handler) *ComboRouter {
+	return cr.route(cr.router.Head, "HEAD", h...)
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/router_test.go

@@ -0,0 +1,199 @@
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_Router_Handle(t *testing.T) {
+	Convey("Register all HTTP methods routes", t, func() {
+		m := Classic()
+		m.Get("/get", func() string {
+			return "GET"
+		})
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/get", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Body.String(), ShouldEqual, "GET")
+
+		m.Patch("/patch", func() string {
+			return "PATCH"
+		})
+		resp = httptest.NewRecorder()
+		req, err = http.NewRequest("PATCH", "/patch", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Body.String(), ShouldEqual, "PATCH")
+
+		m.Post("/post", func() string {
+			return "POST"
+		})
+		resp = httptest.NewRecorder()
+		req, err = http.NewRequest("POST", "/post", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Body.String(), ShouldEqual, "POST")
+
+		m.Put("/put", func() string {
+			return "PUT"
+		})
+		resp = httptest.NewRecorder()
+		req, err = http.NewRequest("PUT", "/put", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Body.String(), ShouldEqual, "PUT")
+
+		m.Delete("/delete", func() string {
+			return "DELETE"
+		})
+		resp = httptest.NewRecorder()
+		req, err = http.NewRequest("DELETE", "/delete", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Body.String(), ShouldEqual, "DELETE")
+
+		m.Options("/options", func() string {
+			return "OPTIONS"
+		})
+		resp = httptest.NewRecorder()
+		req, err = http.NewRequest("OPTIONS", "/options", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Body.String(), ShouldEqual, "OPTIONS")
+
+		m.Head("/head", func() string {
+			return "HEAD"
+		})
+		resp = httptest.NewRecorder()
+		req, err = http.NewRequest("HEAD", "/head", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Body.String(), ShouldEqual, "HEAD")
+
+		m.Any("/any", func() string {
+			return "ANY"
+		})
+		resp = httptest.NewRecorder()
+		req, err = http.NewRequest("GET", "/any", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Body.String(), ShouldEqual, "ANY")
+
+		m.Route("/route", "GET,POST", func() string {
+			return "ROUTE"
+		})
+		resp = httptest.NewRecorder()
+		req, err = http.NewRequest("POST", "/route", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Body.String(), ShouldEqual, "ROUTE")
+	})
+
+	Convey("Register all HTTP methods routes with combo", t, func() {
+		m := Classic()
+		m.SetURLPrefix("/prefix")
+		m.Use(Renderer())
+		m.Combo("/", func(ctx *Context) {
+			ctx.Data["prefix"] = "Prefix_"
+		}).
+			Get(func(ctx *Context) string { return ctx.Data["prefix"].(string) + "GET" }).
+			Patch(func(ctx *Context) string { return ctx.Data["prefix"].(string) + "PATCH" }).
+			Post(func(ctx *Context) string { return ctx.Data["prefix"].(string) + "POST" }).
+			Put(func(ctx *Context) string { return ctx.Data["prefix"].(string) + "PUT" }).
+			Delete(func(ctx *Context) string { return ctx.Data["prefix"].(string) + "DELETE" }).
+			Options(func(ctx *Context) string { return ctx.Data["prefix"].(string) + "OPTIONS" }).
+			Head(func(ctx *Context) string { return ctx.Data["prefix"].(string) + "HEAD" })
+
+		for name := range _HTTP_METHODS {
+			resp := httptest.NewRecorder()
+			req, err := http.NewRequest(name, "/", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+			So(resp.Body.String(), ShouldEqual, "Prefix_"+name)
+		}
+
+		defer func() {
+			So(recover(), ShouldNotBeNil)
+		}()
+		m.Combo("/").Get(func() {}).Get(nil)
+	})
+
+	Convey("Register duplicated routes", t, func() {
+		r := NewRouter()
+		r.Get("/")
+		r.Get("/")
+	})
+
+	Convey("Register invalid HTTP method", t, func() {
+		defer func() {
+			So(recover(), ShouldNotBeNil)
+		}()
+		r := NewRouter()
+		r.Handle("404", "/", nil)
+	})
+}
+
+func Test_Router_Group(t *testing.T) {
+	Convey("Register route group", t, func() {
+		m := Classic()
+		m.Group("/api", func() {
+			m.Group("/v1", func() {
+				m.Get("/list", func() string {
+					return "Well done!"
+				})
+			})
+		})
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/api/v1/list", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Body.String(), ShouldEqual, "Well done!")
+	})
+}
+
+func Test_Router_NotFound(t *testing.T) {
+	Convey("Custom not found handler", t, func() {
+		m := Classic()
+		m.Get("/", func() {})
+		m.NotFound(func() string {
+			return "Custom not found"
+		})
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/404", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Body.String(), ShouldEqual, "Custom not found")
+	})
+}
+
+func Test_Router_splat(t *testing.T) {
+	Convey("Register router with glob", t, func() {
+		m := Classic()
+		m.Get("/*", func(ctx *Context) string {
+			return ctx.Params("*")
+		})
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "/hahaha", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Body.String(), ShouldEqual, "hahaha")
+	})
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/static.go

@@ -0,0 +1,205 @@
+// Copyright 2013 Martini Authors
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"log"
+	"net/http"
+	"path"
+	"path/filepath"
+	"strings"
+	"sync"
+)
+
+// StaticOptions is a struct for specifying configuration options for the macaron.Static middleware.
+type StaticOptions struct {
+	// Prefix is the optional prefix used to serve the static directory content
+	Prefix string
+	// SkipLogging will disable [Static] log messages when a static file is served.
+	SkipLogging bool
+	// IndexFile defines which file to serve as index if it exists.
+	IndexFile string
+	// Expires defines which user-defined function to use for producing a HTTP Expires Header
+	// https://developers.google.com/speed/docs/insights/LeverageBrowserCaching
+	Expires func() string
+	// FileSystem is the interface for supporting any implmentation of file system.
+	FileSystem http.FileSystem
+}
+
+// FIXME: to be deleted.
+type staticMap struct {
+	lock sync.RWMutex
+	data map[string]*http.Dir
+}
+
+func (sm *staticMap) Set(dir *http.Dir) {
+	sm.lock.Lock()
+	defer sm.lock.Unlock()
+
+	sm.data[string(*dir)] = dir
+}
+
+func (sm *staticMap) Get(name string) *http.Dir {
+	sm.lock.RLock()
+	defer sm.lock.RUnlock()
+
+	return sm.data[name]
+}
+
+func (sm *staticMap) Delete(name string) {
+	sm.lock.Lock()
+	defer sm.lock.Unlock()
+
+	delete(sm.data, name)
+}
+
+var statics = staticMap{sync.RWMutex{}, map[string]*http.Dir{}}
+
+// staticFileSystem implements http.FileSystem interface.
+type staticFileSystem struct {
+	dir *http.Dir
+}
+
+func newStaticFileSystem(directory string) staticFileSystem {
+	if !filepath.IsAbs(directory) {
+		directory = filepath.Join(Root, directory)
+	}
+	dir := http.Dir(directory)
+	statics.Set(&dir)
+	return staticFileSystem{&dir}
+}
+
+func (fs staticFileSystem) Open(name string) (http.File, error) {
+	return fs.dir.Open(name)
+}
+
+func prepareStaticOption(dir string, opt StaticOptions) StaticOptions {
+	// Defaults
+	if len(opt.IndexFile) == 0 {
+		opt.IndexFile = "index.html"
+	}
+	// Normalize the prefix if provided
+	if opt.Prefix != "" {
+		// Ensure we have a leading '/'
+		if opt.Prefix[0] != '/' {
+			opt.Prefix = "/" + opt.Prefix
+		}
+		// Remove any trailing '/'
+		opt.Prefix = strings.TrimRight(opt.Prefix, "/")
+	}
+	if opt.FileSystem == nil {
+		opt.FileSystem = newStaticFileSystem(dir)
+	}
+	return opt
+}
+
+func prepareStaticOptions(dir string, options []StaticOptions) StaticOptions {
+	var opt StaticOptions
+	if len(options) > 0 {
+		opt = options[0]
+	}
+	return prepareStaticOption(dir, opt)
+}
+
+func staticHandler(ctx *Context, log *log.Logger, opt StaticOptions) bool {
+	if ctx.Req.Method != "GET" && ctx.Req.Method != "HEAD" {
+		return false
+	}
+
+	file := ctx.Req.URL.Path
+	// if we have a prefix, filter requests by stripping the prefix
+	if opt.Prefix != "" {
+		if !strings.HasPrefix(file, opt.Prefix) {
+			return false
+		}
+		file = file[len(opt.Prefix):]
+		if file != "" && file[0] != '/' {
+			return false
+		}
+	}
+
+	f, err := opt.FileSystem.Open(file)
+	if err != nil {
+		return false
+	}
+	defer f.Close()
+
+	fi, err := f.Stat()
+	if err != nil {
+		return true // File exists but fail to open.
+	}
+
+	// Try to serve index file
+	if fi.IsDir() {
+		// Redirect if missing trailing slash.
+		if !strings.HasSuffix(ctx.Req.URL.Path, "/") {
+			http.Redirect(ctx.Resp, ctx.Req.Request, ctx.Req.URL.Path+"/", http.StatusFound)
+			return true
+		}
+
+		file = path.Join(file, opt.IndexFile)
+		f, err = opt.FileSystem.Open(file)
+		if err != nil {
+			return false // Discard error.
+		}
+		defer f.Close()
+
+		fi, err = f.Stat()
+		if err != nil || fi.IsDir() {
+			return true
+		}
+	}
+
+	if !opt.SkipLogging {
+		log.Println("[Static] Serving " + file)
+	}
+
+	// Add an Expires header to the static content
+	if opt.Expires != nil {
+		ctx.Resp.Header().Set("Expires", opt.Expires())
+	}
+
+	http.ServeContent(ctx.Resp, ctx.Req.Request, file, fi.ModTime(), f)
+	return true
+}
+
+// Static returns a middleware handler that serves static files in the given directory.
+func Static(directory string, staticOpt ...StaticOptions) Handler {
+	opt := prepareStaticOptions(directory, staticOpt)
+
+	return func(ctx *Context, log *log.Logger) {
+		staticHandler(ctx, log, opt)
+	}
+}
+
+// Statics registers multiple static middleware handlers all at once.
+func Statics(opt StaticOptions, dirs ...string) Handler {
+	if len(dirs) == 0 {
+		panic("no static directory is given")
+	}
+	opts := make([]StaticOptions, len(dirs))
+	for i := range dirs {
+		opts[i] = prepareStaticOption(dirs[i], opt)
+	}
+
+	return func(ctx *Context, log *log.Logger) {
+		for i := range opts {
+			if staticHandler(ctx, log, opts[i]) {
+				return
+			}
+		}
+	}
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/static_test.go

@@ -0,0 +1,246 @@
+// Copyright 2013 Martini Authors
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	"bytes"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path"
+	"strings"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var currentRoot, _ = os.Getwd()
+
+func Test_Static(t *testing.T) {
+	Convey("Serve static files", t, func() {
+		m := New()
+		m.Use(Static("./"))
+
+		resp := httptest.NewRecorder()
+		resp.Body = new(bytes.Buffer)
+		req, err := http.NewRequest("GET", "http://localhost:4000/macaron.go", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(resp.Header().Get("Expires"), ShouldBeBlank)
+		So(resp.Body.Len(), ShouldBeGreaterThan, 0)
+
+		Convey("Change static path", func() {
+			m.Get("/", func(ctx *Context) {
+				ctx.ChangeStaticPath("./", "inject")
+			})
+
+			resp := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", "/", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+
+			resp = httptest.NewRecorder()
+			resp.Body = new(bytes.Buffer)
+			req, err = http.NewRequest("GET", "http://localhost:4000/inject.go", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+			So(resp.Code, ShouldEqual, http.StatusOK)
+			So(resp.Header().Get("Expires"), ShouldBeBlank)
+			So(resp.Body.Len(), ShouldBeGreaterThan, 0)
+		})
+	})
+
+	Convey("Serve static files with local path", t, func() {
+		Root = os.TempDir()
+		f, err := ioutil.TempFile(Root, "static_content")
+		So(err, ShouldBeNil)
+		f.WriteString("Expected Content")
+		f.Close()
+
+		m := New()
+		m.Use(Static("."))
+
+		resp := httptest.NewRecorder()
+		resp.Body = new(bytes.Buffer)
+		req, err := http.NewRequest("GET", "http://localhost:4000/"+path.Base(strings.Replace(f.Name(), "\\", "/", -1)), nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(resp.Header().Get("Expires"), ShouldBeBlank)
+		So(resp.Body.String(), ShouldEqual, "Expected Content")
+	})
+
+	Convey("Serve static files with head", t, func() {
+		m := New()
+		m.Use(Static(currentRoot))
+
+		resp := httptest.NewRecorder()
+		resp.Body = new(bytes.Buffer)
+		req, err := http.NewRequest("HEAD", "http://localhost:4000/macaron.go", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(resp.Body.Len(), ShouldEqual, 0)
+	})
+
+	Convey("Serve static files as post", t, func() {
+		m := New()
+		m.Use(Static(currentRoot))
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("POST", "http://localhost:4000/macaron.go", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Code, ShouldEqual, http.StatusNotFound)
+	})
+
+	Convey("Serve static files with bad directory", t, func() {
+		m := Classic()
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "http://localhost:4000/macaron.go", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+		So(resp.Code, ShouldNotEqual, http.StatusOK)
+	})
+}
+
+func Test_Static_Options(t *testing.T) {
+	Convey("Serve static files with options logging", t, func() {
+		var buf bytes.Buffer
+		m := NewWithLogger(&buf)
+		opt := StaticOptions{}
+		m.Use(Static(currentRoot, opt))
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "http://localhost:4000/macaron.go", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(buf.String(), ShouldEqual, "[Macaron] [Static] Serving /macaron.go\n")
+
+		// Not disable logging.
+		m.Handlers()
+		buf.Reset()
+		opt.SkipLogging = true
+		m.Use(Static(currentRoot, opt))
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(buf.Len(), ShouldEqual, 0)
+	})
+
+	Convey("Serve static files with options serve index", t, func() {
+		var buf bytes.Buffer
+		m := NewWithLogger(&buf)
+		opt := StaticOptions{IndexFile: "macaron.go"}
+		m.Use(Static(currentRoot, opt))
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "http://localhost:4000/", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(buf.String(), ShouldEqual, "[Macaron] [Static] Serving /macaron.go\n")
+	})
+
+	Convey("Serve static files with options prefix", t, func() {
+		var buf bytes.Buffer
+		m := NewWithLogger(&buf)
+		opt := StaticOptions{Prefix: "public"}
+		m.Use(Static(currentRoot, opt))
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "http://localhost:4000/public/macaron.go", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusOK)
+		So(buf.String(), ShouldEqual, "[Macaron] [Static] Serving /macaron.go\n")
+	})
+
+	Convey("Serve static files with options expires", t, func() {
+		var buf bytes.Buffer
+		m := NewWithLogger(&buf)
+		opt := StaticOptions{Expires: func() string { return "46" }}
+		m.Use(Static(currentRoot, opt))
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "http://localhost:4000/macaron.go", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Header().Get("Expires"), ShouldEqual, "46")
+	})
+}
+
+func Test_Static_Redirect(t *testing.T) {
+	Convey("Serve static files with redirect", t, func() {
+		m := New()
+		m.Use(Static(currentRoot, StaticOptions{Prefix: "/public"}))
+
+		resp := httptest.NewRecorder()
+		req, err := http.NewRequest("GET", "http://localhost:4000/public", nil)
+		So(err, ShouldBeNil)
+		m.ServeHTTP(resp, req)
+
+		So(resp.Code, ShouldEqual, http.StatusFound)
+		So(resp.Header().Get("Location"), ShouldEqual, "/public/")
+	})
+}
+
+func Test_Statics(t *testing.T) {
+	Convey("Serve multiple static routers", t, func() {
+		Convey("Register empty directory", func() {
+			defer func() {
+				So(recover(), ShouldNotBeNil)
+			}()
+
+			m := New()
+			m.Use(Statics(StaticOptions{}))
+
+			resp := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", "http://localhost:4000/", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+		})
+
+		Convey("Serve normally", func() {
+			var buf bytes.Buffer
+			m := NewWithLogger(&buf)
+			m.Use(Statics(StaticOptions{}, currentRoot, currentRoot+"/inject"))
+
+			resp := httptest.NewRecorder()
+			req, err := http.NewRequest("GET", "http://localhost:4000/macaron.go", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+
+			So(resp.Code, ShouldEqual, http.StatusOK)
+			So(buf.String(), ShouldEqual, "[Macaron] [Static] Serving /macaron.go\n")
+
+			resp = httptest.NewRecorder()
+			req, err = http.NewRequest("GET", "http://localhost:4000/inject/inject.go", nil)
+			So(err, ShouldBeNil)
+			m.ServeHTTP(resp, req)
+
+			So(resp.Code, ShouldEqual, http.StatusOK)
+			So(buf.String(), ShouldEndWith, "[Macaron] [Static] Serving /inject/inject.go\n")
+		})
+	})
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/tree.go

@@ -0,0 +1,421 @@
+// Copyright 2013 Beego Authors
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+// NOTE: last sync 0c93364 on Dec 19, 2014.
+
+import (
+	"path"
+	"regexp"
+	"strings"
+
+	"github.com/Unknwon/com"
+)
+
+type leafInfo struct {
+	// Names of wildcards that lead to this leaf.
+	// eg, ["id" "name"] for the wildcard ":id" and ":name".
+	wildcards []string
+	// Not nil if the leaf is regexp.
+	regexps *regexp.Regexp
+	handle  Handle
+}
+
+func (leaf *leafInfo) match(wildcardValues []string) (ok bool, params Params) {
+	if leaf.regexps == nil {
+		if len(wildcardValues) == 0 && len(leaf.wildcards) > 0 {
+			if com.IsSliceContainsStr(leaf.wildcards, ":") {
+				params = make(map[string]string)
+				j := 0
+				for _, v := range leaf.wildcards {
+					if v == ":" {
+						continue
+					}
+					params[v] = ""
+					j += 1
+				}
+				return true, params
+			}
+			return false, nil
+		} else if len(wildcardValues) == 0 {
+			return true, nil // Static path.
+		}
+
+		// Match *
+		if len(leaf.wildcards) == 1 && leaf.wildcards[0] == ":splat" {
+			params = make(map[string]string)
+			params[":splat"] = path.Join(wildcardValues...)
+			return true, params
+		}
+
+		// Match *.*
+		if len(leaf.wildcards) == 3 && leaf.wildcards[0] == "." {
+			params = make(map[string]string)
+			lastone := wildcardValues[len(wildcardValues)-1]
+			strs := strings.SplitN(lastone, ".", 2)
+			if len(strs) == 2 {
+				params[":ext"] = strs[1]
+			} else {
+				params[":ext"] = ""
+			}
+			params[":path"] = path.Join(wildcardValues[:len(wildcardValues)-1]...) + "/" + strs[0]
+			return true, params
+		}
+
+		// Match :id
+		params = make(map[string]string)
+		j := 0
+		for _, v := range leaf.wildcards {
+			if v == ":" {
+				continue
+			}
+			if v == "." {
+				lastone := wildcardValues[len(wildcardValues)-1]
+				strs := strings.SplitN(lastone, ".", 2)
+				if len(strs) == 2 {
+					params[":ext"] = strs[1]
+				} else {
+					params[":ext"] = ""
+				}
+				if len(wildcardValues[j:]) == 1 {
+					params[":path"] = strs[0]
+				} else {
+					params[":path"] = path.Join(wildcardValues[j:]...) + "/" + strs[0]
+				}
+				return true, params
+			}
+			if len(wildcardValues) <= j {
+				return false, nil
+			}
+			params[v] = wildcardValues[j]
+			j++
+		}
+		if len(params) != len(wildcardValues) {
+			return false, nil
+		}
+		return true, params
+	}
+
+	if !leaf.regexps.MatchString(path.Join(wildcardValues...)) {
+		return false, nil
+	}
+	params = make(map[string]string)
+	matches := leaf.regexps.FindStringSubmatch(path.Join(wildcardValues...))
+	for i, match := range matches[1:] {
+		params[leaf.wildcards[i]] = match
+	}
+	return true, params
+}
+
+// Tree represents a router tree for Macaron instance.
+type Tree struct {
+	fixroutes map[string]*Tree
+	wildcard  *Tree
+	leaves    []*leafInfo
+}
+
+// NewTree initializes and returns a router tree.
+func NewTree() *Tree {
+	return &Tree{
+		fixroutes: make(map[string]*Tree),
+	}
+}
+
+// splitPath splites patthen into parts.
+//
+// Examples:
+//		"/" -> []
+// 		"/admin" -> ["admin"]
+// 		"/admin/" -> ["admin"]
+// 		"/admin/users" -> ["admin", "users"]
+func splitPath(pattern string) []string {
+	if len(pattern) == 0 {
+		return []string{}
+	}
+
+	elements := strings.Split(pattern, "/")
+	if elements[0] == "" {
+		elements = elements[1:]
+	}
+	if elements[len(elements)-1] == "" {
+		elements = elements[:len(elements)-1]
+	}
+	return elements
+}
+
+// AddRouter adds a new route to router tree.
+func (t *Tree) AddRouter(pattern string, handle Handle) {
+	t.addSegments(splitPath(pattern), handle, nil, "")
+}
+
+// splitSegment splits segment into parts.
+//
+// Examples:
+// 		"admin" -> false, nil, ""
+// 		":id" -> true, [:id], ""
+// 		"?:id" -> true, [: :id], ""        : meaning can empty
+// 		":id:int" -> true, [:id], ([0-9]+)
+// 		":name:string" -> true, [:name], ([\w]+)
+// 		":id([0-9]+)" -> true, [:id], ([0-9]+)
+// 		":id([0-9]+)_:name" -> true, [:id :name], ([0-9]+)_(.+)
+// 		"cms_:id_:page.html" -> true, [:id :page], cms_(.+)_(.+).html
+// 		"*" -> true, [:splat], ""
+// 		"*.*" -> true,[. :path :ext], ""      . meaning separator
+func splitSegment(key string) (bool, []string, string) {
+	if strings.HasPrefix(key, "*") {
+		if key == "*.*" {
+			return true, []string{".", ":path", ":ext"}, ""
+		} else {
+			return true, []string{":splat"}, ""
+		}
+	}
+	if strings.ContainsAny(key, ":") {
+		var paramsNum int
+		var out []rune
+		var start bool
+		var startexp bool
+		var param []rune
+		var expt []rune
+		var skipnum int
+		params := []string{}
+		reg := regexp.MustCompile(`[a-zA-Z0-9]+`)
+		for i, v := range key {
+			if skipnum > 0 {
+				skipnum -= 1
+				continue
+			}
+			if start {
+				//:id:int and :name:string
+				if v == ':' {
+					if len(key) >= i+4 {
+						if key[i+1:i+4] == "int" {
+							out = append(out, []rune("([0-9]+)")...)
+							params = append(params, ":"+string(param))
+							start = false
+							startexp = false
+							skipnum = 3
+							param = make([]rune, 0)
+							paramsNum += 1
+							continue
+						}
+					}
+					if len(key) >= i+7 {
+						if key[i+1:i+7] == "string" {
+							out = append(out, []rune(`([\w]+)`)...)
+							params = append(params, ":"+string(param))
+							paramsNum += 1
+							start = false
+							startexp = false
+							skipnum = 6
+							param = make([]rune, 0)
+							continue
+						}
+					}
+				}
+				// params only support a-zA-Z0-9
+				if reg.MatchString(string(v)) {
+					param = append(param, v)
+					continue
+				}
+				if v != '(' {
+					out = append(out, []rune(`(.+)`)...)
+					params = append(params, ":"+string(param))
+					param = make([]rune, 0)
+					paramsNum += 1
+					start = false
+					startexp = false
+				}
+			}
+			if startexp {
+				if v != ')' {
+					expt = append(expt, v)
+					continue
+				}
+			}
+			if v == ':' {
+				param = make([]rune, 0)
+				start = true
+			} else if v == '(' {
+				startexp = true
+				start = false
+				params = append(params, ":"+string(param))
+				paramsNum += 1
+				expt = make([]rune, 0)
+				expt = append(expt, '(')
+			} else if v == ')' {
+				startexp = false
+				expt = append(expt, ')')
+				out = append(out, expt...)
+				param = make([]rune, 0)
+			} else if v == '?' {
+				params = append(params, ":")
+			} else {
+				out = append(out, v)
+			}
+		}
+		if len(param) > 0 {
+			if paramsNum > 0 {
+				out = append(out, []rune(`(.+)`)...)
+			}
+			params = append(params, ":"+string(param))
+		}
+		return true, params, string(out)
+	} else {
+		return false, nil, ""
+	}
+}
+
+// addSegments add segments to the router tree.
+func (t *Tree) addSegments(segments []string, handle Handle, wildcards []string, reg string) {
+	// Fixed root route.
+	if len(segments) == 0 {
+		if reg != "" {
+			filterCards := make([]string, 0, len(wildcards))
+			for _, v := range wildcards {
+				if v == ":" || v == "." {
+					continue
+				}
+				filterCards = append(filterCards, v)
+			}
+			t.leaves = append(t.leaves, &leafInfo{
+				handle:    handle,
+				wildcards: filterCards,
+				regexps:   regexp.MustCompile("^" + reg + "$"),
+			})
+		} else {
+			t.leaves = append(t.leaves, &leafInfo{
+				handle:    handle,
+				wildcards: wildcards,
+			})
+		}
+		return
+	}
+
+	seg := segments[0]
+	iswild, params, regexpStr := splitSegment(seg)
+	//for the router  /login/*/access match /login/2009/11/access
+	if !iswild && com.IsSliceContainsStr(wildcards, ":splat") {
+		iswild = true
+		regexpStr = seg
+	}
+	if seg == "*" && len(wildcards) > 0 && reg == "" {
+		iswild = true
+		regexpStr = "(.+)"
+	}
+	if iswild {
+		if t.wildcard == nil {
+			t.wildcard = NewTree()
+		}
+		if regexpStr != "" {
+			if reg == "" {
+				rr := ""
+				for _, w := range wildcards {
+					if w == "." || w == ":" {
+						continue
+					}
+					if w == ":splat" {
+						rr = rr + "(.+)/"
+					} else {
+						rr = rr + "([^/]+)/"
+					}
+				}
+				regexpStr = rr + regexpStr
+			} else {
+				regexpStr = "/" + regexpStr
+			}
+		} else if reg != "" {
+			if seg == "*.*" {
+				regexpStr = "/([^.]+).(.+)"
+			} else {
+				for _, w := range params {
+					if w == "." || w == ":" {
+						continue
+					}
+					regexpStr = "/([^/]+)" + regexpStr
+				}
+			}
+		}
+		t.wildcard.addSegments(segments[1:], handle, append(wildcards, params...), reg+regexpStr)
+	} else {
+		subTree, ok := t.fixroutes[seg]
+		if !ok {
+			subTree = NewTree()
+			t.fixroutes[seg] = subTree
+		}
+		subTree.addSegments(segments[1:], handle, wildcards, reg)
+	}
+}
+
+func (t *Tree) match(segments []string, wildcardValues []string) (handle Handle, params Params) {
+	// Handle leaf nodes.
+	if len(segments) == 0 {
+		for _, l := range t.leaves {
+			if ok, pa := l.match(wildcardValues); ok {
+				return l.handle, pa
+			}
+		}
+		if t.wildcard != nil {
+			for _, l := range t.wildcard.leaves {
+				if ok, pa := l.match(wildcardValues); ok {
+					return l.handle, pa
+				}
+			}
+
+		}
+		return nil, nil
+	}
+
+	seg, segs := segments[0], segments[1:]
+
+	subTree, ok := t.fixroutes[seg]
+	if ok {
+		handle, params = subTree.match(segs, wildcardValues)
+	} else if len(segs) == 0 { //.json .xml
+		if subindex := strings.LastIndex(seg, "."); subindex != -1 {
+			subTree, ok = t.fixroutes[seg[:subindex]]
+			if ok {
+				handle, params = subTree.match(segs, wildcardValues)
+				if handle != nil {
+					if params == nil {
+						params = make(map[string]string)
+					}
+					params[":ext"] = seg[subindex+1:]
+					return handle, params
+				}
+			}
+		}
+	}
+	if handle == nil && t.wildcard != nil {
+		handle, params = t.wildcard.match(segs, append(wildcardValues, seg))
+	}
+	if handle == nil {
+		for _, l := range t.leaves {
+			if ok, pa := l.match(append(wildcardValues, segments...)); ok {
+				return l.handle, pa
+			}
+		}
+	}
+	return handle, params
+}
+
+// Match returns Handle and params if any route is matched.
+func (t *Tree) Match(pattern string) (Handle, Params) {
+	if len(pattern) == 0 || pattern[0] != '/' {
+		return nil, nil
+	}
+
+	return t.match(splitPath(pattern), nil)
+}

Godeps/_workspace/src/github.com/Unknwon/macaron/tree_test.go

@@ -0,0 +1,112 @@
+// Copyright 2014 Unknwon
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package macaron
+
+import (
+	// "net/http"
+	"strings"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func Test_splitSegment(t *testing.T) {
+	type result struct {
+		Ok    bool
+		Parts []string
+		Regex string
+	}
+	cases := map[string]result{
+		"admin":              result{false, nil, ""},
+		":id":                result{true, []string{":id"}, ""},
+		"?:id":               result{true, []string{":", ":id"}, ""},
+		":id:int":            result{true, []string{":id"}, "([0-9]+)"},
+		":name:string":       result{true, []string{":name"}, `([\w]+)`},
+		":id([0-9]+)":        result{true, []string{":id"}, "([0-9]+)"},
+		":id([0-9]+)_:name":  result{true, []string{":id", ":name"}, "([0-9]+)_(.+)"},
+		"cms_:id_:page.html": result{true, []string{":id", ":page"}, "cms_(.+)_(.+).html"},
+		"*":                  result{true, []string{":splat"}, ""},
+		"*.*":                result{true, []string{".", ":path", ":ext"}, ""},
+	}
+	Convey("Splits segment into parts", t, func() {
+		for key, result := range cases {
+			ok, parts, regex := splitSegment(key)
+			So(ok, ShouldEqual, result.Ok)
+			if result.Parts == nil {
+				So(parts, ShouldBeNil)
+			} else {
+				So(parts, ShouldNotBeNil)
+				So(strings.Join(parts, " "), ShouldEqual, strings.Join(result.Parts, " "))
+			}
+			So(regex, ShouldEqual, result.Regex)
+		}
+	})
+}
+
+func Test_Tree_Match(t *testing.T) {
+	type result struct {
+		pattern string
+		reqUrl  string
+		params  map[string]string
+	}
+
+	cases := []result{
+		{"/:id", "/123", map[string]string{":id": "123"}},
+		{"/hello/?:id", "/hello", map[string]string{":id": ""}},
+		{"/", "/", nil},
+		{"", "", nil},
+		{"/customer/login", "/customer/login", nil},
+		{"/customer/login", "/customer/login.json", map[string]string{":ext": "json"}},
+		{"/*", "/customer/123", map[string]string{":splat": "customer/123"}},
+		{"/*", "/customer/2009/12/11", map[string]string{":splat": "customer/2009/12/11"}},
+		{"/aa/*/bb", "/aa/2009/bb", map[string]string{":splat": "2009"}},
+		{"/cc/*/dd", "/cc/2009/11/dd", map[string]string{":splat": "2009/11"}},
+		{"/ee/:year/*/ff", "/ee/2009/11/ff", map[string]string{":year": "2009", ":splat": "11"}},
+		{"/thumbnail/:size/uploads/*", "/thumbnail/100x100/uploads/items/2014/04/20/dPRCdChkUd651t1Hvs18.jpg",
+			map[string]string{":size": "100x100", ":splat": "items/2014/04/20/dPRCdChkUd651t1Hvs18.jpg"}},
+		{"/*.*", "/nice/api.json", map[string]string{":path": "nice/api", ":ext": "json"}},
+		{"/:name/*.*", "/nice/api.json", map[string]string{":name": "nice", ":path": "api", ":ext": "json"}},
+		{"/:name/test/*.*", "/nice/test/api.json", map[string]string{":name": "nice", ":path": "api", ":ext": "json"}},
+		{"/dl/:width:int/:height:int/*.*", "/dl/48/48/05ac66d9bda00a3acf948c43e306fc9a.jpg",
+			map[string]string{":width": "48", ":height": "48", ":ext": "jpg", ":path": "05ac66d9bda00a3acf948c43e306fc9a"}},
+		{"/v1/shop/:id:int", "/v1/shop/123", map[string]string{":id": "123"}},
+		{"/:year:int/:month:int/:id/:endid", "/1111/111/aaa/aaa", map[string]string{":year": "1111", ":month": "111", ":id": "aaa", ":endid": "aaa"}},
+		{"/v1/shop/:id/:name", "/v1/shop/123/nike", map[string]string{":id": "123", ":name": "nike"}},
+		{"/v1/shop/:id/account", "/v1/shop/123/account", map[string]string{":id": "123"}},
+		{"/v1/shop/:name:string", "/v1/shop/nike", map[string]string{":name": "nike"}},
+		{"/v1/shop/:id([0-9]+)", "/v1/shop//123", map[string]string{":id": "123"}},
+		{"/v1/shop/:id([0-9]+)_:name", "/v1/shop/123_nike", map[string]string{":id": "123", ":name": "nike"}},
+		{"/v1/shop/:id(.+)_cms.html", "/v1/shop/123_cms.html", map[string]string{":id": "123"}},
+		{"/v1/shop/cms_:id(.+)_:page(.+).html", "/v1/shop/cms_123_1.html", map[string]string{":id": "123", ":page": "1"}},
+		{"/v1/:v/cms/aaa_:id(.+)_:page(.+).html", "/v1/2/cms/aaa_123_1.html", map[string]string{":v": "2", ":id": "123", ":page": "1"}},
+		{"/v1/:v/cms_:id(.+)_:page(.+).html", "/v1/2/cms_123_1.html", map[string]string{":v": "2", ":id": "123", ":page": "1"}},
+		{"/v1/:v(.+)_cms/ttt_:id(.+)_:page(.+).html", "/v1/2_cms/ttt_123_1.html", map[string]string{":v": "2", ":id": "123", ":page": "1"}},
+	}
+
+	Convey("Match routers in tree", t, func() {
+		for _, c := range cases {
+			t := NewTree()
+			t.AddRouter(c.pattern, nil)
+			_, params := t.Match(c.reqUrl)
+			if params != nil {
+				for k, v := range c.params {
+					vv, ok := params[k]
+					So(ok, ShouldBeTrue)
+					So(vv, ShouldEqual, v)
+				}
+			}
+		}
+	})
+}

Godeps/_workspace/src/github.com/codegangsta/cli/.travis.yml

@@ -0,0 +1,6 @@
+language: go
+go: 1.1
+
+script:
+- go vet ./...
+- go test -v ./...

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

@@ -0,0 +1,21 @@
+Copyright (C) 2013 Jeremy Saenz
+All Rights Reserved.
+
+MIT LICENSE
+
+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/cli/README.md

@@ -0,0 +1,285 @@
+[![Build Status](https://travis-ci.org/codegangsta/cli.png?branch=master)](https://travis-ci.org/codegangsta/cli)
+
+# cli.go
+cli.go is simple, fast, and fun package for building command line apps in Go. The goal is to enable developers to write fast and distributable command line applications in an expressive way.
+
+You can view the API docs here:
+http://godoc.org/github.com/codegangsta/cli
+
+## Overview
+Command line apps are usually so tiny that there is absolutely no reason why your code should *not* be self-documenting. Things like generating help text and parsing command flags/options should not hinder productivity when writing a command line app.
+
+**This is where cli.go comes into play.** cli.go makes command line programming fun, organized, and expressive!
+
+## Installation
+Make sure you have a working Go environment (go 1.1 is *required*). [See the install instructions](http://golang.org/doc/install.html).
+
+To install `cli.go`, simply run:
+```
+$ go get github.com/codegangsta/cli
+```
+
+Make sure your `PATH` includes to the `$GOPATH/bin` directory so your commands can be easily used:
+```
+export PATH=$PATH:$GOPATH/bin
+```
+
+## Getting Started
+One of the philosophies behind cli.go is that an API should be playful and full of discovery. So a cli.go app can be as little as one line of code in `main()`. 
+
+``` go
+package main
+
+import (
+  "os"
+  "github.com/codegangsta/cli"
+)
+
+func main() {
+  cli.NewApp().Run(os.Args)
+}
+```
+
+This app will run and show help text, but is not very useful. Let's give an action to execute and some help documentation:
+
+``` go
+package main
+
+import (
+  "os"
+  "github.com/codegangsta/cli"
+)
+
+func main() {
+  app := cli.NewApp()
+  app.Name = "boom"
+  app.Usage = "make an explosive entrance"
+  app.Action = func(c *cli.Context) {
+    println("boom! I say!")
+  }
+  
+  app.Run(os.Args)
+}
+```
+
+Running this already gives you a ton of functionality, plus support for things like subcommands and flags, which are covered below.
+
+## Example
+
+Being a programmer can be a lonely job. Thankfully by the power of automation that is not the case! Let's create a greeter app to fend off our demons of loneliness!
+
+Start by creating a directory named `greet`, and within it, add a file, `greet.go` with the following code in it:
+
+``` go
+package main
+
+import (
+  "os"
+  "github.com/codegangsta/cli"
+)
+
+func main() {
+  app := cli.NewApp()
+  app.Name = "greet"
+  app.Usage = "fight the loneliness!"
+  app.Action = func(c *cli.Context) {
+    println("Hello friend!")
+  }
+
+  app.Run(os.Args)
+}
+```
+
+Install our command to the `$GOPATH/bin` directory:
+
+```
+$ go install
+```
+
+Finally run our new command:
+
+```
+$ greet
+Hello friend!
+```
+
+cli.go also generates some bitchass help text:
+```
+$ greet help
+NAME:
+    greet - fight the loneliness!
+
+USAGE:
+    greet [global options] command [command options] [arguments...]
+
+VERSION:
+    0.0.0
+
+COMMANDS:
+    help, h  Shows a list of commands or help for one command
+
+GLOBAL OPTIONS
+    --version	Shows version information
+```
+
+### Arguments
+You can lookup arguments by calling the `Args` function on `cli.Context`.
+
+``` go
+...
+app.Action = func(c *cli.Context) {
+  println("Hello", c.Args()[0])
+}
+...
+```
+
+### Flags
+Setting and querying flags is simple.
+``` go
+...
+app.Flags = []cli.Flag {
+  cli.StringFlag{
+    Name: "lang",
+    Value: "english",
+    Usage: "language for the greeting",
+  },
+}
+app.Action = func(c *cli.Context) {
+  name := "someone"
+  if len(c.Args()) > 0 {
+    name = c.Args()[0]
+  }
+  if c.String("lang") == "spanish" {
+    println("Hola", name)
+  } else {
+    println("Hello", name)
+  }
+}
+...
+```
+
+#### Alternate Names
+
+You can set alternate (or short) names for flags by providing a comma-delimited list for the `Name`. e.g.
+
+``` go
+app.Flags = []cli.Flag {
+  cli.StringFlag{
+    Name: "lang, l",
+    Value: "english",
+    Usage: "language for the greeting",
+  },
+}
+```
+
+#### Values from the Environment
+
+You can also have the default value set from the environment via `EnvVar`.  e.g.
+
+``` go
+app.Flags = []cli.Flag {
+  cli.StringFlag{
+    Name: "lang, l",
+    Value: "english",
+    Usage: "language for the greeting",
+    EnvVar: "APP_LANG",
+  },
+}
+```
+
+That flag can then be set with `--lang spanish` or `-l spanish`. Note that giving two different forms of the same flag in the same command invocation is an error.
+
+### Subcommands
+
+Subcommands can be defined for a more git-like command line app.
+```go
+...
+app.Commands = []cli.Command{
+  {
+    Name:      "add",
+    ShortName: "a",
+    Usage:     "add a task to the list",
+    Action: func(c *cli.Context) {
+      println("added task: ", c.Args().First())
+    },
+  },
+  {
+    Name:      "complete",
+    ShortName: "c",
+    Usage:     "complete a task on the list",
+    Action: func(c *cli.Context) {
+      println("completed task: ", c.Args().First())
+    },
+  },
+  {
+    Name:      "template",
+    ShortName: "r",
+    Usage:     "options for task templates",
+    Subcommands: []cli.Command{
+      {
+        Name:  "add",
+        Usage: "add a new template",
+        Action: func(c *cli.Context) {
+            println("new task template: ", c.Args().First())
+        },
+      },
+      {
+        Name:  "remove",
+        Usage: "remove an existing template",
+        Action: func(c *cli.Context) {
+          println("removed task template: ", c.Args().First())
+        },
+      },
+    },
+  },     
+}
+...
+```
+
+### Bash Completion
+
+You can enable completion commands by setting the `EnableBashCompletion`
+flag on the `App` object.  By default, this setting will only auto-complete to
+show an app's subcommands, but you can write your own completion methods for
+the App or its subcommands.
+```go
+...
+var tasks = []string{"cook", "clean", "laundry", "eat", "sleep", "code"}
+app := cli.NewApp()
+app.EnableBashCompletion = true
+app.Commands = []cli.Command{
+  {
+    Name: "complete",
+    ShortName: "c",
+    Usage: "complete a task on the list",
+    Action: func(c *cli.Context) {
+       println("completed task: ", c.Args().First())
+    },
+    BashComplete: func(c *cli.Context) {
+      // This will complete if no args are passed
+      if len(c.Args()) > 0 {
+        return
+      }
+      for _, t := range tasks {
+        fmt.Println(t)
+      }
+    },
+  }
+}
+...
+```
+
+#### To Enable
+
+Source the `autocomplete/bash_autocomplete` file in your `.bashrc` file while
+setting the `PROG` variable to the name of your program:
+
+`PROG=myprogram source /.../cli/autocomplete/bash_autocomplete`
+
+
+## Contribution Guidelines
+Feel free to put up a pull request to fix a bug or maybe add a feature. I will give it a code review and make sure that it does not break backwards compatibility. If I or any other collaborators agree that it is in line with the vision of the project, we will work with you to get the code into a mergeable state and merge it into the master branch.
+
+If you are have contributed something significant to the project, I will most likely add you as a collaborator. As a collaborator you are given the ability to merge others pull requests. It is very important that new code does not break existing code, so be careful about what code you do choose to merge. If you have any questions feel free to link @codegangsta to the issue in question and we can review it together.
+
+If you feel like you have contributed to the project but have not yet been added as a collaborator, I probably forgot to add you. Hit @codegangsta up over email and we will get it figured out.

Godeps/_workspace/src/github.com/codegangsta/cli/app.go

@@ -0,0 +1,251 @@
+package cli
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"time"
+)
+
+// App is the main structure of a cli application. It is recomended that
+// and app be created with the cli.NewApp() function
+type App struct {
+	// The name of the program. Defaults to os.Args[0]
+	Name string
+	// Description of the program.
+	Usage string
+	// Version of the program
+	Version string
+	// List of commands to execute
+	Commands []Command
+	// List of flags to parse
+	Flags []Flag
+	// Boolean to enable bash completion commands
+	EnableBashCompletion bool
+	// Boolean to hide built-in help command
+	HideHelp bool
+	// Boolean to hide built-in version flag
+	HideVersion bool
+	// An action to execute when the bash-completion flag is set
+	BashComplete func(context *Context)
+	// An action to execute before any subcommands are run, but after the context is ready
+	// If a non-nil error is returned, no subcommands are run
+	Before func(context *Context) error
+	// The action to execute when no subcommands are specified
+	Action func(context *Context)
+	// Execute this function if the proper command cannot be found
+	CommandNotFound func(context *Context, command string)
+	// Compilation date
+	Compiled time.Time
+	// Author
+	Author string
+	// Author e-mail
+	Email string
+}
+
+// Tries to find out when this binary was compiled.
+// Returns the current time if it fails to find it.
+func compileTime() time.Time {
+	info, err := os.Stat(os.Args[0])
+	if err != nil {
+		return time.Now()
+	}
+	return info.ModTime()
+}
+
+// Creates a new cli Application with some reasonable defaults for Name, Usage, Version and Action.
+func NewApp() *App {
+	return &App{
+		Name:         os.Args[0],
+		Usage:        "A new cli application",
+		Version:      "0.0.0",
+		BashComplete: DefaultAppComplete,
+		Action:       helpCommand.Action,
+		Compiled:     compileTime(),
+	}
+}
+
+// Entry point to the cli app. Parses the arguments slice and routes to the proper flag/args combination
+func (a *App) Run(arguments []string) error {
+	// append help to commands
+	if a.Command(helpCommand.Name) == nil && !a.HideHelp {
+		a.Commands = append(a.Commands, helpCommand)
+		a.appendFlag(HelpFlag)
+	}
+
+	//append version/help flags
+	if a.EnableBashCompletion {
+		a.appendFlag(BashCompletionFlag)
+	}
+
+	if !a.HideVersion {
+		a.appendFlag(VersionFlag)
+	}
+
+	// parse flags
+	set := flagSet(a.Name, a.Flags)
+	set.SetOutput(ioutil.Discard)
+	err := set.Parse(arguments[1:])
+	nerr := normalizeFlags(a.Flags, set)
+	if nerr != nil {
+		fmt.Println(nerr)
+		context := NewContext(a, set, set)
+		ShowAppHelp(context)
+		fmt.Println("")
+		return nerr
+	}
+	context := NewContext(a, set, set)
+
+	if err != nil {
+		fmt.Printf("Incorrect Usage.\n\n")
+		ShowAppHelp(context)
+		fmt.Println("")
+		return err
+	}
+
+	if checkCompletions(context) {
+		return nil
+	}
+
+	if checkHelp(context) {
+		return nil
+	}
+
+	if checkVersion(context) {
+		return nil
+	}
+
+	if a.Before != nil {
+		err := a.Before(context)
+		if err != nil {
+			return err
+		}
+	}
+
+	args := context.Args()
+	if args.Present() {
+		name := args.First()
+		c := a.Command(name)
+		if c != nil {
+			return c.Run(context)
+		}
+	}
+
+	// Run default Action
+	a.Action(context)
+	return nil
+}
+
+// Another entry point to the cli app, takes care of passing arguments and error handling
+func (a *App) RunAndExitOnError() {
+	if err := a.Run(os.Args); err != nil {
+		os.Stderr.WriteString(fmt.Sprintln(err))
+		os.Exit(1)
+	}
+}
+
+// Invokes the subcommand given the context, parses ctx.Args() to generate command-specific flags
+func (a *App) RunAsSubcommand(ctx *Context) error {
+	// append help to commands
+	if len(a.Commands) > 0 {
+		if a.Command(helpCommand.Name) == nil && !a.HideHelp {
+			a.Commands = append(a.Commands, helpCommand)
+			a.appendFlag(HelpFlag)
+		}
+	}
+
+	// append flags
+	if a.EnableBashCompletion {
+		a.appendFlag(BashCompletionFlag)
+	}
+
+	// parse flags
+	set := flagSet(a.Name, a.Flags)
+	set.SetOutput(ioutil.Discard)
+	err := set.Parse(ctx.Args().Tail())
+	nerr := normalizeFlags(a.Flags, set)
+	context := NewContext(a, set, ctx.globalSet)
+
+	if nerr != nil {
+		fmt.Println(nerr)
+		if len(a.Commands) > 0 {
+			ShowSubcommandHelp(context)
+		} else {
+			ShowCommandHelp(ctx, context.Args().First())
+		}
+		fmt.Println("")
+		return nerr
+	}
+
+	if err != nil {
+		fmt.Printf("Incorrect Usage.\n\n")
+		ShowSubcommandHelp(context)
+		return err
+	}
+
+	if checkCompletions(context) {
+		return nil
+	}
+
+	if len(a.Commands) > 0 {
+		if checkSubcommandHelp(context) {
+			return nil
+		}
+	} else {
+		if checkCommandHelp(ctx, context.Args().First()) {
+			return nil
+		}
+	}
+
+	if a.Before != nil {
+		err := a.Before(context)
+		if err != nil {
+			return err
+		}
+	}
+
+	args := context.Args()
+	if args.Present() {
+		name := args.First()
+		c := a.Command(name)
+		if c != nil {
+			return c.Run(context)
+		}
+	}
+
+	// Run default Action
+	if len(a.Commands) > 0 {
+		a.Action(context)
+	} else {
+		a.Action(ctx)
+	}
+
+	return nil
+}
+
+// Returns the named command on App. Returns nil if the command does not exist
+func (a *App) Command(name string) *Command {
+	for _, c := range a.Commands {
+		if c.HasName(name) {
+			return &c
+		}
+	}
+
+	return nil
+}
+
+func (a *App) hasFlag(flag Flag) bool {
+	for _, f := range a.Flags {
+		if flag == f {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (a *App) appendFlag(flag Flag) {
+	if !a.hasFlag(flag) {
+		a.Flags = append(a.Flags, flag)
+	}
+}

Godeps/_workspace/src/github.com/codegangsta/cli/app_test.go

@@ -0,0 +1,423 @@
+package cli_test
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/codegangsta/cli"
+)
+
+func ExampleApp() {
+	// set args for examples sake
+	os.Args = []string{"greet", "--name", "Jeremy"}
+
+	app := cli.NewApp()
+	app.Name = "greet"
+	app.Flags = []cli.Flag{
+		cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
+	}
+	app.Action = func(c *cli.Context) {
+		fmt.Printf("Hello %v\n", c.String("name"))
+	}
+	app.Run(os.Args)
+	// Output:
+	// Hello Jeremy
+}
+
+func ExampleAppSubcommand() {
+	// set args for examples sake
+	os.Args = []string{"say", "hi", "english", "--name", "Jeremy"}
+	app := cli.NewApp()
+	app.Name = "say"
+	app.Commands = []cli.Command{
+		{
+			Name:        "hello",
+			ShortName:   "hi",
+			Usage:       "use it to see a description",
+			Description: "This is how we describe hello the function",
+			Subcommands: []cli.Command{
+				{
+					Name:        "english",
+					ShortName:   "en",
+					Usage:       "sends a greeting in english",
+					Description: "greets someone in english",
+					Flags: []cli.Flag{
+						cli.StringFlag{
+							Name:  "name",
+							Value: "Bob",
+							Usage: "Name of the person to greet",
+						},
+					},
+					Action: func(c *cli.Context) {
+						fmt.Println("Hello,", c.String("name"))
+					},
+				},
+			},
+		},
+	}
+
+	app.Run(os.Args)
+	// Output:
+	// Hello, Jeremy
+}
+
+func ExampleAppHelp() {
+	// set args for examples sake
+	os.Args = []string{"greet", "h", "describeit"}
+
+	app := cli.NewApp()
+	app.Name = "greet"
+	app.Flags = []cli.Flag{
+		cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
+	}
+	app.Commands = []cli.Command{
+		{
+			Name:        "describeit",
+			ShortName:   "d",
+			Usage:       "use it to see a description",
+			Description: "This is how we describe describeit the function",
+			Action: func(c *cli.Context) {
+				fmt.Printf("i like to describe things")
+			},
+		},
+	}
+	app.Run(os.Args)
+	// Output:
+	// NAME:
+	//    describeit - use it to see a description
+	//
+	// USAGE:
+	//    command describeit [arguments...]
+	//
+	// DESCRIPTION:
+	//    This is how we describe describeit the function
+}
+
+func ExampleAppBashComplete() {
+	// set args for examples sake
+	os.Args = []string{"greet", "--generate-bash-completion"}
+
+	app := cli.NewApp()
+	app.Name = "greet"
+	app.EnableBashCompletion = true
+	app.Commands = []cli.Command{
+		{
+			Name:        "describeit",
+			ShortName:   "d",
+			Usage:       "use it to see a description",
+			Description: "This is how we describe describeit the function",
+			Action: func(c *cli.Context) {
+				fmt.Printf("i like to describe things")
+			},
+		}, {
+			Name:        "next",
+			Usage:       "next example",
+			Description: "more stuff to see when generating bash completion",
+			Action: func(c *cli.Context) {
+				fmt.Printf("the next example")
+			},
+		},
+	}
+
+	app.Run(os.Args)
+	// Output:
+	// describeit
+	// d
+	// next
+	// help
+	// h
+}
+
+func TestApp_Run(t *testing.T) {
+	s := ""
+
+	app := cli.NewApp()
+	app.Action = func(c *cli.Context) {
+		s = s + c.Args().First()
+	}
+
+	err := app.Run([]string{"command", "foo"})
+	expect(t, err, nil)
+	err = app.Run([]string{"command", "bar"})
+	expect(t, err, nil)
+	expect(t, s, "foobar")
+}
+
+var commandAppTests = []struct {
+	name     string
+	expected bool
+}{
+	{"foobar", true},
+	{"batbaz", true},
+	{"b", true},
+	{"f", true},
+	{"bat", false},
+	{"nothing", false},
+}
+
+func TestApp_Command(t *testing.T) {
+	app := cli.NewApp()
+	fooCommand := cli.Command{Name: "foobar", ShortName: "f"}
+	batCommand := cli.Command{Name: "batbaz", ShortName: "b"}
+	app.Commands = []cli.Command{
+		fooCommand,
+		batCommand,
+	}
+
+	for _, test := range commandAppTests {
+		expect(t, app.Command(test.name) != nil, test.expected)
+	}
+}
+
+func TestApp_CommandWithArgBeforeFlags(t *testing.T) {
+	var parsedOption, firstArg string
+
+	app := cli.NewApp()
+	command := cli.Command{
+		Name: "cmd",
+		Flags: []cli.Flag{
+			cli.StringFlag{Name: "option", Value: "", Usage: "some option"},
+		},
+		Action: func(c *cli.Context) {
+			parsedOption = c.String("option")
+			firstArg = c.Args().First()
+		},
+	}
+	app.Commands = []cli.Command{command}
+
+	app.Run([]string{"", "cmd", "my-arg", "--option", "my-option"})
+
+	expect(t, parsedOption, "my-option")
+	expect(t, firstArg, "my-arg")
+}
+
+func TestApp_Float64Flag(t *testing.T) {
+	var meters float64
+
+	app := cli.NewApp()
+	app.Flags = []cli.Flag{
+		cli.Float64Flag{Name: "height", Value: 1.5, Usage: "Set the height, in meters"},
+	}
+	app.Action = func(c *cli.Context) {
+		meters = c.Float64("height")
+	}
+
+	app.Run([]string{"", "--height", "1.93"})
+	expect(t, meters, 1.93)
+}
+
+func TestApp_ParseSliceFlags(t *testing.T) {
+	var parsedOption, firstArg string
+	var parsedIntSlice []int
+	var parsedStringSlice []string
+
+	app := cli.NewApp()
+	command := cli.Command{
+		Name: "cmd",
+		Flags: []cli.Flag{
+			cli.IntSliceFlag{Name: "p", Value: &cli.IntSlice{}, Usage: "set one or more ip addr"},
+			cli.StringSliceFlag{Name: "ip", Value: &cli.StringSlice{}, Usage: "set one or more ports to open"},
+		},
+		Action: func(c *cli.Context) {
+			parsedIntSlice = c.IntSlice("p")
+			parsedStringSlice = c.StringSlice("ip")
+			parsedOption = c.String("option")
+			firstArg = c.Args().First()
+		},
+	}
+	app.Commands = []cli.Command{command}
+
+	app.Run([]string{"", "cmd", "my-arg", "-p", "22", "-p", "80", "-ip", "8.8.8.8", "-ip", "8.8.4.4"})
+
+	IntsEquals := func(a, b []int) bool {
+		if len(a) != len(b) {
+			return false
+		}
+		for i, v := range a {
+			if v != b[i] {
+				return false
+			}
+		}
+		return true
+	}
+
+	StrsEquals := func(a, b []string) bool {
+		if len(a) != len(b) {
+			return false
+		}
+		for i, v := range a {
+			if v != b[i] {
+				return false
+			}
+		}
+		return true
+	}
+	var expectedIntSlice = []int{22, 80}
+	var expectedStringSlice = []string{"8.8.8.8", "8.8.4.4"}
+
+	if !IntsEquals(parsedIntSlice, expectedIntSlice) {
+		t.Errorf("%v does not match %v", parsedIntSlice, expectedIntSlice)
+	}
+
+	if !StrsEquals(parsedStringSlice, expectedStringSlice) {
+		t.Errorf("%v does not match %v", parsedStringSlice, expectedStringSlice)
+	}
+}
+
+func TestApp_BeforeFunc(t *testing.T) {
+	beforeRun, subcommandRun := false, false
+	beforeError := fmt.Errorf("fail")
+	var err error
+
+	app := cli.NewApp()
+
+	app.Before = func(c *cli.Context) error {
+		beforeRun = true
+		s := c.String("opt")
+		if s == "fail" {
+			return beforeError
+		}
+
+		return nil
+	}
+
+	app.Commands = []cli.Command{
+		cli.Command{
+			Name: "sub",
+			Action: func(c *cli.Context) {
+				subcommandRun = true
+			},
+		},
+	}
+
+	app.Flags = []cli.Flag{
+		cli.StringFlag{Name: "opt"},
+	}
+
+	// run with the Before() func succeeding
+	err = app.Run([]string{"command", "--opt", "succeed", "sub"})
+
+	if err != nil {
+		t.Fatalf("Run error: %s", err)
+	}
+
+	if beforeRun == false {
+		t.Errorf("Before() not executed when expected")
+	}
+
+	if subcommandRun == false {
+		t.Errorf("Subcommand not executed when expected")
+	}
+
+	// reset
+	beforeRun, subcommandRun = false, false
+
+	// run with the Before() func failing
+	err = app.Run([]string{"command", "--opt", "fail", "sub"})
+
+	// should be the same error produced by the Before func
+	if err != beforeError {
+		t.Errorf("Run error expected, but not received")
+	}
+
+	if beforeRun == false {
+		t.Errorf("Before() not executed when expected")
+	}
+
+	if subcommandRun == true {
+		t.Errorf("Subcommand executed when NOT expected")
+	}
+
+}
+
+func TestAppHelpPrinter(t *testing.T) {
+	oldPrinter := cli.HelpPrinter
+	defer func() {
+		cli.HelpPrinter = oldPrinter
+	}()
+
+	var wasCalled = false
+	cli.HelpPrinter = func(template string, data interface{}) {
+		wasCalled = true
+	}
+
+	app := cli.NewApp()
+	app.Run([]string{"-h"})
+
+	if wasCalled == false {
+		t.Errorf("Help printer expected to be called, but was not")
+	}
+}
+
+func TestAppVersionPrinter(t *testing.T) {
+	oldPrinter := cli.VersionPrinter
+	defer func() {
+		cli.VersionPrinter = oldPrinter
+	}()
+
+	var wasCalled = false
+	cli.VersionPrinter = func(c *cli.Context) {
+		wasCalled = true
+	}
+
+	app := cli.NewApp()
+	ctx := cli.NewContext(app, nil, nil)
+	cli.ShowVersion(ctx)
+
+	if wasCalled == false {
+		t.Errorf("Version printer expected to be called, but was not")
+	}
+}
+
+func TestAppCommandNotFound(t *testing.T) {
+	beforeRun, subcommandRun := false, false
+	app := cli.NewApp()
+
+	app.CommandNotFound = func(c *cli.Context, command string) {
+		beforeRun = true
+	}
+
+	app.Commands = []cli.Command{
+		cli.Command{
+			Name: "bar",
+			Action: func(c *cli.Context) {
+				subcommandRun = true
+			},
+		},
+	}
+
+	app.Run([]string{"command", "foo"})
+
+	expect(t, beforeRun, true)
+	expect(t, subcommandRun, false)
+}
+
+func TestGlobalFlagsInSubcommands(t *testing.T) {
+	subcommandRun := false
+	app := cli.NewApp()
+
+	app.Flags = []cli.Flag{
+		cli.BoolFlag{Name: "debug, d", Usage: "Enable debugging"},
+	}
+
+	app.Commands = []cli.Command{
+		cli.Command{
+			Name: "foo",
+			Subcommands: []cli.Command{
+				{
+					Name: "bar",
+					Action: func(c *cli.Context) {
+						if c.GlobalBool("debug") {
+							subcommandRun = true
+						}
+					},
+				},
+			},
+		},
+	}
+
+	app.Run([]string{"command", "-d", "foo", "bar"})
+
+	expect(t, subcommandRun, true)
+}

Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/bash_autocomplete

@@ -0,0 +1,13 @@
+#! /bin/bash
+
+_cli_bash_autocomplete() {
+     local cur prev opts base
+     COMPREPLY=()
+     cur="${COMP_WORDS[COMP_CWORD]}"
+     prev="${COMP_WORDS[COMP_CWORD-1]}"
+     opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} --generate-bash-completion )
+     COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+     return 0
+ }
+  
+ complete -F _cli_bash_autocomplete $PROG

Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/zsh_autocomplete

@@ -0,0 +1,5 @@
+autoload -U compinit && compinit
+autoload -U bashcompinit && bashcompinit
+
+script_dir=$(dirname $0)
+source ${script_dir}/bash_autocomplete

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

@@ -0,0 +1,19 @@
+// Package cli provides a minimal framework for creating and organizing command line
+// Go applications. cli is designed to be easy to understand and write, the most simple
+// cli application can be written as follows:
+//   func main() {
+//     cli.NewApp().Run(os.Args)
+//   }
+//
+// Of course this application does not do much, so let's make this an actual application:
+//   func main() {
+//     app := cli.NewApp()
+//     app.Name = "greet"
+//     app.Usage = "say a greeting"
+//     app.Action = func(c *cli.Context) {
+//       println("Greetings")
+//     }
+//
+//     app.Run(os.Args)
+//   }
+package cli

Godeps/_workspace/src/github.com/codegangsta/cli/cli_test.go

@@ -0,0 +1,100 @@
+package cli_test
+
+import (
+	"os"
+
+	"github.com/codegangsta/cli"
+)
+
+func Example() {
+	app := cli.NewApp()
+	app.Name = "todo"
+	app.Usage = "task list on the command line"
+	app.Commands = []cli.Command{
+		{
+			Name:      "add",
+			ShortName: "a",
+			Usage:     "add a task to the list",
+			Action: func(c *cli.Context) {
+				println("added task: ", c.Args().First())
+			},
+		},
+		{
+			Name:      "complete",
+			ShortName: "c",
+			Usage:     "complete a task on the list",
+			Action: func(c *cli.Context) {
+				println("completed task: ", c.Args().First())
+			},
+		},
+	}
+
+	app.Run(os.Args)
+}
+
+func ExampleSubcommand() {
+	app := cli.NewApp()
+	app.Name = "say"
+	app.Commands = []cli.Command{
+		{
+			Name:        "hello",
+			ShortName:   "hi",
+			Usage:       "use it to see a description",
+			Description: "This is how we describe hello the function",
+			Subcommands: []cli.Command{
+				{
+					Name:        "english",
+					ShortName:   "en",
+					Usage:       "sends a greeting in english",
+					Description: "greets someone in english",
+					Flags: []cli.Flag{
+						cli.StringFlag{
+							Name:  "name",
+							Value: "Bob",
+							Usage: "Name of the person to greet",
+						},
+					},
+					Action: func(c *cli.Context) {
+						println("Hello, ", c.String("name"))
+					},
+				}, {
+					Name:      "spanish",
+					ShortName: "sp",
+					Usage:     "sends a greeting in spanish",
+					Flags: []cli.Flag{
+						cli.StringFlag{
+							Name:  "surname",
+							Value: "Jones",
+							Usage: "Surname of the person to greet",
+						},
+					},
+					Action: func(c *cli.Context) {
+						println("Hola, ", c.String("surname"))
+					},
+				}, {
+					Name:      "french",
+					ShortName: "fr",
+					Usage:     "sends a greeting in french",
+					Flags: []cli.Flag{
+						cli.StringFlag{
+							Name:  "nickname",
+							Value: "Stevie",
+							Usage: "Nickname of the person to greet",
+						},
+					},
+					Action: func(c *cli.Context) {
+						println("Bonjour, ", c.String("nickname"))
+					},
+				},
+			},
+		}, {
+			Name:  "bye",
+			Usage: "says goodbye",
+			Action: func(c *cli.Context) {
+				println("bye")
+			},
+		},
+	}
+
+	app.Run(os.Args)
+}

Godeps/_workspace/src/github.com/codegangsta/cli/command.go

@@ -0,0 +1,144 @@
+package cli
+
+import (
+	"fmt"
+	"io/ioutil"
+	"strings"
+)
+
+// Command is a subcommand for a cli.App.
+type Command struct {
+	// The name of the command
+	Name string
+	// short name of the command. Typically one character
+	ShortName string
+	// A short description of the usage of this command
+	Usage string
+	// A longer explanation of how the command works
+	Description string
+	// The function to call when checking for bash command completions
+	BashComplete func(context *Context)
+	// An action to execute before any sub-subcommands are run, but after the context is ready
+	// If a non-nil error is returned, no sub-subcommands are run
+	Before func(context *Context) error
+	// The function to call when this command is invoked
+	Action func(context *Context)
+	// List of child commands
+	Subcommands []Command
+	// List of flags to parse
+	Flags []Flag
+	// Treat all flags as normal arguments if true
+	SkipFlagParsing bool
+	// Boolean to hide built-in help command
+	HideHelp bool
+}
+
+// Invokes the command given the context, parses ctx.Args() to generate command-specific flags
+func (c Command) Run(ctx *Context) error {
+
+	if len(c.Subcommands) > 0 || c.Before != nil {
+		return c.startApp(ctx)
+	}
+
+	if !c.HideHelp {
+		// append help to flags
+		c.Flags = append(
+			c.Flags,
+			HelpFlag,
+		)
+	}
+
+	if ctx.App.EnableBashCompletion {
+		c.Flags = append(c.Flags, BashCompletionFlag)
+	}
+
+	set := flagSet(c.Name, c.Flags)
+	set.SetOutput(ioutil.Discard)
+
+	firstFlagIndex := -1
+	for index, arg := range ctx.Args() {
+		if strings.HasPrefix(arg, "-") {
+			firstFlagIndex = index
+			break
+		}
+	}
+
+	var err error
+	if firstFlagIndex > -1 && !c.SkipFlagParsing {
+		args := ctx.Args()
+		regularArgs := args[1:firstFlagIndex]
+		flagArgs := args[firstFlagIndex:]
+		err = set.Parse(append(flagArgs, regularArgs...))
+	} else {
+		err = set.Parse(ctx.Args().Tail())
+	}
+
+	if err != nil {
+		fmt.Printf("Incorrect Usage.\n\n")
+		ShowCommandHelp(ctx, c.Name)
+		fmt.Println("")
+		return err
+	}
+
+	nerr := normalizeFlags(c.Flags, set)
+	if nerr != nil {
+		fmt.Println(nerr)
+		fmt.Println("")
+		ShowCommandHelp(ctx, c.Name)
+		fmt.Println("")
+		return nerr
+	}
+	context := NewContext(ctx.App, set, ctx.globalSet)
+
+	if checkCommandCompletions(context, c.Name) {
+		return nil
+	}
+
+	if checkCommandHelp(context, c.Name) {
+		return nil
+	}
+	context.Command = c
+	c.Action(context)
+	return nil
+}
+
+// Returns true if Command.Name or Command.ShortName matches given name
+func (c Command) HasName(name string) bool {
+	return c.Name == name || c.ShortName == name
+}
+
+func (c Command) startApp(ctx *Context) error {
+	app := NewApp()
+
+	// set the name and usage
+	app.Name = fmt.Sprintf("%s %s", ctx.App.Name, c.Name)
+	if c.Description != "" {
+		app.Usage = c.Description
+	} else {
+		app.Usage = c.Usage
+	}
+
+	// set CommandNotFound
+	app.CommandNotFound = ctx.App.CommandNotFound
+
+	// set the flags and commands
+	app.Commands = c.Subcommands
+	app.Flags = c.Flags
+	app.HideHelp = c.HideHelp
+
+	// bash completion
+	app.EnableBashCompletion = ctx.App.EnableBashCompletion
+	if c.BashComplete != nil {
+		app.BashComplete = c.BashComplete
+	}
+
+	// set the actions
+	app.Before = c.Before
+	if c.Action != nil {
+		app.Action = c.Action
+	} else {
+		app.Action = helpSubcommand.Action
+	}
+
+	return app.RunAsSubcommand(ctx)
+}

Godeps/_workspace/src/github.com/codegangsta/cli/command_test.go

@@ -0,0 +1,49 @@
+package cli_test
+
+import (
+	"flag"
+	"testing"
+
+	"github.com/codegangsta/cli"
+)
+
+func TestCommandDoNotIgnoreFlags(t *testing.T) {
+	app := cli.NewApp()
+	set := flag.NewFlagSet("test", 0)
+	test := []string{"blah", "blah", "-break"}
+	set.Parse(test)
+
+	c := cli.NewContext(app, set, set)
+
+	command := cli.Command{
+		Name:        "test-cmd",
+		ShortName:   "tc",
+		Usage:       "this is for testing",
+		Description: "testing",
+		Action:      func(_ *cli.Context) {},
+	}
+	err := command.Run(c)
+
+	expect(t, err.Error(), "flag provided but not defined: -break")
+}
+
+func TestCommandIgnoreFlags(t *testing.T) {
+	app := cli.NewApp()
+	set := flag.NewFlagSet("test", 0)
+	test := []string{"blah", "blah"}
+	set.Parse(test)
+
+	c := cli.NewContext(app, set, set)
+
+	command := cli.Command{
+		Name:            "test-cmd",
+		ShortName:       "tc",
+		Usage:           "this is for testing",
+		Description:     "testing",
+		Action:          func(_ *cli.Context) {},
+		SkipFlagParsing: true,
+	}
+	err := command.Run(c)
+
+	expect(t, err, nil)
+}

Godeps/_workspace/src/github.com/codegangsta/cli/context.go

@@ -0,0 +1,339 @@
+package cli
+
+import (
+	"errors"
+	"flag"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Context is a type that is passed through to
+// each Handler action in a cli application. Context
+// can be used to retrieve context-specific Args and
+// parsed command-line options.
+type Context struct {
+	App            *App
+	Command        Command
+	flagSet        *flag.FlagSet
+	globalSet      *flag.FlagSet
+	setFlags       map[string]bool
+	globalSetFlags map[string]bool
+}
+
+// Creates a new context. For use in when invoking an App or Command action.
+func NewContext(app *App, set *flag.FlagSet, globalSet *flag.FlagSet) *Context {
+	return &Context{App: app, flagSet: set, globalSet: globalSet}
+}
+
+// Looks up the value of a local int flag, returns 0 if no int flag exists
+func (c *Context) Int(name string) int {
+	return lookupInt(name, c.flagSet)
+}
+
+// Looks up the value of a local time.Duration flag, returns 0 if no time.Duration flag exists
+func (c *Context) Duration(name string) time.Duration {
+	return lookupDuration(name, c.flagSet)
+}
+
+// Looks up the value of a local float64 flag, returns 0 if no float64 flag exists
+func (c *Context) Float64(name string) float64 {
+	return lookupFloat64(name, c.flagSet)
+}
+
+// Looks up the value of a local bool flag, returns false if no bool flag exists
+func (c *Context) Bool(name string) bool {
+	return lookupBool(name, c.flagSet)
+}
+
+// Looks up the value of a local boolT flag, returns false if no bool flag exists
+func (c *Context) BoolT(name string) bool {
+	return lookupBoolT(name, c.flagSet)
+}
+
+// Looks up the value of a local string flag, returns "" if no string flag exists
+func (c *Context) String(name string) string {
+	return lookupString(name, c.flagSet)
+}
+
+// Looks up the value of a local string slice flag, returns nil if no string slice flag exists
+func (c *Context) StringSlice(name string) []string {
+	return lookupStringSlice(name, c.flagSet)
+}
+
+// Looks up the value of a local int slice flag, returns nil if no int slice flag exists
+func (c *Context) IntSlice(name string) []int {
+	return lookupIntSlice(name, c.flagSet)
+}
+
+// Looks up the value of a local generic flag, returns nil if no generic flag exists
+func (c *Context) Generic(name string) interface{} {
+	return lookupGeneric(name, c.flagSet)
+}
+
+// Looks up the value of a global int flag, returns 0 if no int flag exists
+func (c *Context) GlobalInt(name string) int {
+	return lookupInt(name, c.globalSet)
+}
+
+// Looks up the value of a global time.Duration flag, returns 0 if no time.Duration flag exists
+func (c *Context) GlobalDuration(name string) time.Duration {
+	return lookupDuration(name, c.globalSet)
+}
+
+// Looks up the value of a global bool flag, returns false if no bool flag exists
+func (c *Context) GlobalBool(name string) bool {
+	return lookupBool(name, c.globalSet)
+}
+
+// Looks up the value of a global string flag, returns "" if no string flag exists
+func (c *Context) GlobalString(name string) string {
+	return lookupString(name, c.globalSet)
+}
+
+// Looks up the value of a global string slice flag, returns nil if no string slice flag exists
+func (c *Context) GlobalStringSlice(name string) []string {
+	return lookupStringSlice(name, c.globalSet)
+}
+
+// Looks up the value of a global int slice flag, returns nil if no int slice flag exists
+func (c *Context) GlobalIntSlice(name string) []int {
+	return lookupIntSlice(name, c.globalSet)
+}
+
+// Looks up the value of a global generic flag, returns nil if no generic flag exists
+func (c *Context) GlobalGeneric(name string) interface{} {
+	return lookupGeneric(name, c.globalSet)
+}
+
+// Determines if the flag was actually set
+func (c *Context) IsSet(name string) bool {
+	if c.setFlags == nil {
+		c.setFlags = make(map[string]bool)
+		c.flagSet.Visit(func(f *flag.Flag) {
+			c.setFlags[f.Name] = true
+		})
+	}
+	return c.setFlags[name] == true
+}
+
+// Determines if the global flag was actually set
+func (c *Context) GlobalIsSet(name string) bool {
+	if c.globalSetFlags == nil {
+		c.globalSetFlags = make(map[string]bool)
+		c.globalSet.Visit(func(f *flag.Flag) {
+			c.globalSetFlags[f.Name] = true
+		})
+	}
+	return c.globalSetFlags[name] == true
+}
+
+// Returns a slice of flag names used in this context.
+func (c *Context) FlagNames() (names []string) {
+	for _, flag := range c.Command.Flags {
+		name := strings.Split(flag.getName(), ",")[0]
+		if name == "help" {
+			continue
+		}
+		names = append(names, name)
+	}
+	return
+}
+
+// Returns a slice of global flag names used by the app.
+func (c *Context) GlobalFlagNames() (names []string) {
+	for _, flag := range c.App.Flags {
+		name := strings.Split(flag.getName(), ",")[0]
+		if name == "help" || name == "version" {
+			continue
+		}
+		names = append(names, name)
+	}
+	return
+}
+
+type Args []string
+
+// Returns the command line arguments associated with the context.
+func (c *Context) Args() Args {
+	args := Args(c.flagSet.Args())
+	return args
+}
+
+// Returns the nth argument, or else a blank string
+func (a Args) Get(n int) string {
+	if len(a) > n {
+		return a[n]
+	}
+	return ""
+}
+
+// Returns the first argument, or else a blank string
+func (a Args) First() string {
+	return a.Get(0)
+}
+
+// Return the rest of the arguments (not the first one)
+// or else an empty string slice
+func (a Args) Tail() []string {
+	if len(a) >= 2 {
+		return []string(a)[1:]
+	}
+	return []string{}
+}
+
+// Checks if there are any arguments present
+func (a Args) Present() bool {
+	return len(a) != 0
+}
+
+// Swaps arguments at the given indexes
+func (a Args) Swap(from, to int) error {
+	if from >= len(a) || to >= len(a) {
+		return errors.New("index out of range")
+	}
+	a[from], a[to] = a[to], a[from]
+	return nil
+}
+
+func lookupInt(name string, set *flag.FlagSet) int {
+	f := set.Lookup(name)
+	if f != nil {
+		val, err := strconv.Atoi(f.Value.String())
+		if err != nil {
+			return 0
+		}
+		return val
+	}
+
+	return 0
+}
+
+func lookupDuration(name string, set *flag.FlagSet) time.Duration {
+	f := set.Lookup(name)
+	if f != nil {
+		val, err := time.ParseDuration(f.Value.String())
+		if err == nil {
+			return val
+		}
+	}
+
+	return 0
+}
+
+func lookupFloat64(name string, set *flag.FlagSet) float64 {
+	f := set.Lookup(name)
+	if f != nil {
+		val, err := strconv.ParseFloat(f.Value.String(), 64)
+		if err != nil {
+			return 0
+		}
+		return val
+	}
+
+	return 0
+}
+
+func lookupString(name string, set *flag.FlagSet) string {
+	f := set.Lookup(name)
+	if f != nil {
+		return f.Value.String()
+	}
+
+	return ""
+}
+
+func lookupStringSlice(name string, set *flag.FlagSet) []string {
+	f := set.Lookup(name)
+	if f != nil {
+		return (f.Value.(*StringSlice)).Value()
+
+	}
+
+	return nil
+}
+
+func lookupIntSlice(name string, set *flag.FlagSet) []int {
+	f := set.Lookup(name)
+	if f != nil {
+		return (f.Value.(*IntSlice)).Value()
+
+	}
+
+	return nil
+}
+
+func lookupGeneric(name string, set *flag.FlagSet) interface{} {
+	f := set.Lookup(name)
+	if f != nil {
+		return f.Value
+	}
+	return nil
+}
+
+func lookupBool(name string, set *flag.FlagSet) bool {
+	f := set.Lookup(name)
+	if f != nil {
+		val, err := strconv.ParseBool(f.Value.String())
+		if err != nil {
+			return false
+		}
+		return val
+	}
+
+	return false
+}
+
+func lookupBoolT(name string, set *flag.FlagSet) bool {
+	f := set.Lookup(name)
+	if f != nil {
+		val, err := strconv.ParseBool(f.Value.String())
+		if err != nil {
+			return true
+		}
+		return val
+	}
+
+	return false
+}
+
+func copyFlag(name string, ff *flag.Flag, set *flag.FlagSet) {
+	switch ff.Value.(type) {
+	case *StringSlice:
+	default:
+		set.Set(name, ff.Value.String())
+	}
+}
+
+func normalizeFlags(flags []Flag, set *flag.FlagSet) error {
+	visited := make(map[string]bool)
+	set.Visit(func(f *flag.Flag) {
+		visited[f.Name] = true
+	})
+	for _, f := range flags {
+		parts := strings.Split(f.getName(), ",")
+		if len(parts) == 1 {
+			continue
+		}
+		var ff *flag.Flag
+		for _, name := range parts {
+			name = strings.Trim(name, " ")
+			if visited[name] {
+				if ff != nil {
+					return errors.New("Cannot use two forms of the same flag: " + name + " " + ff.Name)
+				}
+				ff = set.Lookup(name)
+			}
+		}
+		if ff == nil {
+			continue
+		}
+		for _, name := range parts {
+			name = strings.Trim(name, " ")
+			if !visited[name] {
+				copyFlag(name, ff, set)
+			}
+		}
+	}
+	return nil
+}

Godeps/_workspace/src/github.com/codegangsta/cli/context_test.go

@@ -0,0 +1,99 @@
+package cli_test
+
+import (
+	"flag"
+	"testing"
+	"time"
+
+	"github.com/codegangsta/cli"
+)
+
+func TestNewContext(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Int("myflag", 12, "doc")
+	globalSet := flag.NewFlagSet("test", 0)
+	globalSet.Int("myflag", 42, "doc")
+	command := cli.Command{Name: "mycommand"}
+	c := cli.NewContext(nil, set, globalSet)
+	c.Command = command
+	expect(t, c.Int("myflag"), 12)
+	expect(t, c.GlobalInt("myflag"), 42)
+	expect(t, c.Command.Name, "mycommand")
+}
+
+func TestContext_Int(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Int("myflag", 12, "doc")
+	c := cli.NewContext(nil, set, set)
+	expect(t, c.Int("myflag"), 12)
+}
+
+func TestContext_Duration(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Duration("myflag", time.Duration(12*time.Second), "doc")
+	c := cli.NewContext(nil, set, set)
+	expect(t, c.Duration("myflag"), time.Duration(12*time.Second))
+}
+
+func TestContext_String(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.String("myflag", "hello world", "doc")
+	c := cli.NewContext(nil, set, set)
+	expect(t, c.String("myflag"), "hello world")
+}
+
+func TestContext_Bool(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Bool("myflag", false, "doc")
+	c := cli.NewContext(nil, set, set)
+	expect(t, c.Bool("myflag"), false)
+}
+
+func TestContext_BoolT(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Bool("myflag", true, "doc")
+	c := cli.NewContext(nil, set, set)
+	expect(t, c.BoolT("myflag"), true)
+}
+
+func TestContext_Args(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Bool("myflag", false, "doc")
+	c := cli.NewContext(nil, set, set)
+	set.Parse([]string{"--myflag", "bat", "baz"})
+	expect(t, len(c.Args()), 2)
+	expect(t, c.Bool("myflag"), true)
+}
+
+func TestContext_IsSet(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Bool("myflag", false, "doc")
+	set.String("otherflag", "hello world", "doc")
+	globalSet := flag.NewFlagSet("test", 0)
+	globalSet.Bool("myflagGlobal", true, "doc")
+	c := cli.NewContext(nil, set, globalSet)
+	set.Parse([]string{"--myflag", "bat", "baz"})
+	globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"})
+	expect(t, c.IsSet("myflag"), true)
+	expect(t, c.IsSet("otherflag"), false)
+	expect(t, c.IsSet("bogusflag"), false)
+	expect(t, c.IsSet("myflagGlobal"), false)
+}
+
+func TestContext_GlobalIsSet(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Bool("myflag", false, "doc")
+	set.String("otherflag", "hello world", "doc")
+	globalSet := flag.NewFlagSet("test", 0)
+	globalSet.Bool("myflagGlobal", true, "doc")
+	globalSet.Bool("myflagGlobalUnset", true, "doc")
+	c := cli.NewContext(nil, set, globalSet)
+	set.Parse([]string{"--myflag", "bat", "baz"})
+	globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"})
+	expect(t, c.GlobalIsSet("myflag"), false)
+	expect(t, c.GlobalIsSet("otherflag"), false)
+	expect(t, c.GlobalIsSet("bogusflag"), false)
+	expect(t, c.GlobalIsSet("myflagGlobal"), true)
+	expect(t, c.GlobalIsSet("myflagGlobalUnset"), false)
+	expect(t, c.GlobalIsSet("bogusGlobal"), false)
+}

Godeps/_workspace/src/github.com/codegangsta/cli/flag.go

@@ -0,0 +1,410 @@
+package cli
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// This flag enables bash-completion for all commands and subcommands
+var BashCompletionFlag = BoolFlag{
+	Name: "generate-bash-completion",
+}
+
+// This flag prints the version for the application
+var VersionFlag = BoolFlag{
+	Name:  "version, v",
+	Usage: "print the version",
+}
+
+// This flag prints the help for all commands and subcommands
+var HelpFlag = BoolFlag{
+	Name:  "help, h",
+	Usage: "show help",
+}
+
+// Flag is a common interface related to parsing flags in cli.
+// For more advanced flag parsing techniques, it is recomended that
+// this interface be implemented.
+type Flag interface {
+	fmt.Stringer
+	// Apply Flag settings to the given flag set
+	Apply(*flag.FlagSet)
+	getName() string
+}
+
+func flagSet(name string, flags []Flag) *flag.FlagSet {
+	set := flag.NewFlagSet(name, flag.ContinueOnError)
+
+	for _, f := range flags {
+		f.Apply(set)
+	}
+	return set
+}
+
+func eachName(longName string, fn func(string)) {
+	parts := strings.Split(longName, ",")
+	for _, name := range parts {
+		name = strings.Trim(name, " ")
+		fn(name)
+	}
+}
+
+// Generic is a generic parseable type identified by a specific flag
+type Generic interface {
+	Set(value string) error
+	String() string
+}
+
+// GenericFlag is the flag type for types implementing Generic
+type GenericFlag struct {
+	Name   string
+	Value  Generic
+	Usage  string
+	EnvVar string
+}
+
+func (f GenericFlag) String() string {
+	return withEnvHint(f.EnvVar, fmt.Sprintf("%s%s %v\t`%v` %s", prefixFor(f.Name), f.Name, f.Value, "-"+f.Name+" option -"+f.Name+" option", f.Usage))
+}
+
+func (f GenericFlag) Apply(set *flag.FlagSet) {
+	val := f.Value
+	if f.EnvVar != "" {
+		if envVal := os.Getenv(f.EnvVar); envVal != "" {
+			val.Set(envVal)
+		}
+	}
+
+	eachName(f.Name, func(name string) {
+		set.Var(f.Value, name, f.Usage)
+	})
+}
+
+func (f GenericFlag) getName() string {
+	return f.Name
+}
+
+type StringSlice []string
+
+func (f *StringSlice) Set(value string) error {
+	*f = append(*f, value)
+	return nil
+}
+
+func (f *StringSlice) String() string {
+	return fmt.Sprintf("%s", *f)
+}
+
+func (f *StringSlice) Value() []string {
+	return *f
+}
+
+type StringSliceFlag struct {
+	Name   string
+	Value  *StringSlice
+	Usage  string
+	EnvVar string
+}
+
+func (f StringSliceFlag) String() string {
+	firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
+	pref := prefixFor(firstName)
+	return withEnvHint(f.EnvVar, fmt.Sprintf("%s '%v'\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
+}
+
+func (f StringSliceFlag) Apply(set *flag.FlagSet) {
+	if f.EnvVar != "" {
+		if envVal := os.Getenv(f.EnvVar); envVal != "" {
+			newVal := &StringSlice{}
+			for _, s := range strings.Split(envVal, ",") {
+				newVal.Set(s)
+			}
+			f.Value = newVal
+		}
+	}
+
+	eachName(f.Name, func(name string) {
+		set.Var(f.Value, name, f.Usage)
+	})
+}
+
+func (f StringSliceFlag) getName() string {
+	return f.Name
+}
+
+type IntSlice []int
+
+func (f *IntSlice) Set(value string) error {
+
+	tmp, err := strconv.Atoi(value)
+	if err != nil {
+		return err
+	} else {
+		*f = append(*f, tmp)
+	}
+	return nil
+}
+
+func (f *IntSlice) String() string {
+	return fmt.Sprintf("%d", *f)
+}
+
+func (f *IntSlice) Value() []int {
+	return *f
+}
+
+type IntSliceFlag struct {
+	Name   string
+	Value  *IntSlice
+	Usage  string
+	EnvVar string
+}
+
+func (f IntSliceFlag) String() string {
+	firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
+	pref := prefixFor(firstName)
+	return withEnvHint(f.EnvVar, fmt.Sprintf("%s '%v'\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
+}
+
+func (f IntSliceFlag) Apply(set *flag.FlagSet) {
+	if f.EnvVar != "" {
+		if envVal := os.Getenv(f.EnvVar); envVal != "" {
+			newVal := &IntSlice{}
+			for _, s := range strings.Split(envVal, ",") {
+				err := newVal.Set(s)
+				if err != nil {
+					fmt.Fprintf(os.Stderr, err.Error())
+				}
+			}
+			f.Value = newVal
+		}
+	}
+
+	eachName(f.Name, func(name string) {
+		set.Var(f.Value, name, f.Usage)
+	})
+}
+
+func (f IntSliceFlag) getName() string {
+	return f.Name
+}
+
+type BoolFlag struct {
+	Name   string
+	Usage  string
+	EnvVar string
+}
+
+func (f BoolFlag) String() string {
+	return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
+}
+
+func (f BoolFlag) Apply(set *flag.FlagSet) {
+	val := false
+	if f.EnvVar != "" {
+		if envVal := os.Getenv(f.EnvVar); envVal != "" {
+			envValBool, err := strconv.ParseBool(envVal)
+			if err == nil {
+				val = envValBool
+			}
+		}
+	}
+
+	eachName(f.Name, func(name string) {
+		set.Bool(name, val, f.Usage)
+	})
+}
+
+func (f BoolFlag) getName() string {
+	return f.Name
+}
+
+type BoolTFlag struct {
+	Name   string
+	Usage  string
+	EnvVar string
+}
+
+func (f BoolTFlag) String() string {
+	return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
+}
+
+func (f BoolTFlag) Apply(set *flag.FlagSet) {
+	val := true
+	if f.EnvVar != "" {
+		if envVal := os.Getenv(f.EnvVar); envVal != "" {
+			envValBool, err := strconv.ParseBool(envVal)
+			if err == nil {
+				val = envValBool
+			}
+		}
+	}
+
+	eachName(f.Name, func(name string) {
+		set.Bool(name, val, f.Usage)
+	})
+}
+
+func (f BoolTFlag) getName() string {
+	return f.Name
+}
+
+type StringFlag struct {
+	Name   string
+	Value  string
+	Usage  string
+	EnvVar string
+}
+
+func (f StringFlag) String() string {
+	var fmtString string
+	fmtString = "%s %v\t%v"
+
+	if len(f.Value) > 0 {
+		fmtString = "%s '%v'\t%v"
+	} else {
+		fmtString = "%s %v\t%v"
+	}
+
+	return withEnvHint(f.EnvVar, fmt.Sprintf(fmtString, prefixedNames(f.Name), f.Value, f.Usage))
+}
+
+func (f StringFlag) Apply(set *flag.FlagSet) {
+	if f.EnvVar != "" {
+		if envVal := os.Getenv(f.EnvVar); envVal != "" {
+			f.Value = envVal
+		}
+	}
+
+	eachName(f.Name, func(name string) {
+		set.String(name, f.Value, f.Usage)
+	})
+}
+
+func (f StringFlag) getName() string {
+	return f.Name
+}
+
+type IntFlag struct {
+	Name   string
+	Value  int
+	Usage  string
+	EnvVar string
+}
+
+func (f IntFlag) String() string {
+	return withEnvHint(f.EnvVar, fmt.Sprintf("%s '%v'\t%v", prefixedNames(f.Name), f.Value, f.Usage))
+}
+
+func (f IntFlag) Apply(set *flag.FlagSet) {
+	if f.EnvVar != "" {
+		if envVal := os.Getenv(f.EnvVar); envVal != "" {
+			envValInt, err := strconv.ParseUint(envVal, 10, 64)
+			if err == nil {
+				f.Value = int(envValInt)
+			}
+		}
+	}
+
+	eachName(f.Name, func(name string) {
+		set.Int(name, f.Value, f.Usage)
+	})
+}
+
+func (f IntFlag) getName() string {
+	return f.Name
+}
+
+type DurationFlag struct {
+	Name   string
+	Value  time.Duration
+	Usage  string
+	EnvVar string
+}
+
+func (f DurationFlag) String() string {
+	return withEnvHint(f.EnvVar, fmt.Sprintf("%s '%v'\t%v", prefixedNames(f.Name), f.Value, f.Usage))
+}
+
+func (f DurationFlag) Apply(set *flag.FlagSet) {
+	if f.EnvVar != "" {
+		if envVal := os.Getenv(f.EnvVar); envVal != "" {
+			envValDuration, err := time.ParseDuration(envVal)
+			if err == nil {
+				f.Value = envValDuration
+			}
+		}
+	}
+
+	eachName(f.Name, func(name string) {
+		set.Duration(name, f.Value, f.Usage)
+	})
+}
+
+func (f DurationFlag) getName() string {
+	return f.Name
+}
+
+type Float64Flag struct {
+	Name   string
+	Value  float64
+	Usage  string
+	EnvVar string
+}
+
+func (f Float64Flag) String() string {
+	return withEnvHint(f.EnvVar, fmt.Sprintf("%s '%v'\t%v", prefixedNames(f.Name), f.Value, f.Usage))
+}
+
+func (f Float64Flag) Apply(set *flag.FlagSet) {
+	if f.EnvVar != "" {
+		if envVal := os.Getenv(f.EnvVar); envVal != "" {
+			envValFloat, err := strconv.ParseFloat(envVal, 10)
+			if err == nil {
+				f.Value = float64(envValFloat)
+			}
+		}
+	}
+
+	eachName(f.Name, func(name string) {
+		set.Float64(name, f.Value, f.Usage)
+	})
+}
+
+func (f Float64Flag) getName() string {
+	return f.Name
+}
+
+func prefixFor(name string) (prefix string) {
+	if len(name) == 1 {
+		prefix = "-"
+	} else {
+		prefix = "--"
+	}
+
+	return
+}
+
+func prefixedNames(fullName string) (prefixed string) {
+	parts := strings.Split(fullName, ",")
+	for i, name := range parts {
+		name = strings.Trim(name, " ")
+		prefixed += prefixFor(name) + name
+		if i < len(parts)-1 {
+			prefixed += ", "
+		}
+	}
+	return
+}
+
+func withEnvHint(envVar, str string) string {
+	envText := ""
+	if envVar != "" {
+		envText = fmt.Sprintf(" [$%s]", envVar)
+	}
+	return str + envText
+}

Godeps/_workspace/src/github.com/codegangsta/cli/flag_test.go

@@ -0,0 +1,587 @@
+package cli_test
+
+import (
+	"fmt"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/codegangsta/cli"
+)
+
+var boolFlagTests = []struct {
+	name     string
+	expected string
+}{
+	{"help", "--help\t"},
+	{"h", "-h\t"},
+}
+
+func TestBoolFlagHelpOutput(t *testing.T) {
+
+	for _, test := range boolFlagTests {
+		flag := cli.BoolFlag{Name: test.name}
+		output := flag.String()
+
+		if output != test.expected {
+			t.Errorf("%s does not match %s", output, test.expected)
+		}
+	}
+}
+
+var stringFlagTests = []struct {
+	name     string
+	value    string
+	expected string
+}{
+	{"help", "", "--help \t"},
+	{"h", "", "-h \t"},
+	{"h", "", "-h \t"},
+	{"test", "Something", "--test 'Something'\t"},
+}
+
+func TestStringFlagHelpOutput(t *testing.T) {
+
+	for _, test := range stringFlagTests {
+		flag := cli.StringFlag{Name: test.name, Value: test.value}
+		output := flag.String()
+
+		if output != test.expected {
+			t.Errorf("%s does not match %s", output, test.expected)
+		}
+	}
+}
+
+func TestStringFlagWithEnvVarHelpOutput(t *testing.T) {
+
+	os.Setenv("APP_FOO", "derp")
+	for _, test := range stringFlagTests {
+		flag := cli.StringFlag{Name: test.name, Value: test.value, EnvVar: "APP_FOO"}
+		output := flag.String()
+
+		if !strings.HasSuffix(output, " [$APP_FOO]") {
+			t.Errorf("%s does not end with [$APP_FOO]", output)
+		}
+	}
+}
+
+var stringSliceFlagTests = []struct {
+	name     string
+	value    *cli.StringSlice
+	expected string
+}{
+	{"help", func() *cli.StringSlice {
+		s := &cli.StringSlice{}
+		s.Set("")
+		return s
+	}(), "--help '--help option --help option'\t"},
+	{"h", func() *cli.StringSlice {
+		s := &cli.StringSlice{}
+		s.Set("")
+		return s
+	}(), "-h '-h option -h option'\t"},
+	{"h", func() *cli.StringSlice {
+		s := &cli.StringSlice{}
+		s.Set("")
+		return s
+	}(), "-h '-h option -h option'\t"},
+	{"test", func() *cli.StringSlice {
+		s := &cli.StringSlice{}
+		s.Set("Something")
+		return s
+	}(), "--test '--test option --test option'\t"},
+}
+
+func TestStringSliceFlagHelpOutput(t *testing.T) {
+
+	for _, test := range stringSliceFlagTests {
+		flag := cli.StringSliceFlag{Name: test.name, Value: test.value}
+		output := flag.String()
+
+		if output != test.expected {
+			t.Errorf("%q does not match %q", output, test.expected)
+		}
+	}
+}
+
+func TestStringSliceFlagWithEnvVarHelpOutput(t *testing.T) {
+
+	os.Setenv("APP_QWWX", "11,4")
+	for _, test := range stringSliceFlagTests {
+		flag := cli.StringSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_QWWX"}
+		output := flag.String()
+
+		if !strings.HasSuffix(output, " [$APP_QWWX]") {
+			t.Errorf("%q does not end with [$APP_QWWX]", output)
+		}
+	}
+}
+
+var intFlagTests = []struct {
+	name     string
+	expected string
+}{
+	{"help", "--help '0'\t"},
+	{"h", "-h '0'\t"},
+}
+
+func TestIntFlagHelpOutput(t *testing.T) {
+
+	for _, test := range intFlagTests {
+		flag := cli.IntFlag{Name: test.name}
+		output := flag.String()
+
+		if output != test.expected {
+			t.Errorf("%s does not match %s", output, test.expected)
+		}
+	}
+}
+
+func TestIntFlagWithEnvVarHelpOutput(t *testing.T) {
+
+	os.Setenv("APP_BAR", "2")
+	for _, test := range intFlagTests {
+		flag := cli.IntFlag{Name: test.name, EnvVar: "APP_BAR"}
+		output := flag.String()
+
+		if !strings.HasSuffix(output, " [$APP_BAR]") {
+			t.Errorf("%s does not end with [$APP_BAR]", output)
+		}
+	}
+}
+
+var durationFlagTests = []struct {
+	name     string
+	expected string
+}{
+	{"help", "--help '0'\t"},
+	{"h", "-h '0'\t"},
+}
+
+func TestDurationFlagHelpOutput(t *testing.T) {
+
+	for _, test := range durationFlagTests {
+		flag := cli.DurationFlag{Name: test.name}
+		output := flag.String()
+
+		if output != test.expected {
+			t.Errorf("%s does not match %s", output, test.expected)
+		}
+	}
+}
+
+func TestDurationFlagWithEnvVarHelpOutput(t *testing.T) {
+
+	os.Setenv("APP_BAR", "2h3m6s")
+	for _, test := range durationFlagTests {
+		flag := cli.DurationFlag{Name: test.name, EnvVar: "APP_BAR"}
+		output := flag.String()
+
+		if !strings.HasSuffix(output, " [$APP_BAR]") {
+			t.Errorf("%s does not end with [$APP_BAR]", output)
+		}
+	}
+}
+
+var intSliceFlagTests = []struct {
+	name     string
+	value    *cli.IntSlice
+	expected string
+}{
+	{"help", &cli.IntSlice{}, "--help '--help option --help option'\t"},
+	{"h", &cli.IntSlice{}, "-h '-h option -h option'\t"},
+	{"h", &cli.IntSlice{}, "-h '-h option -h option'\t"},
+	{"test", func() *cli.IntSlice {
+		i := &cli.IntSlice{}
+		i.Set("9")
+		return i
+	}(), "--test '--test option --test option'\t"},
+}
+
+func TestIntSliceFlagHelpOutput(t *testing.T) {
+
+	for _, test := range intSliceFlagTests {
+		flag := cli.IntSliceFlag{Name: test.name, Value: test.value}
+		output := flag.String()
+
+		if output != test.expected {
+			t.Errorf("%q does not match %q", output, test.expected)
+		}
+	}
+}
+
+func TestIntSliceFlagWithEnvVarHelpOutput(t *testing.T) {
+
+	os.Setenv("APP_SMURF", "42,3")
+	for _, test := range intSliceFlagTests {
+		flag := cli.IntSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_SMURF"}
+		output := flag.String()
+
+		if !strings.HasSuffix(output, " [$APP_SMURF]") {
+			t.Errorf("%q does not end with [$APP_SMURF]", output)
+		}
+	}
+}
+
+var float64FlagTests = []struct {
+	name     string
+	expected string
+}{
+	{"help", "--help '0'\t"},
+	{"h", "-h '0'\t"},
+}
+
+func TestFloat64FlagHelpOutput(t *testing.T) {
+
+	for _, test := range float64FlagTests {
+		flag := cli.Float64Flag{Name: test.name}
+		output := flag.String()
+
+		if output != test.expected {
+			t.Errorf("%s does not match %s", output, test.expected)
+		}
+	}
+}
+
+func TestFloat64FlagWithEnvVarHelpOutput(t *testing.T) {
+
+	os.Setenv("APP_BAZ", "99.4")
+	for _, test := range float64FlagTests {
+		flag := cli.Float64Flag{Name: test.name, EnvVar: "APP_BAZ"}
+		output := flag.String()
+
+		if !strings.HasSuffix(output, " [$APP_BAZ]") {
+			t.Errorf("%s does not end with [$APP_BAZ]", output)
+		}
+	}
+}
+
+var genericFlagTests = []struct {
+	name     string
+	value    cli.Generic
+	expected string
+}{
+	{"help", &Parser{}, "--help <nil>\t`-help option -help option` "},
+	{"h", &Parser{}, "-h <nil>\t`-h option -h option` "},
+	{"test", &Parser{}, "--test <nil>\t`-test option -test option` "},
+}
+
+func TestGenericFlagHelpOutput(t *testing.T) {
+
+	for _, test := range genericFlagTests {
+		flag := cli.GenericFlag{Name: test.name}
+		output := flag.String()
+
+		if output != test.expected {
+			t.Errorf("%q does not match %q", output, test.expected)
+		}
+	}
+}
+
+func TestGenericFlagWithEnvVarHelpOutput(t *testing.T) {
+
+	os.Setenv("APP_ZAP", "3")
+	for _, test := range genericFlagTests {
+		flag := cli.GenericFlag{Name: test.name, EnvVar: "APP_ZAP"}
+		output := flag.String()
+
+		if !strings.HasSuffix(output, " [$APP_ZAP]") {
+			t.Errorf("%s does not end with [$APP_ZAP]", output)
+		}
+	}
+}
+
+func TestParseMultiString(t *testing.T) {
+	(&cli.App{
+		Flags: []cli.Flag{
+			cli.StringFlag{Name: "serve, s"},
+		},
+		Action: func(ctx *cli.Context) {
+			if ctx.String("serve") != "10" {
+				t.Errorf("main name not set")
+			}
+			if ctx.String("s") != "10" {
+				t.Errorf("short name not set")
+			}
+		},
+	}).Run([]string{"run", "-s", "10"})
+}
+
+func TestParseMultiStringFromEnv(t *testing.T) {
+	os.Setenv("APP_COUNT", "20")
+	(&cli.App{
+		Flags: []cli.Flag{
+			cli.StringFlag{Name: "count, c", EnvVar: "APP_COUNT"},
+		},
+		Action: func(ctx *cli.Context) {
+			if ctx.String("count") != "20" {
+				t.Errorf("main name not set")
+			}
+			if ctx.String("c") != "20" {
+				t.Errorf("short name not set")
+			}
+		},
+	}).Run([]string{"run"})
+}
+
+func TestParseMultiStringSlice(t *testing.T) {
+	(&cli.App{
+		Flags: []cli.Flag{
+			cli.StringSliceFlag{Name: "serve, s", Value: &cli.StringSlice{}},
+		},
+		Action: func(ctx *cli.Context) {
+			if !reflect.DeepEqual(ctx.StringSlice("serve"), []string{"10", "20"}) {
+				t.Errorf("main name not set")
+			}
+			if !reflect.DeepEqual(ctx.StringSlice("s"), []string{"10", "20"}) {
+				t.Errorf("short name not set")
+			}
+		},
+	}).Run([]string{"run", "-s", "10", "-s", "20"})
+}
+
+func TestParseMultiStringSliceFromEnv(t *testing.T) {
+	os.Setenv("APP_INTERVALS", "20,30,40")
+
+	(&cli.App{
+		Flags: []cli.Flag{
+			cli.StringSliceFlag{Name: "intervals, i", Value: &cli.StringSlice{}, EnvVar: "APP_INTERVALS"},
+		},
+		Action: func(ctx *cli.Context) {
+			if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) {
+				t.Errorf("main name not set from env")
+			}
+			if !reflect.DeepEqual(ctx.StringSlice("i"), []string{"20", "30", "40"}) {
+				t.Errorf("short name not set from env")
+			}
+		},
+	}).Run([]string{"run"})
+}
+
+func TestParseMultiInt(t *testing.T) {
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.IntFlag{Name: "serve, s"},
+		},
+		Action: func(ctx *cli.Context) {
+			if ctx.Int("serve") != 10 {
+				t.Errorf("main name not set")
+			}
+			if ctx.Int("s") != 10 {
+				t.Errorf("short name not set")
+			}
+		},
+	}
+	a.Run([]string{"run", "-s", "10"})
+}
+
+func TestParseMultiIntFromEnv(t *testing.T) {
+	os.Setenv("APP_TIMEOUT_SECONDS", "10")
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.IntFlag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
+		},
+		Action: func(ctx *cli.Context) {
+			if ctx.Int("timeout") != 10 {
+				t.Errorf("main name not set")
+			}
+			if ctx.Int("t") != 10 {
+				t.Errorf("short name not set")
+			}
+		},
+	}
+	a.Run([]string{"run"})
+}
+
+func TestParseMultiIntSlice(t *testing.T) {
+	(&cli.App{
+		Flags: []cli.Flag{
+			cli.IntSliceFlag{Name: "serve, s", Value: &cli.IntSlice{}},
+		},
+		Action: func(ctx *cli.Context) {
+			if !reflect.DeepEqual(ctx.IntSlice("serve"), []int{10, 20}) {
+				t.Errorf("main name not set")
+			}
+			if !reflect.DeepEqual(ctx.IntSlice("s"), []int{10, 20}) {
+				t.Errorf("short name not set")
+			}
+		},
+	}).Run([]string{"run", "-s", "10", "-s", "20"})
+}
+
+func TestParseMultiIntSliceFromEnv(t *testing.T) {
+	os.Setenv("APP_INTERVALS", "20,30,40")
+
+	(&cli.App{
+		Flags: []cli.Flag{
+			cli.IntSliceFlag{Name: "intervals, i", Value: &cli.IntSlice{}, EnvVar: "APP_INTERVALS"},
+		},
+		Action: func(ctx *cli.Context) {
+			if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) {
+				t.Errorf("main name not set from env")
+			}
+			if !reflect.DeepEqual(ctx.IntSlice("i"), []int{20, 30, 40}) {
+				t.Errorf("short name not set from env")
+			}
+		},
+	}).Run([]string{"run"})
+}
+
+func TestParseMultiFloat64(t *testing.T) {
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.Float64Flag{Name: "serve, s"},
+		},
+		Action: func(ctx *cli.Context) {
+			if ctx.Float64("serve") != 10.2 {
+				t.Errorf("main name not set")
+			}
+			if ctx.Float64("s") != 10.2 {
+				t.Errorf("short name not set")
+			}
+		},
+	}
+	a.Run([]string{"run", "-s", "10.2"})
+}
+
+func TestParseMultiFloat64FromEnv(t *testing.T) {
+	os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
+		},
+		Action: func(ctx *cli.Context) {
+			if ctx.Float64("timeout") != 15.5 {
+				t.Errorf("main name not set")
+			}
+			if ctx.Float64("t") != 15.5 {
+				t.Errorf("short name not set")
+			}
+		},
+	}
+	a.Run([]string{"run"})
+}
+
+func TestParseMultiBool(t *testing.T) {
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.BoolFlag{Name: "serve, s"},
+		},
+		Action: func(ctx *cli.Context) {
+			if ctx.Bool("serve") != true {
+				t.Errorf("main name not set")
+			}
+			if ctx.Bool("s") != true {
+				t.Errorf("short name not set")
+			}
+		},
+	}
+	a.Run([]string{"run", "--serve"})
+}
+
+func TestParseMultiBoolFromEnv(t *testing.T) {
+	os.Setenv("APP_DEBUG", "1")
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.BoolFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
+		},
+		Action: func(ctx *cli.Context) {
+			if ctx.Bool("debug") != true {
+				t.Errorf("main name not set from env")
+			}
+			if ctx.Bool("d") != true {
+				t.Errorf("short name not set from env")
+			}
+		},
+	}
+	a.Run([]string{"run"})
+}
+
+func TestParseMultiBoolT(t *testing.T) {
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.BoolTFlag{Name: "serve, s"},
+		},
+		Action: func(ctx *cli.Context) {
+			if ctx.BoolT("serve") != true {
+				t.Errorf("main name not set")
+			}
+			if ctx.BoolT("s") != true {
+				t.Errorf("short name not set")
+			}
+		},
+	}
+	a.Run([]string{"run", "--serve"})
+}
+
+func TestParseMultiBoolTFromEnv(t *testing.T) {
+	os.Setenv("APP_DEBUG", "0")
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.BoolTFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
+		},
+		Action: func(ctx *cli.Context) {
+			if ctx.BoolT("debug") != false {
+				t.Errorf("main name not set from env")
+			}
+			if ctx.BoolT("d") != false {
+				t.Errorf("short name not set from env")
+			}
+		},
+	}
+	a.Run([]string{"run"})
+}
+
+type Parser [2]string
+
+func (p *Parser) Set(value string) error {
+	parts := strings.Split(value, ",")
+	if len(parts) != 2 {
+		return fmt.Errorf("invalid format")
+	}
+
+	(*p)[0] = parts[0]
+	(*p)[1] = parts[1]
+
+	return nil
+}
+
+func (p *Parser) String() string {
+	return fmt.Sprintf("%s,%s", p[0], p[1])
+}
+
+func TestParseGeneric(t *testing.T) {
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.GenericFlag{Name: "serve, s", Value: &Parser{}},
+		},
+		Action: func(ctx *cli.Context) {
+			if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"10", "20"}) {
+				t.Errorf("main name not set")
+			}
+			if !reflect.DeepEqual(ctx.Generic("s"), &Parser{"10", "20"}) {
+				t.Errorf("short name not set")
+			}
+		},
+	}
+	a.Run([]string{"run", "-s", "10,20"})
+}
+
+func TestParseGenericFromEnv(t *testing.T) {
+	os.Setenv("APP_SERVE", "20,30")
+	a := cli.App{
+		Flags: []cli.Flag{
+			cli.GenericFlag{Name: "serve, s", Value: &Parser{}, EnvVar: "APP_SERVE"},
+		},
+		Action: func(ctx *cli.Context) {
+			if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"20", "30"}) {
+				t.Errorf("main name not set from env")
+			}
+			if !reflect.DeepEqual(ctx.Generic("s"), &Parser{"20", "30"}) {
+				t.Errorf("short name not set from env")
+			}
+		},
+	}
+	a.Run([]string{"run"})
+}