for release

bin/src/github.com/revel/modules/README.md

@@ -0,0 +1,7 @@
+modules
+=======
+
+Set of officially supported modules for Revel applications
+
+### Caution
+this is a work in progress

bin/src/github.com/revel/modules/auth/README.md

@@ -0,0 +1,6 @@
+modules/auth
+===============
+
+Basic user/auth module
+
+This should be modeled after [flask-security](https://github.com/mattupstate/flask-security)

bin/src/github.com/revel/modules/auth/auth.go

@@ -0,0 +1,78 @@
+package auth
+
+import (
+// "errors"
+)
+
+var (
+	Store StorageDriver
+)
+
+// Store = gormauth.NewGormAuthDriver()
+
+type UserAuth interface {
+	// getters/setters implemented by the app-level model
+	UserId() string
+	Secret() string
+	HashedSecret() string
+	SetHashedSecret(string)
+
+	SecretDriver
+	// // implemented by secret driver
+	// Authenticate() (bool, error)
+}
+
+type SecretDriver interface {
+	Authenticate() (bool, error)
+	HashSecret(args ...interface{}) (string, error)
+
+	// stuff for documentation
+	// UserContext is expected in these?
+
+	// Secret expects 0 or non-0 arguments
+	// When no parameter is passed, it acts as a getter
+	// When one or more parameters are passed, it acts as a setter
+	// A driver should specify the expected arguments and their meanings
+
+	// Register()
+	// Login()
+	// Logout()
+}
+
+type StorageDriver interface {
+	Save(user interface{}) error
+	// Load should take a partially filled struct
+	// (with values needed to look up)
+	// and fills in the rest
+	Load(user interface{}) error
+}
+
+// func init() {
+// 	// auth.Store = gorm...
+// }
+
+// func (c App) Login(email, password string) {
+
+// 	u := User {
+// 		Email ...
+// 	}
+
+// 	good, err := auth.Authenticate(email, password)
+
+// 	user, err := user_info.GetUserByEmail(email)
+// }
+
+// Bycrypt Authenticate() expects a single string argument of the plaintext password
+// It returns true on success and false if error or password mismatch
+// func Authenticate(attemptedUser UserAuth) (bool, error) {
+// 	// check user in Store
+// 	loadedUser, err := Store.Load(attemptedUser.UserId())
+// 	if err != nil {
+// 		return false, errors.New("User Not Found")
+// 	}
+
+// 	loadedUser.Authenticate(attemptedUser.Secret())
+
+// 	// successfully authenticated
+// 	return true, nil
+// }

bin/src/github.com/revel/modules/auth/auth_test.go

@@ -0,0 +1,134 @@
+package auth_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/revel/modules/auth"
+	"github.com/revel/modules/auth/driver/secret"
+)
+
+type User struct {
+	email    string
+	password string
+	hashpass string
+
+	secret.BcryptAuth // SecurityDriver for testing
+}
+
+func NewUser(email, pass string) *User {
+	u := &User{
+		email:    email,
+		password: pass,
+	}
+	u.UserContext = u
+	return u
+}
+
+func (self *User) UserId() string {
+	return self.email
+}
+
+func (self *User) Secret() string {
+	return self.password
+}
+
+func (self *User) HashedSecret() string {
+	return self.hashpass
+}
+
+func (self *User) SetHashedSecret(hpass string) {
+	self.hashpass = hpass
+}
+
+// func (self *User) Load() string
+
+type TestStore struct {
+	data map[string]string
+}
+
+func (self *TestStore) Save(user interface{}) error {
+	u, ok := user.(*User)
+	if !ok {
+		return errors.New("TestStore.Save() expected arg of type User")
+	}
+
+	hPass, err := u.HashSecret(u.Secret())
+	if err != nil {
+		return err
+	}
+	self.data[u.UserId()] = hPass
+
+	return nil
+}
+func (self *TestStore) Load(user interface{}) error {
+	u, ok := user.(*User)
+	if !ok {
+		return errors.New("TestStore.Load() expected arg of type User")
+	}
+
+	hpass, ok := self.data[u.UserId()]
+	if !ok {
+		return errors.New("Record Not Found")
+	}
+	u.SetHashedSecret(hpass)
+	return nil
+}
+
+func TestPasswordHash(t *testing.T) {
+	auth.Store = &TestStore{
+		data: make(map[string]string),
+	}
+	u := NewUser("demo@domain.com", "demopass")
+	fail := NewUser("demo@domain.com", "")
+
+	var err error
+	u.hashpass, err = u.HashSecret(u.password)
+	if err != nil {
+		t.Errorf("Should have hashed password, get error: %v\n", err)
+	}
+	fail.hashpass, err = fail.HashSecret(fail.password)
+	if err == nil {
+		t.Errorf("Should have failed hashing\n")
+	}
+}
+
+func TestAuthenticate(t *testing.T) {
+	auth.Store = &TestStore{
+		data: make(map[string]string),
+	}
+
+	// user registered a long time ago
+	u := NewUser("demo@domain.com", "demopass")
+	err := auth.Store.Save(u)
+	if err != nil {
+		t.Errorf("Should have saved user: %v", err)
+	}
+
+	// users now logging in
+	pass := NewUser("demo@domain.com", "demopass")
+	fail := NewUser("demo@domain.com", "invalid")
+
+	// valid user is now trying to login
+	// check user in DB
+	err = auth.Store.Load(pass)
+	if err != nil {
+		t.Errorf("Should have loaded pass user: %v\n", err)
+	}
+	// check credentials
+	ok, err := pass.Authenticate()
+	if !ok || err != nil {
+		t.Errorf("Should have authenticated user")
+	}
+
+	// invalid user is now trying to login
+	err = auth.Store.Load(fail)
+	if err != nil {
+		t.Errorf("Should have loaded fail user")
+	}
+	// this should fail
+	ok, err = fail.Authenticate()
+	if ok || err != nil {
+		t.Errorf("Should have failed to authenticate user: %v\n", err)
+	}
+}

bin/src/github.com/revel/modules/auth/doc.go

@@ -0,0 +1,27 @@
+/*	A basic user authentication module for Revel
+
+ list of concerns:
+- Separating out the interface and driver
+- Removing DB/Storage dependency
+- UUID as default identifier?
+- how to deal with password/secret or generally, method of authorization
+- default {views,controllers,routes} for register/login/logut ?
+- reset password in most basic ?
+- activation (and other features) in a second / more sophisticated driver
+- filter for checking that user is authenticated
+
+
+I think a driver is made up of 2 parts
+data prep and data storage
+register and password reset are part of data prep
+as is the auth hash method
+they don't care how the data is stored
+
+then there is the data store
+
+perhaps each auth user model should instantiate 2 drivers instead of 1?
+one for data prep components and one for storage
+so the security driver and the storage driver
+
+*/
+package auth

bin/src/github.com/revel/modules/auth/driver/secret/bcrypt.go

@@ -0,0 +1,73 @@
+package secret
+
+import (
+	"errors"
+
+	"golang.org/x/crypto/bcrypt"
+	"github.com/revel/modules/auth"
+)
+
+// example implementation of a Revel auth security driver
+// This driver should be embedded into your app-level User model
+// It expects your User model to have `Password` and `HashedPassword` string fields
+//
+// Your User model also needs to set itself as the UserContext for the BcryptAuth driver
+//
+// func NewUser(email, pass string) *User {
+// 	u := &User{
+// 		email:    email,
+// 		password: pass,
+// 	}
+// 	u.UserContext = u
+// }
+//
+type BcryptAuth struct {
+	UserContext auth.UserAuth
+}
+
+// Bcrypt Secret() returns the hashed version of the password.
+// It expects an argument of type string, which is the plain text password
+func (self *BcryptAuth) HashSecret(args ...interface{}) (string, error) {
+	if auth.Store == nil {
+		return "", errors.New("Auth module StorageDriver not set")
+	}
+	argLen := len(args)
+	if argLen == 0 {
+		// we are getting
+		return string(self.UserContext.HashedSecret()), nil
+	}
+
+	if argLen == 1 {
+		// we are setting
+		password, ok := args[0].(string)
+		if !ok {
+			return "", errors.New("Wrong argument type provided, expected plaintext password as string")
+		}
+		hPass, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
+		if err != nil {
+			return "", err
+		}
+
+		self.UserContext.SetHashedSecret(string(hPass))
+		return self.UserContext.HashedSecret(), nil
+	}
+
+	// bad argument count
+	return "", errors.New("Too many arguments provided, expected one")
+}
+
+// Bycrypt Authenticate() expects a single string argument of the plaintext password
+// It returns true on success and false if error or password mismatch
+func (self *BcryptAuth) Authenticate() (bool, error) {
+	// check password
+	err := bcrypt.CompareHashAndPassword([]byte(self.UserContext.HashedSecret()), []byte(self.UserContext.Secret()))
+	if err == bcrypt.ErrMismatchedHashAndPassword {
+		return false, nil
+	}
+	if err != nil {
+		return false, err
+	}
+
+	// successfully authenticated
+	return true, nil
+}

bin/src/github.com/revel/modules/auth/driver/storage/mysql/README.md

@@ -0,0 +1,3 @@
+Mysql Auth driver
+==================
+

bin/src/github.com/revel/modules/auth/driver/storage/postgres/README.md

@@ -0,0 +1,3 @@
+Postgresql Auth driver
+==================
+

bin/src/github.com/revel/modules/auth/driver/storage/sqlite/README.md

@@ -0,0 +1,3 @@
+Sqlite Auth driver
+==================
+

bin/src/github.com/revel/modules/auth/user.go

@@ -0,0 +1,17 @@
+package auth
+
+// var storageDriver auth.StorageDriver // postgres in example
+
+// type AuthUserModel struct {
+// 	userId   string
+// 	security *SecurityDriver // bcrypt in example
+
+// }
+
+// func (self *AuthUserModel) UserId() string {
+// 	return self.userId
+// }
+
+// func (self *AuthUserModel) Secret() string {
+// 	return self.security.Secret()
+// }

bin/src/github.com/revel/modules/csrf/app/csrf.go

@@ -0,0 +1,121 @@
+package csrf
+
+import (
+	"crypto/rand"
+	"crypto/subtle"
+	"encoding/hex"
+	"html/template"
+	"io"
+	"math"
+	"net/url"
+
+	"github.com/revel/revel"
+)
+
+// allowMethods are HTTP methods that do NOT require a token
+var allowedMethods = map[string]bool{
+	"GET":     true,
+	"HEAD":    true,
+	"OPTIONS": true,
+	"TRACE":   true,
+}
+
+func RandomString(length int) (string, error) {
+	buffer := make([]byte, int(math.Ceil(float64(length)/2)))
+	if _, err := io.ReadFull(rand.Reader, buffer); err != nil {
+		return "", nil
+	}
+	str := hex.EncodeToString(buffer)
+	return str[:length], nil
+}
+
+func RefreshToken(c *revel.Controller) {
+	token, err := RandomString(64)
+	if err != nil {
+		panic(err)
+	}
+	c.Session["csrf_token"] = token
+}
+
+// CsrfFilter enables CSRF request token creation and verification.
+//
+// Usage:
+//  1) Add `csrf.CsrfFilter` to the app's filters (it must come after the revel.SessionFilter).
+//  2) Add CSRF fields to a form with the template tag `{{ csrftoken . }}`. The filter adds a function closure to the `RenderArgs` that can pull out the secret and make the token as-needed, caching the value in the request. Ajax support provided through the `X-CSRFToken` header.
+func CsrfFilter(c *revel.Controller, fc []revel.Filter) {
+	token, foundToken := c.Session["csrf_token"]
+
+	if !foundToken {
+		RefreshToken(c)
+	}
+
+	referer, refErr := url.Parse(c.Request.Header.Get("Referer"))
+	isSameOrigin := sameOrigin(c.Request.URL, referer)
+
+	// If the Request method isn't in the white listed methods
+	if !allowedMethods[c.Request.Method] && !IsExempt(c) {
+		// Token wasn't present at all
+		if !foundToken {
+			c.Result = c.Forbidden("REVEL CSRF: Session token missing.")
+			return
+		}
+
+		// Referer header is invalid
+		if refErr != nil {
+			c.Result = c.Forbidden("REVEL CSRF: HTTP Referer malformed.")
+			return
+		}
+
+		// Same origin
+		if !isSameOrigin {
+			c.Result = c.Forbidden("REVEL CSRF: Same origin mismatch.")
+			return
+		}
+
+		var requestToken string
+		// First check for token in post data
+		if c.Request.Method == "POST" {
+			requestToken = c.Request.FormValue("csrftoken")
+		}
+
+		// Then check for token in custom headers, as with AJAX
+		if requestToken == "" {
+			requestToken = c.Request.Header.Get("X-CSRFToken")
+		}
+
+		if requestToken == "" || !compareToken(requestToken, token) {
+			c.Result = c.Forbidden("REVEL CSRF: Invalid token.")
+			return
+		}
+	}
+
+	fc[0](c, fc[1:])
+
+	// Only add token to RenderArgs if the request is: not AJAX, not missing referer header, and is same origin.
+	if c.Request.Header.Get("X-CSRFToken") == "" && isSameOrigin {
+		c.RenderArgs["_csrftoken"] = token
+	}
+}
+
+func compareToken(requestToken, token string) bool {
+	// ConstantTimeCompare will panic if the []byte aren't the same length
+	if len(requestToken) != len(token) {
+		return false
+	}
+	return subtle.ConstantTimeCompare([]byte(requestToken), []byte(token)) == 1
+}
+
+// Validates same origin policy
+func sameOrigin(u1, u2 *url.URL) bool {
+	return u1.Scheme == u2.Scheme && u1.Host == u2.Host
+}
+
+func init() {
+	revel.TemplateFuncs["csrftoken"] = func(renderArgs map[string]interface{}) template.HTML {
+		if tokenFunc, ok := renderArgs["_csrftoken"]; !ok {
+			panic("REVEL CSRF: _csrftoken missing from RenderArgs.")
+		} else {
+			return template.HTML(tokenFunc.(func() string)())
+		}
+	}
+}

