vendor dependencies with dep

vendor/github.com/go-pg/migrations/.travis.yml

@@ -0,0 +1,22 @@
+sudo: false
+language: go
+
+services:
+- postgresql
+
+addons:
+  postgresql: "9.4"
+
+go:
+  - 1.7
+  - 1.8
+  - tip
+
+matrix:
+  allow_failures:
+    - go: tip
+
+install:
+  - go get github.com/go-pg/pg
+  - go get github.com/onsi/ginkgo
+  - go get github.com/onsi/gomega

vendor/github.com/go-pg/migrations/Makefile

@@ -0,0 +1,3 @@
+all:
+	go test ./...
+	go test ./... -short -race

vendor/github.com/go-pg/migrations/README.md

@@ -0,0 +1,5 @@
+# SQL migrations for Golang and PostgreSQL
+
+[![Build Status](https://travis-ci.org/go-pg/migrations.svg)](https://travis-ci.org/go-pg/migrations)
+
+This package allows you to run migrations on your PostgreSQL database using [Golang Postgres client](https://github.com/go-pg/pg). See [example](example) for details.

vendor/github.com/go-pg/migrations/db.go

@@ -0,0 +1,79 @@
+package migrations
+
+import (
+	"io"
+	"strings"
+
+	"github.com/go-pg/pg"
+	"github.com/go-pg/pg/orm"
+	"github.com/go-pg/pg/types"
+)
+
+var tableName = "gopg_migrations"
+
+func SetTableName(name string) {
+	tableName = name
+}
+
+type DB interface {
+	Exec(query interface{}, params ...interface{}) (orm.Result, error)
+	ExecOne(query interface{}, params ...interface{}) (orm.Result, error)
+	Query(model, query interface{}, params ...interface{}) (orm.Result, error)
+	QueryOne(model, query interface{}, params ...interface{}) (orm.Result, error)
+
+	Model(model ...interface{}) *orm.Query
+	Select(model interface{}) error
+	Insert(model ...interface{}) error
+	Update(model ...interface{}) error
+	Delete(model interface{}) error
+	CreateTable(model interface{}, opt *orm.CreateTableOptions) error
+	DropTable(model interface{}, opt *orm.DropTableOptions) error
+
+	CopyFrom(r io.Reader, query interface{}, params ...interface{}) (orm.Result, error)
+	CopyTo(w io.Writer, query interface{}, params ...interface{}) (orm.Result, error)
+
+	FormatQuery(dst []byte, query string, params ...interface{}) []byte
+}
+
+func getTableName() types.ValueAppender {
+	return pg.Q(tableName)
+}
+
+func Version(db DB) (int64, error) {
+	var version int64
+	_, err := db.QueryOne(pg.Scan(&version), `
+		SELECT version FROM ? ORDER BY id DESC LIMIT 1
+	`, getTableName())
+	if err != nil {
+		if err == pg.ErrNoRows {
+			return 0, nil
+		}
+		return 0, err
+	}
+	return version, nil
+}
+
+func SetVersion(db DB, version int64) error {
+	_, err := db.Exec(`
+		INSERT INTO ? (version, created_at) VALUES (?, now())
+	`, getTableName(), version)
+	return err
+}
+
+func createTables(db DB) error {
+	if ind := strings.IndexByte(tableName, '.'); ind >= 0 {
+		_, err := db.Exec(`CREATE SCHEMA IF NOT EXISTS ?`, pg.Q(tableName[:ind]))
+		if err != nil {
+			return err
+		}
+	}
+
+	_, err := db.Exec(`
+		CREATE TABLE IF NOT EXISTS ? (
+			id serial,
+			version bigint,
+			created_at timestamptz
+		)
+	`, getTableName())
+	return err
+}

vendor/github.com/go-pg/migrations/db_test.go

@@ -0,0 +1,161 @@
+package migrations_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/go-pg/migrations"
+
+	"github.com/go-pg/pg"
+)
+
+func connectDB() *pg.DB {
+	db := pg.Connect(&pg.Options{
+		User: "postgres",
+	})
+
+	_, err := db.Exec("DROP TABLE IF EXISTS gopg_migrations")
+	if err != nil {
+		panic(err)
+	}
+
+	return db
+}
+
+func TestVersion(t *testing.T) {
+	db := connectDB()
+
+	_, _, err := migrations.Run(db, "init")
+	if err != nil {
+		t.Fatalf("init failed: %s", err)
+	}
+
+	version, err := migrations.Version(db)
+	if err != nil {
+		t.Fatalf("Version failed: %s", err)
+	}
+	if version != 0 {
+		t.Fatalf("got version %d, wanted 0", version)
+	}
+
+	if err := migrations.SetVersion(db, 999); err != nil {
+		t.Fatalf("SetVersion failed: %s", err)
+	}
+
+	version, err = migrations.Version(db)
+	if err != nil {
+		t.Fatalf("Version failed: %s", err)
+	}
+	if version != 999 {
+		t.Fatalf("got version %d, wanted %d", version)
+	}
+}
+
+func TestUpDown(t *testing.T) {
+	db := connectDB()
+
+	_, _, err := migrations.Run(db, "init")
+	if err != nil {
+		t.Fatalf("init failed: %s", err)
+	}
+
+	migrations.Set([]migrations.Migration{
+		{Version: 2, Up: doNothing, Down: doNothing},
+		{Version: 1, Up: doNothing, Down: doNothing},
+		{Version: 3, Up: doNothing, Down: doNothing},
+	})
+	oldVersion, newVersion, err := migrations.Run(db, "up")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if oldVersion != 0 {
+		t.Fatalf("got %d, wanted 0", oldVersion)
+	}
+	if newVersion != 3 {
+		t.Fatalf("got %d, wanted 3", newVersion)
+	}
+
+	version, err := migrations.Version(db)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if version != 3 {
+		t.Fatalf("got version %d, wanted 3", version)
+	}
+
+	for i := 2; i >= -5; i-- {
+		wantOldVersion := int64(i + 1)
+		wantNewVersion := int64(i)
+		if wantNewVersion < 0 {
+			wantOldVersion = 0
+			wantNewVersion = 0
+		}
+
+		oldVersion, newVersion, err = migrations.Run(db, "down")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if oldVersion != wantOldVersion {
+			t.Fatalf("got %d, wanted %d", oldVersion, wantOldVersion)
+		}
+		if newVersion != wantNewVersion {
+			t.Fatalf("got %d, wanted %d", newVersion, wantNewVersion)
+		}
+
+		version, err = migrations.Version(db)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if version != wantNewVersion {
+			t.Fatalf("got version %d, wanted %d", version, wantNewVersion)
+		}
+	}
+}
+
+func TestSetVersion(t *testing.T) {
+	db := connectDB()
+
+	_, _, err := migrations.Run(db, "init")
+	if err != nil {
+		t.Fatalf("init failed: %s", err)
+	}
+
+	migrations.Set([]migrations.Migration{
+		{Version: 1, Up: doPanic, Down: doPanic},
+		{Version: 2, Up: doPanic, Down: doPanic},
+		{Version: 3, Up: doPanic, Down: doPanic},
+	})
+
+	for i := 0; i < 5; i++ {
+		wantOldVersion := int64(i)
+		wantNewVersion := int64(i + 1)
+
+		oldVersion, newVersion, err := migrations.Run(
+			db, "set_version", fmt.Sprint(wantNewVersion))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if oldVersion != wantOldVersion {
+			t.Fatalf("got %d, wanted %d", oldVersion, wantOldVersion)
+		}
+		if newVersion != wantNewVersion {
+			t.Fatalf("got %d, wanted %d", newVersion, wantNewVersion)
+		}
+
+		version, err := migrations.Version(db)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if version != wantNewVersion {
+			t.Fatalf("got version %d, wanted %d", version, wantNewVersion)
+		}
+	}
+}
+
+func doNothing(db migrations.DB) error {
+	return nil
+}
+
+func doPanic(db migrations.DB) error {
+	panic("this migration should not be run")
+}

vendor/github.com/go-pg/migrations/example/1_initial.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/go-pg/migrations"
+)
+
+func init() {
+	migrations.Register(func(db migrations.DB) error {
+		fmt.Println("creating table my_table...")
+		_, err := db.Exec(`CREATE TABLE my_table()`)
+		return err
+	}, func(db migrations.DB) error {
+		fmt.Println("dropping table my_table...")
+		_, err := db.Exec(`DROP TABLE my_table`)
+		return err
+	})
+}

vendor/github.com/go-pg/migrations/example/2_add_id.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/go-pg/migrations"
+)
+
+func init() {
+	migrations.Register(func(db migrations.DB) error {
+		fmt.Println("adding id column...")
+		_, err := db.Exec(`ALTER TABLE my_table ADD id serial`)
+		return err
+	}, func(db migrations.DB) error {
+		fmt.Println("dropping id column...")
+		_, err := db.Exec(`ALTER TABLE my_table DROP id`)
+		return err
+	})
+}