bin/src/github.com/revel/modules/csrf/app/csrf_test.go

@@ -0,0 +1,169 @@
+package csrf
+
+import (
+	"bytes"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strconv"
+	"testing"
+
+	"github.com/revel/revel"
+)
+
+var testFilters = []revel.Filter{
+	CsrfFilter,
+	func(c *revel.Controller, fc []revel.Filter) {
+		c.RenderHtml("{{ csrftoken . }}")
+	},
+}
+
+func TestTokenInSession(t *testing.T) {
+	resp := httptest.NewRecorder()
+	getRequest, _ := http.NewRequest("GET", "http://www.example.com/", nil)
+	c := revel.NewController(revel.NewRequest(getRequest), revel.NewResponse(resp))
+	c.Session = make(revel.Session)
+
+	testFilters[0](c, testFilters)
+
+	if _, ok := c.Session["csrf_token"]; !ok {
+		t.Fatal("token should be present in session")
+	}
+}
+
+func TestPostWithoutToken(t *testing.T) {
+	resp := httptest.NewRecorder()
+	postRequest, _ := http.NewRequest("POST", "http://www.example.com/", nil)
+	c := revel.NewController(revel.NewRequest(postRequest), revel.NewResponse(resp))
+	c.Session = make(revel.Session)
+
+	testFilters[0](c, testFilters)
+
+	if c.Response.Status != 403 {
+		t.Fatal("post without token should be forbidden")
+	}
+}
+
+func TestNoReferrer(t *testing.T) {
+	resp := httptest.NewRecorder()
+	postRequest, _ := http.NewRequest("POST", "http://www.example.com/", nil)
+
+	c := revel.NewController(revel.NewRequest(postRequest), revel.NewResponse(resp))
+	c.Session = make(revel.Session)
+
+	RefreshToken(c)
+	token := c.Session["csrf_token"]
+
+	// make a new request with the token
+	data := url.Values{}
+	data.Set("csrftoken", token)
+	formPostRequest, _ := http.NewRequest("POST", "http://www.example.com/", bytes.NewBufferString(data.Encode()))
+	formPostRequest.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+	formPostRequest.Header.Add("Content-Length", strconv.Itoa(len(data.Encode())))
+
+	// and replace the old request
+	c.Request = revel.NewRequest(formPostRequest)
+
+	testFilters[0](c, testFilters)
+
+	if c.Response.Status != 403 {
+		t.Fatal("post without referer should be forbidden")
+	}
+}
+
+func TestRefererHttps(t *testing.T) {
+	resp := httptest.NewRecorder()
+	postRequest, _ := http.NewRequest("POST", "http://www.example.com/", nil)
+	c := revel.NewController(revel.NewRequest(postRequest), revel.NewResponse(resp))
+
+	c.Session = make(revel.Session)
+
+	RefreshToken(c)
+	token := c.Session["csrf_token"]
+
+	// make a new request with the token
+	data := url.Values{}
+	data.Set("csrftoken", token)
+	formPostRequest, _ := http.NewRequest("POST", "https://www.example.com/", bytes.NewBufferString(data.Encode()))
+	formPostRequest.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+	formPostRequest.Header.Add("Content-Length", strconv.Itoa(len(data.Encode())))
+	formPostRequest.Header.Add("Referer", "http://www.example.com/")
+
+	// and replace the old request
+	c.Request = revel.NewRequest(formPostRequest)
+
+	testFilters[0](c, testFilters)
+
+	if c.Response.Status != 403 {
+		t.Fatal("posts to https should have an https referer")
+	}
+}
+
+func TestHeaderWithToken(t *testing.T) {
+	resp := httptest.NewRecorder()
+	postRequest, _ := http.NewRequest("POST", "http://www.example.com/", nil)
+	c := revel.NewController(revel.NewRequest(postRequest), revel.NewResponse(resp))
+
+	c.Session = make(revel.Session)
+
+	RefreshToken(c)
+	token := c.Session["csrf_token"]
+
+	// make a new request with the token
+	formPostRequest, _ := http.NewRequest("POST", "http://www.example.com/", nil)
+	formPostRequest.Header.Add("X-CSRFToken", token)
+	formPostRequest.Header.Add("Referer", "http://www.example.com/")
+
+	// and replace the old request
+	c.Request = revel.NewRequest(formPostRequest)
+
+	testFilters[0](c, testFilters)
+
+	if c.Response.Status == 403 {
+		t.Fatal("post with http header token should be allowed")
+	}
+}
+
+func TestFormPostWithToken(t *testing.T) {
+	resp := httptest.NewRecorder()
+	postRequest, _ := http.NewRequest("POST", "http://www.example.com/", nil)
+	c := revel.NewController(revel.NewRequest(postRequest), revel.NewResponse(resp))
+
+	c.Session = make(revel.Session)
+
+	RefreshToken(c)
+	token := c.Session["csrf_token"]
+
+	// make a new request with the token
+	data := url.Values{}
+	data.Set("csrftoken", token)
+	formPostRequest, _ := http.NewRequest("POST", "http://www.example.com/", bytes.NewBufferString(data.Encode()))
+	formPostRequest.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+	formPostRequest.Header.Add("Content-Length", strconv.Itoa(len(data.Encode())))
+	formPostRequest.Header.Add("Referer", "http://www.example.com/")
+
+	// and replace the old request
+	c.Request = revel.NewRequest(formPostRequest)
+
+	testFilters[0](c, testFilters)
+
+	if c.Response.Status == 403 {
+		t.Fatal("form post with token should be allowed")
+	}
+}
+
+func TestNoTokenInArgsWhenCORs(t *testing.T) {
+	resp := httptest.NewRecorder()
+
+	getRequest, _ := http.NewRequest("GET", "http://www.example1.com/", nil)
+	getRequest.Header.Add("Referer", "http://www.example2.com/")
+
+	c := revel.NewController(revel.NewRequest(getRequest), revel.NewResponse(resp))
+	c.Session = make(revel.Session)
+
+	testFilters[0](c, testFilters)
+
+	if _, ok := c.RenderArgs["_csrftoken"]; ok {
+		t.Fatal("RenderArgs should not contain token when not same origin")
+	}
+}

bin/src/github.com/revel/modules/csrf/app/exempt.go

@@ -0,0 +1,36 @@
+package csrf
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/revel/revel"
+)
+
+var (
+	exemptPath   = make(map[string]bool)
+	exemptAction = make(map[string]bool)
+)
+
+func MarkExempt(route string) {
+	if strings.HasPrefix(route, "/") {
+		// e.g. "/controller/action"
+		exemptPath[strings.ToLower(route)] = true
+	} else if routeParts := strings.Split(route, "."); len(routeParts) == 2 {
+		// e.g. "ControllerName.ActionName"
+		exemptAction[route] = true
+	} else {
+		err := fmt.Sprintf("csrf.MarkExempt() received invalid argument \"%v\". Either provide a path prefixed with \"/\" or controller action in the form of \"ControllerName.ActionName\".", route)
+		panic(err)
+	}
+}
+
+func IsExempt(c *revel.Controller) bool {
+	if _, ok := exemptPath[strings.ToLower(c.Request.Request.URL.Path)]; ok {
+		return true
+	} else if _, ok := exemptAction[c.Action]; ok {
+		return true
+	}
+
+	return false
+}

bin/src/github.com/revel/modules/csrf/app/exempt_test.go

@@ -0,0 +1,55 @@
+package csrf
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/revel/revel"
+)
+
+func TestExemptPath(t *testing.T) {
+	MarkExempt("/Controller/Action")
+
+	resp := httptest.NewRecorder()
+	postRequest, _ := http.NewRequest("POST", "http://www.example.com/Controller/Action", nil)
+	c := revel.NewController(revel.NewRequest(postRequest), revel.NewResponse(resp))
+	c.Session = make(revel.Session)
+
+	testFilters[0](c, testFilters)
+
+	if c.Response.Status == 403 {
+		t.Fatal("post to csrf exempt action should pass")
+	}
+}
+
+func TestExemptPathCaseInsensitive(t *testing.T) {
+	MarkExempt("/Controller/Action")
+
+	resp := httptest.NewRecorder()
+	postRequest, _ := http.NewRequest("POST", "http://www.example.com/controller/action", nil)
+	c := revel.NewController(revel.NewRequest(postRequest), revel.NewResponse(resp))
+	c.Session = make(revel.Session)
+
+	testFilters[0](c, testFilters)
+
+	if c.Response.Status == 403 {
+		t.Fatal("post to csrf exempt action should pass")
+	}
+}
+
+func TestExemptAction(t *testing.T) {
+	MarkExempt("Controller.Action")
+
+	resp := httptest.NewRecorder()
+	postRequest, _ := http.NewRequest("POST", "http://www.example.com/Controller/Action", nil)
+	c := revel.NewController(revel.NewRequest(postRequest), revel.NewResponse(resp))
+	c.Session = make(revel.Session)
+	c.Action = "Controller.Action"
+
+	testFilters[0](c, testFilters)
+
+	if c.Response.Status == 403 {
+		t.Fatal("post to csrf exempt action should pass")
+	}
+}

bin/src/github.com/revel/modules/db/app/db.go

@@ -0,0 +1,86 @@
+// This module configures a database connection for the application.
+//
+// Developers use this module by importing and calling db.Init().
+// A "Transactional" controller type is provided as a way to import interceptors
+// that manage the transaction
+//
+// In particular, a transaction is begun before each request and committed on
+// success.  If a panic occurred during the request, the transaction is rolled
+// back.  (The application may also roll the transaction back itself.)
+package db
+
+import (
+	"database/sql"
+	"github.com/revel/revel"
+)
+
+var (
+	Db     *sql.DB
+	Driver string
+	Spec   string
+)
+
+func Init() {
+	// Read configuration.
+	var found bool
+	if Driver, found = revel.Config.String("db.driver"); !found {
+		revel.ERROR.Fatal("No db.driver found.")
+	}
+	if Spec, found = revel.Config.String("db.spec"); !found {
+		revel.ERROR.Fatal("No db.spec found.")
+	}
+
+	// Open a connection.
+	var err error
+	Db, err = sql.Open(Driver, Spec)
+	if err != nil {
+		revel.ERROR.Fatal(err)
+	}
+}
+
+type Transactional struct {
+	*revel.Controller
+	Txn *sql.Tx
+}
+
+// Begin a transaction
+func (c *Transactional) Begin() revel.Result {
+	txn, err := Db.Begin()
+	if err != nil {
+		panic(err)
+	}
+	c.Txn = txn
+	return nil
+}
+
+// Rollback if it's still going (must have panicked).
+func (c *Transactional) Rollback() revel.Result {
+	if c.Txn != nil {
+		if err := c.Txn.Rollback(); err != nil {
+			if err != sql.ErrTxDone {
+				panic(err)
+			}
+		}
+		c.Txn = nil
+	}
+	return nil
+}
+
+// Commit the transaction.
+func (c *Transactional) Commit() revel.Result {
+	if c.Txn != nil {
+		if err := c.Txn.Commit(); err != nil {
+			if err != sql.ErrTxDone {
+				panic(err)
+			}
+		}
+		c.Txn = nil
+	}
+	return nil
+}
+
+func init() {
+	revel.InterceptMethod((*Transactional).Begin, revel.BEFORE)
+	revel.InterceptMethod((*Transactional).Commit, revel.AFTER)
+	revel.InterceptMethod((*Transactional).Rollback, revel.FINALLY)
+}

bin/src/github.com/revel/modules/jobs/app/controllers/status.go

@@ -0,0 +1,32 @@
+package controllers
+
+import (
+	"github.com/revel/revel"
+	"github.com/revel/modules/jobs/app/jobs"
+	"github.com/robfig/cron"
+	"strings"
+)
+
+type Jobs struct {
+	*revel.Controller
+}
+
+func (c Jobs) Status() revel.Result {
+	remoteAddress := c.Request.RemoteAddr
+	if revel.Config.BoolDefault("jobs.acceptproxyaddress", false) {
+		if proxiedAddress, isProxied := c.Request.Header["X-Forwarded-For"]; isProxied {
+			remoteAddress = proxiedAddress[0]
+		}
+	}
+	if !strings.HasPrefix(remoteAddress, "127.0.0.1") && !strings.HasPrefix(remoteAddress, "::1") {
+		return c.Forbidden("%s is not local", remoteAddress)
+	}
+	entries := jobs.MainCron.Entries()
+	return c.Render(entries)
+}
+
+func init() {
+	revel.TemplateFuncs["castjob"] = func(job cron.Job) *jobs.Job {
+		return job.(*jobs.Job)
+	}
+}

bin/src/github.com/revel/modules/jobs/app/jobs/job.go

@@ -0,0 +1,66 @@
+package jobs
+
+import (
+	"github.com/revel/revel"
+	"github.com/robfig/cron"
+	"reflect"
+	"runtime/debug"
+	"sync"
+	"sync/atomic"
+)
+
+type Job struct {
+	Name    string
+	inner   cron.Job
+	status  uint32
+	running sync.Mutex
+}
+
+const UNNAMED = "(unnamed)"
+
+func New(job cron.Job) *Job {
+	name := reflect.TypeOf(job).Name()
+	if name == "Func" {
+		name = UNNAMED
+	}
+	return &Job{
+		Name:  name,
+		inner: job,
+	}
+}
+
+func (j *Job) Status() string {
+	if atomic.LoadUint32(&j.status) > 0 {
+		return "RUNNING"
+	}
+	return "IDLE"
+}
+
+func (j *Job) Run() {
+	// If the job panics, just print a stack trace.
+	// Don't let the whole process die.
+	defer func() {
+		if err := recover(); err != nil {
+			if revelError := revel.NewErrorFromPanic(err); revelError != nil {
+				revel.ERROR.Print(err, "\n", revelError.Stack)
+			} else {
+				revel.ERROR.Print(err, "\n", string(debug.Stack()))
+			}
+		}
+	}()
+
+	if !selfConcurrent {
+		j.running.Lock()
+		defer j.running.Unlock()
+	}
+
+	if workPermits != nil {
+		workPermits <- struct{}{}
+		defer func() { <-workPermits }()
+	}
+
+	atomic.StoreUint32(&j.status, 1)
+	defer atomic.StoreUint32(&j.status, 0)
+
+	j.inner.Run()
+}

bin/src/github.com/revel/modules/jobs/app/jobs/jobrunner.go

@@ -0,0 +1,64 @@
+// A job runner for executing scheduled or ad-hoc tasks asynchronously from HTTP requests.
+//
+// It adds a couple of features on top of the cron package to make it play nicely with Revel:
+// 1. Protection against job panics.  (They print to ERROR instead of take down the process)
+// 2. (Optional) Limit on the number of jobs that may run simulatenously, to
+//    limit resource consumption.
+// 3. (Optional) Protection against multiple instances of a single job running
+//    concurrently.  If one execution runs into the next, the next will be queued.
+// 4. Cron expressions may be defined in app.conf and are reusable across jobs.
+// 5. Job status reporting.
+package jobs
+
+import (
+	"github.com/revel/revel"
+	"github.com/robfig/cron"
+	"strings"
+	"time"
+)
+
+// Callers can use jobs.Func to wrap a raw func.
+// (Copying the type to this package makes it more visible)
+//
+// For example:
+//    jobs.Schedule("cron.frequent", jobs.Func(myFunc))
+type Func func()
+
+func (r Func) Run() { r() }
+
+func Schedule(spec string, job cron.Job) error {
+	// Look to see if given spec is a key from the Config.
+	if strings.HasPrefix(spec, "cron.") {
+		confSpec, found := revel.Config.String(spec)
+		if !found {
+			panic("Cron spec not found: " + spec)
+		}
+		spec = confSpec
+	}
+	sched, err := cron.Parse(spec)
+	if err != nil {
+		return err
+	}
+	MainCron.Schedule(sched, New(job))
+	return nil
+}
+
+// Run the given job at a fixed interval.
+// The interval provided is the time between the job ending and the job being run again.
+// The time that the job takes to run is not included in the interval.
+func Every(duration time.Duration, job cron.Job) {
+	MainCron.Schedule(cron.Every(duration), New(job))
+}
+
+// Run the given job right now.
+func Now(job cron.Job) {
+	go New(job).Run()
+}
+
+// Run the given job once, after the given delay.
+func In(duration time.Duration, job cron.Job) {
+	go func() {
+		time.Sleep(duration)
+		New(job).Run()
+	}()
+}

bin/src/github.com/revel/modules/jobs/app/jobs/plugin.go

@@ -0,0 +1,32 @@
+package jobs
+
+import (
+	"fmt"
+	"github.com/revel/revel"
+	"github.com/robfig/cron"
+)
+
+const DEFAULT_JOB_POOL_SIZE = 10
+
+var (
+	// Singleton instance of the underlying job scheduler.
+	MainCron *cron.Cron
+
+	// This limits the number of jobs allowed to run concurrently.
+	workPermits chan struct{}
+
+	// Is a single job allowed to run concurrently with itself?
+	selfConcurrent bool
+)
+
+func init() {
+	MainCron = cron.New()
+	revel.OnAppStart(func() {
+		if size := revel.Config.IntDefault("jobs.pool", DEFAULT_JOB_POOL_SIZE); size > 0 {
+			workPermits = make(chan struct{}, size)
+		}
+		selfConcurrent = revel.Config.BoolDefault("jobs.selfconcurrent", false)
+		MainCron.Start()
+		fmt.Println("Go to /@jobs to see job status.")
+	})
+}

bin/src/github.com/revel/modules/jobs/app/views/Jobs/Status.html

@@ -0,0 +1,39 @@
+<html>
+	<head>
+		<style>
+body {
+  font-size: 12px;
+  font-family: sans-serif;
+}
+table {
+  border-collapse: collapse;
+  border: none;
+}
+table td, table th {
+  padding: 4 10px;
+  border: none;
+}
+table tr:nth-child(odd) {
+  background-color: #f0f0f0;
+}
+th {
+  text-align: left;
+}
+		</style>
+	</head>
+	<body>
+
+<h1>Scheduled Jobs</h1>
+
+<table>
+	<tr><th>Name</th><th>Status</th><th>Last run</th><th>Next run</th></tr>
+{{range .entries}}
+	{{$job := castjob .Job}}
+	<tr>
+		<td>{{$job.Name}}</td>
+		<td>{{$job.Status}}</td>
+		<td>{{if not .Prev.IsZero}}{{.Prev.Format "2006-01-02 15:04:05"}}{{end}}</td>
+		<td>{{if not .Next.IsZero}}{{.Next.Format "2006-01-02 15:04:05"}}{{end}}</td>
+	</tr>
+{{end}}
+</table>

bin/src/github.com/revel/modules/jobs/conf/routes

@@ -0,0 +1 @@
+GET     /@jobs      Jobs.Status

bin/src/github.com/revel/modules/pprof/README.md