vendor/github.com/go-pg/migrations/example/3_seed_data.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/go-pg/migrations"
+)
+
+func init() {
+	migrations.Register(func(db migrations.DB) error {
+		fmt.Println("seeding my_table...")
+		_, err := db.Exec(`INSERT INTO my_table VALUES (1)`)
+		return err
+	}, func(db migrations.DB) error {
+		fmt.Println("truncating my_table...")
+		_, err := db.Exec(`TRUNCATE my_table`)
+		return err
+	})
+}

vendor/github.com/go-pg/migrations/example/README.md

@@ -0,0 +1,64 @@
+# Example
+
+You need to create database `pg_migrations_example` before running this example.
+
+```bash
+> psql -c "CREATE DATABASE pg_migrations_example"
+CREATE DATABASE
+
+> go run *.go init
+version is 0
+
+> go run *.go version
+version is 0
+
+> go run *.go
+creating table my_table...
+adding id column...
+seeding my_table...
+migrated from version 0 to 3
+
+> go run *.go version
+version is 3
+
+> go run *.go reset
+truncating my_table...
+dropping id column...
+dropping table my_table...
+migrated from version 3 to 0
+
+> go run *.go
+creating table my_table...
+adding id column...
+seeding my_table...
+migrated from version 0 to 3
+
+> go run *.go down
+truncating my_table...
+migrated from version 3 to 2
+
+> go run *.go version
+version is 2
+
+> go run *.go set_version 1
+migrated from version 2 to 1
+
+> go run *.go create add email to users
+created migration 4_add_email_to_users.go
+```
+
+## Transactions
+
+If you'd want to wrap the whole run in a big transaction, which may be the case if you have multi-statement migrations, the code in `main.go` should be slightly modified:
+
+```go
+var oldVersion, newVersion int64
+
+err := db.RunInTransaction(func(tx *pg.Tx) (err error) {
+    oldVersion, newVersion, err = migrations.Run(tx, flag.Args()...)
+    return
+})
+if err != nil {
+    exitf(err.Error())
+}
+```

vendor/github.com/go-pg/migrations/example/main.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/go-pg/migrations"
+	"github.com/go-pg/pg"
+)
+
+const usageText = `This program runs command on the db. Supported commands are:
+  - init - creates gopg_migrations table.
+  - up - runs all available migrations.
+  - down - reverts last migration.
+  - reset - reverts all migrations.
+  - version - prints current db version.
+  - set_version [version] - sets db version without running migrations.
+
+Usage:
+  go run *.go <command> [args]
+`
+
+func main() {
+	flag.Usage = usage
+	flag.Parse()
+
+	db := pg.Connect(&pg.Options{
+		User:     "postgres",
+		Database: "pg_migrations_example",
+	})
+
+	oldVersion, newVersion, err := migrations.Run(db, flag.Args()...)
+	if err != nil {
+		exitf(err.Error())
+	}
+	if newVersion != oldVersion {
+		fmt.Printf("migrated from version %d to %d\n", oldVersion, newVersion)
+	} else {
+		fmt.Printf("version is %d\n", oldVersion)
+	}
+}
+
+func usage() {
+	fmt.Printf(usageText)
+	flag.PrintDefaults()
+	os.Exit(2)
+}
+
+func errorf(s string, args ...interface{}) {
+	fmt.Fprintf(os.Stderr, s+"\n", args...)
+}
+
+func exitf(s string, args ...interface{}) {
+	errorf(s, args...)
+	os.Exit(1)
+}