@@ -0,0 +1,19 @@
+Revel pprof module
+============
+
+#### How to use:
+
+1. Open your app.conf file and add the following line:  
+`module.pprof=github.com/revel/modules/pprof`  
+This will enable the pprof module.
+
+2. Next, open your routes file and add:  
+`module:pprof` **Note:** Do not change these routes. The pprof command-line tool by default assumes these routes.
+
+Congrats! You can now profile your application. To use the web interface, visit `http://<host>:<port>/debug/pprof`. You can also use the `go tool pprof` command to profile your application and get a little deeper. Use the command by running `go tool pprof <binary> http://<host>:<port>`. For example, if you modified the booking sample, you would run: `go tool pprof $GOPATH/bin/booking http://localhost:9000` (assuming you used the default `revel run` arguments.
+
+The command-line tool will take a 30-second CPU profile, and save the results to a temporary file in your `$HOME/pprof` directory. You can reference this file at a later time by using the same command as above, but by specifying the filename instead of the server address.
+
+In order to fully utilize the command-line tool, you may need the graphviz utilities. If you're on OS X, you can install these easily using Homebrew: `brew install graphviz`.
+
+To read more about profiling Go programs, here is some reading material: [The Go Blog](http://blog.golang.org/profiling-go-programs) : [net/pprof package documentation](http://golang.org/pkg/net/http/pprof/)

bin/src/github.com/revel/modules/pprof/app/controllers/pprof.go

@@ -0,0 +1,39 @@
+package controllers
+
+import (
+	"github.com/revel/revel"
+	"net/http"
+	"net/http/pprof"
+)
+
+type Pprof struct {
+	*revel.Controller
+}
+
+// The PprofHandler type makes it easy to call the net/http/pprof handler methods
+// since they all have the same method signature
+type PprofHandler func(http.ResponseWriter, *http.Request)
+
+func (r PprofHandler) Apply(req *revel.Request, resp *revel.Response) {
+	r(resp.Out, req.Request)
+}
+
+func (c Pprof) Profile() revel.Result {
+	return PprofHandler(pprof.Profile)
+}
+
+func (c Pprof) Symbol() revel.Result {
+	return PprofHandler(pprof.Symbol)
+}
+
+func (c Pprof) Cmdline() revel.Result {
+	return PprofHandler(pprof.Cmdline)
+}
+
+func (c Pprof) Trace() revel.Result {
+	return PprofHandler(pprof.Trace)
+}
+
+func (c Pprof) Index() revel.Result {
+	return PprofHandler(pprof.Index)
+}

bin/src/github.com/revel/modules/pprof/conf/routes

@@ -0,0 +1,6 @@
+GET /pprof/profile       Pprof.Profile
+GET /pprof/symbol        Pprof.Symbol
+GET /debug/pprof/cmdline Pprof.Cmdline
+GET /debug/pprof/trace   Pprof.Trace
+GET /debug/pprof/*       Pprof.Index
+GET /debug/pprof/        Pprof.Index

bin/src/github.com/revel/modules/static/app/controllers/static.go

@@ -0,0 +1,121 @@
+package controllers
+
+import (
+	"github.com/revel/revel"
+	"os"
+	fpath "path/filepath"
+	"strings"
+	"syscall"
+)
+
+type Static struct {
+	*revel.Controller
+}
+
+// This method handles requests for files. The supplied prefix may be absolute
+// or relative. If the prefix is relative it is assumed to be relative to the
+// application directory. The filepath may either be just a file or an
+// additional filepath to search for the given file. This response may return
+// the following responses in the event of an error or invalid request;
+//   403(Forbidden): If the prefix filepath combination results in a directory.
+//   404(Not found): If the prefix and filepath combination results in a non-existent file.
+//   500(Internal Server Error): There are a few edge cases that would likely indicate some configuration error outside of revel.
+//
+// Note that when defining routes in routes/conf the parameters must not have
+// spaces around the comma.
+//   Bad:  Static.Serve("public/img", "favicon.png")
+//   Good: Static.Serve("public/img","favicon.png")
+//
+// Examples:
+// Serving a directory
+//   Route (conf/routes):
+//     GET /public/{<.*>filepath} Static.Serve("public")
+//   Request:
+//     public/js/sessvars.js
+//   Calls
+//     Static.Serve("public","js/sessvars.js")
+//
+// Serving a file
+//   Route (conf/routes):
+//     GET /favicon.ico Static.Serve("public/img","favicon.png")
+//   Request:
+//     favicon.ico
+//   Calls:
+//     Static.Serve("public/img", "favicon.png")
+func (c Static) Serve(prefix, filepath string) revel.Result {
+	// Fix for #503.
+	prefix = c.Params.Fixed.Get("prefix")
+	if prefix == "" {
+		return c.NotFound("")
+	}
+
+	return serve(c, prefix, filepath)
+}
+
+// This method allows modules to serve binary files. The parameters are the same
+// as Static.Serve with the additional module name pre-pended to the list of
+// arguments.
+func (c Static) ServeModule(moduleName, prefix, filepath string) revel.Result {
+	// Fix for #503.
+	prefix = c.Params.Fixed.Get("prefix")
+	if prefix == "" {
+		return c.NotFound("")
+	}
+
+	var basePath string
+	for _, module := range revel.Modules {
+		if module.Name == moduleName {
+			basePath = module.Path
+		}
+	}
+
+	absPath := fpath.Join(basePath, fpath.FromSlash(prefix))
+
+	return serve(c, absPath, filepath)
+}
+
+
+// This method allows static serving of application files in a verified manner.
+func serve(c Static, prefix, filepath string) revel.Result {
+	var basePath string
+	if !fpath.IsAbs(prefix) {
+		basePath = revel.BasePath
+	}
+
+	basePathPrefix := fpath.Join(basePath, fpath.FromSlash(prefix))
+	fname := fpath.Join(basePathPrefix, fpath.FromSlash(filepath))
+	// Verify the request file path is within the application's scope of access
+	if !strings.HasPrefix(fname, basePathPrefix) {
+		revel.WARN.Printf("Attempted to read file outside of base path: %s", fname)
+		return c.NotFound("")
+	}
+
+	// Verify file path is accessible
+	finfo, err := os.Stat(fname)
+	if err != nil {
+		if os.IsNotExist(err) || err.(*os.PathError).Err == syscall.ENOTDIR {
+			revel.WARN.Printf("File not found (%s): %s ", fname, err)
+			return c.NotFound("File not found")
+		}
+		revel.ERROR.Printf("Error trying to get fileinfo for '%s': %s", fname, err)
+		return c.RenderError(err)
+	}
+
+	// Disallow directory listing
+	if finfo.Mode().IsDir() {
+		revel.WARN.Printf("Attempted directory listing of %s", fname)
+		return c.Forbidden("Directory listing not allowed")
+	}
+
+	// Open request file path
+	file, err := os.Open(fname)
+	if err != nil {
+		if os.IsNotExist(err) {
+			revel.WARN.Printf("File not found (%s): %s ", fname, err)
+			return c.NotFound("File not found")
+		}
+		revel.ERROR.Printf("Error opening '%s': %s", fname, err)
+		return c.RenderError(err)
+	}
+	return c.RenderFile(file, revel.Inline)
+}

bin/src/github.com/revel/modules/testrunner/app/controllers/testrunner.go

@@ -0,0 +1,248 @@
+package controllers
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"html/template"
+	"reflect"
+	"strings"
+
+	"github.com/revel/revel"
+	"github.com/revel/revel/testing"
+)
+
+// TestRunner is a controller which is used for running application tests in browser.
+type TestRunner struct {
+	*revel.Controller
+}
+
+// TestSuiteDesc is used for storing information about a single test suite.
+// This structure is required by revel test cmd.
+type TestSuiteDesc struct {
+	Name  string
+	Tests []TestDesc
+
+	// Elem is reflect.Type which can be used for accessing methods
+	// of the test suite.
+	Elem reflect.Type
+}
+
+// TestDesc is used for describing a single test of some test suite.
+// This structure is required by revel test cmd.
+type TestDesc struct {
+	Name string
+}
+
+// TestSuiteResult stores the results the whole test suite.
+// This structure is required by revel test cmd.
+type TestSuiteResult struct {
+	Name    string
+	Passed  bool
+	Results []TestResult
+}
+
+// TestResult represents the results of running a single test of some test suite.
+// This structure is required by revel test cmd.
+type TestResult struct {
+	Name         string
+	Passed       bool
+	ErrorHTML    template.HTML
+	ErrorSummary string
+}
+
+var (
+	testSuites []TestSuiteDesc // A list of all available tests.
+
+	none = []reflect.Value{} // It is used as input for reflect call in a few places.
+
+	// registeredTests simplifies the search of test suites by their name.
+	// "TestSuite.TestName" is used as a key. Value represents index in testSuites.
+	registeredTests map[string]int
+)
+
+/*
+	Controller's action methods are below.
+*/
+
+// Index is an action which renders the full list of available test suites and their tests.
+func (c TestRunner) Index() revel.Result {
+	return c.Render(testSuites)
+}
+
+// Run runs a single test, given by the argument.
+func (c TestRunner) Run(suite, test string) revel.Result {
+	// Check whether requested test exists.
+	suiteIndex, ok := registeredTests[suite+"."+test]
+	if !ok {
+		return c.NotFound("Test %s.%s does not exist", suite, test)
+	}
+
+	result := TestResult{Name: test}
+
+	// Found the suite, create a new instance and run the named method.
+	t := testSuites[suiteIndex].Elem
+	v := reflect.New(t)
+	func() {
+		// When the function stops executing try to recover from panic.
+		defer func() {
+			if err := recover(); err != nil {
+				// If panic error is empty, exit.
+				panicErr := revel.NewErrorFromPanic(err)
+				if panicErr == nil {
+					return
+				}
+
+				// Otherwise, prepare and format the response of server if possible.
+				testSuite := v.Elem().FieldByName("TestSuite").Interface().(testing.TestSuite)
+				res := formatResponse(testSuite)
+
+				// Render the error and save to the result structure.
+				var buffer bytes.Buffer
+				tmpl, _ := revel.MainTemplateLoader.Template("TestRunner/FailureDetail.html")
+				tmpl.Render(&buffer, map[string]interface{}{
+					"error":    panicErr,
+					"response": res,
+					"postfix":  suite + "_" + test,
+				})
+				result.ErrorSummary = errorSummary(panicErr)
+				result.ErrorHTML = template.HTML(buffer.String())
+			}
+		}()
+
+		// Initialize the test suite with a NewTestSuite()
+		testSuiteInstance := v.Elem().FieldByName("TestSuite")
+		testSuiteInstance.Set(reflect.ValueOf(testing.NewTestSuite()))
+
+		// Make sure After method will be executed at the end.
+		if m := v.MethodByName("After"); m.IsValid() {
+			defer m.Call(none)
+		}
+
+		// Start from running Before method of test suite if exists.
+		if m := v.MethodByName("Before"); m.IsValid() {
+			m.Call(none)
+		}
+
+		// Start the test method itself.
+		v.MethodByName(test).Call(none)
+
+		// No panic means success.
+		result.Passed = true
+	}()
+
+	return c.RenderJson(result)
+}
+
+// List returns a JSON list of test suites and tests.
+// It is used by revel test command line tool.
+func (c TestRunner) List() revel.Result {
+	return c.RenderJson(testSuites)
+}
+
+/*
+	Below are helper functions.
+*/
+
+// describeSuite expects testsuite interface as input parameter
+// and returns its description in a form of TestSuiteDesc structure.
+func describeSuite(testSuite interface{}) TestSuiteDesc {
+	t := reflect.TypeOf(testSuite)
+
+	// Get a list of methods of the embedded test type.
+	// It will be used to make sure the same tests are not included in multiple test suites.
+	super := t.Elem().Field(0).Type
+	superMethods := map[string]bool{}
+	for i := 0; i < super.NumMethod(); i++ {
+		// Save the current method's name.
+		superMethods[super.Method(i).Name] = true
+	}
+
+	// Get a list of methods on the test suite that take no parameters, return
+	// no results, and were not part of the embedded type's method set.
+	var tests []TestDesc
+	for i := 0; i < t.NumMethod(); i++ {
+		m := t.Method(i)
+		mt := m.Type
+
+		// Make sure the test method meets the criterias:
+		// - method of testSuite without input parameters;
+		// - nothing is returned;
+		// - has "Test" prefix;
+		// - doesn't belong to the embedded structure.
+		methodWithoutParams := (mt.NumIn() == 1 && mt.In(0) == t)
+		nothingReturned := (mt.NumOut() == 0)
+		hasTestPrefix := (strings.HasPrefix(m.Name, "Test"))
+		if methodWithoutParams && nothingReturned && hasTestPrefix && !superMethods[m.Name] {
+			// Register the test suite's index so we can quickly find it by test's name later.
+			registeredTests[t.Elem().Name()+"."+m.Name] = len(testSuites)
+
+			// Add test to the list of tests.
+			tests = append(tests, TestDesc{m.Name})
+		}
+	}
+
+	return TestSuiteDesc{
+		Name:  t.Elem().Name(),
+		Tests: tests,
+		Elem:  t.Elem(),
+	}
+}
+
+// errorSummary gets an error and returns its summary in human readable format.
+func errorSummary(err *revel.Error) (message string) {
+	message = fmt.Sprintf("%4sStatus: %s\n%4sIn %s", "", err.Description, "", err.Path)
+
+	// If line of error isn't known return the message as is.
+	if err.Line == 0 {
+		return
+	}
+
+	// Otherwise, include info about the line number and the relevant
+	// source code lines.
+	message += fmt.Sprintf(" (around line %d): ", err.Line)
+	for _, line := range err.ContextSource() {
+		if line.IsError {
+			message += line.Source
+		}
+	}
+
+	return
+}
+
+// formatResponse gets *revel.TestSuite as input parameter and
+// transform response related info into a readable format.
+func formatResponse(t testing.TestSuite) map[string]string {
+	if t.Response == nil {
+		return map[string]string{}
+	}
+
+	// Beautify the response JSON to make it human readable.
+	resp, err := json.MarshalIndent(t.Response, "", "  ")
+	if err != nil {
+		revel.ERROR.Println(err)
+	}
+
+	// Remove extra new line symbols so they do not take too much space on a result page.
+	// Allow no more than 1 line break at a time.
+	body := strings.Replace(string(t.ResponseBody), "\n\n", "\n", -1)
+	body = strings.Replace(body, "\r\n\r\n", "\r\n", -1)
+
+	return map[string]string{
+		"Headers": string(resp),
+		"Body":    strings.TrimSpace(body),
+	}
+}
+
+func init() {
+	// Every time app is restarted convert the list of available test suites
+	// provided by the revel testing package into a format which will be used by
+	// the testrunner module and revel test cmd.
+	revel.OnAppStart(func() {
+		// Extracting info about available test suites from revel/testing package.
+		registeredTests = map[string]int{}
+		for _, testSuite := range testing.TestSuites {
+			testSuites = append(testSuites, describeSuite(testSuite))
+		}
+	})
+}

bin/src/github.com/revel/modules/testrunner/app/plugin.go

@@ -0,0 +1,12 @@
+package app
+
+import (
+	"fmt"
+	"github.com/revel/revel"
+)
+
+func init() {
+	revel.OnAppStart(func() {
+		fmt.Println("Go to /@tests to run the tests.")
+	})
+}

bin/src/github.com/revel/modules/testrunner/app/views/TestRunner/FailureDetail.html

@@ -0,0 +1,45 @@
+<div class="panel panel-default">
+	<div class="panel-heading">
+		<b>{{.error.Description}}</b>
+	</div>
+	<div class="panel-body">
+
+		<ul class="nav nav-tabs" role="tablist">
+			<li class="active"><a href="#error_{{.postfix}}" role="tab" data-toggle="tab">Error</a></li>
+			<li><a href="#stack_{{.postfix}}" role="tab" data-toggle="tab">Stack</a></li>
+			{{if .response}}
+				<li><a href="#headers_{{.postfix}}" role="tab" data-toggle="tab">Headers</a></li>
+				<li><a href="#body_{{.postfix}}" role="tab" data-toggle="tab">Response Body</a></li>
+			{{end}}
+		</ul>
+
+		<div class="tab-content" id="result_{{.postfix}}">
+			<div class="tab-pane active" id="error_{{.postfix}}">
+				<div class="panel panel-danger">
+					<div class="panel-heading">
+						In {{.error.Path}}{{if .error.Line}} (around {{if .error.Line}}line {{.error.Line}}{{end}}{{if .error.Column}} column {{.error.Column}}{{end}}){{end}}:
+					</div>
+					<div class="panel-body">
+						{{range .error.ContextSource}}
+							{{if .IsError}}
+								<pre><code class="go">{{.Source}}</code></pre>
+							{{end}}
+						{{end}}
+					</div>
+				</div>
+			</div>
+			<div class="tab-pane" id="stack_{{.postfix}}">
+				<pre><code class="bash">{{.error.Stack}}</code></pre>
+			</div>
+			{{if .response}}
+				<div class="tab-pane" id="headers_{{.postfix}}">
+					<pre><code class="json">{{.response.Headers}}</code></pre>
+				</div>
+				<div class="tab-pane" id="body_{{.postfix}}">
+					<pre><code class="html">{{.response.Body}}</code></pre>
+				</div>
+			{{end}}
+		</div>
+
+	</div>
+</div>

bin/src/github.com/revel/modules/testrunner/app/views/TestRunner/Index.html

@@ -0,0 +1,110 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<title>Revel Test Runner</title>
+		<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+		<link href="{{url `Root`}}/@tests/public/css/bootstrap.min.css" type="text/css" rel="stylesheet"></link>
+		<link href="{{url `Root`}}/@tests/public/css/github.css" type="text/css" rel="stylesheet"></link>
+		<script src="{{url `Root`}}/@tests/public/js/jquery-1.9.1.min.js" type="text/javascript"></script>
+		<script src="{{url `Root`}}/@tests/public/js/bootstrap.min.js" type="text/javascript"></script>
+		<script src="{{url `Root`}}/@tests/public/js/highlight.pack.js" type="text/javascript"></script>
+		<style>
+		header { padding:20px 0; background-color:#ADD8E6 }
+		.passed td { background-color: #90EE90 !important; }
+		.failed td { background-color: #FFB6C1 !important; }
+		.tests td.name, .tests td.result { padding-top: 13px; }
+		pre { font-size:10px; white-space: pre; }
+		.name { width: 25%; }
+		.w100 { width: 100%; }
+		</style>
+	</head>
+	<body>
+		<header>
+			<div class="container">
+				<table class="w100"><tr><td>
+					<h1>Test Runner</h1>
+					<p class="lead">Run all of your application's tests from here.</p>
+				</td><td style="padding-left:150px;" class="text-right">
+					<button class="btn btn-lg btn-success" all-tests="">Run All Tests</button>
+				</td></tr></table>
+			</div>
+		</header>
+
+		<div class="container">
+			{{range .testSuites}}
+				<p class="lead" style="margin-top:20px;">{{.Name}}</p>
+				<table class="table table-striped tests" suite="{{.Name}}">
+					{{range .Tests}}
+						<tr>
+							<td class="name">{{.Name}}</td>
+							<td class="result">
+							</td>
+							<td class="text-right"><button test="{{.Name}}" class="btn btn-success">Run</button></td>
+						</tr>
+					{{end}}
+				</table>
+			{{end}}
+		</div>
+
+	<script>
+	var buttons = [];
+	var running;
+
+	$("button[test]").click(function() {
+		var button = $(this).addClass("disabled").text("Running");
+		addToQueue(button);
+	});
+
+	$("button[all-tests]").click(function() {
+		var button = $(this).addClass("disabled").text("Running");
+		$("button[test]").click();
+	});
+
+	function addToQueue(button) {
+		buttons.push(button);
+		if (!running) {
+			running = true;
+			nextTest();
+		}
+	}
+
+	function nextTest() {
+		if (buttons.length == 0) {
+			running = false;
+		} else {
+			var next = buttons.shift();
+			runTest(next);
+		}
+	}
+
+	function runTest(button) {
+		var suite = button.parents("table").attr("suite");
+		var test = button.attr("test");
+		var row = button.parents("tr");
+		var resultCell = row.children(".result");
+		$.ajax({
+			dataType: "json",
+			url: "{{url `Root`}}/@tests/"+suite+"/"+test,
+			success: function(result) {
+				row.attr("class", result.Passed ? "passed" : "failed");
+				if (result.Passed) {
+					resultCell.html("");
+				} else {
+					resultCell.html(result.ErrorHTML);
+
+					$("#result_" + suite + "_" + test + " pre code").each(function(i, block) {
+						hljs.highlightBlock(block);
+					});
+				}
+				button.removeClass("disabled").text("Run");
+				if (buttons.length == 0) {
+					$("button[all-tests]").removeClass("disabled").text("Run All Tests");
+				}
+				nextTest();
+			}
+		});
+	}
+	</script>
+
+	</body>
+</html>

bin/src/github.com/revel/modules/testrunner/app/views/TestRunner/SuiteResult.html

@@ -0,0 +1,48 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<title>Revel Test Runner</title>
+		<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+
+<style>
+body {
+	margin: 0;
+	font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+	font-size: 14px;
+	line-height: 20px;
+	color: #333333;
+	background-color: #ffffff;
+}
+header { padding:20px 0; }
+header.passed { background-color: #90EE90 !important; }
+header.failed { background-color: #FFB6C1 !important; }
+table { margin-top: 20px; padding: 8px; line-height: 20px; }
+td { vertical-align: top; padding-right:20px; }
+a { color: #0088cc; }
+.container { margin-left: auto; margin-right: auto; width: 940px; overflow: hidden; }
+.result h2 { font-size: 16px; border-bottom: 1px solid #f0f0f0; padding-bottom: 0.2em; }
+.result.failed b { font-weight:bold; color: #C00; font-size: 14px; }
+.result.failed h2 { color: #C00; }
+.result .info { font-size: 12px; }
+.result .info pre  { overflow: auto; background-color: #f0f0f0; width: 100%; max-height: 500px; }
+</style>
+
+	</head>
+	<body>
+		<header class="{{if .Passed}}passed{{else}}failed{{end}}">
+			<div class="container">
+				<h1>{{.Name}}</h1>
+				<p>{{if .Passed}}PASSED{{else}}FAILED{{end}}</p>
+			</div>
+		</header>
+
+		<div class="container">
+			{{range .Results}}
+				<div class="result {{if .Passed}}passed{{else}}failed{{end}}">
+					<div><h2>{{.Name}}</h2></div>
+					<div class="info">{{if .ErrorHTML}}{{.ErrorHTML}}{{else}}PASSED{{end}}</div>
+				</div>
+			{{end}}
+		</div>
+	</body>
+</html>

bin/src/github.com/revel/modules/testrunner/conf/routes

@@ -0,0 +1,4 @@
+GET /@tests                       TestRunner.Index
+GET /@tests.list                  TestRunner.List
+GET /@tests/public/*filepath      Static.ServeModule(testrunner,public)
+GET /@tests/:suite/:test          TestRunner.Run

bin/src/github.com/revel/modules/testrunner/public/css/bootstrap.min.css

@@ -0,0 +1,5 @@
+/*!
+ * Bootstrap v3.2.0 (http://getbootstrap.com)
+ * Copyright 2011-2014 Twitter, Inc.
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+ *//*! normalize.css v3.0.1 | MIT License | git.io/normalize */html{font-family:sans-serif;-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%}body{margin:0}article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block}audio,canvas,progress,video{display:inline-block;vertical-align:baseline}audio:not([controls]){display:none;height:0}[hidden],template{display:none}a{background:0 0}a:active,a:hover{outline:0}abbr[title]{border-bottom:1px dotted}b,strong{font-weight:700}dfn{font-style:italic}h1{margin:.67em 0;font-size:2em}mark{color:#000;background:#ff0}small{font-size:80%}sub,sup{position:relative;font-size:75%;line-height:0;vertical-align:baseline}sup{top:-.5em}sub{bottom:-.25em}img{border:0}svg:not(:root){overflow:hidden}figure{margin:1em 40px}hr{height:0;-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box}pre{overflow:auto}code,kbd,pre,samp{font-family:monospace,monospace;font-size:1em}button,input,optgroup,select,textarea{margin:0;font:inherit;color:inherit}button{overflow:visible}button,select{text-transform:none}button,html input[type=button],input[type=reset],input[type=submit]{-webkit-appearance:button;cursor:pointer}button[disabled],html input[disabled]{cursor:default}button::-moz-focus-inner,input::-moz-focus-inner{padding:0;border:0}input{line-height:normal}input[type=checkbox],input[type=radio]{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;padding:0}input[type=number]::-webkit-inner-spin-button,input[type=number]::-webkit-outer-spin-button{height:auto}input[type=search]{-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;-webkit-appearance:textfield}input[type=search]::-webkit-search-cancel-button,input[type=search]::-webkit-search-decoration{-webkit-appearance:none}fieldset{padding:.35em .625em .75em;margin:0 2px;border:1px solid silver}legend{padding:0;border:0}textarea{overflow:auto}optgroup{font-weight:700}table{border-spacing:0;border-collapse:collapse}td,th{padding:0}@media print{*{color:#000!important;text-shadow:none!important;background:transparent!important;-webkit-box-shadow:none!important;box-shadow:none!important}a,a:visited{text-decoration:underline}a[href]:after{content:" (" attr(href) ")"}abbr[title]:after{content:" (" attr(title) ")"}a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100%!important}p,h2,h3{orphans:3;widows:3}h2,h3{page-break-after:avoid}select{background:#fff!important}.navbar{display:none}.table td,.table th{background-color:#fff!important}.btn>.caret,.dropup>.btn>.caret{border-top-color:#000!important}.label{border:1px solid #000}.table{border-collapse:collapse!important}.table-bordered th,.table-bordered td{border:1px solid #ddd!important}}@font-face{font-family:'Glyphicons Halflings';src:url(../fonts/glyphicons-halflings-regular.eot);src:url(../fonts/glyphicons-halflings-regular.eot?#iefix) format('embedded-opentype'),url(../fonts/glyphicons-halflings-regular.woff) format('woff'),url(../fonts/glyphicons-halflings-regular.ttf) format('truetype'),url(../fonts/glyphicons-halflings-regular.svg#glyphicons_halflingsregular) format('svg')}.glyphicon{position:relative;top:1px;display:inline-block;font-family:'Glyphicons Halflings';font-style:normal;font-weight:400;line-height:1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.glyphicon-asterisk:before{content:"\2a"}.glyphicon-plus:before{content:"\2b"}.glyphicon-euro:before{content:"\20ac"}.glyphicon-minus:before{content:"\2212"}.glyphicon-cloud:before{content:"\2601"}.glyphicon-envelope:before{content:"\2709"}.glyphicon-pencil:before{content:"\270f"}.glyphicon-glass:before{content:"\e001"}.glyphicon-music:before{content:"\e002"}.glyphicon-search:before{content:"\e003"}.glyphicon-heart:before{content:"\e005"}.glyphicon-star:before{content:"\e006"}.glyphicon-star-empty:before{content:"\e007"}.glyphicon-user:before{content:"\e008"}.glyphicon-film:before{content:"\e009"}.glyphicon-th-large:before{content:"\e010"}.glyphicon-th:before{content:"\e011"}.glyphicon-th-list:before{content:"\e012"}.glyphicon-ok:before{content:"\e013"}.glyphicon-remove:before{content:"\e014"}.glyphicon-zoom-in:before{content:"\e015"}.glyphicon-zoom-out:before{content:"\e016"}.glyphicon-off:before{content:"\e017"}.glyphicon-signal:before{content:"\e018"}.glyphicon-cog:before{content:"\e019"}.glyphicon-trash:before{content:"\e020"}.glyphicon-home:before{content:"\e021"}.glyphicon-file:before{content:"\e022"}.glyphicon-time:before{content:"\e023"}.glyphicon-road:before{content:"\e024"}.glyphicon-download-alt:before{content:"\e025"}.glyphicon-download:before{content:"\e026"}.glyphicon-upload:before{content:"\e027"}.glyphicon-inbox:before{content:"\e028"}.glyphicon-play-circle:before{content:"\e029"}.glyphicon-repeat:before{content:"\e030"}.glyphicon-Line truncated

bin/src/github.com/revel/modules/testrunner/public/css/github.css

@@ -0,0 +1,127 @@
+/*
+
+github.com style (c) Vasily Polovnyov <vast@whiteants.net>
+
+*/
+
+.hljs {
+  display: block;
+  overflow-x: auto;
+  padding: 0.5em;
+  color: #333;
+  background: #f8f8f8;
+  -webkit-text-size-adjust: none;
+}
+
+.hljs-comment,
+.hljs-template_comment,
+.diff .hljs-header,
+.hljs-javadoc {
+  color: #998;
+  font-style: italic;
+}
+
+.hljs-keyword,
+.css .rule .hljs-keyword,
+.hljs-winutils,
+.javascript .hljs-title,
+.nginx .hljs-title,
+.hljs-subst,
+.hljs-request,
+.hljs-status {
+  color: #333;
+  font-weight: bold;
+}
+
+.hljs-number,
+.hljs-hexcolor,
+.ruby .hljs-constant {
+  color: #008080;
+}
+
+.hljs-string,
+.hljs-tag .hljs-value,
+.hljs-phpdoc,
+.hljs-dartdoc,
+.tex .hljs-formula {
+  color: #d14;
+}
+
+.hljs-title,
+.hljs-id,
+.scss .hljs-preprocessor {
+  color: #900;
+  font-weight: bold;
+}
+
+.javascript .hljs-title,
+.hljs-list .hljs-keyword,
+.hljs-subst {
+  font-weight: normal;
+}
+
+.hljs-class .hljs-title,
+.hljs-type,
+.vhdl .hljs-literal,
+.tex .hljs-command {
+  color: #458;
+  font-weight: bold;
+}
+
+.hljs-tag,
+.hljs-tag .hljs-title,
+.hljs-rules .hljs-property,
+.django .hljs-tag .hljs-keyword {
+  color: #000080;
+  font-weight: normal;
+}
+
+.hljs-attribute,
+.hljs-variable,
+.lisp .hljs-body {
+  color: #008080;
+}
+
+.hljs-regexp {
+  color: #009926;
+}
+
+.hljs-symbol,
+.ruby .hljs-symbol .hljs-string,
+.lisp .hljs-keyword,
+.clojure .hljs-keyword,
+.scheme .hljs-keyword,
+.tex .hljs-special,
+.hljs-prompt {
+  color: #990073;
+}
+
+.hljs-built_in {
+  color: #0086b3;
+}
+
+.hljs-preprocessor,
+.hljs-pragma,
+.hljs-pi,
+.hljs-doctype,
+.hljs-shebang,
+.hljs-cdata {
+  color: #999;
+  font-weight: bold;
+}
+
+.hljs-deletion {
+  background: #fdd;
+}
+
+.hljs-addition {
+  background: #dfd;
+}
+
+.diff .hljs-change {
+  background: #0086b3;
+}
+
+.hljs-chunk {
+  color: #aaa;
+}

bin/src/github.com/revel/modules/testrunner/public/js/bootstrap.min.js

@@ -0,0 +1,6 @@
+/*!
+ * Bootstrap v3.2.0 (http://getbootstrap.com)
+ * Copyright 2011-2014 Twitter, Inc.
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+ */
+if("undefined"==typeof jQuery)throw new Error("Bootstrap's JavaScript requires jQuery");+function(a){"use strict";function b(){var a=document.createElement("bootstrap"),b={WebkitTransition:"webkitTransitionEnd",MozTransition:"transitionend",OTransition:"oTransitionEnd otransitionend",transition:"transitionend"};for(var c in b)if(void 0!==a.style[c])return{end:b[c]};return!1}a.fn.emulateTransitionEnd=function(b){var c=!1,d=this;a(this).one("bsTransitionEnd",function(){c=!0});var e=function(){c||a(d).trigger(a.support.transition.end)};return setTimeout(e,b),this},a(function(){a.support.transition=b(),a.support.transition&&(a.event.special.bsTransitionEnd={bindType:a.support.transition.end,delegateType:a.support.transition.end,handle:function(b){return a(b.target).is(this)?b.handleObj.handler.apply(this,arguments):void 0}})})}(jQuery),+function(a){"use strict";function b(b){return this.each(function(){var c=a(this),e=c.data("bs.alert");e||c.data("bs.alert",e=new d(this)),"string"==typeof b&&e[b].call(c)})}var c='[data-dismiss="alert"]',d=function(b){a(b).on("click",c,this.close)};d.VERSION="3.2.0",d.prototype.close=function(b){function c(){f.detach().trigger("closed.bs.alert").remove()}var d=a(this),e=d.attr("data-target");e||(e=d.attr("href"),e=e&&e.replace(/.*(?=#[^\s]*$)/,""));var f=a(e);b&&b.preventDefault(),f.length||(f=d.hasClass("alert")?d:d.parent()),f.trigger(b=a.Event("close.bs.alert")),b.isDefaultPrevented()||(f.removeClass("in"),a.support.transition&&f.hasClass("fade")?f.one("bsTransitionEnd",c).emulateTransitionEnd(150):c())};var e=a.fn.alert;a.fn.alert=b,a.fn.alert.Constructor=d,a.fn.alert.noConflict=function(){return a.fn.alert=e,this},a(document).on("click.bs.alert.data-api",c,d.prototype.close)}(jQuery),+function(a){"use strict";function b(b){return this.each(function(){var d=a(this),e=d.data("bs.button"),f="object"==typeof b&&b;e||d.data("bs.button",e=new c(this,f)),"toggle"==b?e.toggle():b&&e.setState(b)})}var c=function(b,d){this.$element=a(b),this.options=a.extend({},c.DEFAULTS,d),this.isLoading=!1};c.VERSION="3.2.0",c.DEFAULTS={loadingText:"loading..."},c.prototype.setState=function(b){var c="disabled",d=this.$element,e=d.is("input")?"val":"html",f=d.data();b+="Text",null==f.resetText&&d.data("resetText",d[e]()),d[e](null==f[b]?this.options[b]:f[b]),setTimeout(a.proxy(function(){"loadingText"==b?(this.isLoading=!0,d.addClass(c).attr(c,c)):this.isLoading&&(this.isLoading=!1,d.removeClass(c).removeAttr(c))},this),0)},c.prototype.toggle=function(){var a=!0,b=this.$element.closest('[data-toggle="buttons"]');if(b.length){var c=this.$element.find("input");"radio"==c.prop("type")&&(c.prop("checked")&&this.$element.hasClass("active")?a=!1:b.find(".active").removeClass("active")),a&&c.prop("checked",!this.$element.hasClass("active")).trigger("change")}a&&this.$element.toggleClass("active")};var d=a.fn.button;a.fn.button=b,a.fn.button.Constructor=c,a.fn.button.noConflict=function(){return a.fn.button=d,this},a(document).on("click.bs.button.data-api",'[data-toggle^="button"]',function(c){var d=a(c.target);d.hasClass("btn")||(d=d.closest(".btn")),b.call(d,"toggle"),c.preventDefault()})}(jQuery),+function(a){"use strict";function b(b){return this.each(function(){var d=a(this),e=d.data("bs.carousel"),f=a.extend({},c.DEFAULTS,d.data(),"object"==typeof b&&b),g="string"==typeof b?b:f.slide;e||d.data("bs.carousel",e=new c(this,f)),"number"==typeof b?e.to(b):g?e[g]():f.interval&&e.pause().cycle()})}var c=function(b,c){this.$element=a(b).on("keydown.bs.carousel",a.proxy(this.keydown,this)),this.$indicators=this.$element.find(".carousel-indicators"),this.options=c,this.paused=this.sliding=this.interval=this.$active=this.$items=null,"hover"==this.options.pause&&this.$element.on("mouseenter.bs.carousel",a.proxy(this.pause,this)).on("mouseleave.bs.carousel",a.proxy(this.cycle,this))};c.VERSION="3.2.0",c.DEFAULTS={interval:5e3,pause:"hover",wrap:!0},c.prototype.keydown=function(a){switch(a.which){case 37:this.prev();break;case 39:this.next();break;default:return}a.preventDefault()},c.prototype.cycle=function(b){return b||(this.paused=!1),this.interval&&clearInterval(this.interval),this.options.interval&&!this.paused&&(this.interval=setInterval(a.proxy(this.next,this),this.options.interval)),this},c.prototype.getItemIndex=function(a){return this.$items=a.parent().children(".item"),this.$items.index(a||this.$active)},c.prototype.to=function(b){var c=this,d=this.getItemIndex(this.$active=this.$element.find(".item.active"));return b>this.$items.length-1||0>b?void 0:this.sliding?this.$element.one("slid.bs.carousel",function(){c.to(b)}):d==b?this.pause().cycle():this.slide(b>d?"next":"prev",a(this.$items[b]))},c.prototype.pause=function(b){return b||(this.paused=!0),this.$element.find(".next, .prev").length&&a.support.transition&&(this.$element.trigger(a.support.transition.end),this.cycle(!0)),this.interval=clearInterval(this.interval),this},c.prototype.next=function(){return this.sliding?void 0:this.slide("next")},c.Line truncated

bin/src/github.com/revel/modules/testrunner/public/js/highlight.pack.js

@@ -0,0 +1 @@
+var hljs=new function(){function j(v){return v.replace(/&/gm,"&amp;").replace(/</gm,"&lt;").replace(/>/gm,"&gt;")}function t(v){return v.nodeName.toLowerCase()}function h(w,x){var v=w&&w.exec(x);return v&&v.index==0}function r(w){var v=(w.className+" "+(w.parentNode?w.parentNode.className:"")).split(/\s+/);v=v.map(function(x){return x.replace(/^lang(uage)?-/,"")});return v.filter(function(x){return i(x)||/no(-?)highlight/.test(x)})[0]}function o(x,y){var v={};for(var w in x){v[w]=x[w]}if(y){for(var w in y){v[w]=y[w]}}return v}function u(x){var v=[];(function w(y,z){for(var A=y.firstChild;A;A=A.nextSibling){if(A.nodeType==3){z+=A.nodeValue.length}else{if(A.nodeType==1){v.push({event:"start",offset:z,node:A});z=w(A,z);if(!t(A).match(/br|hr|img|input/)){v.push({event:"stop",offset:z,node:A})}}}}return z})(x,0);return v}function q(w,y,C){var x=0;var F="";var z=[];function B(){if(!w.length||!y.length){return w.length?w:y}if(w[0].offset!=y[0].offset){return(w[0].offset<y[0].offset)?w:y}return y[0].event=="start"?w:y}function A(H){function G(I){return" "+I.nodeName+'="'+j(I.value)+'"'}F+="<"+t(H)+Array.prototype.map.call(H.attributes,G).join("")+">"}function E(G){F+="</"+t(G)+">"}function v(G){(G.event=="start"?A:E)(G.node)}while(w.length||y.length){var D=B();F+=j(C.substr(x,D[0].offset-x));x=D[0].offset;if(D==w){z.reverse().forEach(E);do{v(D.splice(0,1)[0]);D=B()}while(D==w&&D.length&&D[0].offset==x);z.reverse().forEach(A)}else{if(D[0].event=="start"){z.push(D[0].node)}else{z.pop()}v(D.splice(0,1)[0])}}return F+j(C.substr(x))}function m(y){function v(z){return(z&&z.source)||z}function w(A,z){return RegExp(v(A),"m"+(y.cI?"i":"")+(z?"g":""))}function x(D,C){if(D.compiled){return}D.compiled=true;D.k=D.k||D.bK;if(D.k){var z={};var E=function(G,F){if(y.cI){F=F.toLowerCase()}F.split(" ").forEach(function(H){var I=H.split("|");z[I[0]]=[G,I[1]?Number(I[1]):1]})};if(typeof D.k=="string"){E("keyword",D.k)}else{Object.keys(D.k).forEach(function(F){E(F,D.k[F])})}D.k=z}D.lR=w(D.l||/\b[A-Za-z0-9_]+\b/,true);if(C){if(D.bK){D.b="\\b("+D.bK.split(" ").join("|")+")\\b"}if(!D.b){D.b=/\B|\b/}D.bR=w(D.b);if(!D.e&&!D.eW){D.e=/\B|\b/}if(D.e){D.eR=w(D.e)}D.tE=v(D.e)||"";if(D.eW&&C.tE){D.tE+=(D.e?"|":"")+C.tE}}if(D.i){D.iR=w(D.i)}if(D.r===undefined){D.r=1}if(!D.c){D.c=[]}var B=[];D.c.forEach(function(F){if(F.v){F.v.forEach(function(G){B.push(o(F,G))})}else{B.push(F=="self"?D:F)}});D.c=B;D.c.forEach(function(F){x(F,D)});if(D.starts){x(D.starts,C)}var A=D.c.map(function(F){return F.bK?"\\.?("+F.b+")\\.?":F.b}).concat([D.tE,D.i]).map(v).filter(Boolean);D.t=A.length?w(A.join("|"),true):{exec:function(F){return null}}}x(y)}function c(T,L,J,R){function v(V,W){for(var U=0;U<W.c.length;U++){if(h(W.c[U].bR,V)){return W.c[U]}}}function z(V,U){if(h(V.eR,U)){return V}if(V.eW){return z(V.parent,U)}}function A(U,V){return !J&&h(V.iR,U)}function E(W,U){var V=M.cI?U[0].toLowerCase():U[0];return W.k.hasOwnProperty(V)&&W.k[V]}function w(aa,Y,X,W){var U=W?"":b.classPrefix,V='<span class="'+U,Z=X?"":"</span>";V+=aa+'">';return V+Y+Z}function N(){if(!I.k){return j(C)}var U="";var X=0;I.lR.lastIndex=0;var V=I.lR.exec(C);while(V){U+=j(C.substr(X,V.index-X));var W=E(I,V);if(W){H+=W[1];U+=w(W[0],j(V[0]))}else{U+=j(V[0])}X=I.lR.lastIndex;V=I.lR.exec(C)}return U+j(C.substr(X))}function F(){if(I.sL&&!f[I.sL]){return j(C)}var U=I.sL?c(I.sL,C,true,S):e(C);if(I.r>0){H+=U.r}if(I.subLanguageMode=="continuous"){S=U.top}return w(U.language,U.value,false,true)}function Q(){return I.sL!==undefined?F():N()}function P(W,V){var U=W.cN?w(W.cN,"",true):"";if(W.rB){D+=U;C=""}else{if(W.eB){D+=j(V)+U;C=""}else{D+=U;C=V}}I=Object.create(W,{parent:{value:I}})}function G(U,Y){C+=U;if(Y===undefined){D+=Q();return 0}var W=v(Y,I);if(W){D+=Q();P(W,Y);return W.rB?0:Y.length}var X=z(I,Y);if(X){var V=I;if(!(V.rE||V.eE)){C+=Y}D+=Q();do{if(I.cN){D+="</span>"}H+=I.r;I=I.parent}while(I!=X.parent);if(V.eE){D+=j(Y)}C="";if(X.starts){P(X.starts,"")}return V.rE?0:Y.length}if(A(Y,I)){throw new Error('Illegal lexeme "'+Y+'" for mode "'+(I.cN||"<unnamed>")+'"')}C+=Y;return Y.length||1}var M=i(T);if(!M){throw new Error('Unknown language: "'+T+'"')}m(M);var I=R||M;var S;var D="";for(var K=I;K!=M;K=K.parent){if(K.cN){D=w(K.cN,"",true)+D}}var C="";var H=0;try{var B,y,x=0;while(true){I.t.lastIndex=x;B=I.t.exec(L);if(!B){break}y=G(L.substr(x,B.index-x),B[0]);x=B.index+y}G(L.substr(x));for(var K=I;K.parent;K=K.parent){if(K.cN){D+="</span>"}}return{r:H,value:D,language:T,top:I}}catch(O){if(O.message.indexOf("Illegal")!=-1){return{r:0,value:j(L)}}else{throw O}}}function e(y,x){x=x||b.languages||Object.keys(f);var v={r:0,value:j(y)};var w=v;x.forEach(function(z){if(!i(z)){return}var A=c(z,y,false);A.language=z;if(A.r>w.r){w=A}if(A.r>v.r){w=v;v=A}});if(w.language){v.second_best=w}return v}function g(v){if(b.tabReplace){v=v.replace(/^((<[^>]+>|\t)+)/gm,function(w,z,y,x){return z.replace(/\t/g,b.tabReplace)})}if(b.useBR){v=v.replace(/\n/g,"<br>")}return v}function p(A){var B=r(A);if(/no(-?)highlight/.test(B)){retuLine truncated

bin/src/github.com/revel/modules/testrunner/public/js/jquery-1.9.1.min.js

@@ -0,0 +1,5 @@
+/*! jQuery v1.9.1 | (c) 2005, 2012 jQuery Foundation, Inc. | jquery.org/license
+//@ sourceMappingURL=jquery.min.map
+*/(function(e,t){var n,r,i=typeof t,o=e.document,a=e.location,s=e.jQuery,u=e.$,l={},c=[],p="1.9.1",f=c.concat,d=c.push,h=c.slice,g=c.indexOf,m=l.toString,y=l.hasOwnProperty,v=p.trim,b=function(e,t){return new b.fn.init(e,t,r)},x=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,w=/\S+/g,T=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,N=/^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/,C=/^<(\w+)\s*\/?>(?:<\/\1>|)$/,k=/^[\],:{}\s]*$/,E=/(?:^|:|,)(?:\s*\[)+/g,S=/\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,A=/"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g,j=/^-ms-/,D=/-([\da-z])/gi,L=function(e,t){return t.toUpperCase()},H=function(e){(o.addEventListener||"load"===e.type||"complete"===o.readyState)&&(q(),b.ready())},q=function(){o.addEventListener?(o.removeEventListener("DOMContentLoaded",H,!1),e.removeEventListener("load",H,!1)):(o.detachEvent("onreadystatechange",H),e.detachEvent("onload",H))};b.fn=b.prototype={jquery:p,constructor:b,init:function(e,n,r){var i,a;if(!e)return this;if("string"==typeof e){if(i="<"===e.charAt(0)&&">"===e.charAt(e.length-1)&&e.length>=3?[null,e,null]:N.exec(e),!i||!i[1]&&n)return!n||n.jquery?(n||r).find(e):this.constructor(n).find(e);if(i[1]){if(n=n instanceof b?n[0]:n,b.merge(this,b.parseHTML(i[1],n&&n.nodeType?n.ownerDocument||n:o,!0)),C.test(i[1])&&b.isPlainObject(n))for(i in n)b.isFunction(this[i])?this[i](n[i]):this.attr(i,n[i]);return this}if(a=o.getElementById(i[2]),a&&a.parentNode){if(a.id!==i[2])return r.find(e);this.length=1,this[0]=a}return this.context=o,this.selector=e,this}return e.nodeType?(this.context=this[0]=e,this.length=1,this):b.isFunction(e)?r.ready(e):(e.selector!==t&&(this.selector=e.selector,this.context=e.context),b.makeArray(e,this))},selector:"",length:0,size:function(){return this.length},toArray:function(){return h.call(this)},get:function(e){return null==e?this.toArray():0>e?this[this.length+e]:this[e]},pushStack:function(e){var t=b.merge(this.constructor(),e);return t.prevObject=this,t.context=this.context,t},each:function(e,t){return b.each(this,e,t)},ready:function(e){return b.ready.promise().done(e),this},slice:function(){return this.pushStack(h.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(e){var t=this.length,n=+e+(0>e?t:0);return this.pushStack(n>=0&&t>n?[this[n]]:[])},map:function(e){return this.pushStack(b.map(this,function(t,n){return e.call(t,n,t)}))},end:function(){return this.prevObject||this.constructor(null)},push:d,sort:[].sort,splice:[].splice},b.fn.init.prototype=b.fn,b.extend=b.fn.extend=function(){var e,n,r,i,o,a,s=arguments[0]||{},u=1,l=arguments.length,c=!1;for("boolean"==typeof s&&(c=s,s=arguments[1]||{},u=2),"object"==typeof s||b.isFunction(s)||(s={}),l===u&&(s=this,--u);l>u;u++)if(null!=(o=arguments[u]))for(i in o)e=s[i],r=o[i],s!==r&&(c&&r&&(b.isPlainObject(r)||(n=b.isArray(r)))?(n?(n=!1,a=e&&b.isArray(e)?e:[]):a=e&&b.isPlainObject(e)?e:{},s[i]=b.extend(c,a,r)):r!==t&&(s[i]=r));return s},b.extend({noConflict:function(t){return e.$===b&&(e.$=u),t&&e.jQuery===b&&(e.jQuery=s),b},isReady:!1,readyWait:1,holdReady:function(e){e?b.readyWait++:b.ready(!0)},ready:function(e){if(e===!0?!--b.readyWait:!b.isReady){if(!o.body)return setTimeout(b.ready);b.isReady=!0,e!==!0&&--b.readyWait>0||(n.resolveWith(o,[b]),b.fn.trigger&&b(o).trigger("ready").off("ready"))}},isFunction:function(e){return"function"===b.type(e)},isArray:Array.isArray||function(e){return"array"===b.type(e)},isWindow:function(e){return null!=e&&e==e.window},isNumeric:function(e){return!isNaN(parseFloat(e))&&isFinite(e)},type:function(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?l[m.call(e)]||"object":typeof e},isPlainObject:function(e){if(!e||"object"!==b.type(e)||e.nodeType||b.isWindow(e))return!1;try{if(e.constructor&&!y.call(e,"constructor")&&!y.call(e.constructor.prototype,"isPrototypeOf"))return!1}catch(n){return!1}var r;for(r in e);return r===t||y.call(e,r)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},error:function(e){throw Error(e)},parseHTML:function(e,t,n){if(!e||"string"!=typeof e)return null;"boolean"==typeof t&&(n=t,t=!1),t=t||o;var r=C.exec(e),i=!n&&[];return r?[t.createElement(r[1])]:(r=b.buildFragment([e],t,i),i&&b(i).remove(),b.merge([],r.childNodes))},parseJSON:function(n){return e.JSON&&e.JSON.parse?e.JSON.parse(n):null===n?n:"string"==typeof n&&(n=b.trim(n),n&&k.test(n.replace(S,"@").replace(A,"]").replace(E,"")))?Function("return "+n)():(b.error("Invalid JSON: "+n),t)},parseXML:function(n){var r,i;if(!n||"string"!=typeof n)return null;try{e.DOMParser?(i=new DOMParser,r=i.parseFromString(n,"text/xml")):(r=new ActiveXObject("Microsoft.XMLDOM"),r.async="false",r.loadXML(n))}catch(o){r=t}return r&&r.documentElement&&!r.getElementsByTagName("parsererror").length||b.error("Invalid XML: "+n),r},noop:function(){},globalEval:function(t){t&&b.trim(t)&&(e.execScript||function(t){e.eval.call(e,t)})(t)},camelCase:function(e){return e.replace(j,"ms-").replace(D,L)},nodeName:function(Line truncated
+return(!i||i!==r&&!b.contains(r,i))&&(e.type=o.origType,n=o.handler.apply(this,arguments),e.type=t),n}}}),b.support.submitBubbles||(b.event.special.submit={setup:function(){return b.nodeName(this,"form")?!1:(b.event.add(this,"click._submit keypress._submit",function(e){var n=e.target,r=b.nodeName(n,"input")||b.nodeName(n,"button")?n.form:t;r&&!b._data(r,"submitBubbles")&&(b.event.add(r,"submit._submit",function(e){e._submit_bubble=!0}),b._data(r,"submitBubbles",!0))}),t)},postDispatch:function(e){e._submit_bubble&&(delete e._submit_bubble,this.parentNode&&!e.isTrigger&&b.event.simulate("submit",this.parentNode,e,!0))},teardown:function(){return b.nodeName(this,"form")?!1:(b.event.remove(this,"._submit"),t)}}),b.support.changeBubbles||(b.event.special.change={setup:function(){return Z.test(this.nodeName)?(("checkbox"===this.type||"radio"===this.type)&&(b.event.add(this,"propertychange._change",function(e){"checked"===e.originalEvent.propertyName&&(this._just_changed=!0)}),b.event.add(this,"click._change",function(e){this._just_changed&&!e.isTrigger&&(this._just_changed=!1),b.event.simulate("change",this,e,!0)})),!1):(b.event.add(this,"beforeactivate._change",function(e){var t=e.target;Z.test(t.nodeName)&&!b._data(t,"changeBubbles")&&(b.event.add(t,"change._change",function(e){!this.parentNode||e.isSimulated||e.isTrigger||b.event.simulate("change",this.parentNode,e,!0)}),b._data(t,"changeBubbles",!0))}),t)},handle:function(e){var n=e.target;return this!==n||e.isSimulated||e.isTrigger||"radio"!==n.type&&"checkbox"!==n.type?e.handleObj.handler.apply(this,arguments):t},teardown:function(){return b.event.remove(this,"._change"),!Z.test(this.nodeName)}}),b.support.focusinBubbles||b.each({focus:"focusin",blur:"focusout"},function(e,t){var n=0,r=function(e){b.event.simulate(t,e.target,b.event.fix(e),!0)};b.event.special[t]={setup:function(){0===n++&&o.addEventListener(e,r,!0)},teardown:function(){0===--n&&o.removeEventListener(e,r,!0)}}}),b.fn.extend({on:function(e,n,r,i,o){var a,s;if("object"==typeof e){"string"!=typeof n&&(r=r||n,n=t);for(a in e)this.on(a,n,r,e[a],o);return this}if(null==r&&null==i?(i=n,r=n=t):null==i&&("string"==typeof n?(i=r,r=t):(i=r,r=n,n=t)),i===!1)i=ot;else if(!i)return this;return 1===o&&(s=i,i=function(e){return b().off(e),s.apply(this,arguments)},i.guid=s.guid||(s.guid=b.guid++)),this.each(function(){b.event.add(this,e,i,r,n)})},one:function(e,t,n,r){return this.on(e,t,n,r,1)},off:function(e,n,r){var i,o;if(e&&e.preventDefault&&e.handleObj)return i=e.handleObj,b(e.delegateTarget).off(i.namespace?i.origType+"."+i.namespace:i.origType,i.selector,i.handler),this;if("object"==typeof e){for(o in e)this.off(o,n,e[o]);return this}return(n===!1||"function"==typeof n)&&(r=n,n=t),r===!1&&(r=ot),this.each(function(){b.event.remove(this,e,r,n)})},bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},trigger:function(e,t){return this.each(function(){b.event.trigger(e,t,this)})},triggerHandler:function(e,n){var r=this[0];return r?b.event.trigger(e,n,r,!0):t}}),function(e,t){var n,r,i,o,a,s,u,l,c,p,f,d,h,g,m,y,v,x="sizzle"+-new Date,w=e.document,T={},N=0,C=0,k=it(),E=it(),S=it(),A=typeof t,j=1<<31,D=[],L=D.pop,H=D.push,q=D.slice,M=D.indexOf||function(e){var t=0,n=this.length;for(;n>t;t++)if(this[t]===e)return t;return-1},_="[\\x20\\t\\r\\n\\f]",F="(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",O=F.replace("w","w#"),B="([*^$|!~]?=)",P="\\["+_+"*("+F+")"+_+"*(?:"+B+_+"*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|("+O+")|)|)"+_+"*\\]",R=":("+F+")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|"+P.replace(3,8)+")*)|.*)\\)|)",W=RegExp("^"+_+"+|((?:^|[^\\\\])(?:\\\\.)*)"+_+"+$","g"),$=RegExp("^"+_+"*,"+_+"*"),I=RegExp("^"+_+"*([\\x20\\t\\r\\n\\f>+~])"+_+"*"),z=RegExp(R),X=RegExp("^"+O+"$"),U={ID:RegExp("^#("+F+")"),CLASS:RegExp("^\\.("+F+")"),NAME:RegExp("^\\[name=['\"]?("+F+")['\"]?\\]"),TAG:RegExp("^("+F.replace("w","w*")+")"),ATTR:RegExp("^"+P),PSEUDO:RegExp("^"+R),CHILD:RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+_+"*(even|odd|(([+-]|)(\\d*)n|)"+_+"*(?:([+-]|)"+_+"*(\\d+)|))"+_+"*\\)|)","i"),needsContext:RegExp("^"+_+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+_+"*((?:-\\d)?\\d*)"+_+"*\\)|)(?=[^-]|$)","i")},V=/[\x20\t\r\n\f]*[+~]/,Y=/^[^{]+\{\s*\[native code/,J=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,G=/^(?:input|select|textarea|button)$/i,Q=/^h\d$/i,K=/'|\\/g,Z=/\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,et=/\\([\da-fA-F]{1,6}[\x20\t\r\n\f]?|.)/g,tt=function(e,t){var n="0x"+t-65536;return n!==n?t:0>n?String.fromCharCode(n+65536):String.fromCharCode(55296|n>>10,56320|1023&n)};try{q.call(w.documentElement.childNodes,0)[0].nodeType}catch(nt){q=function(e){var t,n=[];while(t=this[e++])n.push(t);return n}}function rt(e){return Y.test(e+"")}function it(){var e,t=[];return e=function(n,r){return t.push(n+Line truncated
+}b.merge(d,s.childNodes),s.textContent="";while(s.firstChild)s.removeChild(s.firstChild);s=f.lastChild}else d.push(t.createTextNode(o));s&&f.removeChild(s),b.support.appendChecked||b.grep(Ot(d,"input"),Bt),h=0;while(o=d[h++])if((!r||-1===b.inArray(o,r))&&(a=b.contains(o.ownerDocument,o),s=Ot(f.appendChild(o),"script"),a&&Mt(s),n)){i=0;while(o=s[i++])kt.test(o.type||"")&&n.push(o)}return s=null,f},cleanData:function(e,t){var n,r,o,a,s=0,u=b.expando,l=b.cache,p=b.support.deleteExpando,f=b.event.special;for(;null!=(n=e[s]);s++)if((t||b.acceptData(n))&&(o=n[u],a=o&&l[o])){if(a.events)for(r in a.events)f[r]?b.event.remove(n,r):b.removeEvent(n,r,a.handle);l[o]&&(delete l[o],p?delete n[u]:typeof n.removeAttribute!==i?n.removeAttribute(u):n[u]=null,c.push(o))}}});var Pt,Rt,Wt,$t=/alpha\([^)]*\)/i,It=/opacity\s*=\s*([^)]*)/,zt=/^(top|right|bottom|left)$/,Xt=/^(none|table(?!-c[ea]).+)/,Ut=/^margin/,Vt=RegExp("^("+x+")(.*)$","i"),Yt=RegExp("^("+x+")(?!px)[a-z%]+$","i"),Jt=RegExp("^([+-])=("+x+")","i"),Gt={BODY:"block"},Qt={position:"absolute",visibility:"hidden",display:"block"},Kt={letterSpacing:0,fontWeight:400},Zt=["Top","Right","Bottom","Left"],en=["Webkit","O","Moz","ms"];function tn(e,t){if(t in e)return t;var n=t.charAt(0).toUpperCase()+t.slice(1),r=t,i=en.length;while(i--)if(t=en[i]+n,t in e)return t;return r}function nn(e,t){return e=t||e,"none"===b.css(e,"display")||!b.contains(e.ownerDocument,e)}function rn(e,t){var n,r,i,o=[],a=0,s=e.length;for(;s>a;a++)r=e[a],r.style&&(o[a]=b._data(r,"olddisplay"),n=r.style.display,t?(o[a]||"none"!==n||(r.style.display=""),""===r.style.display&&nn(r)&&(o[a]=b._data(r,"olddisplay",un(r.nodeName)))):o[a]||(i=nn(r),(n&&"none"!==n||!i)&&b._data(r,"olddisplay",i?n:b.css(r,"display"))));for(a=0;s>a;a++)r=e[a],r.style&&(t&&"none"!==r.style.display&&""!==r.style.display||(r.style.display=t?o[a]||"":"none"));return e}b.fn.extend({css:function(e,n){return b.access(this,function(e,n,r){var i,o,a={},s=0;if(b.isArray(n)){for(o=Rt(e),i=n.length;i>s;s++)a[n[s]]=b.css(e,n[s],!1,o);return a}return r!==t?b.style(e,n,r):b.css(e,n)},e,n,arguments.length>1)},show:function(){return rn(this,!0)},hide:function(){return rn(this)},toggle:function(e){var t="boolean"==typeof e;return this.each(function(){(t?e:nn(this))?b(this).show():b(this).hide()})}}),b.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=Wt(e,"opacity");return""===n?"1":n}}}},cssNumber:{columnCount:!0,fillOpacity:!0,fontWeight:!0,lineHeight:!0,opacity:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":b.support.cssFloat?"cssFloat":"styleFloat"},style:function(e,n,r,i){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var o,a,s,u=b.camelCase(n),l=e.style;if(n=b.cssProps[u]||(b.cssProps[u]=tn(l,u)),s=b.cssHooks[n]||b.cssHooks[u],r===t)return s&&"get"in s&&(o=s.get(e,!1,i))!==t?o:l[n];if(a=typeof r,"string"===a&&(o=Jt.exec(r))&&(r=(o[1]+1)*o[2]+parseFloat(b.css(e,n)),a="number"),!(null==r||"number"===a&&isNaN(r)||("number"!==a||b.cssNumber[u]||(r+="px"),b.support.clearCloneStyle||""!==r||0!==n.indexOf("background")||(l[n]="inherit"),s&&"set"in s&&(r=s.set(e,r,i))===t)))try{l[n]=r}catch(c){}}},css:function(e,n,r,i){var o,a,s,u=b.camelCase(n);return n=b.cssProps[u]||(b.cssProps[u]=tn(e.style,u)),s=b.cssHooks[n]||b.cssHooks[u],s&&"get"in s&&(a=s.get(e,!0,r)),a===t&&(a=Wt(e,n,i)),"normal"===a&&n in Kt&&(a=Kt[n]),""===r||r?(o=parseFloat(a),r===!0||b.isNumeric(o)?o||0:a):a},swap:function(e,t,n,r){var i,o,a={};for(o in t)a[o]=e.style[o],e.style[o]=t[o];i=n.apply(e,r||[]);for(o in t)e.style[o]=a[o];return i}}),e.getComputedStyle?(Rt=function(t){return e.getComputedStyle(t,null)},Wt=function(e,n,r){var i,o,a,s=r||Rt(e),u=s?s.getPropertyValue(n)||s[n]:t,l=e.style;return s&&(""!==u||b.contains(e.ownerDocument,e)||(u=b.style(e,n)),Yt.test(u)&&Ut.test(n)&&(i=l.width,o=l.minWidth,a=l.maxWidth,l.minWidth=l.maxWidth=l.width=u,u=s.width,l.width=i,l.minWidth=o,l.maxWidth=a)),u}):o.documentElement.currentStyle&&(Rt=function(e){return e.currentStyle},Wt=function(e,n,r){var i,o,a,s=r||Rt(e),u=s?s[n]:t,l=e.style;return null==u&&l&&l[n]&&(u=l[n]),Yt.test(u)&&!zt.test(n)&&(i=l.left,o=e.runtimeStyle,a=o&&o.left,a&&(o.left=e.currentStyle.left),l.left="fontSize"===n?"1em":u,u=l.pixelLeft+"px",l.left=i,a&&(o.left=a)),""===u?"auto":u});function on(e,t,n){var r=Vt.exec(t);return r?Math.max(0,r[1]-(n||0))+(r[2]||"px"):t}function an(e,t,n,r,i){var o=n===(r?"border":"content")?4:"width"===t?1:0,a=0;for(;4>o;o+=2)"margin"===n&&(a+=b.css(e,n+Zt[o],!0,i)),r?("content"===n&&(a-=b.css(e,"padding"+Zt[o],!0,i)),"margin"!==n&&(a-=b.css(e,"border"+Zt[o]+"Width",!0,i))):(a+=b.css(e,"padding"+Zt[o],!0,i),"padding"!==n&&(a+=b.css(e,"border"+Zt[o]+"Width",!0,i)));return a}function sn(e,t,n){var r=!0,i="width"===t?e.offsetWidth:e.offsetHeight,o=Rt(e),a=b.support.boxSizing&&"border-box"===b.css(e,"boxSizing",!1,o);if(0>=i||null==i){if(i=Wt(e,t,o),(0>i||null==i)&&(i=e.style[t]),Yt.test(i))return i;r=a&&(b.support.boxSizingReliable||i===e.style[t]),i=parseFloat(i)||0}reLine truncated