vendor/github.com/go-pg/migrations/export_test.go

@@ -0,0 +1,5 @@
+package migrations
+
+func Set(ms []Migration) {
+	allMigrations = ms
+}

vendor/github.com/go-pg/migrations/migrations.go

@@ -0,0 +1,264 @@
+package migrations
+
+import (
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+var allMigrations []Migration
+
+type Migration struct {
+	Version int64
+	Up      func(DB) error
+	Down    func(DB) error
+}
+
+func (m *Migration) String() string {
+	return strconv.FormatInt(m.Version, 10)
+}
+
+// Register registers new database migration. Must be called
+// from file with name like "1_initialize_db.go", where:
+// - 1 - migration version;
+// - initialize_db - comment.
+func Register(up, down func(DB) error) error {
+	_, file, _, _ := runtime.Caller(1)
+	version, err := extractVersion(file)
+	if err != nil {
+		return err
+	}
+
+	allMigrations = append(allMigrations, Migration{
+		Version: version,
+		Up:      up,
+		Down:    down,
+	})
+	return nil
+}
+
+// Run runs command on the db. Supported commands are:
+// - init - creates gopg_migrations table.
+// - up - runs all available migrations.
+// - down - reverts last migration.
+// - reset - reverts all migrations.
+// - version - prints current db version.
+// - set_version - sets db version without running migrations.
+func Run(db DB, a ...string) (oldVersion, newVersion int64, err error) {
+	// Make a copy so there are no side effects of sorting.
+	migrations := make([]Migration, len(allMigrations))
+	copy(migrations, allMigrations)
+	return RunMigrations(db, migrations, a...)
+}
+
+// RunMigrations is like Run, but accepts list of migrations.
+func RunMigrations(db DB, migrations []Migration, a ...string) (oldVersion, newVersion int64, err error) {
+	sortMigrations(migrations)
+
+	var cmd string
+	if len(a) > 0 {
+		cmd = a[0]
+	}
+
+	if cmd == "init" {
+		err = createTables(db)
+		if err != nil {
+			return
+		}
+		cmd = "version"
+	}
+
+	oldVersion, err = Version(db)
+	if err != nil {
+		return
+	}
+
+	switch cmd {
+	case "create":
+		if len(a) < 2 {
+			fmt.Println("Please enter migration description")
+			return
+		}
+
+		var version int64
+		if len(migrations) > 0 {
+			version = migrations[len(migrations)-1].Version
+		}
+
+		filename := fmtMigrationFilename(version+1, strings.Join(a[1:], "_"))
+		err = createMigrationFile(filename)
+		if err != nil {
+			return
+		}
+
+		fmt.Println("created migration", filename)
+		return
+	case "version":
+		return
+	case "up", "":
+		for i := range migrations {
+			m := &migrations[i]
+			if m.Version <= oldVersion {
+				continue
+			}
+			err = m.Up(db)
+			if err != nil {
+				return
+			}
+			newVersion = m.Version
+			err = SetVersion(db, newVersion)
+			if err != nil {
+				return
+			}
+		}
+		return
+	case "down":
+		newVersion, err = down(db, migrations, oldVersion)
+		return
+	case "reset":
+		version := oldVersion
+		for {
+			newVersion, err = down(db, migrations, version)
+			if err != nil || newVersion == version {
+				return
+			}
+			version = newVersion
+		}
+	case "set_version":
+		if len(a) < 2 {
+			err = fmt.Errorf("set_version requires version as 2nd arg, e.g. set_version 42")
+			return
+		}
+
+		newVersion, err = strconv.ParseInt(a[1], 10, 64)
+		if err != nil {
+			return
+		}
+		err = SetVersion(db, newVersion)
+		return
+	default:
+		err = fmt.Errorf("unsupported command: %q", cmd)
+		return
+	}
+}
+
+func down(db DB, migrations []Migration, oldVersion int64) (newVersion int64, err error) {
+	if oldVersion == 0 {
+		return
+	}
+
+	var m *Migration
+	for i := len(migrations) - 1; i >= 0; i-- {
+		mm := &migrations[i]
+		if mm.Version <= oldVersion {
+			m = mm
+			break
+		}
+	}
+	if m == nil {
+		err = fmt.Errorf("migration %d not found\n", oldVersion)
+		return
+	}
+
+	if m.Down != nil {
+		err = m.Down(db)
+		if err != nil {
+			return
+		}
+	}
+
+	newVersion = m.Version - 1
+	err = SetVersion(db, newVersion)
+	return
+}
+
+func extractVersion(name string) (int64, error) {
+	base := filepath.Base(name)
+
+	if ext := filepath.Ext(base); ext != ".go" {
+		return 0, fmt.Errorf("can not extract version from %q", base)
+	}
+
+	idx := strings.IndexByte(base, '_')
+	if idx == -1 {
+		return 0, fmt.Errorf("can not extract version from %q", base)
+	}
+
+	n, err := strconv.ParseInt(base[:idx], 10, 64)
+	if err != nil {
+		return 0, err
+	}
+
+	if n <= 0 {
+		return 0, errors.New("version must be greater than zero")
+	}
+
+	return n, nil
+}
+
+type migrationSorter []Migration
+
+func (ms migrationSorter) Len() int {
+	return len(ms)
+}
+
+func (ms migrationSorter) Swap(i, j int) {
+	ms[i], ms[j] = ms[j], ms[i]
+}
+
+func (ms migrationSorter) Less(i, j int) bool {
+	return ms[i].Version < ms[j].Version
+}
+
+func sortMigrations(migrations []Migration) {
+	ms := migrationSorter(migrations)
+	sort.Sort(ms)
+}
+
+var migrationNameRE = regexp.MustCompile(`[^a-z0-9]+`)
+
+func fmtMigrationFilename(version int64, descr string) string {
+	descr = strings.ToLower(descr)
+	descr = migrationNameRE.ReplaceAllString(descr, "_")
+	return fmt.Sprintf("%d_%s.go", version, descr)
+}
+
+func createMigrationFile(filename string) error {
+	basepath, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+	filename = path.Join(basepath, filename)
+
+	_, err = os.Stat(filename)
+	if !os.IsNotExist(err) {
+		return fmt.Errorf("file=%q already exists (%s)", filename, err)
+	}
+
+	return ioutil.WriteFile(filename, migrationTemplate, 0644)
+}
+
+var migrationTemplate = []byte(`package main
+
+import (
+	"github.com/go-pg/migrations"
+)
+
+func init() {
+	migrations.Register(func(db migrations.DB) error {
+		_, err := db.Exec("")
+		return err
+	}, func(db migrations.DB) error {
+		_, err := db.Exec("")
+		return err
+	})
+}
+`)