Merge pull request #388 from runatlantis/mergeable-pr

Introduce new `mergeable` requirement
2026-08-05 12:28:38 +00:00 · 2018-12-12 14:33:09 -06:00
parent 27eb577215 b6d821326d
commit 858dbe4ed1
5773 changed files with 43216 additions and 2362079 deletions
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -2,195 +2,203 @@


 [[projects]]
-  digest = "1:b856d8248663c39265a764561c1a1a149783f6cc815feb54a1f3a591b91f6eca"
+  digest = "1:55388fd080150b9a072912f97b1f5891eb0b50df43401f8b75fb4273d3fec9fc"
  name = "github.com/Masterminds/semver"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "c7af12943936e8c39859482e61f0574c2fd7fc75"
  version = "v1.4.2"

 [[projects]]
-  digest = "1:d10482a602e3facc4fb1115a862153759339b825503f8420fcfc9738fd547730"
+  digest = "1:46a054a232ea2b7f0a35398d682b433d26ba9975fce9197b1784824402059f5b"
  name = "github.com/Masterminds/sprig"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "6b2a58267f6a8b1dc8e2eb5519b984008fa85e8c"
  version = "v2.15.0"

 [[projects]]
-  digest = "1:24cff84fefa06791f78f9bc6e05c2a3a90710c81ae6b76225280daf33b267d36"
+  digest = "1:8f5416c7f59da8600725ae1ff00a99af1da8b04c211ae6f3c8f8bcab0164f650"
  name = "github.com/aokoli/goutils"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "3391d3790d23d03408670993e957e8f408993c34"
  version = "v1.0.1"

 [[projects]]
-  digest = "1:ed112122ed4a920d944cc99b9d00b0441c11685939c28462c719488d36fe29aa"
+  digest = "1:0f98f59e9a2f4070d66f0c9c39561f68fcd1dc837b22a852d28d0003aebd1b1e"
  name = "github.com/boltdb/bolt"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "2f1ce7a837dcb8da3ec595b1dac9d0632f0f99e8"
  version = "v1.3.1"

 [[projects]]
-  digest = "1:3fc9b0f7d3cf0fd57264f4f092c6e6b443bf9a5d9ce1d9deb4849ab02ffe1878"
+  digest = "1:889290ee5c1f1888baa7caa2b4cdfa8a6abcfb86dd772fe6470ad7925cc44bff"
  name = "github.com/briandowns/spinner"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "48dbb65d7bd5c74ab50d53d04c949f20e3d14944"
  version = "1.0"

 [[projects]]
-  digest = "1:56c130d885a4aacae1dd9c7b71cfe39912c7ebc1ff7d2b46083c8812996dc43b"
+  digest = "1:a2c1d0e43bd3baaa071d1b9ed72c27d78169b2b269f71c105ac4ba34b1be4a39"
  name = "github.com/davecgh/go-spew"
  packages = ["spew"]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "346938d642f2ec3594ed81d874461961cd0faa76"
  version = "v1.1.0"

 [[projects]]
  branch = "master"
-  digest = "1:0fa341ce14006a4302303713264c9f27dfc55aa01bd95281ae9540f11d88064d"
+  digest = "1:a9f44d1fa39a286f0f9cf4a274667810e7c0b7fbd2ff98d21e3900f43fa7ac29"
  name = "github.com/docker/docker"
  packages = ["pkg/fileutils"]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "e2593239d949eee454935daea7a5fe025477322f"

 [[projects]]
  branch = "master"
-  digest = "1:044b2f1eea2f5cfb0d3678baf60892734f59d5c2ea3932cb6ed894a97ccba15c"
+  digest = "1:f4f6279cb37479954644babd8f8ef00584ff9fa63555d2c6718c1c3517170202"
  name = "github.com/elazarl/go-bindata-assetfs"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "30f82fa23fd844bd5bb1e5f216db87fd77b5eb43"

 [[projects]]
-  digest = "1:c9bebdae4ac52d0c3bbe5876de3d72f3bb05b4986865cdb3f15e305e1dc4fbca"
+  digest = "1:938a2672d6ebbb7f7bc63eee3e4b9464c16ffcf77ec8913d3edbf32b4e3984dd"
  name = "github.com/fatih/color"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "570b54cabe6b8eb0bc2dfce68d964677d63b5260"
  version = "v1.5.0"

 [[projects]]
  branch = "master"
-  digest = "1:93a4238f875be092b3bc5c68424a91d8f948d5f0cda99b44bc6de4849047d883"
+  digest = "1:50a46ab1d5edbbdd55125b4d37f1bf503d0807c26461f9ad7b358d6006641d09"
  name = "github.com/flynn-archive/go-shlex"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "3f9db97f856818214da2e1057f8ad84803971cff"

 [[projects]]
-  digest = "1:9f1e571696860f2b4f8a241b43ce91c6085e7aaed849ccca53f590a4dc7b95bd"
+  digest = "1:ffb471a599e572700e9b7ee4b1d4869382d00f9268e84938c92b01a4d5941d23"
  name = "github.com/fsnotify/fsnotify"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "629574ca2a5df945712d3079857300b5e4da0236"
  version = "v1.4.2"

 [[projects]]
-  digest = "1:cb589c43cf1a44b8583a1ffa01eb16cdd7346a396797049f86a6d3c93c73003a"
+  digest = "1:9df33605e48f27f83d7fe1a8a46d937e579208f0772dc16c988e0e4be09f6f5f"
  name = "github.com/go-ozzo/ozzo-validation"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "85dcd8368eba387e65a03488b003e233994e87e9"
  version = "v3.3"

 [[projects]]
-  digest = "1:709292c015123a3bc69ea970dc9abd6667170e7fbf5cdeb10c6d14b250d3385f"
+  digest = "1:e1ff887e232b2d8f4f7c7db15a5fac7be418025afc4dda53c59c765dbb5aa6b4"
  name = "github.com/go-playground/locales"
  packages = [
    ".",
    "currency",
  ]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "f63010822830b6fe52288ee52d5a1151088ce039"
  version = "v0.12.1"

 [[projects]]
-  digest = "1:7ca0f6f2a364f603e843763d35c979b595d71159982791de27f9ec40d532876b"
+  digest = "1:e022cf244bcac1b6ef933f1a2e0adcf6a6dfd7b872d8d41e4d4179bb09a87cbc"
  name = "github.com/go-playground/universal-translator"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "b32fa301c9fe55953584134cb6853a13c87ec0a1"
  version = "v0.16.0"

 [[projects]]
-  digest = "1:fb6b4ea21671a4a8037cccc0a582caada51b4ac550219f42b9e8ce4671bc568b"
+  digest = "1:7f89e0c888fb99c61055c646f5678aae645b0b0a1443d9b2dcd9964d850827ce"
  name = "github.com/go-test/deep"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "6592d9cc0a499ad2d5f574fde80a2b5c5cc3b4f5"
  version = "v1.0.1"

 [[projects]]
-  branch = "master"
-  digest = "1:2179e0f76ac0c9132d0fb2ee03ce9f8116e72e7f55a251757ca92ebee9ba28a9"
-  name = "github.com/google/go-github"
-  packages = ["github"]
-  pruneopts = ""
-  revision = "c004bf0c02fcab9d87a7f2e2f002fd008bf0784c"
+  digest = "1:97df918963298c287643883209a2c3f642e6593379f97ab400c2a2e219ab647d"
+  name = "github.com/golang/protobuf"
+  packages = ["proto"]
+  pruneopts = "UT"
+  revision = "aa810b61a9c79d51363740d207bb46cf8e620ed5"
+  version = "v1.2.0"

 [[projects]]
  branch = "master"
-  digest = "1:9abc49f39e3e23e262594bb4fb70abf74c0c99e94f99153f43b143805e850719"
+  digest = "1:3df35fa0446b2cf51b509c8f49963fc3b615834b74ee6188f151c5245d745170"
+  name = "github.com/google/go-github"
+  packages = ["github"]
+  pruneopts = "UT"
+  revision = "4076fd7418e5e1b04d32ffba6adf5084891952d5"
+
+[[projects]]
+  branch = "master"
+  digest = "1:a63cff6b5d8b95638bfe300385d93b2a6d9d687734b863da8e09dc834510a690"
  name = "github.com/google/go-querystring"
  packages = ["query"]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "53e6ce116135b80d037921a7fdd5138cf32d7a8a"

 [[projects]]
-  digest = "1:c1d7e883c50a26ea34019320d8ae40fad86c9e5d56e63a1ba2cb618cef43e986"
+  digest = "1:8f8811f9be822914c3a25c6a071e93beb4c805d7b026cbf298bc577bc1cc945b"
  name = "github.com/google/uuid"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "064e2069ce9c359c118179501254f67d7d37ba24"
  version = "0.2"

 [[projects]]
-  digest = "1:20ed7daa9b3b38b6d1d39b48ab3fd31122be5419461470d0c28de3e121c93ecf"
+  digest = "1:160eabf7a69910fd74f29c692718bc2437c1c1c7d4c9dea9712357752a70e5df"
  name = "github.com/gorilla/context"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "1ea25387ff6f684839d82767c1733ff4d4d15d0a"
  version = "v1.1"

 [[projects]]
-  digest = "1:c2c8666b4836c81a1d247bdf21c6a6fc1ab586538ab56f74437c2e0df5c375e1"
+  digest = "1:e73f5b0152105f18bc131fba127d9949305c8693f8a762588a82a48f61756f5f"
  name = "github.com/gorilla/mux"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "e3702bed27f0d39777b0b37b664b6280e8ef8fbf"
  version = "v1.6.2"

 [[projects]]
  branch = "master"
-  digest = "1:304c322b62533a48ac052ffee80f67087fce1bc07186cd4e610a1b0e77765836"
+  digest = "1:07671f8997086ed115824d1974507d2b147d1e0463675ea5dbf3be89b1c2c563"
  name = "github.com/hashicorp/errwrap"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "7554cd9344cec97297fa6649b055a8c98c2a1e55"

 [[projects]]
  branch = "master"
-  digest = "1:7660b6ee3fd92bcb9b19f5d359d3fbc8e853257d8a3d49e0424d00b6faa69cfd"
+  digest = "1:06b0de714eda10ccb203ef43155059c734f8d9377421954ae14cbf6af1fcf0b1"
  name = "github.com/hashicorp/go-multierror"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "83588e72410abfbe4df460eeb6f30841ae47d4c4"

 [[projects]]
  branch = "master"
-  digest = "1:2aa07a6931b73e70f07a5bd30ef30a73cd103aa06291213c4e46e3fe52822dea"
+  digest = "1:ada37ea3db98b606d2b61577fbd87c0aabaa95e03b409033ebf58c6e5420b033"
  name = "github.com/hashicorp/go-version"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "fc61389e27c71d120f87031ca8c88a3428f372dd"

 [[projects]]
  branch = "master"
-  digest = "1:c12ac8c5b99dca211fcad8c7de30379cf83377f10a28125e8bdde556ab32896a"
+  digest = "1:b6708572c17a0220ebfcb9a474b37eb7de331a965755ef4bbfaafb49b9c89ed0"
  name = "github.com/hashicorp/hcl"
  packages = [
    ".",
@@ -203,22 +211,22 @@
    "json/scanner",
    "json/token",
  ]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "68e816d1c783414e79bc65b3994d9ab6b0a722ab"

 [[projects]]
-  digest = "1:a480764e28eb23a164526435877e08a26b0fcc7bade83b21a1fb307ed5ecde5a"
+  digest = "1:6b1e7618931d0ed9a17fec1c1d84271907aa61172c50b8272327f6cd4fafb650"
  name = "github.com/huandu/xstrings"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "2bf18b218c51864a87384c06996e40ff9dcff8e1"
  version = "v1.0.0"

 [[projects]]
-  digest = "1:302c6eb8e669c997bec516a138b8fc496018faa1ece4c13e445a2749fbe079bb"
+  digest = "1:3e260afa138eab6492b531a3b3d10ab4cb70512d423faa78b8949dec76e66a21"
  name = "github.com/imdario/mergo"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "9316a62528ac99aaecb4e47eadd6dc8aa6533d58"
  version = "v0.3.5"

@@ -226,234 +234,249 @@
  digest = "1:870d441fe217b8e689d7949fef6e43efbc787e50f200cb1e70dbca9204a1d6be"
  name = "github.com/inconshreveable/mousetrap"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75"
  version = "v1.0"

 [[projects]]
  branch = "master"
-  digest = "1:ecf8d2c7a243668631919f8bc88b0dce210d2350dc357fcba81d02a75ecb4a27"
+  digest = "1:50f15cb5a06d802e166fba193cf64ab26dbca2ae686ee4fc9115a6634a7761f7"
  name = "github.com/lkysow/go-gitlab"
  packages = ["."]
-  pruneopts = ""
-  revision = "fcd13266e57eb071cbedfe8efc7969a7bc4c8f22"
+  pruneopts = "UT"
+  revision = "ea7b793277a7694ebbd09b2cdcee0e003e94ba74"

 [[projects]]
-  digest = "1:1ce378ab2352c756c6d7a0172c22ecbd387659d32712a4ce3bc474273309a5dc"
+  digest = "1:38c6c0068711ac95a80ba4d5d8cf86b5b066cc6d74ddd1e007d4d3eb45751894"
  name = "github.com/magiconair/properties"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "be5ece7dd465ab0765a9682137865547526d1dfb"
  version = "v1.7.3"

 [[projects]]
-  digest = "1:9ea83adf8e96d6304f394d40436f2eb44c1dc3250d223b74088cc253a6cd0a1c"
+  digest = "1:c658e84ad3916da105a761660dcaeb01e63416c8ec7bc62256a9b411a05fcd67"
  name = "github.com/mattn/go-colorable"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "167de6bfdfba052fa6b2d3664c8f5272e23c9072"
  version = "v0.0.9"

 [[projects]]
-  digest = "1:420bb8eabfa6dff0cb5c8e786489a420e7e9d93a8b1d83882cce70c5a5b9bc3e"
+  digest = "1:fa610f9fe6a93f4a75e64c83673dfff9bf1a34bbb21e6102021b6bc7850834a3"
  name = "github.com/mattn/go-isatty"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "fc9e8d8ef48496124e79ae0df75490096eccf6fe"
  version = "v0.0.2"

 [[projects]]
  branch = "master"
-  digest = "1:d1a560b8320893b5b92c25c94a66de450023a0632cde885e9ab123798a1dba0f"
+  digest = "1:ded79ae4dc43f8382f782459c8082f8910e5002fc04a492e98c7a72734ae0dc5"
  name = "github.com/mitchellh/colorstring"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "8631ce90f28644f54aeedcb3e389a85174e067d1"

 [[projects]]
  branch = "master"
-  digest = "1:59d11e81d6fdd12a771321696bb22abdd9a94d26ac864787e98c9b419e428734"
+  digest = "1:12ae6210bdbdad658a9a67fd95cd9c99f7fdbf12f6d36eaf0af704e69dacf4f5"
  name = "github.com/mitchellh/go-homedir"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "b8bc1bf767474819792c23f32d8286a45736f1c6"

 [[projects]]
  branch = "master"
-  digest = "1:c9ede10a9ded782d25d1f0be87c680e11409c23554828f19a19d691a95e76130"
+  digest = "1:3d64942cc75c655215a64496e35a2ca1a30ee0007cd24f41b57631486f3d083c"
  name = "github.com/mitchellh/mapstructure"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "d0303fe809921458f417bcf828397a65db30a7e4"

 [[projects]]
  branch = "master"
-  digest = "1:5875913107a4d3788be6cbe379c03fab558962dd2b9b961a3d86949507bac574"
+  digest = "1:97ea99bf187d8806b57a7cc22a58dd7daab399ac8bc622a959bf8d4307a3ce45"
  name = "github.com/mohae/deepcopy"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "491d3605edfb866af34a48075bd4355ac1bf46ca"

 [[projects]]
-  digest = "1:53f0ca8536bff15e4974b90def20012f61ef4fdb40b8b2712fa09c2820e53974"
+  digest = "1:06e504d29f2627321fe814e9e9a6ea5ac894d584772c071ecf5fc3a7e49ee751"
  name = "github.com/nlopes/slack"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "c86337c0ef2486a15edd804355d9c73d2f2caed1"
  version = "v0.1.0"

 [[projects]]
-  digest = "1:a4e59d0b2821c983b58c317f141cd77df20570979632da8a7a352e5d12698de7"
+  digest = "1:11300fee3c16eca5122c9db9e5244632c4c05d11da33f5bfdde81299287c6104"
  name = "github.com/onsi/gomega"
  packages = ["format"]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "c893efa28eb45626cdaa76c9f653b62488858837"
  version = "v1.2.0"

 [[projects]]
-  digest = "1:049b5bee78dfdc9628ee0e557219c41f683e5b06c5a5f20eaba0105ccc586689"
+  digest = "1:b2ee62e09bec113cf086d2ce0769efcc7bf79481aba8373fd8f7884e94df3462"
  name = "github.com/pelletier/go-buffruneio"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "c37440a7cf42ac63b919c752ca73a85067e05992"
  version = "v0.2.0"

 [[projects]]
-  digest = "1:6d5a9728ae27e477a07bb69f02ea0bade74eb8b0c7346d046337904bbf7af065"
+  digest = "1:e27da28550455cdbd8af6c6a58f91f39b8d44c6cda0f1a4b33348887c0db74fd"
  name = "github.com/pelletier/go-toml"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "5ccdfb18c776b740aecaf085c4d9a2779199c279"
  version = "v1.0.0"

 [[projects]]
  branch = "master"
-  digest = "1:281fc9437816cd2e487c3ad3fbb6152e89cda358c62089c3e459d625cdf92363"
+  digest = "1:ef8f9b6070787c300b6eaedfa8f4ca9fc3ab7970db7265301e69240619465629"
  name = "github.com/petergtz/pegomock"
  packages = [
    ".",
    "internal/verify",
  ]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "b113d17a7e81ba2aa33486b49f7477a9de919cbb"

 [[projects]]
-  digest = "1:7365acd48986e205ccb8652cc746f09c8b7876030d53710ea6ef7d0bd0dcd7ca"
+  digest = "1:40e195917a951a8bf867cd05de2a46aaf1806c50cf92eebf4c16f78cd196f747"
  name = "github.com/pkg/errors"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "645ef00459ed84a119197bfb8d8205042c6df63d"
  version = "v0.8.0"

 [[projects]]
-  digest = "1:8cf46b6c18a91068d446e26b67512cf16f1540b45d90b28b9533706a127f0ca6"
+  digest = "1:9e9193aa51197513b3abcb108970d831fbcf40ef96aa845c4f03276e1fa316d2"
  name = "github.com/sirupsen/logrus"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "c155da19408a8799da419ed3eeb0cb5db0ad5dbc"
  version = "v1.0.5"

 [[projects]]
  branch = "master"
-  digest = "1:c189f11a84aa8b868a4b7cd4605653160424ab299cf7cfb1c5bd2740b949928f"
+  digest = "1:474cab1b14a2905f3110e3953c45d1974998ed8cdb3ccce0ddd6609f85b21f5b"
  name = "github.com/spf13/afero"
  packages = [
    ".",
    "mem",
  ]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "ee1bd8ee15a1306d1f9201acc41ef39cd9f99a1b"

 [[projects]]
-  digest = "1:6ff9b74bfea2625f805edec59395dc37e4a06458dd3c14e3372337e3d35a2ed6"
+  digest = "1:9b28ee2984c69d78afe2ce52b1650ba91a6381f355ff08c1d0e53d9e66bd62fe"
  name = "github.com/spf13/cast"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "acbeb36b902d72a7a4c18e8f3241075e7ab763e4"
  version = "v1.1.0"

 [[projects]]
  branch = "master"
-  digest = "1:146327ce93be37e68bd3ff8541090d96da8cb3adc9e35d57570e9170a29f6bf6"
+  digest = "1:5bafded33341e455f02a63bac95975ea9c7b915c67fb6a12f2e28c6890012114"
  name = "github.com/spf13/cobra"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "b78744579491c1ceeaaa3b40205e56b0591b93a3"

 [[projects]]
  branch = "master"
-  digest = "1:5cb42b990db5dc48b8bc23b6ee77b260713ba3244ca495cd1ed89533dc482a49"
+  digest = "1:9f28b7e326b8cd1db556678b7ce679cf9bf888647e40922f91d9d40f451f942b"
  name = "github.com/spf13/jwalterweatherman"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "12bd96e66386c1960ab0f74ced1362f66f552f7b"

 [[projects]]
-  digest = "1:261bc565833ef4f02121450d74eb88d5ae4bd74bfe5d0e862cddb8550ec35000"
+  digest = "1:1b21a2b4058a779f290c7341cd93267492e0ecea6c8b54f64a4a5fd7ff131034"
  name = "github.com/spf13/pflag"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "e57e3eeb33f795204c1ca35f56c44f83227c6e66"
  version = "v1.0.0"

 [[projects]]
-  digest = "1:59354ad53dfe6ed1b941844cb029cd37c0377598eec3a0d49c03aee2375ef9c4"
+  digest = "1:f8e1a678a2571e265f4bf91a3e5e32aa6b1474a55cb0ea849750cc177b664d96"
  name = "github.com/spf13/viper"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "25b30aa063fc18e48662b86996252eabdcf2f0c7"
  version = "v1.0.0"

 [[projects]]
-  digest = "1:e85837cb04b78f61688c6eba93ea9d14f60d611e2aaf8319999b1a60d2dafbfa"
+  digest = "1:b24d38b282bacf9791408a080f606370efa3d364e4b5fd9ba0f7b87786d3b679"
  name = "github.com/urfave/cli"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "cfb38830724cc34fedffe9a2a29fb54fa9169cd1"
  version = "v1.20.0"

 [[projects]]
-  digest = "1:80cf22cc45eb6fdfce2515a2401b04bffa2be83261577761ab788688dad699a1"
+  digest = "1:f5c90c63522dfbd29d00558d3a12e4223c5b31ae3f1f174fe2068f267502c38b"
  name = "github.com/urfave/negroni"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "fde5e16d32adc7ad637e9cd9ad21d4ebc6192535"
  version = "v0.2.0"

 [[projects]]
  branch = "master"
-  digest = "1:e10c88bfaf62d55e2f19df1de09c322531079fb17d105d3dcb4bd6153e30139a"
+  digest = "1:b45bdff0b14568a4419b3e2f6485ad1667b4bfcf1581972fe619ee5962308939"
  name = "golang.org/x/crypto"
  packages = [
    "pbkdf2",
    "scrypt",
    "ssh/terminal",
  ]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "7d9177d70076375b9a59c8fde23d52d9c4a7ecd5"

 [[projects]]
  branch = "master"
-  digest = "1:130b1bec86c62e121967ee0c69d9c263dc2d3ffe6c7c9a82aca4071c4d068861"
+  digest = "1:1ed1bc6f8442b291888ec51160f3a0a32f47e238c86ebb2f5d193b06ed43d31f"
  name = "golang.org/x/net"
-  packages = ["websocket"]
-  pruneopts = ""
+  packages = [
+    "context",
+    "context/ctxhttp",
+    "websocket",
+  ]
+  pruneopts = "UT"
  revision = "9dfe39835686865bff950a07b394c12a98ddc811"

 [[projects]]
  branch = "master"
-  digest = "1:cc11c1cd2fbbd5a2e883bb581b74c0a61857239fa9cd5cf96e274eb447689354"
+  digest = "1:5276e08fe6a1dfdb65b4f46a2e5d5c9e00be6e499105e441049c3c04a0c83b36"
+  name = "golang.org/x/oauth2"
+  packages = [
+    ".",
+    "internal",
+  ]
+  pruneopts = "UT"
+  revision = "d668ce993890a79bda886613ee587a69dd5da7a6"
+
+[[projects]]
+  branch = "master"
+  digest = "1:5e542b84761e71cb45a2da0c4f64b96181bbb388e3e59f824c9f65f03476fbcb"
  name = "golang.org/x/sys"
  packages = [
    "unix",
    "windows",
  ]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "062cd7e4e68206d8bab9b18396626e855c992658"

 [[projects]]
  branch = "master"
-  digest = "1:6ffd50f330d82d5a92f109253f3831900ccb99f973fb7d614e54ceaf6a41dcec"
+  digest = "1:d2551122162fb14b1c39e53b632b11aa55439a1bc1fe1ab7ac580ba1999a3bf9"
  name = "golang.org/x/text"
  packages = [
    "internal/gen",
@@ -463,23 +486,39 @@
    "unicode/cldr",
    "unicode/norm",
  ]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "1cbadb444a806fd9430d14ad08967ed91da4fa0a"

 [[projects]]
-  digest = "1:9d556ac00a9410814ee329851fded1a38f08db35e20e832778c96241de558fb7"
+  digest = "1:08206298775e5b462e6c0333f4471b44e63f1a70e42952b6ede4ecc9572281eb"
+  name = "google.golang.org/appengine"
+  packages = [
+    "internal",
+    "internal/base",
+    "internal/datastore",
+    "internal/log",
+    "internal/remote_api",
+    "internal/urlfetch",
+    "urlfetch",
+  ]
+  pruneopts = "UT"
+  revision = "4a4468ece617fc8205e99368fa2200e9d1fad421"
+  version = "v1.3.0"
+
+[[projects]]
+  digest = "1:a351fd4cb95e313ecb345a521f276e7a00913d1f2e84c61543bc4fa1785ba7f3"
  name = "gopkg.in/go-playground/validator.v9"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "ab2a8a99087e827c9af87ed6777ba897348fb178"
  version = "v9.20.2"

 [[projects]]
  branch = "v2"
-  digest = "1:81314a486195626940617e43740b4fa073f265b0715c9f54ce2027fee1cb5f61"
+  digest = "1:6570992c02a2137a20be83990a979b6fe892e20ecdc6b756449989b2a7efb8ae"
  name = "gopkg.in/yaml.v2"
  packages = ["."]
-  pruneopts = ""
+  pruneopts = "UT"
  revision = "eb3733d160e74a9c7e442f435eb3bea458e1d19f"

 [solve-meta]
--- a/Gopkg.toml
+++ b/Gopkg.toml
@@ -20,6 +20,10 @@
 #  name = "github.com/x/y"
 #  version = "2.4.0"

+[prune]
+  go-tests = true
+  unused-packages = true
+

 [[constraint]]
  name = "github.com/boltdb/bolt"
--- a/cmd/server.go
+++ b/cmd/server.go
@@ -55,6 +55,7 @@ const (
 	PortFlag                   = "port"
 	RepoWhitelistFlag          = "repo-whitelist"
 	RequireApprovalFlag        = "require-approval"
+	RequireMergeableFlag       = "require-mergeable"
 	SilenceWhitelistErrorsFlag = "silence-whitelist-errors"
 	SSLCertFileFlag            = "ssl-cert-file"
 	SSLKeyFileFlag             = "ssl-key-file"
@@ -186,6 +187,11 @@ var boolFlags = []boolFlag{
 		description:  "Require pull requests to be \"Approved\" before allowing the apply command to be run.",
 		defaultValue: false,
 	},
+	{
+		name:         RequireMergeableFlag,
+		description:  "Require pull requests to be mergeable before allowing the apply command to be run.",
+		defaultValue: false,
+	},
 	{
 		name:         SilenceWhitelistErrorsFlag,
 		description:  "Silences the posting of whitelist error comments.",
--- a/cmd/server_test.go
+++ b/cmd/server_test.go
@@ -346,6 +346,7 @@ func TestExecute_Defaults(t *testing.T) {
 	Equals(t, "info", passedConfig.LogLevel)
 	Equals(t, 4141, passedConfig.Port)
 	Equals(t, false, passedConfig.RequireApproval)
+	Equals(t, false, passedConfig.RequireMergeable)
 	Equals(t, "", passedConfig.SSLCertFile)
 	Equals(t, "", passedConfig.SSLKeyFile)
 }
@@ -443,6 +444,7 @@ func TestExecute_Flags(t *testing.T) {
 		cmd.PortFlag:                   8181,
 		cmd.RepoWhitelistFlag:          "github.com/runatlantis/atlantis",
 		cmd.RequireApprovalFlag:        true,
+		cmd.RequireMergeableFlag:       true,
 		cmd.SSLCertFileFlag:            "cert-file",
 		cmd.SSLKeyFileFlag:             "key-file",
 	})
@@ -469,6 +471,7 @@ func TestExecute_Flags(t *testing.T) {
 	Equals(t, 8181, passedConfig.Port)
 	Equals(t, "github.com/runatlantis/atlantis", passedConfig.RepoWhitelist)
 	Equals(t, true, passedConfig.RequireApproval)
+	Equals(t, true, passedConfig.RequireMergeable)
 	Equals(t, "cert-file", passedConfig.SSLCertFile)
 	Equals(t, "key-file", passedConfig.SSLKeyFile)
 }
@@ -496,6 +499,7 @@ log-level: "debug"
 port: 8181
 repo-whitelist: "github.com/runatlantis/atlantis"
 require-approval: true
+require-mergeable: true
 ssl-cert-file: cert-file
 ssl-key-file: key-file
 `)
@@ -526,6 +530,7 @@ ssl-key-file: key-file
 	Equals(t, 8181, passedConfig.Port)
 	Equals(t, "github.com/runatlantis/atlantis", passedConfig.RepoWhitelist)
 	Equals(t, true, passedConfig.RequireApproval)
+	Equals(t, true, passedConfig.RequireMergeable)
 	Equals(t, "cert-file", passedConfig.SSLCertFile)
 	Equals(t, "key-file", passedConfig.SSLKeyFile)
 }
@@ -580,6 +585,7 @@ ssl-key-file: key-file
 		"PORT":                     "8282",
 		"REPO_WHITELIST":           "override,override",
 		"REQUIRE_APPROVAL":         "false",
+		"REQUIRE_MERGEABLE":        "false",
 		"SSL_CERT_FILE":            "override-cert-file",
 		"SSL_KEY_FILE":             "override-key-file",
 	} {
@@ -610,6 +616,7 @@ ssl-key-file: key-file
 	Equals(t, 8282, passedConfig.Port)
 	Equals(t, "override,override", passedConfig.RepoWhitelist)
 	Equals(t, false, passedConfig.RequireApproval)
+	Equals(t, false, passedConfig.RequireMergeable)
 	Equals(t, "override-cert-file", passedConfig.SSLCertFile)
 	Equals(t, "override-key-file", passedConfig.SSLKeyFile)
 }
@@ -637,6 +644,7 @@ log-level: "debug"
 port: 8181
 repo-whitelist: "github.com/runatlantis/atlantis"
 require-approval: true
+require-mergeable: true
 ssl-cert-file: cert-file
 ssl-key-file: key-file
 `)
@@ -663,6 +671,7 @@ ssl-key-file: key-file
 		cmd.PortFlag:                   8282,
 		cmd.RepoWhitelistFlag:          "override,override",
 		cmd.RequireApprovalFlag:        false,
+		cmd.RequireMergeableFlag:       false,
 		cmd.SSLCertFileFlag:            "override-cert-file",
 		cmd.SSLKeyFileFlag:             "override-key-file",
 	})
@@ -687,6 +696,7 @@ ssl-key-file: key-file
 	Equals(t, 8282, passedConfig.Port)
 	Equals(t, "override,override", passedConfig.RepoWhitelist)
 	Equals(t, false, passedConfig.RequireApproval)
+	Equals(t, false, passedConfig.RequireMergeable)
 	Equals(t, "override-cert-file", passedConfig.SSLCertFile)
 	Equals(t, "override-key-file", passedConfig.SSLKeyFile)
 }
@@ -715,6 +725,7 @@ func TestExecute_FlagEnvVarOverride(t *testing.T) {
 		"PORT":                     "8181",
 		"REPO_WHITELIST":           "*",
 		"REQUIRE_APPROVAL":         "true",
+		"REQUIRE_MERGEABLE":        "true",
 		"SSL_CERT_FILE":            "cert-file",
 		"SSL_KEY_FILE":             "key-file",
 	}
@@ -749,6 +760,7 @@ func TestExecute_FlagEnvVarOverride(t *testing.T) {
 		cmd.PortFlag:                   8282,
 		cmd.RepoWhitelistFlag:          "override,override",
 		cmd.RequireApprovalFlag:        false,
+		cmd.RequireMergeableFlag:       false,
 		cmd.SSLCertFileFlag:            "override-cert-file",
 		cmd.SSLKeyFileFlag:             "override-key-file",
 	})
@@ -775,6 +787,7 @@ func TestExecute_FlagEnvVarOverride(t *testing.T) {
 	Equals(t, 8282, passedConfig.Port)
 	Equals(t, "override,override", passedConfig.RepoWhitelist)
 	Equals(t, false, passedConfig.RequireApproval)
+	Equals(t, false, passedConfig.RequireMergeable)
 	Equals(t, "override-cert-file", passedConfig.SSLCertFile)
 	Equals(t, "override-key-file", passedConfig.SSLKeyFile)
 }
--- a/e2e/e2e.go
+++ b/e2e/e2e.go
@@ -29,7 +29,7 @@ type E2ETester struct {
 	repoURL      string
 	ownerName    string
 	repoName     string
-	hookID       int
+	hookID       int64
 	cloneDirRoot string
 	projectType  Project
 }
--- a/e2e/main.go
+++ b/e2e/main.go
@@ -115,10 +115,9 @@ func main() {

 }

-func createAtlantisWebhook(g *GithubClient, ownerName string, repoName string, hookURL string) (int, error) {
+func createAtlantisWebhook(g *GithubClient, ownerName string, repoName string, hookURL string) (int64, error) {
 	// create atlantis hook
 	atlantisHook := &github.Hook{
-		Name:   github.String("web"),
 		Events: []string{"issue_comment", "pull_request", "push"},
 		Config: map[string]interface{}{
 			"url":          hookURL,
@@ -138,7 +137,7 @@ func createAtlantisWebhook(g *GithubClient, ownerName string, repoName string, h
 }

 // nolint: unparam
-func deleteAtlantisHook(g *GithubClient, ownerName string, repoName string, hookID int) error {
+func deleteAtlantisHook(g *GithubClient, ownerName string, repoName string, hookID int64) error {
 	_, err := g.client.Repositories.DeleteHook(g.ctx, ownerName, repoName, hookID)
 	if err != nil {
 		return err
--- a/runatlantis.io/docs/apply-requirements.md
+++ b/runatlantis.io/docs/apply-requirements.md
@@ -1,29 +1,124 @@
 # Apply Requirements
+[[toc]]

-## Approved
-If you'd like to require pull/merge requests to be approved prior to a user running `atlantis apply` simply run Atlantis with the `--require-approval` flag.
-By default, no approval is required. If you want to configure this on a per-repo/project basis, for example to only require approvals for your production
-configuration you must use an `atlantis.yaml` file:
-```yaml
-version: 2
-projects:
- dir: .
-  apply_requirements: [approved]
-```
+## Intro
+Atlantis allows you to require certain conditions be satisfied **before** an `atlantis apply`
+command can be run:

-::: danger
-A pull request approval might not be as secure as you'd expect:
-* In GitHub **any user with read permissions** to the repo can approve a pull request.
-* In GitLab, you [can set](https://docs.gitlab.com/ee/user/project/merge_requests/merge_request_approvals.html#editing-approvals) who is allowed to approve.
+* [Approved](#approved) – requires pull requests to be approved by at least one user
+* [Mergeable](#mergeable) – requires pull requests to be able to be merged
+
+## What Happens If The Requirement Is Not Met?
+If the requirement is not met, users will see an error if they try to run `atlantis apply`:
+![Mergeable Apply Requirement](./images/apply-requirement.png)
+
+## Supported Requirements
+### Approved
+The `approved` requirement will prevent applies unless the pull request is approved
+by at least one person other than the author.
+
+#### Usage
+You can set the `approved` requirement by:
+1. Passing the `--require-approval` flag to `atlantis server` or
+1. Creating an `atlantis.yaml` file with the `apply_requirements` key:
+    ```yaml
+    version: 2
+    projects:
+    - dir: .
+      apply_requirements: [approved]
+     ```
+
+#### Meaning
+Each VCS provider has different rules around who can approve:
+* **GitHub** – **Any user with read permissions** to the repo can approve a pull request
+* **GitLab** – You [can set](https://docs.gitlab.com/ee/user/project/merge_requests/merge_request_approvals.html#editing-approvals) who is allowed to approve
+* **Bitbucket Cloud (bitbucket.org)** – A user can approve their own pull request but
+  Atlantis does not count that as an approval and requires an approval from at least one user that
+  is not the author of the pull request
+
+:::tip Tip
+If you want to require **certain people** to approve the pull request, look at the
+[mergeable](#mergeable) requirement.
 :::

-::: tip Note
-In Bitbucket Cloud (bitbucket.org), a user can approve their own pull request.
-Atlantis does not count that as an approval and requires at least one user that
-is not the author of the pull request to approve it.
-:::
+### Mergeable
+The `mergeable` requirement will prevent applies unless a pull request is able to be merged.
+
+#### Usage
+You can set the `mergeable` requirement by:
+1. Passing the `--require-mergeable` flag to `atlantis server` or
+1. Creating an `atlantis.yaml` file with the `apply_requirements` key:
+    ```yaml
+    version: 2
+    projects:
+    - dir: .
+      apply_requirements: [mergeable]
+     ```
+
+#### Meaning
+Each VCS provider has a different concept of "mergeability":
+#### GitHub
+In GitHub, if you're not using [Protected Branches](https://help.github.com/articles/about-protected-branches/) then
+all pull requests are mergeable unless there is a conflict.
+
+If you set up Protected Branches then you can enforce:
+* Requiring certain status checks to be passing
+* Requiring certain people to have reviewed and approved the pull request
+* Requiring `CODEOWNERS` to have reviewed and approved the pull request
+* Requiring that the branch is up to date with `master`
+
+See [https://help.github.com/articles/about-protected-branches/](https://help.github.com/articles/about-protected-branches/)
+for more details.
+
+#### GitLab
+For GitLab, a merge request will be mergeable if it has no conflicts and if all
+required approvers have approved the pull request.
+
+We **do not** check if there are [Unresolved Discussions](https://docs.gitlab.com/ee/user/discussions/#resolvable-discussions) because GitLab doesn't
+provide that information in their API response. If you need this feature please
+[open an issue](https://github.com/runatlantis/atlantis/issues/new).
+
+#### Bitbucket.org (Bitbucket Cloud) and Bitbucket Server (Stash)
+For Bitbucket, we just check if there is a conflict that is preventing a
+merge. We don't check anything else because Bitbucket's API doesn't support it.
+
+If you need a specific check, please
+[open an issue](https://github.com/runatlantis/atlantis/issues/new).
+
+## Setting Apply Requirements
+As mentioned above, you can set apply requirements via flags or `atlantis.yaml`.
+
+### Flags Override
+Flags **override** any `atlantis.yaml` settings so they are equivalent to always
+having that apply requirement set.
+
+### Project-Specific Settings
+If you only want some projects/repos to have apply requirements, then you must
+1. Not set the `--require-approval` or `--require-mergeable` flags, since those
+   will override any `atlantis.yaml` settings
+1. Specify which projects have which requirements via an `atlantis.yaml` file.
+   For example if I have two directories, `staging` and `production`, I might use:
+   ```yaml
+   version: 2
+   projects:
+   - dir: staging
+     # By default, apply_requirements is empty so this
+     # isn't strictly necessary.
+     apply_requirements: []
+   - dir: production
+     # This requirement will only apply to the
+     # production directory.
+     apply_requirements: [mergeable]
+
+
+### Multiple Requirements
+You can set both `apply` and `mergeable` requirements.
+
+## Who Can Apply?
+Once the apply requirement is satisfied, **anyone** that can comment on the pull
+request can run the actual `atlantis apply` command.

 ## Next Steps
 * For more information on GitHub pull request reviews and approvals see: [https://help.github.com/articles/about-pull-request-reviews/](https://help.github.com/articles/about-pull-request-reviews/)
 * For more information on GitLab merge request reviews and approvals (only supported on GitLab Enterprise) see: [https://docs.gitlab.com/ee/user/project/merge_requests/merge_request_approvals.html](https://docs.gitlab.com/ee/user/project/merge_requests/merge_request_approvals.html).
-* For more information on Bitbucket pull request reviews and approvals see: [https://confluence.atlassian.com/bitbucket/pull-requests-and-code-review-223220593.html](https://confluence.atlassian.com/bitbucket/pull-requests-and-code-review-223220593.html)
+* For more information on Bitbucket pull request reviews and approvals see: [https://confluence.atlassian.com/bitbucket/pull-requests-and-code-review-223220593.html](https://confluence.atlassian.com/bitbucket/pull-requests-and-code-review-223220593.html)
--- a/runatlantis.io/docs/atlantis-yaml-reference.md
+++ b/runatlantis.io/docs/atlantis-yaml-reference.md
@@ -24,7 +24,7 @@ projects:
  autoplan:
    when_modified: ["*.tf", "../modules/**.tf"]
    enabled: true
-  apply_requirements: [approved]
+  apply_requirements: [mergeable, approved]
  workflow: myworkflow
 workflows:
  myworkflow:
@@ -70,11 +70,11 @@ version:
 projects:
 workflows:
 ```
-| Key        | Type | Default           | Required | Description  |
-| -------------| --- |-------------| -----|---|
-| version      | int | none | yes | This key is required and must be set to `2`|
-| projects      | array[[Project](atlantis-yaml-reference.html#project)] | [] | no | Lists the projects in this repo |
-| workflows      | map[string -> [Workflow](atlantis-yaml-reference.html#workflow)] | {} | no | Custom workflows |
+| Key       | Type                                                             | Default | Required | Description                                 |
+| --------- | ---------------------------------------------------------------- | ------- | -------- | ------------------------------------------- |
+| version   | int                                                              | none    | yes      | This key is required and must be set to `2` |
+| projects  | array[[Project](atlantis-yaml-reference.html#project)]           | []      | no       | Lists the projects in this repo             |
+| workflows | map[string -> [Workflow](atlantis-yaml-reference.html#workflow)] | {}      | no       | Custom workflows                            |

 ### Project
 ```yaml
@@ -87,15 +87,15 @@ apply_requirements: ["approved"]
 workflow: myworkflow
 ```

-| Key        | Type | Default           | Required | Description  |
-| -------------| --- |-------------| -----|---|
-| name      | string | none | maybe | Required if there is more than one project with the same `dir` and `workspace`. This project name can be used with the `-p` flag.|
-| dir      | string | none | yes | The directory of this project relative to the repo root. Use `.` for the root. For example if the project was under `./project1` then use `project1`|
-| workspace      | string| default | no | The [Terraform workspace](https://www.terraform.io/docs/state/workspaces.html) for this project. Atlantis will switch to this workplace when planning/applying and will create it if it doesn't exist.|
-| autoplan      | [Autoplan](atlantis-yaml-reference.html#autoplan) | none | no | A custom autoplan configuration. If not specified, will use the default algorithm. See [Autoplanning](autoplanning.html).|
-| terraform_version      | string | none | no | A specific Terraform version to use when running commands for this project. Requires there to be a binary in the Atlantis `PATH` with the name `terraform{VERSION}`, ex. `terraform0.11.0`|
-| apply_requirements      | array[string] | [] | no | Requirements that must be satisfied before `atlantis apply` can be run. Currently the only supported requirement is `approved`. See [Apply Requirements](apply-requirements.html#approved) for more details.|
-| workflow      | string | none | no | A custom workflow. If not specified, Atlantis will use its default workflow.|
+| Key                | Type                                              | Default | Required | Description                                                                                                                                                                                                           |
+| ------------------ | ------------------------------------------------- | ------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| name               | string                                            | none    | maybe    | Required if there is more than one project with the same `dir` and `workspace`. This project name can be used with the `-p` flag.                                                                                     |
+| dir                | string                                            | none    | yes      | The directory of this project relative to the repo root. Use `.` for the root. For example if the project was under `./project1` then use `project1`                                                                  |
+| workspace          | string                                            | default | no       | The [Terraform workspace](https://www.terraform.io/docs/state/workspaces.html) for this project. Atlantis will switch to this workplace when planning/applying and will create it if it doesn't exist.                |
+| autoplan           | [Autoplan](atlantis-yaml-reference.html#autoplan) | none    | no       | A custom autoplan configuration. If not specified, will use the default algorithm. See [Autoplanning](autoplanning.html).                                                                                             |
+| terraform_version  | string                                            | none    | no       | A specific Terraform version to use when running commands for this project. Requires there to be a binary in the Atlantis `PATH` with the name `terraform{VERSION}`, ex. `terraform0.11.0`                            |
+| apply_requirements | array[string]                                     | []      | no       | Requirements that must be satisfied before `atlantis apply` can be run. Currently the only supported requirements are `approved` and `mergeable`. See [Apply Requirements](apply-requirements.html) for more details. |
+| workflow           | string                                            | none    | no       | A custom workflow. If not specified, Atlantis will use its default workflow.                                                                                                                                          |

 ::: tip
 A project represents a Terraform state. Typically, there is one state per directory and workspace however it's possible to
@@ -108,10 +108,10 @@ Atlantis supports this but requires the `name` key to be specified. See [atlanti
 enabled: true
 when_modified: ["*.tf"]
 ```
-| Key        | Type | Default           | Required | Description  |
-| -------------| --- |-------------| -----|---|
-| enabled      | boolean | true | no | Whether autoplanning is enabled for this project. |
-| when_modified      | array[string] | no | no | Uses [.dockerignore](https://docs.docker.com/engine/reference/builder/#dockerignore-file) syntax. If any modified file in the pull request matches, this project will be planned. If not specified, Atlantis will use its own algorithm. See [Autoplanning](autoplanning.html). Paths are relative to the project's dir.|
+| Key           | Type          | Default | Required | Description                                                                                                                                                                                                                                                                                                              |
+| ------------- | ------------- | ------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| enabled       | boolean       | true    | no       | Whether autoplanning is enabled for this project.                                                                                                                                                                                                                                                                        |
+| when_modified | array[string] | no      | no       | Uses [.dockerignore](https://docs.docker.com/engine/reference/builder/#dockerignore-file) syntax. If any modified file in the pull request matches, this project will be planned. If not specified, Atlantis will use its own algorithm. See [Autoplanning](autoplanning.html). Paths are relative to the project's dir. |

 ### Workflow
 ```yaml
@@ -119,10 +119,10 @@ plan:
 apply:
 ```

-| Key        | Type | Default           | Required | Description  |
-| -------------| --- |-------------| -----|---|
-| plan      | [Stage](atlantis-yaml-reference.html#stage) | `steps: [init, plan]` | no | How to plan for this project. |
-| apply      | [Stage](atlantis-yaml-reference.html#stage)  | `steps: [apply]` | no | How to apply for this project. |
+| Key   | Type                                        | Default               | Required | Description                    |
+| ----- | ------------------------------------------- | --------------------- | -------- | ------------------------------ |
+| plan  | [Stage](atlantis-yaml-reference.html#stage) | `steps: [init, plan]` | no       | How to plan for this project.  |
+| apply | [Stage](atlantis-yaml-reference.html#stage) | `steps: [apply]`      | no       | How to apply for this project. |

 ### Stage
 ```yaml
@@ -133,9 +133,9 @@ steps:
    extra_args: [-lock=false]
 ```

-| Key        | Type | Default           | Required | Description  |
-| -------------| --- |-------------| -----|---|
-| steps      | array[[Step](atlantis-yaml-reference.html#step)] | `[]` | no | List of steps for this stage. If the steps key is empty, no steps will be run for this stage. |
+| Key   | Type                                             | Default | Required | Description                                                                                   |
+| ----- | ------------------------------------------------ | ------- | -------- | --------------------------------------------------------------------------------------------- |
+| steps | array[[Step](atlantis-yaml-reference.html#step)] | `[]`    | no       | List of steps for this stage. If the steps key is empty, no steps will be run for this stage. |

 ### Step
 #### Built-In Commands: init, plan, apply
@@ -145,9 +145,9 @@ Steps can be a single string for a built-in command.
 - plan
 - apply
 ```
-| Key        | Type | Default           | Required | Description  |
-| -------------| --- |-------------| -----|---|
-| init/plan/apply      | string | none | no | Use a built-in command without additional configuration. Only `init`, `plan` and `apply` are supported||
+| Key             | Type   | Default | Required | Description                                                                                            |
+| --------------- | ------ | ------- | -------- | ------------------------------------------------------------------------------------------------------ |
+| init/plan/apply | string | none    | no       | Use a built-in command without additional configuration. Only `init`, `plan` and `apply` are supported |

 #### Built-In Command With Extra Args
 A map from string to `extra_args` for a built-in command with extra arguments.
@@ -159,17 +159,17 @@ A map from string to `extra_args` for a built-in command with extra arguments.
 - apply:
    extra_args: [arg1, arg2]
 ```
-| Key        | Type | Default           | Required | Description  |
-| -------------| --- |-------------| -----|---|
-| init/plan/apply      | map[`extra_args` -> array[string]] | none | no | Use a built-in command and append `extra_args`. Only `init`, `plan` and `apply` are supported as keys and only `extra_args` is supported as a value||
+| Key             | Type                               | Default | Required | Description                                                                                                                                         |
+| --------------- | ---------------------------------- | ------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| init/plan/apply | map[`extra_args` -> array[string]] | none    | no       | Use a built-in command and append `extra_args`. Only `init`, `plan` and `apply` are supported as keys and only `extra_args` is supported as a value |
 #### Custom `run` Command
 Or a custom command
 ```yaml
 - run: custom-command
 ```
-| Key        | Type | Default           | Required | Description  |
-| -------------| --- |-------------| -----|---|
-| run      | string| none | no | Run a custom command|
+| Key | Type   | Default | Required | Description          |
+| --- | ------ | ------- | -------- | -------------------- |
+| run | string | none    | no       | Run a custom command |

 ::: tip
 `run` steps are executed with the following environment variables:
--- a/runatlantis.io/docs/images/apply-requirement.png
+++ b/runatlantis.io/docs/images/apply-requirement.png
--- a/server/events/event_parser_test.go
+++ b/server/events/event_parser_test.go
@@ -278,23 +278,23 @@ func TestParseGitlabMergeEvent(t *testing.T) {
 	Ok(t, err)

 	expBaseRepo := models.Repo{
-		FullName:          "gitlabhq/gitlab-test",
-		Name:              "gitlab-test",
-		SanitizedCloneURL: "https://example.com/gitlabhq/gitlab-test.git",
-		Owner:             "gitlabhq",
-		CloneURL:          "https://gitlab-user:gitlab-token@example.com/gitlabhq/gitlab-test.git",
+		FullName:          "lkysow/atlantis-example",
+		Name:              "atlantis-example",
+		SanitizedCloneURL: "https://gitlab.com/lkysow/atlantis-example.git",
+		Owner:             "lkysow",
+		CloneURL:          "https://gitlab-user:gitlab-token@gitlab.com/lkysow/atlantis-example.git",
 		VCSHost: models.VCSHost{
-			Hostname: "example.com",
+			Hostname: "gitlab.com",
 			Type:     models.Gitlab,
 		},
 	}

 	Equals(t, models.PullRequest{
-		URL:        "http://example.com/diaspora/merge_requests/1",
-		Author:     "root",
-		Num:        1,
-		HeadCommit: "da1560886d4f094c3e6c9ef40349f7d38b5d27d7",
-		Branch:     "ms-viewport",
+		URL:        "https://gitlab.com/lkysow/atlantis-example/merge_requests/12",
+		Author:     "lkysow",
+		Num:        12,
+		HeadCommit: "d2eae324ca26242abca45d7b49d582cddb2a4f15",
+		Branch:     "patch-1",
 		State:      models.OpenPullState,
 		BaseRepo:   expBaseRepo,
 	}, pull)
@@ -302,17 +302,17 @@ func TestParseGitlabMergeEvent(t *testing.T) {

 	Equals(t, expBaseRepo, actBaseRepo)
 	Equals(t, models.Repo{
-		FullName:          "awesome_space/awesome_project",
-		Name:              "awesome_project",
-		SanitizedCloneURL: "http://example.com/awesome_space/awesome_project.git",
-		Owner:             "awesome_space",
-		CloneURL:          "http://gitlab-user:gitlab-token@example.com/awesome_space/awesome_project.git",
+		FullName:          "sourceorg/atlantis-example",
+		Name:              "atlantis-example",
+		SanitizedCloneURL: "https://gitlab.com/sourceorg/atlantis-example.git",
+		Owner:             "sourceorg",
+		CloneURL:          "https://gitlab-user:gitlab-token@gitlab.com/sourceorg/atlantis-example.git",
 		VCSHost: models.VCSHost{
-			Hostname: "example.com",
+			Hostname: "gitlab.com",
 			Type:     models.Gitlab,
 		},
 	}, actHeadRepo)
-	Equals(t, models.User{Username: "root"}, actUser)
+	Equals(t, models.User{Username: "lkysow"}, actUser)

 	t.Log("If the state is closed, should set field correctly.")
 	event.ObjectAttributes.State = "closed"
--- a/server/events/mocks/matchers/go_gitlab_mergecommentevent.go
+++ b/server/events/mocks/matchers/go_gitlab_mergecommentevent.go
@@ -2,9 +2,9 @@
 package matchers

 import (
-	"reflect"
-	"github.com/petergtz/pegomock"
 	go_gitlab "github.com/lkysow/go-gitlab"
+	"github.com/petergtz/pegomock"
+	"reflect"
 )

 func AnyGoGitlabMergeCommentEvent() go_gitlab.MergeCommentEvent {
--- a/server/events/mocks/matchers/go_gitlab_mergeevent.go
+++ b/server/events/mocks/matchers/go_gitlab_mergeevent.go
@@ -2,9 +2,9 @@
 package matchers

 import (
-	"reflect"
-	"github.com/petergtz/pegomock"
 	go_gitlab "github.com/lkysow/go-gitlab"
+	"github.com/petergtz/pegomock"
+	"reflect"
 )

 func AnyGoGitlabMergeEvent() go_gitlab.MergeEvent {
--- a/server/events/mocks/matchers/ptr_to_go_gitlab_mergerequest.go
+++ b/server/events/mocks/matchers/ptr_to_go_gitlab_mergerequest.go
@@ -2,9 +2,9 @@
 package matchers

 import (
-	"reflect"
-	"github.com/petergtz/pegomock"
 	go_gitlab "github.com/lkysow/go-gitlab"
+	"github.com/petergtz/pegomock"
+	"reflect"
 )

 func AnyPtrToGoGitlabMergeRequest() *go_gitlab.MergeRequest {
--- a/server/events/project_command_builder_test.go
+++ b/server/events/project_command_builder_test.go
@@ -350,6 +350,58 @@ projects:
 			ExpWorkspace: "myworkspace",
 			ExpDir:       ".",
 		},
+		{
+			Description: "atlantis.yaml with mergeable apply requirement",
+			Cmd: events.CommentCommand{
+				Name:        events.PlanCommand,
+				ProjectName: "myproject",
+			},
+			AtlantisYAML: `
+version: 2
+projects:
+- name: myproject
+  dir: .
+  workspace: myworkspace
+  apply_requirements: [mergeable]`,
+			ExpProjectConfig: &valid.Project{
+				Dir:       ".",
+				Workspace: "myworkspace",
+				Autoplan: valid.Autoplan{
+					WhenModified: []string{"**/*.tf*"},
+					Enabled:      true,
+				},
+				ApplyRequirements: []string{"mergeable"},
+				Name:              String("myproject"),
+			},
+			ExpWorkspace: "myworkspace",
+			ExpDir:       ".",
+		},
+		{
+			Description: "atlantis.yaml with mergeable and approved apply requirements",
+			Cmd: events.CommentCommand{
+				Name:        events.PlanCommand,
+				ProjectName: "myproject",
+			},
+			AtlantisYAML: `
+version: 2
+projects:
+- name: myproject
+  dir: .
+  workspace: myworkspace
+  apply_requirements: [mergeable, approved]`,
+			ExpProjectConfig: &valid.Project{
+				Dir:       ".",
+				Workspace: "myworkspace",
+				Autoplan: valid.Autoplan{
+					WhenModified: []string{"**/*.tf*"},
+					Enabled:      true,
+				},
+				ApplyRequirements: []string{"mergeable", "approved"},
+				Name:              String("myproject"),
+			},
+			ExpWorkspace: "myworkspace",
+			ExpDir:       ".",
+		},
 		{
 			Description: "atlantis.yaml with multiple dir/workspaces matching",
 			Cmd: events.CommentCommand{
--- a/server/events/project_command_runner.go
+++ b/server/events/project_command_runner.go
@@ -78,17 +78,19 @@ type ProjectCommandRunner interface {

 // DefaultProjectCommandRunner implements ProjectCommandRunner.
 type DefaultProjectCommandRunner struct {
-	Locker                  ProjectLocker
-	LockURLGenerator        LockURLGenerator
-	InitStepRunner          StepRunner
-	PlanStepRunner          StepRunner
-	ApplyStepRunner         StepRunner
-	RunStepRunner           StepRunner
-	PullApprovedChecker     runtime.PullApprovedChecker
-	WorkingDir              WorkingDir
-	Webhooks                WebhooksSender
-	WorkingDirLocker        WorkingDirLocker
-	RequireApprovalOverride bool
+	Locker                   ProjectLocker
+	LockURLGenerator         LockURLGenerator
+	InitStepRunner           StepRunner
+	PlanStepRunner           StepRunner
+	ApplyStepRunner          StepRunner
+	RunStepRunner            StepRunner
+	PullApprovedChecker      runtime.PullApprovedChecker
+	PullMergeableChecker     runtime.PullMergeableChecker
+	WorkingDir               WorkingDir
+	Webhooks                 WebhooksSender
+	WorkingDirLocker         WorkingDirLocker
+	RequireApprovalOverride  bool
+	RequireMergeableOverride bool
 }

 // Plan runs terraform plan for the project described by ctx.
@@ -207,15 +209,20 @@ func (p *DefaultProjectCommandRunner) doApply(ctx models.ProjectCommandContext)
 	}
 	absPath := filepath.Join(repoDir, ctx.RepoRelDir)

+	// Figure out what our apply requirements are.
 	var applyRequirements []string
-	if ctx.ProjectConfig != nil {
+	if p.RequireApprovalOverride || p.RequireMergeableOverride {
+		// If any server flags are set, they override project config.
+		if p.RequireMergeableOverride {
+			applyRequirements = append(applyRequirements, raw.MergeableApplyRequirement)
+		}
+		if p.RequireApprovalOverride {
+			applyRequirements = append(applyRequirements, raw.ApprovedApplyRequirement)
+		}
+	} else if ctx.ProjectConfig != nil {
+		// Else we use the project config if it's set.
 		applyRequirements = ctx.ProjectConfig.ApplyRequirements
 	}
-	// todo: this class shouldn't know about the server-side approval requirement.
-	// Instead the project_command_builder should figure this out and store this information in the ctx. # refactor
-	if p.RequireApprovalOverride {
-		applyRequirements = []string{raw.ApprovedApplyRequirement}
-	}
 	for _, req := range applyRequirements {
 		switch req {
 		case raw.ApprovedApplyRequirement:
@@ -226,6 +233,14 @@ func (p *DefaultProjectCommandRunner) doApply(ctx models.ProjectCommandContext)
 			if !approved {
 				return "", "Pull request must be approved before running apply.", nil
 			}
+		case raw.MergeableApplyRequirement:
+			mergeable, err := p.PullMergeableChecker.PullIsMergeable(ctx.BaseRepo, ctx.Pull) // nolint: vetshadow
+			if err != nil {
+				return "", "", errors.Wrap(err, "checking if pull request is mergeable")
+			}
+			if !mergeable {
+				return "", "Pull request must be mergeable before running apply.", nil
+			}
 		}
 	}
 	// Acquire internal lock for the directory we're going to operate in.
--- a/server/events/project_command_runner_test.go
+++ b/server/events/project_command_runner_test.go
@@ -134,16 +134,17 @@ func TestDefaultProjectCommandRunner_Plan(t *testing.T) {
 			mockLocker := mocks.NewMockProjectLocker()

 			runner := events.DefaultProjectCommandRunner{
-				Locker:              mockLocker,
-				LockURLGenerator:    mockURLGenerator{},
-				InitStepRunner:      mockInit,
-				PlanStepRunner:      mockPlan,
-				ApplyStepRunner:     mockApply,
-				RunStepRunner:       mockRun,
-				PullApprovedChecker: nil,
-				WorkingDir:          mockWorkingDir,
-				Webhooks:            nil,
-				WorkingDirLocker:    events.NewDefaultWorkingDirLocker(),
+				Locker:               mockLocker,
+				LockURLGenerator:     mockURLGenerator{},
+				InitStepRunner:       mockInit,
+				PlanStepRunner:       mockPlan,
+				ApplyStepRunner:      mockApply,
+				RunStepRunner:        mockRun,
+				PullApprovedChecker:  nil,
+				PullMergeableChecker: nil,
+				WorkingDir:           mockWorkingDir,
+				Webhooks:             nil,
+				WorkingDirLocker:     events.NewDefaultWorkingDirLocker(),
 			}

 			repoDir := "/tmp/mydir"
@@ -229,6 +230,24 @@ func TestDefaultProjectCommandRunner_ApplyNotApproved(t *testing.T) {
 	Equals(t, "Pull request must be approved before running apply.", res.Failure)
 }

+func TestDefaultProjectCommandRunner_ApplyNotMergeable(t *testing.T) {
+	RegisterMockTestingT(t)
+	mockWorkingDir := mocks.NewMockWorkingDir()
+	mockMergeable := mocks2.NewMockPullMergeableChecker()
+	runner := &events.DefaultProjectCommandRunner{
+		WorkingDir:               mockWorkingDir,
+		PullMergeableChecker:     mockMergeable,
+		WorkingDirLocker:         events.NewDefaultWorkingDirLocker(),
+		RequireMergeableOverride: true,
+	}
+	ctx := models.ProjectCommandContext{}
+	When(mockWorkingDir.GetWorkingDir(ctx.BaseRepo, ctx.Pull, ctx.Workspace)).ThenReturn("/tmp/mydir", nil)
+	When(mockMergeable.PullIsMergeable(ctx.BaseRepo, ctx.Pull)).ThenReturn(false, nil)
+
+	res := runner.Apply(ctx)
+	Equals(t, "Pull request must be mergeable before running apply.", res.Failure)
+}
+
 func TestDefaultProjectCommandRunner_Apply(t *testing.T) {
 	cases := []struct {
 		description string
@@ -275,7 +294,43 @@ func TestDefaultProjectCommandRunner_Apply(t *testing.T) {
 					},
 				},
 			},
-			expSteps: []string{"approved", "apply"},
+			expSteps: []string{"approve", "apply"},
+			expOut:   "apply",
+		},
+		{
+			description: "no workflow, mergeable required, use defaults",
+			projCfg: &valid.Project{
+				Dir:               ".",
+				ApplyRequirements: []string{"mergeable"},
+			},
+			globalCfg: &valid.Config{
+				Version: 2,
+				Projects: []valid.Project{
+					{
+						Dir:               ".",
+						ApplyRequirements: []string{"mergeable"},
+					},
+				},
+			},
+			expSteps: []string{"mergeable", "apply"},
+			expOut:   "apply",
+		},
+		{
+			description: "no workflow, mergeable and approved required, use defaults",
+			projCfg: &valid.Project{
+				Dir:               ".",
+				ApplyRequirements: []string{"mergeable", "approved"},
+			},
+			globalCfg: &valid.Config{
+				Version: 2,
+				Projects: []valid.Project{
+					{
+						Dir:               ".",
+						ApplyRequirements: []string{"mergeable", "approved"},
+					},
+				},
+			},
+			expSteps: []string{"mergeable", "approved", "apply"},
 			expOut:   "apply",
 		},
 		{
@@ -349,21 +404,23 @@ func TestDefaultProjectCommandRunner_Apply(t *testing.T) {
 			mockApply := mocks.NewMockStepRunner()
 			mockRun := mocks.NewMockStepRunner()
 			mockApproved := mocks2.NewMockPullApprovedChecker()
+			mockMergeable := mocks2.NewMockPullMergeableChecker()
 			mockWorkingDir := mocks.NewMockWorkingDir()
 			mockLocker := mocks.NewMockProjectLocker()
 			mockSender := mocks.NewMockWebhooksSender()

 			runner := events.DefaultProjectCommandRunner{
-				Locker:              mockLocker,
-				LockURLGenerator:    mockURLGenerator{},
-				InitStepRunner:      mockInit,
-				PlanStepRunner:      mockPlan,
-				ApplyStepRunner:     mockApply,
-				RunStepRunner:       mockRun,
-				PullApprovedChecker: mockApproved,
-				WorkingDir:          mockWorkingDir,
-				Webhooks:            mockSender,
-				WorkingDirLocker:    events.NewDefaultWorkingDirLocker(),
+				Locker:               mockLocker,
+				LockURLGenerator:     mockURLGenerator{},
+				InitStepRunner:       mockInit,
+				PlanStepRunner:       mockPlan,
+				ApplyStepRunner:      mockApply,
+				RunStepRunner:        mockRun,
+				PullApprovedChecker:  mockApproved,
+				PullMergeableChecker: mockMergeable,
+				WorkingDir:           mockWorkingDir,
+				Webhooks:             mockSender,
+				WorkingDirLocker:     events.NewDefaultWorkingDirLocker(),
 			}

 			repoDir := "/tmp/mydir"
@@ -385,6 +442,7 @@ func TestDefaultProjectCommandRunner_Apply(t *testing.T) {
 			When(mockApply.Run(ctx, nil, repoDir)).ThenReturn("apply", nil)
 			When(mockRun.Run(ctx, nil, repoDir)).ThenReturn("run", nil)
 			When(mockApproved.PullIsApproved(ctx.BaseRepo, ctx.Pull)).ThenReturn(true, nil)
+			When(mockMergeable.PullIsMergeable(ctx.BaseRepo, ctx.Pull)).ThenReturn(true, nil)

 			res := runner.Apply(ctx)
 			Equals(t, c.expOut, res.ApplySuccess)
@@ -393,6 +451,8 @@ func TestDefaultProjectCommandRunner_Apply(t *testing.T) {
 				switch step {
 				case "approved":
 					mockApproved.VerifyWasCalledOnce().PullIsApproved(ctx.BaseRepo, ctx.Pull)
+				case "mergeable":
+					mockMergeable.VerifyWasCalledOnce().PullIsMergeable(ctx.BaseRepo, ctx.Pull)
 				case "init":
 					mockInit.VerifyWasCalledOnce().Run(ctx, nil, repoDir)
 				case "plan":
--- a/server/events/runtime/mocks/mock_pull_mergeable_checker.go
+++ b/server/events/runtime/mocks/mock_pull_mergeable_checker.go
@@ -0,0 +1,106 @@
+// Code generated by pegomock. DO NOT EDIT.
+// Source: github.com/runatlantis/atlantis/server/events/runtime (interfaces: PullMergeableChecker)
+
+package mocks
+
+import (
+	pegomock "github.com/petergtz/pegomock"
+	models "github.com/runatlantis/atlantis/server/events/models"
+	"reflect"
+	"time"
+)
+
+type MockPullMergeableChecker struct {
+	fail func(message string, callerSkip ...int)
+}
+
+func NewMockPullMergeableChecker() *MockPullMergeableChecker {
+	return &MockPullMergeableChecker{fail: pegomock.GlobalFailHandler}
+}
+
+func (mock *MockPullMergeableChecker) PullIsMergeable(baseRepo models.Repo, pull models.PullRequest) (bool, error) {
+	if mock == nil {
+		panic("mock must not be nil. Use myMock := NewMockPullMergeableChecker().")
+	}
+	params := []pegomock.Param{baseRepo, pull}
+	result := pegomock.GetGenericMockFrom(mock).Invoke("PullIsMergeable", params, []reflect.Type{reflect.TypeOf((*bool)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
+	var ret0 bool
+	var ret1 error
+	if len(result) != 0 {
+		if result[0] != nil {
+			ret0 = result[0].(bool)
+		}
+		if result[1] != nil {
+			ret1 = result[1].(error)
+		}
+	}
+	return ret0, ret1
+}
+
+func (mock *MockPullMergeableChecker) VerifyWasCalledOnce() *VerifierPullMergeableChecker {
+	return &VerifierPullMergeableChecker{
+		mock:                   mock,
+		invocationCountMatcher: pegomock.Times(1),
+	}
+}
+
+func (mock *MockPullMergeableChecker) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierPullMergeableChecker {
+	return &VerifierPullMergeableChecker{
+		mock:                   mock,
+		invocationCountMatcher: invocationCountMatcher,
+	}
+}
+
+func (mock *MockPullMergeableChecker) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, inOrderContext *pegomock.InOrderContext) *VerifierPullMergeableChecker {
+	return &VerifierPullMergeableChecker{
+		mock:                   mock,
+		invocationCountMatcher: invocationCountMatcher,
+		inOrderContext:         inOrderContext,
+	}
+}
+
+func (mock *MockPullMergeableChecker) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierPullMergeableChecker {
+	return &VerifierPullMergeableChecker{
+		mock:                   mock,
+		invocationCountMatcher: invocationCountMatcher,
+		timeout:                timeout,
+	}
+}
+
+type VerifierPullMergeableChecker struct {
+	mock                   *MockPullMergeableChecker
+	invocationCountMatcher pegomock.Matcher
+	inOrderContext         *pegomock.InOrderContext
+	timeout                time.Duration
+}
+
+func (verifier *VerifierPullMergeableChecker) PullIsMergeable(baseRepo models.Repo, pull models.PullRequest) *PullMergeableChecker_PullIsMergeable_OngoingVerification {
+	params := []pegomock.Param{baseRepo, pull}
+	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "PullIsMergeable", params, verifier.timeout)
+	return &PullMergeableChecker_PullIsMergeable_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
+}
+
+type PullMergeableChecker_PullIsMergeable_OngoingVerification struct {
+	mock              *MockPullMergeableChecker
+	methodInvocations []pegomock.MethodInvocation
+}
+
+func (c *PullMergeableChecker_PullIsMergeable_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest) {
+	baseRepo, pull := c.GetAllCapturedArguments()
+	return baseRepo[len(baseRepo)-1], pull[len(pull)-1]
+}
+
+func (c *PullMergeableChecker_PullIsMergeable_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest) {
+	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
+	if len(params) > 0 {
+		_param0 = make([]models.Repo, len(params[0]))
+		for u, param := range params[0] {
+			_param0[u] = param.(models.Repo)
+		}
+		_param1 = make([]models.PullRequest, len(params[1]))
+		for u, param := range params[1] {
+			_param1[u] = param.(models.PullRequest)
+		}
+	}
+	return
+}
--- a/server/events/runtime/pull_mergeable_checker.go
+++ b/server/events/runtime/pull_mergeable_checker.go
@@ -0,0 +1,11 @@
+package runtime
+
+import (
+	"github.com/runatlantis/atlantis/server/events/models"
+)
+
+//go:generate pegomock generate -m --use-experimental-model-gen --package mocks -o mocks/mock_pull_mergeable_checker.go PullMergeableChecker
+
+type PullMergeableChecker interface {
+	PullIsMergeable(baseRepo models.Repo, pull models.PullRequest) (bool, error)
+}
--- a/server/events/testdata/gitlab-merge-request-event.json
+++ b/server/events/testdata/gitlab-merge-request-event.json
@@ -1,154 +1,174 @@
 {
  "object_kind": "merge_request",
+  "event_type": "merge_request",
  "user": {
-    "name": "Administrator",
-    "username": "root",
-    "avatar_url": "http://www.gravatar.com/avatar/e64c7d89f26bd1972efa854d13d7dd61?s=40\u0026d=identicon"
+    "name": "Luke Kysow",
+    "username": "lkysow",
+    "avatar_url": "https://secure.gravatar.com/avatar/25fd57e71590fe28736624ff24d41c5f?s=80&d=identicon"
  },
  "project": {
-    "id": 1,
-    "name": "Gitlab Test",
-    "description": "Aut reprehenderit ut est.",
-    "web_url": "http://example.com/gitlabhq/gitlab-test",
+    "id": 4580910,
+    "name": "atlantis-example",
+    "description": "",
+    "web_url": "https://gitlab.com/lkysow/atlantis-example",
    "avatar_url": null,
-    "git_ssh_url": "git@example.com:gitlabhq/gitlab-test.git",
-    "git_http_url": "https://example.com/gitlabhq/gitlab-test.git",
-    "namespace": "GitlabHQ",
+    "git_ssh_url": "git@gitlab.com:lkysow/atlantis-example.git",
+    "git_http_url": "https://gitlab.com/lkysow/atlantis-example.git",
+    "namespace": "lkysow",
    "visibility_level": 20,
-    "path_with_namespace": "gitlabhq/gitlab-test",
+    "path_with_namespace": "lkysow/atlantis-example",
    "default_branch": "master",
-    "homepage": "http://example.com/gitlabhq/gitlab-test",
-    "url": "https://example.com/gitlabhq/gitlab-test.git",
-    "ssh_url": "git@example.com:gitlabhq/gitlab-test.git",
-    "http_url": "https://example.com/gitlabhq/gitlab-test.git"
-  },
-  "repository": {
-    "name": "Gitlab Test",
-    "url": "https://example.com/gitlabhq/gitlab-test.git",
-    "description": "Aut reprehenderit ut est.",
-    "homepage": "http://example.com/gitlabhq/gitlab-test"
+    "ci_config_path": null,
+    "homepage": "https://gitlab.com/lkysow/atlantis-example",
+    "url": "git@gitlab.com:lkysow/atlantis-example.git",
+    "ssh_url": "git@gitlab.com:lkysow/atlantis-example.git",
+    "http_url": "https://gitlab.com/lkysow/atlantis-example.git"
  },
  "object_attributes": {
-    "id": 99,
-    "target_branch": "master",
-    "source_branch": "ms-viewport",
-    "source_project_id": 14,
-    "author_id": 51,
-    "assignee_id": 6,
-    "title": "MS-Viewport",
-    "created_at": "2013-12-03T17:23:34Z",
-    "updated_at": "2013-12-03T17:23:34Z",
-    "st_commits": null,
-    "st_diffs": null,
-    "milestone_id": null,
-    "state": "opened",
-    "merge_status": "unchecked",
-    "target_project_id": 14,
-    "iid": 1,
+    "assignee_id": null,
+    "author_id": 1755902,
+    "created_at": "2018-12-12 16:15:21 UTC",
    "description": "",
+    "head_pipeline_id": null,
+    "id": 20809239,
+    "iid": 12,
+    "last_edited_at": null,
+    "last_edited_by_id": null,
+    "merge_commit_sha": null,
+    "merge_error": null,
+    "merge_params": {
+      "force_remove_source_branch": "0"
+    },
+    "merge_status": "unchecked",
+    "merge_user_id": null,
+    "merge_when_pipeline_succeeds": false,
+    "milestone_id": null,
+    "source_branch": "patch-1",
+    "source_project_id": 4580910,
+    "state": "opened",
+    "target_branch": "master",
+    "target_project_id": 4580910,
+    "time_estimate": 0,
+    "title": "Update main.tf",
+    "updated_at": "2018-12-12 16:15:21 UTC",
+    "updated_by_id": null,
+    "url": "https://gitlab.com/lkysow/atlantis-example/merge_requests/12",
    "source": {
-      "name": "Awesome Project",
-      "description": "Aut reprehenderit ut est.",
-      "web_url": "http://example.com/awesome_space/awesome_project",
+      "id": 4580910,
+      "name": "atlantis-example",
+      "description": "",
+      "web_url": "https://gitlab.com/sourceorg/atlantis-example",
      "avatar_url": null,
-      "git_ssh_url": "git@example.com:awesome_space/awesome_project.git",
-      "git_http_url": "http://example.com/awesome_space/awesome_project.git",
-      "namespace": "Awesome Space",
+      "git_ssh_url": "git@gitlab.com:sourceorg/atlantis-example.git",
+      "git_http_url": "https://gitlab.com/sourceorg/atlantis-example.git",
+      "namespace": "sourceorg",
      "visibility_level": 20,
-      "path_with_namespace": "awesome_space/awesome_project",
+      "path_with_namespace": "sourceorg/atlantis-example",
      "default_branch": "master",
-      "homepage": "http://example.com/awesome_space/awesome_project",
-      "url": "http://example.com/awesome_space/awesome_project.git",
-      "ssh_url": "git@example.com:awesome_space/awesome_project.git",
-      "http_url": "http://example.com/awesome_space/awesome_project.git"
+      "ci_config_path": null,
+      "homepage": "https://gitlab.com/sourceorg/atlantis-example",
+      "url": "git@gitlab.com:sourceorg/atlantis-example.git",
+      "ssh_url": "git@gitlab.com:sourceorg/atlantis-example.git",
+      "http_url": "https://gitlab.com/sourceorg/atlantis-example.git"
    },
    "target": {
-      "name": "Awesome Project",
-      "description": "Aut reprehenderit ut est.",
-      "web_url": "http://example.com/awesome_space/awesome_project",
+      "id": 4580910,
+      "name": "atlantis-example",
+      "description": "",
+      "web_url": "https://gitlab.com/lkysow/atlantis-example",
      "avatar_url": null,
-      "git_ssh_url": "git@example.com:awesome_space/awesome_project.git",
-      "git_http_url": "http://example.com/awesome_space/awesome_project.git",
-      "namespace": "Awesome Space",
+      "git_ssh_url": "git@gitlab.com:lkysow/atlantis-example.git",
+      "git_http_url": "https://gitlab.com/lkysow/atlantis-example.git",
+      "namespace": "lkysow",
      "visibility_level": 20,
-      "path_with_namespace": "awesome_space/awesome_project",
+      "path_with_namespace": "lkysow/atlantis-example",
      "default_branch": "master",
-      "homepage": "http://example.com/awesome_space/awesome_project",
-      "url": "http://example.com/awesome_space/awesome_project.git",
-      "ssh_url": "git@example.com:awesome_space/awesome_project.git",
-      "http_url": "http://example.com/awesome_space/awesome_project.git"
+      "ci_config_path": null,
+      "homepage": "https://gitlab.com/lkysow/atlantis-example",
+      "url": "git@gitlab.com:lkysow/atlantis-example.git",
+      "ssh_url": "git@gitlab.com:lkysow/atlantis-example.git",
+      "http_url": "https://gitlab.com/lkysow/atlantis-example.git"
    },
    "last_commit": {
-      "id": "da1560886d4f094c3e6c9ef40349f7d38b5d27d7",
-      "message": "fixed readme",
-      "timestamp": "2012-01-03T23:36:29+02:00",
-      "url": "http://example.com/awesome_space/awesome_project/commits/da1560886d4f094c3e6c9ef40349f7d38b5d27d7",
+      "id": "d2eae324ca26242abca45d7b49d582cddb2a4f15",
+      "message": "Update main.tf",
+      "timestamp": "2018-12-12T16:15:10Z",
+      "url": "https://gitlab.com/lkysow/atlantis-example/commit/d2eae324ca26242abca45d7b49d582cddb2a4f15",
      "author": {
-        "name": "GitLab dev user",
-        "email": "gitlabdev@dv6700.(none)"
+        "name": "Luke Kysow",
+        "email": "lkysow@gmail.com"
      }
    },
    "work_in_progress": false,
-    "url": "http://example.com/diaspora/merge_requests/1",
-    "action": "open",
-    "assignee": {
-      "name": "User1",
-      "username": "user1",
-      "avatar_url": "http://www.gravatar.com/avatar/e64c7d89f26bd1972efa854d13d7dd61?s=40\u0026d=identicon"
-    }
+    "total_time_spent": 0,
+    "human_total_time_spent": null,
+    "human_time_estimate": null,
+    "action": "open"
  },
  "labels": [
-    {
-      "id": 206,
-      "title": "API",
-      "color": "#ffffff",
-      "project_id": 14,
-      "created_at": "2013-12-03T17:15:43Z",
-      "updated_at": "2013-12-03T17:15:43Z",
-      "template": false,
-      "description": "API related issues",
-      "type": "ProjectLabel",
-      "group_id": 41
-    }
+
  ],
  "changes": {
-    "updated_by_id": [
-      null,
-      1
-    ],
-    "updated_at": [
-      "2017-09-15 16:50:55 UTC",
-      "2017-09-15 16:52:00 UTC"
-    ],
-    "labels": {
-      "previous": [
-        {
-          "id": 206,
-          "title": "API",
-          "color": "#ffffff",
-          "project_id": 14,
-          "created_at": "2013-12-03T17:15:43Z",
-          "updated_at": "2013-12-03T17:15:43Z",
-          "template": false,
-          "description": "API related issues",
-          "type": "ProjectLabel",
-          "group_id": 41
-        }
-      ],
-      "current": [
-        {
-          "id": 205,
-          "title": "Platform",
-          "color": "#123123",
-          "project_id": 14,
-          "created_at": "2013-12-03T17:15:43Z",
-          "updated_at": "2013-12-03T17:15:43Z",
-          "template": false,
-          "description": "Platform related issues",
-          "type": "ProjectLabel",
-          "group_id": 41
-        }
-      ]
+    "author_id": {
+      "previous": null,
+      "current": 1755902
+    },
+    "created_at": {
+      "previous": null,
+      "current": "2018-12-12 16:15:21 UTC"
+    },
+    "description": {
+      "previous": null,
+      "current": ""
+    },
+    "id": {
+      "previous": null,
+      "current": 20809239
+    },
+    "iid": {
+      "previous": null,
+      "current": 12
+    },
+    "merge_params": {
+      "previous": {
+      },
+      "current": {
+        "force_remove_source_branch": "0"
+      }
+    },
+    "source_branch": {
+      "previous": null,
+      "current": "patch-1"
+    },
+    "source_project_id": {
+      "previous": null,
+      "current": 4580910
+    },
+    "target_branch": {
+      "previous": null,
+      "current": "master"
+    },
+    "target_project_id": {
+      "previous": null,
+      "current": 4580910
+    },
+    "title": {
+      "previous": null,
+      "current": "Update main.tf"
+    },
+    "updated_at": {
+      "previous": null,
+      "current": "2018-12-12 16:15:21 UTC"
+    },
+    "total_time_spent": {
+      "previous": null,
+      "current": 0
    }
+  },
+  "repository": {
+    "name": "atlantis-example",
+    "url": "git@gitlab.com:lkysow/atlantis-example.git",
+    "description": "",
+    "homepage": "https://gitlab.com/lkysow/atlantis-example"
  }
-}
+}
--- a/server/events/vcs/bitbucketcloud/client.go
+++ b/server/events/vcs/bitbucketcloud/client.go
@@ -124,6 +124,27 @@ func (b *Client) PullIsApproved(repo models.Repo, pull models.PullRequest) (bool
 	return false, nil
 }

+// PullIsMergeable returns true if the merge request has no conflicts and can be merged.
+func (b *Client) PullIsMergeable(repo models.Repo, pull models.PullRequest) (bool, error) {
+	// NOTE: The 1.0 API is deprecated, but the 2.0 API does not provide this endpoint.
+	path := fmt.Sprintf("%s/1.0/repositories/%s/pullrequests/%d/conflict-status", b.BaseURL, repo.FullName, pull.Num)
+	resp, err := b.makeRequest("GET", path, nil)
+	if err != nil {
+		return false, err
+	}
+	var conflictStatus ConflictStatus
+	if err := json.Unmarshal(resp, &conflictStatus); err != nil {
+		return false, errors.Wrapf(err, "Could not parse response %q", string(resp))
+	}
+	if err := validator.New().Struct(conflictStatus); err != nil {
+		return false, errors.Wrapf(err, "API response %q was missing fields", string(resp))
+	}
+	if !*conflictStatus.MergeImpossible && !*conflictStatus.IsConflicted {
+		return true, nil
+	}
+	return false, nil
+}
+
 // UpdateStatus updates the status of a commit.
 func (b *Client) UpdateStatus(repo models.Repo, pull models.PullRequest, status models.CommitStatus, description string) error {
 	bbState := "FAILED"
--- a/server/events/vcs/bitbucketcloud/models.go
+++ b/server/events/vcs/bitbucketcloud/models.go
@@ -80,3 +80,8 @@ type Comment struct {
 type CommentContent struct {
 	Raw *string `json:"raw,omitempty" validate:"required"`
 }
+
+type ConflictStatus struct {
+	MergeImpossible *bool `json:"mergeimpossible,omitempty" validate:"required"`
+	IsConflicted    *bool `json:"isconflicted,omitempty" validate:"required"`
+}
--- a/server/events/vcs/bitbucketserver/client.go
+++ b/server/events/vcs/bitbucketserver/client.go
@@ -178,6 +178,30 @@ func (b *Client) PullIsApproved(repo models.Repo, pull models.PullRequest) (bool
 	return false, nil
 }

+// PullIsMergeable returns true if the merge request has no conflicts and can be merged.
+func (b *Client) PullIsMergeable(repo models.Repo, pull models.PullRequest) (bool, error) {
+	projectKey, err := b.GetProjectKey(repo.Name, repo.SanitizedCloneURL)
+	if err != nil {
+		return false, err
+	}
+	path := fmt.Sprintf("%s/rest/api/1.0/projects/%s/repos/%s/pull-requests/%d/merge", b.BaseURL, projectKey, repo.Name, pull.Num)
+	resp, err := b.makeRequest("GET", path, nil)
+	if err != nil {
+		return false, err
+	}
+	var mergeStatus MergeStatus
+	if err := json.Unmarshal(resp, &mergeStatus); err != nil {
+		return false, errors.Wrapf(err, "Could not parse response %q", string(resp))
+	}
+	if err := validator.New().Struct(mergeStatus); err != nil {
+		return false, errors.Wrapf(err, "API response %q was missing fields", string(resp))
+	}
+	if *mergeStatus.CanMerge && !*mergeStatus.Conflicted {
+		return true, nil
+	}
+	return false, nil
+}
+
 // UpdateStatus updates the status of a commit.
 func (b *Client) UpdateStatus(repo models.Repo, pull models.PullRequest, status models.CommitStatus, description string) error {
 	bbState := "FAILED"
--- a/server/events/vcs/bitbucketserver/models.go
+++ b/server/events/vcs/bitbucketserver/models.go
@@ -64,3 +64,8 @@ type Changes struct {
 	NextPageStart *int  `json:"nextPageStart,omitempty"`
 	IsLastPage    *bool `json:"isLastPage,omitempty" validate:"required"`
 }
+
+type MergeStatus struct {
+	CanMerge   *bool `json:"canMerge,omitempty" validate:"required"`
+	Conflicted *bool `json:"conflicted,omitempty" validate:"required"`
+}
--- a/server/events/vcs/client.go
+++ b/server/events/vcs/client.go
@@ -24,5 +24,6 @@ type Client interface {
 	GetModifiedFiles(repo models.Repo, pull models.PullRequest) ([]string, error)
 	CreateComment(repo models.Repo, pullNum int, comment string) error
 	PullIsApproved(repo models.Repo, pull models.PullRequest) (bool, error)
+	PullIsMergeable(repo models.Repo, pull models.PullRequest) (bool, error)
 	UpdateStatus(repo models.Repo, pull models.PullRequest, state models.CommitStatus, description string) error
 }
--- a/server/events/vcs/fixtures/github-pull-request.json
+++ b/server/events/vcs/fixtures/github-pull-request.json
@@ -0,0 +1,510 @@
+{
+  "url": "https://api.github.com/repos/octocat/Hello-World/pulls/1347",
+  "id": 1,
+  "node_id": "MDExOlB1bGxSZXF1ZXN0MQ==",
+  "html_url": "https://github.com/octocat/Hello-World/pull/1347",
+  "diff_url": "https://github.com/octocat/Hello-World/pull/1347.diff",
+  "patch_url": "https://github.com/octocat/Hello-World/pull/1347.patch",
+  "issue_url": "https://api.github.com/repos/octocat/Hello-World/issues/1347",
+  "commits_url": "https://api.github.com/repos/octocat/Hello-World/pulls/1347/commits",
+  "review_comments_url": "https://api.github.com/repos/octocat/Hello-World/pulls/1347/comments",
+  "review_comment_url": "https://api.github.com/repos/octocat/Hello-World/pulls/comments{/number}",
+  "comments_url": "https://api.github.com/repos/octocat/Hello-World/issues/1347/comments",
+  "statuses_url": "https://api.github.com/repos/octocat/Hello-World/statuses/6dcb09b5b57875f334f61aebed695e2e4193db5e",
+  "number": 1347,
+  "state": "open",
+  "locked": true,
+  "title": "new-feature",
+  "user": {
+    "login": "octocat",
+    "id": 1,
+    "node_id": "MDQ6VXNlcjE=",
+    "avatar_url": "https://github.com/images/error/octocat_happy.gif",
+    "gravatar_id": "",
+    "url": "https://api.github.com/users/octocat",
+    "html_url": "https://github.com/octocat",
+    "followers_url": "https://api.github.com/users/octocat/followers",
+    "following_url": "https://api.github.com/users/octocat/following{/other_user}",
+    "gists_url": "https://api.github.com/users/octocat/gists{/gist_id}",
+    "starred_url": "https://api.github.com/users/octocat/starred{/owner}{/repo}",
+    "subscriptions_url": "https://api.github.com/users/octocat/subscriptions",
+    "organizations_url": "https://api.github.com/users/octocat/orgs",
+    "repos_url": "https://api.github.com/users/octocat/repos",
+    "events_url": "https://api.github.com/users/octocat/events{/privacy}",
+    "received_events_url": "https://api.github.com/users/octocat/received_events",
+    "type": "User",
+    "site_admin": false
+  },
+  "body": "Please pull these awesome changes",
+  "labels": [
+    {
+      "id": 208045946,
+      "node_id": "MDU6TGFiZWwyMDgwNDU5NDY=",
+      "url": "https://api.github.com/repos/octocat/Hello-World/labels/bug",
+      "name": "bug",
+      "description": "Something isn't working",
+      "color": "f29513",
+      "default": true
+    }
+  ],
+  "milestone": {
+    "url": "https://api.github.com/repos/octocat/Hello-World/milestones/1",
+    "html_url": "https://github.com/octocat/Hello-World/milestones/v1.0",
+    "labels_url": "https://api.github.com/repos/octocat/Hello-World/milestones/1/labels",
+    "id": 1002604,
+    "node_id": "MDk6TWlsZXN0b25lMTAwMjYwNA==",
+    "number": 1,
+    "state": "open",
+    "title": "v1.0",
+    "description": "Tracking milestone for version 1.0",
+    "creator": {
+      "login": "octocat",
+      "id": 1,
+      "node_id": "MDQ6VXNlcjE=",
+      "avatar_url": "https://github.com/images/error/octocat_happy.gif",
+      "gravatar_id": "",
+      "url": "https://api.github.com/users/octocat",
+      "html_url": "https://github.com/octocat",
+      "followers_url": "https://api.github.com/users/octocat/followers",
+      "following_url": "https://api.github.com/users/octocat/following{/other_user}",
+      "gists_url": "https://api.github.com/users/octocat/gists{/gist_id}",
+      "starred_url": "https://api.github.com/users/octocat/starred{/owner}{/repo}",
+      "subscriptions_url": "https://api.github.com/users/octocat/subscriptions",
+      "organizations_url": "https://api.github.com/users/octocat/orgs",
+      "repos_url": "https://api.github.com/users/octocat/repos",
+      "events_url": "https://api.github.com/users/octocat/events{/privacy}",
+      "received_events_url": "https://api.github.com/users/octocat/received_events",
+      "type": "User",
+      "site_admin": false
+    },
+    "open_issues": 4,
+    "closed_issues": 8,
+    "created_at": "2011-04-10T20:09:31Z",
+    "updated_at": "2014-03-03T18:58:10Z",
+    "closed_at": "2013-02-12T13:22:01Z",
+    "due_on": "2012-10-09T23:39:01Z"
+  },
+  "active_lock_reason": "too heated",
+  "created_at": "2011-01-26T19:01:12Z",
+  "updated_at": "2011-01-26T19:01:12Z",
+  "closed_at": "2011-01-26T19:01:12Z",
+  "merged_at": "2011-01-26T19:01:12Z",
+  "merge_commit_sha": "e5bd3914e2e596debea16f433f57875b5b90bcd6",
+  "assignee": {
+    "login": "octocat",
+    "id": 1,
+    "node_id": "MDQ6VXNlcjE=",
+    "avatar_url": "https://github.com/images/error/octocat_happy.gif",
+    "gravatar_id": "",
+    "url": "https://api.github.com/users/octocat",
+    "html_url": "https://github.com/octocat",
+    "followers_url": "https://api.github.com/users/octocat/followers",
+    "following_url": "https://api.github.com/users/octocat/following{/other_user}",
+    "gists_url": "https://api.github.com/users/octocat/gists{/gist_id}",
+    "starred_url": "https://api.github.com/users/octocat/starred{/owner}{/repo}",
+    "subscriptions_url": "https://api.github.com/users/octocat/subscriptions",
+    "organizations_url": "https://api.github.com/users/octocat/orgs",
+    "repos_url": "https://api.github.com/users/octocat/repos",
+    "events_url": "https://api.github.com/users/octocat/events{/privacy}",
+    "received_events_url": "https://api.github.com/users/octocat/received_events",
+    "type": "User",
+    "site_admin": false
+  },
+  "assignees": [
+    {
+      "login": "octocat",
+      "id": 1,
+      "node_id": "MDQ6VXNlcjE=",
+      "avatar_url": "https://github.com/images/error/octocat_happy.gif",
+      "gravatar_id": "",
+      "url": "https://api.github.com/users/octocat",
+      "html_url": "https://github.com/octocat",
+      "followers_url": "https://api.github.com/users/octocat/followers",
+      "following_url": "https://api.github.com/users/octocat/following{/other_user}",
+      "gists_url": "https://api.github.com/users/octocat/gists{/gist_id}",
+      "starred_url": "https://api.github.com/users/octocat/starred{/owner}{/repo}",
+      "subscriptions_url": "https://api.github.com/users/octocat/subscriptions",
+      "organizations_url": "https://api.github.com/users/octocat/orgs",
+      "repos_url": "https://api.github.com/users/octocat/repos",
+      "events_url": "https://api.github.com/users/octocat/events{/privacy}",
+      "received_events_url": "https://api.github.com/users/octocat/received_events",
+      "type": "User",
+      "site_admin": false
+    },
+    {
+      "login": "hubot",
+      "id": 1,
+      "node_id": "MDQ6VXNlcjE=",
+      "avatar_url": "https://github.com/images/error/hubot_happy.gif",
+      "gravatar_id": "",
+      "url": "https://api.github.com/users/hubot",
+      "html_url": "https://github.com/hubot",
+      "followers_url": "https://api.github.com/users/hubot/followers",
+      "following_url": "https://api.github.com/users/hubot/following{/other_user}",
+      "gists_url": "https://api.github.com/users/hubot/gists{/gist_id}",
+      "starred_url": "https://api.github.com/users/hubot/starred{/owner}{/repo}",
+      "subscriptions_url": "https://api.github.com/users/hubot/subscriptions",
+      "organizations_url": "https://api.github.com/users/hubot/orgs",
+      "repos_url": "https://api.github.com/users/hubot/repos",
+      "events_url": "https://api.github.com/users/hubot/events{/privacy}",
+      "received_events_url": "https://api.github.com/users/hubot/received_events",
+      "type": "User",
+      "site_admin": true
+    }
+  ],
+  "requested_reviewers": [
+    {
+      "login": "other_user",
+      "id": 1,
+      "node_id": "MDQ6VXNlcjE=",
+      "avatar_url": "https://github.com/images/error/other_user_happy.gif",
+      "gravatar_id": "",
+      "url": "https://api.github.com/users/other_user",
+      "html_url": "https://github.com/other_user",
+      "followers_url": "https://api.github.com/users/other_user/followers",
+      "following_url": "https://api.github.com/users/other_user/following{/other_user}",
+      "gists_url": "https://api.github.com/users/other_user/gists{/gist_id}",
+      "starred_url": "https://api.github.com/users/other_user/starred{/owner}{/repo}",
+      "subscriptions_url": "https://api.github.com/users/other_user/subscriptions",
+      "organizations_url": "https://api.github.com/users/other_user/orgs",
+      "repos_url": "https://api.github.com/users/other_user/repos",
+      "events_url": "https://api.github.com/users/other_user/events{/privacy}",
+      "received_events_url": "https://api.github.com/users/other_user/received_events",
+      "type": "User",
+      "site_admin": false
+    }
+  ],
+  "requested_teams": [
+    {
+      "id": 1,
+      "node_id": "MDQ6VGVhbTE=",
+      "url": "https://api.github.com/teams/1",
+      "name": "Justice League",
+      "slug": "justice-league",
+      "description": "A great team.",
+      "privacy": "closed",
+      "permission": "admin",
+      "members_url": "https://api.github.com/teams/1/members{/member}",
+      "repositories_url": "https://api.github.com/teams/1/repos",
+      "parent": null
+    }
+  ],
+  "head": {
+    "label": "new-topic",
+    "ref": "new-topic",
+    "sha": "6dcb09b5b57875f334f61aebed695e2e4193db5e",
+    "user": {
+      "login": "octocat",
+      "id": 1,
+      "node_id": "MDQ6VXNlcjE=",
+      "avatar_url": "https://github.com/images/error/octocat_happy.gif",
+      "gravatar_id": "",
+      "url": "https://api.github.com/users/octocat",
+      "html_url": "https://github.com/octocat",
+      "followers_url": "https://api.github.com/users/octocat/followers",
+      "following_url": "https://api.github.com/users/octocat/following{/other_user}",
+      "gists_url": "https://api.github.com/users/octocat/gists{/gist_id}",
+      "starred_url": "https://api.github.com/users/octocat/starred{/owner}{/repo}",
+      "subscriptions_url": "https://api.github.com/users/octocat/subscriptions",
+      "organizations_url": "https://api.github.com/users/octocat/orgs",
+      "repos_url": "https://api.github.com/users/octocat/repos",
+      "events_url": "https://api.github.com/users/octocat/events{/privacy}",
+      "received_events_url": "https://api.github.com/users/octocat/received_events",
+      "type": "User",
+      "site_admin": false
+    },
+    "repo": {
+      "id": 1296269,
+      "node_id": "MDEwOlJlcG9zaXRvcnkxMjk2MjY5",
+      "name": "Hello-World",
+      "full_name": "octocat/Hello-World",
+      "owner": {
+        "login": "octocat",
+        "id": 1,
+        "node_id": "MDQ6VXNlcjE=",
+        "avatar_url": "https://github.com/images/error/octocat_happy.gif",
+        "gravatar_id": "",
+        "url": "https://api.github.com/users/octocat",
+        "html_url": "https://github.com/octocat",
+        "followers_url": "https://api.github.com/users/octocat/followers",
+        "following_url": "https://api.github.com/users/octocat/following{/other_user}",
+        "gists_url": "https://api.github.com/users/octocat/gists{/gist_id}",
+        "starred_url": "https://api.github.com/users/octocat/starred{/owner}{/repo}",
+        "subscriptions_url": "https://api.github.com/users/octocat/subscriptions",
+        "organizations_url": "https://api.github.com/users/octocat/orgs",
+        "repos_url": "https://api.github.com/users/octocat/repos",
+        "events_url": "https://api.github.com/users/octocat/events{/privacy}",
+        "received_events_url": "https://api.github.com/users/octocat/received_events",
+        "type": "User",
+        "site_admin": false
+      },
+      "private": false,
+      "html_url": "https://github.com/octocat/Hello-World",
+      "description": "This your first repo!",
+      "fork": true,
+      "url": "https://api.github.com/repos/octocat/Hello-World",
+      "archive_url": "http://api.github.com/repos/octocat/Hello-World/{archive_format}{/ref}",
+      "assignees_url": "http://api.github.com/repos/octocat/Hello-World/assignees{/user}",
+      "blobs_url": "http://api.github.com/repos/octocat/Hello-World/git/blobs{/sha}",
+      "branches_url": "http://api.github.com/repos/octocat/Hello-World/branches{/branch}",
+      "collaborators_url": "http://api.github.com/repos/octocat/Hello-World/collaborators{/collaborator}",
+      "comments_url": "http://api.github.com/repos/octocat/Hello-World/comments{/number}",
+      "commits_url": "http://api.github.com/repos/octocat/Hello-World/commits{/sha}",
+      "compare_url": "http://api.github.com/repos/octocat/Hello-World/compare/{base}...{head}",
+      "contents_url": "http://api.github.com/repos/octocat/Hello-World/contents/{+path}",
+      "contributors_url": "http://api.github.com/repos/octocat/Hello-World/contributors",
+      "deployments_url": "http://api.github.com/repos/octocat/Hello-World/deployments",
+      "downloads_url": "http://api.github.com/repos/octocat/Hello-World/downloads",
+      "events_url": "http://api.github.com/repos/octocat/Hello-World/events",
+      "forks_url": "http://api.github.com/repos/octocat/Hello-World/forks",
+      "git_commits_url": "http://api.github.com/repos/octocat/Hello-World/git/commits{/sha}",
+      "git_refs_url": "http://api.github.com/repos/octocat/Hello-World/git/refs{/sha}",
+      "git_tags_url": "http://api.github.com/repos/octocat/Hello-World/git/tags{/sha}",
+      "git_url": "git:github.com/octocat/Hello-World.git",
+      "issue_comment_url": "http://api.github.com/repos/octocat/Hello-World/issues/comments{/number}",
+      "issue_events_url": "http://api.github.com/repos/octocat/Hello-World/issues/events{/number}",
+      "issues_url": "http://api.github.com/repos/octocat/Hello-World/issues{/number}",
+      "keys_url": "http://api.github.com/repos/octocat/Hello-World/keys{/key_id}",
+      "labels_url": "http://api.github.com/repos/octocat/Hello-World/labels{/name}",
+      "languages_url": "http://api.github.com/repos/octocat/Hello-World/languages",
+      "merges_url": "http://api.github.com/repos/octocat/Hello-World/merges",
+      "milestones_url": "http://api.github.com/repos/octocat/Hello-World/milestones{/number}",
+      "notifications_url": "http://api.github.com/repos/octocat/Hello-World/notifications{?since,all,participating}",
+      "pulls_url": "http://api.github.com/repos/octocat/Hello-World/pulls{/number}",
+      "releases_url": "http://api.github.com/repos/octocat/Hello-World/releases{/id}",
+      "ssh_url": "git@github.com:octocat/Hello-World.git",
+      "stargazers_url": "http://api.github.com/repos/octocat/Hello-World/stargazers",
+      "statuses_url": "http://api.github.com/repos/octocat/Hello-World/statuses/{sha}",
+      "subscribers_url": "http://api.github.com/repos/octocat/Hello-World/subscribers",
+      "subscription_url": "http://api.github.com/repos/octocat/Hello-World/subscription",
+      "tags_url": "http://api.github.com/repos/octocat/Hello-World/tags",
+      "teams_url": "http://api.github.com/repos/octocat/Hello-World/teams",
+      "trees_url": "http://api.github.com/repos/octocat/Hello-World/git/trees{/sha}",
+      "clone_url": "https://github.com/octocat/Hello-World.git",
+      "mirror_url": "git:git.example.com/octocat/Hello-World",
+      "hooks_url": "http://api.github.com/repos/octocat/Hello-World/hooks",
+      "svn_url": "https://svn.github.com/octocat/Hello-World",
+      "homepage": "https://github.com",
+      "language": null,
+      "forks_count": 9,
+      "stargazers_count": 80,
+      "watchers_count": 80,
+      "size": 108,
+      "default_branch": "master",
+      "open_issues_count": 0,
+      "topics": [
+        "octocat",
+        "atom",
+        "electron",
+        "API"
+      ],
+      "has_issues": true,
+      "has_projects": true,
+      "has_wiki": true,
+      "has_pages": false,
+      "has_downloads": true,
+      "archived": false,
+      "pushed_at": "2011-01-26T19:06:43Z",
+      "created_at": "2011-01-26T19:01:12Z",
+      "updated_at": "2011-01-26T19:14:43Z",
+      "permissions": {
+        "admin": false,
+        "push": false,
+        "pull": true
+      },
+      "allow_rebase_merge": true,
+      "allow_squash_merge": true,
+      "allow_merge_commit": true,
+      "subscribers_count": 42,
+      "network_count": 0
+    }
+  },
+  "base": {
+    "label": "master",
+    "ref": "master",
+    "sha": "6dcb09b5b57875f334f61aebed695e2e4193db5e",
+    "user": {
+      "login": "octocat",
+      "id": 1,
+      "node_id": "MDQ6VXNlcjE=",
+      "avatar_url": "https://github.com/images/error/octocat_happy.gif",
+      "gravatar_id": "",
+      "url": "https://api.github.com/users/octocat",
+      "html_url": "https://github.com/octocat",
+      "followers_url": "https://api.github.com/users/octocat/followers",
+      "following_url": "https://api.github.com/users/octocat/following{/other_user}",
+      "gists_url": "https://api.github.com/users/octocat/gists{/gist_id}",
+      "starred_url": "https://api.github.com/users/octocat/starred{/owner}{/repo}",
+      "subscriptions_url": "https://api.github.com/users/octocat/subscriptions",
+      "organizations_url": "https://api.github.com/users/octocat/orgs",
+      "repos_url": "https://api.github.com/users/octocat/repos",
+      "events_url": "https://api.github.com/users/octocat/events{/privacy}",
+      "received_events_url": "https://api.github.com/users/octocat/received_events",
+      "type": "User",
+      "site_admin": false
+    },
+    "repo": {
+      "id": 1296269,
+      "node_id": "MDEwOlJlcG9zaXRvcnkxMjk2MjY5",
+      "name": "Hello-World",
+      "full_name": "octocat/Hello-World",
+      "owner": {
+        "login": "octocat",
+        "id": 1,
+        "node_id": "MDQ6VXNlcjE=",
+        "avatar_url": "https://github.com/images/error/octocat_happy.gif",
+        "gravatar_id": "",
+        "url": "https://api.github.com/users/octocat",
+        "html_url": "https://github.com/octocat",
+        "followers_url": "https://api.github.com/users/octocat/followers",
+        "following_url": "https://api.github.com/users/octocat/following{/other_user}",
+        "gists_url": "https://api.github.com/users/octocat/gists{/gist_id}",
+        "starred_url": "https://api.github.com/users/octocat/starred{/owner}{/repo}",
+        "subscriptions_url": "https://api.github.com/users/octocat/subscriptions",
+        "organizations_url": "https://api.github.com/users/octocat/orgs",
+        "repos_url": "https://api.github.com/users/octocat/repos",
+        "events_url": "https://api.github.com/users/octocat/events{/privacy}",
+        "received_events_url": "https://api.github.com/users/octocat/received_events",
+        "type": "User",
+        "site_admin": false
+      },
+      "private": false,
+      "html_url": "https://github.com/octocat/Hello-World",
+      "description": "This your first repo!",
+      "fork": true,
+      "url": "https://api.github.com/repos/octocat/Hello-World",
+      "archive_url": "http://api.github.com/repos/octocat/Hello-World/{archive_format}{/ref}",
+      "assignees_url": "http://api.github.com/repos/octocat/Hello-World/assignees{/user}",
+      "blobs_url": "http://api.github.com/repos/octocat/Hello-World/git/blobs{/sha}",
+      "branches_url": "http://api.github.com/repos/octocat/Hello-World/branches{/branch}",
+      "collaborators_url": "http://api.github.com/repos/octocat/Hello-World/collaborators{/collaborator}",
+      "comments_url": "http://api.github.com/repos/octocat/Hello-World/comments{/number}",
+      "commits_url": "http://api.github.com/repos/octocat/Hello-World/commits{/sha}",
+      "compare_url": "http://api.github.com/repos/octocat/Hello-World/compare/{base}...{head}",
+      "contents_url": "http://api.github.com/repos/octocat/Hello-World/contents/{+path}",
+      "contributors_url": "http://api.github.com/repos/octocat/Hello-World/contributors",
+      "deployments_url": "http://api.github.com/repos/octocat/Hello-World/deployments",
+      "downloads_url": "http://api.github.com/repos/octocat/Hello-World/downloads",
+      "events_url": "http://api.github.com/repos/octocat/Hello-World/events",
+      "forks_url": "http://api.github.com/repos/octocat/Hello-World/forks",
+      "git_commits_url": "http://api.github.com/repos/octocat/Hello-World/git/commits{/sha}",
+      "git_refs_url": "http://api.github.com/repos/octocat/Hello-World/git/refs{/sha}",
+      "git_tags_url": "http://api.github.com/repos/octocat/Hello-World/git/tags{/sha}",
+      "git_url": "git:github.com/octocat/Hello-World.git",
+      "issue_comment_url": "http://api.github.com/repos/octocat/Hello-World/issues/comments{/number}",
+      "issue_events_url": "http://api.github.com/repos/octocat/Hello-World/issues/events{/number}",
+      "issues_url": "http://api.github.com/repos/octocat/Hello-World/issues{/number}",
+      "keys_url": "http://api.github.com/repos/octocat/Hello-World/keys{/key_id}",
+      "labels_url": "http://api.github.com/repos/octocat/Hello-World/labels{/name}",
+      "languages_url": "http://api.github.com/repos/octocat/Hello-World/languages",
+      "merges_url": "http://api.github.com/repos/octocat/Hello-World/merges",
+      "milestones_url": "http://api.github.com/repos/octocat/Hello-World/milestones{/number}",
+      "notifications_url": "http://api.github.com/repos/octocat/Hello-World/notifications{?since,all,participating}",
+      "pulls_url": "http://api.github.com/repos/octocat/Hello-World/pulls{/number}",
+      "releases_url": "http://api.github.com/repos/octocat/Hello-World/releases{/id}",
+      "ssh_url": "git@github.com:octocat/Hello-World.git",
+      "stargazers_url": "http://api.github.com/repos/octocat/Hello-World/stargazers",
+      "statuses_url": "http://api.github.com/repos/octocat/Hello-World/statuses/{sha}",
+      "subscribers_url": "http://api.github.com/repos/octocat/Hello-World/subscribers",
+      "subscription_url": "http://api.github.com/repos/octocat/Hello-World/subscription",
+      "tags_url": "http://api.github.com/repos/octocat/Hello-World/tags",
+      "teams_url": "http://api.github.com/repos/octocat/Hello-World/teams",
+      "trees_url": "http://api.github.com/repos/octocat/Hello-World/git/trees{/sha}",
+      "clone_url": "https://github.com/octocat/Hello-World.git",
+      "mirror_url": "git:git.example.com/octocat/Hello-World",
+      "hooks_url": "http://api.github.com/repos/octocat/Hello-World/hooks",
+      "svn_url": "https://svn.github.com/octocat/Hello-World",
+      "homepage": "https://github.com",
+      "language": null,
+      "forks_count": 9,
+      "stargazers_count": 80,
+      "watchers_count": 80,
+      "size": 108,
+      "default_branch": "master",
+      "open_issues_count": 0,
+      "topics": [
+        "octocat",
+        "atom",
+        "electron",
+        "API"
+      ],
+      "has_issues": true,
+      "has_projects": true,
+      "has_wiki": true,
+      "has_pages": false,
+      "has_downloads": true,
+      "archived": false,
+      "pushed_at": "2011-01-26T19:06:43Z",
+      "created_at": "2011-01-26T19:01:12Z",
+      "updated_at": "2011-01-26T19:14:43Z",
+      "permissions": {
+        "admin": false,
+        "push": false,
+        "pull": true
+      },
+      "allow_rebase_merge": true,
+      "allow_squash_merge": true,
+      "allow_merge_commit": true,
+      "subscribers_count": 42,
+      "network_count": 0
+    }
+  },
+  "_links": {
+    "self": {
+      "href": "https://api.github.com/repos/octocat/Hello-World/pulls/1347"
+    },
+    "html": {
+      "href": "https://github.com/octocat/Hello-World/pull/1347"
+    },
+    "issue": {
+      "href": "https://api.github.com/repos/octocat/Hello-World/issues/1347"
+    },
+    "comments": {
+      "href": "https://api.github.com/repos/octocat/Hello-World/issues/1347/comments"
+    },
+    "review_comments": {
+      "href": "https://api.github.com/repos/octocat/Hello-World/pulls/1347/comments"
+    },
+    "review_comment": {
+      "href": "https://api.github.com/repos/octocat/Hello-World/pulls/comments{/number}"
+    },
+    "commits": {
+      "href": "https://api.github.com/repos/octocat/Hello-World/pulls/1347/commits"
+    },
+    "statuses": {
+      "href": "https://api.github.com/repos/octocat/Hello-World/statuses/6dcb09b5b57875f334f61aebed695e2e4193db5e"
+    }
+  },
+  "author_association": "OWNER",
+  "merged": false,
+  "mergeable": true,
+  "rebaseable": true,
+  "mergeable_state": "clean",
+  "merged_by": {
+    "login": "octocat",
+    "id": 1,
+    "node_id": "MDQ6VXNlcjE=",
+    "avatar_url": "https://github.com/images/error/octocat_happy.gif",
+    "gravatar_id": "",
+    "url": "https://api.github.com/users/octocat",
+    "html_url": "https://github.com/octocat",
+    "followers_url": "https://api.github.com/users/octocat/followers",
+    "following_url": "https://api.github.com/users/octocat/following{/other_user}",
+    "gists_url": "https://api.github.com/users/octocat/gists{/gist_id}",
+    "starred_url": "https://api.github.com/users/octocat/starred{/owner}{/repo}",
+    "subscriptions_url": "https://api.github.com/users/octocat/subscriptions",
+    "organizations_url": "https://api.github.com/users/octocat/orgs",
+    "repos_url": "https://api.github.com/users/octocat/repos",
+    "events_url": "https://api.github.com/users/octocat/events{/privacy}",
+    "received_events_url": "https://api.github.com/users/octocat/received_events",
+    "type": "User",
+    "site_admin": false
+  },
+  "comments": 10,
+  "review_comments": 0,
+  "maintainer_can_modify": true,
+  "commits": 3,
+  "additions": 100,
+  "deletions": 3,
+  "changed_files": 5
+}
--- a/server/events/vcs/github_client.go
+++ b/server/events/vcs/github_client.go
@@ -121,6 +121,28 @@ func (g *GithubClient) PullIsApproved(repo models.Repo, pull models.PullRequest)
 	return false, nil
 }

+// PullIsMergeable returns true if the pull request is mergeable.
+func (g *GithubClient) PullIsMergeable(repo models.Repo, pull models.PullRequest) (bool, error) {
+	githubPR, err := g.GetPullRequest(repo, pull.Num)
+	if err != nil {
+		return false, errors.Wrap(err, "getting pull request")
+	}
+	state := githubPR.GetMergeableState()
+	// We map our mergeable check to when the GitHub merge button is clickable.
+	// This corresponds to the following states:
+	// clean: No conflicts, all requirements satisfied.
+	//        Merging is allowed (green box).
+	// unstable: Failing/pending commit status that is not part of the required
+	//           status checks. Merging is allowed (yellow box).
+	// has_hooks: GitHub Enterprise only, if a repo has custom pre-receive
+	//            hooks. Merging is allowed (green box).
+	// See: https://github.com/octokit/octokit.net/issues/1763
+	if state != "clean" && state != "unstable" && state != "has_hooks" {
+		return false, nil
+	}
+	return true, nil
+}
+
 // GetPullRequest returns the pull request.
 func (g *GithubClient) GetPullRequest(repo models.Repo, num int) (*github.PullRequest, error) {
 	pull, _, err := g.client.PullRequests.Get(g.ctx, repo.Owner, repo.Name, num)
--- a/server/events/vcs/github_client_test.go
+++ b/server/events/vcs/github_client_test.go
@@ -7,6 +7,7 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"net/url"
+	"strings"
 	"testing"

 	"github.com/runatlantis/atlantis/server/events/models"
@@ -138,6 +139,99 @@ func TestGithubClient_UpdateStatus(t *testing.T) {
 	}
 }

+func TestGithubClient_PullIsMergeable(t *testing.T) {
+	cases := []struct {
+		state        string
+		expMergeable bool
+	}{
+		{
+			"dirty",
+			false,
+		},
+		{
+			"unknown",
+			false,
+		},
+		{
+			"blocked",
+			false,
+		},
+		{
+			"behind",
+			false,
+		},
+		{
+			"random",
+			false,
+		},
+		{
+			"unstable",
+			true,
+		},
+		{
+			"has_hooks",
+			true,
+		},
+		{
+			"clean",
+			true,
+		},
+		{
+			"",
+			false,
+		},
+	}
+
+	// Use a real GitHub json response and edit the mergeable_state field.
+	jsBytes, err := ioutil.ReadFile("fixtures/github-pull-request.json")
+	Ok(t, err)
+	json := string(jsBytes)
+
+	for _, c := range cases {
+		t.Run(c.state, func(t *testing.T) {
+			response := strings.Replace(json,
+				`"mergeable_state": "clean"`,
+				fmt.Sprintf(`"mergeable_state": "%s"`, c.state),
+				1,
+			)
+
+			testServer := httptest.NewTLSServer(
+				http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+					switch r.RequestURI {
+					case "/api/v3/repos/owner/repo/pulls/1":
+						w.Write([]byte(response)) // nolint: errcheck
+						return
+					default:
+						t.Errorf("got unexpected request at %q", r.RequestURI)
+						http.Error(w, "not found", http.StatusNotFound)
+						return
+					}
+				}))
+			testServerURL, err := url.Parse(testServer.URL)
+			Ok(t, err)
+			client, err := vcs.NewGithubClient(testServerURL.Host, "user", "pass")
+			Ok(t, err)
+			defer disableSSLVerification()()
+
+			actMergeable, err := client.PullIsMergeable(models.Repo{
+				FullName:          "owner/repo",
+				Owner:             "owner",
+				Name:              "repo",
+				CloneURL:          "",
+				SanitizedCloneURL: "",
+				VCSHost: models.VCSHost{
+					Type:     models.Github,
+					Hostname: "github.com",
+				},
+			}, models.PullRequest{
+				Num: 1,
+			})
+			Ok(t, err)
+			Equals(t, c.expMergeable, actMergeable)
+		})
+	}
+}
+
 // disableSSLVerification disables ssl verification for the global http client
 // and returns a function to be called in a defer that will re-enable it.
 func disableSSLVerification() func() {
--- a/server/events/vcs/gitlab_client.go
+++ b/server/events/vcs/gitlab_client.go
@@ -143,6 +143,30 @@ func (g *GitlabClient) PullIsApproved(repo models.Repo, pull models.PullRequest)
 	return true, nil
 }

+// PullIsMergeable returns true if the merge request can be merged.
+// In GitLab, there isn't a single field that tells us if the pull request is
+// mergeable so for now we check the merge_status and approvals_before_merge
+// fields. We aren't checking if there are unresolved discussions or failing
+// pipelines because those only block merges if the repo is set to require that.
+// In order to check if the repo required these, we'd need to make another API
+// call to get the repo settings. For now I'm going to leave this as is and if
+// some users require checking this as well then we can revisit.
+// It's also possible that GitLab implements their own "mergeable" field in
+// their API in the future.
+// See:
+// - https://gitlab.com/gitlab-org/gitlab-ee/issues/3169
+// - https://gitlab.com/gitlab-org/gitlab-ce/issues/42344
+func (g *GitlabClient) PullIsMergeable(repo models.Repo, pull models.PullRequest) (bool, error) {
+	mr, _, err := g.Client.MergeRequests.GetMergeRequest(repo.FullName, pull.Num)
+	if err != nil {
+		return false, err
+	}
+	if mr.MergeStatus == "can_be_merged" && mr.ApprovalsBeforeMerge <= 0 {
+		return true, nil
+	}
+	return false, nil
+}
+
 // UpdateStatus updates the build status of a commit.
 func (g *GitlabClient) UpdateStatus(repo models.Repo, pull models.PullRequest, state models.CommitStatus, description string) error {
 	const statusContext = "Atlantis"
--- a/server/events/vcs/mocks/mock_client.go
+++ b/server/events/vcs/mocks/mock_client.go
@@ -71,6 +71,25 @@ func (mock *MockClient) PullIsApproved(repo models.Repo, pull models.PullRequest
 	return ret0, ret1
 }

+func (mock *MockClient) PullIsMergeable(repo models.Repo, pull models.PullRequest) (bool, error) {
+	if mock == nil {
+		panic("mock must not be nil. Use myMock := NewMockClient().")
+	}
+	params := []pegomock.Param{repo, pull}
+	result := pegomock.GetGenericMockFrom(mock).Invoke("PullIsMergeable", params, []reflect.Type{reflect.TypeOf((*bool)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
+	var ret0 bool
+	var ret1 error
+	if len(result) != 0 {
+		if result[0] != nil {
+			ret0 = result[0].(bool)
+		}
+		if result[1] != nil {
+			ret1 = result[1].(error)
+		}
+	}
+	return ret0, ret1
+}
+
 func (mock *MockClient) UpdateStatus(repo models.Repo, pull models.PullRequest, state models.CommitStatus, description string) error {
 	if mock == nil {
 		panic("mock must not be nil. Use myMock := NewMockClient().")
@@ -220,6 +239,37 @@ func (c *Client_PullIsApproved_OngoingVerification) GetAllCapturedArguments() (_
 	return
 }

+func (verifier *VerifierClient) PullIsMergeable(repo models.Repo, pull models.PullRequest) *Client_PullIsMergeable_OngoingVerification {
+	params := []pegomock.Param{repo, pull}
+	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "PullIsMergeable", params, verifier.timeout)
+	return &Client_PullIsMergeable_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
+}
+
+type Client_PullIsMergeable_OngoingVerification struct {
+	mock              *MockClient
+	methodInvocations []pegomock.MethodInvocation
+}
+
+func (c *Client_PullIsMergeable_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest) {
+	repo, pull := c.GetAllCapturedArguments()
+	return repo[len(repo)-1], pull[len(pull)-1]
+}
+
+func (c *Client_PullIsMergeable_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest) {
+	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
+	if len(params) > 0 {
+		_param0 = make([]models.Repo, len(params[0]))
+		for u, param := range params[0] {
+			_param0[u] = param.(models.Repo)
+		}
+		_param1 = make([]models.PullRequest, len(params[1]))
+		for u, param := range params[1] {
+			_param1[u] = param.(models.PullRequest)
+		}
+	}
+	return
+}
+
 func (verifier *VerifierClient) UpdateStatus(repo models.Repo, pull models.PullRequest, state models.CommitStatus, description string) *Client_UpdateStatus_OngoingVerification {
 	params := []pegomock.Param{repo, pull, state, description}
 	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpdateStatus", params, verifier.timeout)
--- a/server/events/vcs/mocks/mock_proxy.go
+++ b/server/events/vcs/mocks/mock_proxy.go
@@ -71,6 +71,25 @@ func (mock *MockClientProxy) PullIsApproved(repo models.Repo, pull models.PullRe
 	return ret0, ret1
 }

+func (mock *MockClientProxy) PullIsMergeable(repo models.Repo, pull models.PullRequest) (bool, error) {
+	if mock == nil {
+		panic("mock must not be nil. Use myMock := NewMockClientProxy().")
+	}
+	params := []pegomock.Param{repo, pull}
+	result := pegomock.GetGenericMockFrom(mock).Invoke("PullIsMergeable", params, []reflect.Type{reflect.TypeOf((*bool)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
+	var ret0 bool
+	var ret1 error
+	if len(result) != 0 {
+		if result[0] != nil {
+			ret0 = result[0].(bool)
+		}
+		if result[1] != nil {
+			ret1 = result[1].(error)
+		}
+	}
+	return ret0, ret1
+}
+
 func (mock *MockClientProxy) UpdateStatus(repo models.Repo, pull models.PullRequest, state models.CommitStatus, description string) error {
 	if mock == nil {
 		panic("mock must not be nil. Use myMock := NewMockClientProxy().")
@@ -220,6 +239,37 @@ func (c *ClientProxy_PullIsApproved_OngoingVerification) GetAllCapturedArguments
 	return
 }

+func (verifier *VerifierClientProxy) PullIsMergeable(repo models.Repo, pull models.PullRequest) *ClientProxy_PullIsMergeable_OngoingVerification {
+	params := []pegomock.Param{repo, pull}
+	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "PullIsMergeable", params, verifier.timeout)
+	return &ClientProxy_PullIsMergeable_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
+}
+
+type ClientProxy_PullIsMergeable_OngoingVerification struct {
+	mock              *MockClientProxy
+	methodInvocations []pegomock.MethodInvocation
+}
+
+func (c *ClientProxy_PullIsMergeable_OngoingVerification) GetCapturedArguments() (models.Repo, models.PullRequest) {
+	repo, pull := c.GetAllCapturedArguments()
+	return repo[len(repo)-1], pull[len(pull)-1]
+}
+
+func (c *ClientProxy_PullIsMergeable_OngoingVerification) GetAllCapturedArguments() (_param0 []models.Repo, _param1 []models.PullRequest) {
+	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
+	if len(params) > 0 {
+		_param0 = make([]models.Repo, len(params[0]))
+		for u, param := range params[0] {
+			_param0[u] = param.(models.Repo)
+		}
+		_param1 = make([]models.PullRequest, len(params[1]))
+		for u, param := range params[1] {
+			_param1[u] = param.(models.PullRequest)
+		}
+	}
+	return
+}
+
 func (verifier *VerifierClientProxy) UpdateStatus(repo models.Repo, pull models.PullRequest, state models.CommitStatus, description string) *ClientProxy_UpdateStatus_OngoingVerification {
 	params := []pegomock.Param{repo, pull, state, description}
 	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpdateStatus", params, verifier.timeout)
--- a/server/events/vcs/not_configured_vcs_client.go
+++ b/server/events/vcs/not_configured_vcs_client.go
@@ -35,6 +35,9 @@ func (a *NotConfiguredVCSClient) CreateComment(repo models.Repo, pullNum int, co
 func (a *NotConfiguredVCSClient) PullIsApproved(repo models.Repo, pull models.PullRequest) (bool, error) {
 	return false, a.err()
 }
+func (a *NotConfiguredVCSClient) PullIsMergeable(repo models.Repo, pull models.PullRequest) (bool, error) {
+	return false, a.err()
+}
 func (a *NotConfiguredVCSClient) UpdateStatus(repo models.Repo, pull models.PullRequest, state models.CommitStatus, description string) error {
 	return a.err()
 }
--- a/server/events/vcs/proxy.go
+++ b/server/events/vcs/proxy.go
@@ -25,6 +25,7 @@ type ClientProxy interface {
 	GetModifiedFiles(repo models.Repo, pull models.PullRequest) ([]string, error)
 	CreateComment(repo models.Repo, pullNum int, comment string) error
 	PullIsApproved(repo models.Repo, pull models.PullRequest) (bool, error)
+	PullIsMergeable(repo models.Repo, pull models.PullRequest) (bool, error)
 	UpdateStatus(repo models.Repo, pull models.PullRequest, state models.CommitStatus, description string) error
 }

@@ -71,6 +72,10 @@ func (d *DefaultClientProxy) PullIsApproved(repo models.Repo, pull models.PullRe
 	return d.clients[repo.VCSHost.Type].PullIsApproved(repo, pull)
 }

+func (d *DefaultClientProxy) PullIsMergeable(repo models.Repo, pull models.PullRequest) (bool, error) {
+	return d.clients[repo.VCSHost.Type].PullIsMergeable(repo, pull)
+}
+
 func (d *DefaultClientProxy) UpdateStatus(repo models.Repo, pull models.PullRequest, state models.CommitStatus, description string) error {
 	return d.clients[repo.VCSHost.Type].UpdateStatus(repo, pull, state, description)
 }
--- a/server/events/yaml/parser_validator_test.go
+++ b/server/events/yaml/parser_validator_test.go
@@ -226,6 +226,74 @@ workflows:
 				},
 			},
 		},
+		{
+			description: "project field with mergeable apply requirement",
+			input: `
+version: 2
+projects:
+- dir: .
+  workspace: myworkspace
+  terraform_version: v0.11.0
+  apply_requirements: [mergeable]
+  workflow: myworkflow
+  autoplan:
+    enabled: false
+workflows:
+  myworkflow: ~`,
+			exp: valid.Config{
+				Version: 2,
+				Projects: []valid.Project{
+					{
+						Dir:              ".",
+						Workspace:        "myworkspace",
+						Workflow:         String("myworkflow"),
+						TerraformVersion: tfVersion,
+						Autoplan: valid.Autoplan{
+							WhenModified: []string{"**/*.tf*"},
+							Enabled:      false,
+						},
+						ApplyRequirements: []string{"mergeable"},
+					},
+				},
+				Workflows: map[string]valid.Workflow{
+					"myworkflow": {},
+				},
+			},
+		},
+		{
+			description: "project field with mergeable and approved apply requirements",
+			input: `
+version: 2
+projects:
+- dir: .
+  workspace: myworkspace
+  terraform_version: v0.11.0
+  apply_requirements: [mergeable, approved]
+  workflow: myworkflow
+  autoplan:
+    enabled: false
+workflows:
+  myworkflow: ~`,
+			exp: valid.Config{
+				Version: 2,
+				Projects: []valid.Project{
+					{
+						Dir:              ".",
+						Workspace:        "myworkspace",
+						Workflow:         String("myworkflow"),
+						TerraformVersion: tfVersion,
+						Autoplan: valid.Autoplan{
+							WhenModified: []string{"**/*.tf*"},
+							Enabled:      false,
+						},
+						ApplyRequirements: []string{"mergeable", "approved"},
+					},
+				},
+				Workflows: map[string]valid.Workflow{
+					"myworkflow": {},
+				},
+			},
+		},
 		{
 			description: "project dir with ..",
 			input: `
--- a/server/events/yaml/raw/project.go
+++ b/server/events/yaml/raw/project.go
@@ -13,8 +13,9 @@ import (
 )

 const (
-	DefaultWorkspace         = "default"
-	ApprovedApplyRequirement = "approved"
+	DefaultWorkspace          = "default"
+	ApprovedApplyRequirement  = "approved"
+	MergeableApplyRequirement = "mergeable"
 )

 type Project struct {
@@ -37,8 +38,8 @@ func (p Project) Validate() error {
 	validApplyReq := func(value interface{}) error {
 		reqs := value.([]string)
 		for _, r := range reqs {
-			if r != ApprovedApplyRequirement {
-				return fmt.Errorf("%q not supported, only %s is supported", r, ApprovedApplyRequirement)
+			if r != ApprovedApplyRequirement && r != MergeableApplyRequirement {
+				return fmt.Errorf("%q not supported, only %s and %s are supported", r, ApprovedApplyRequirement, MergeableApplyRequirement)
 			}
 		}
 		return nil
--- a/server/events/yaml/raw/project_test.go
+++ b/server/events/yaml/raw/project_test.go
@@ -31,7 +31,7 @@ func TestProject_UnmarshalYAML(t *testing.T) {
 			},
 		},
 		{
-			description: "all fields set",
+			description: "all fields set including mergeable apply requirement",
 			input: `
 name: myname
 dir: mydir
@@ -101,16 +101,32 @@ func TestProject_Validate(t *testing.T) {
 				Dir:               String("."),
 				ApplyRequirements: []string{"unsupported"},
 			},
-			expErr: "apply_requirements: \"unsupported\" not supported, only approved is supported.",
+			expErr: "apply_requirements: \"unsupported\" not supported, only approved and mergeable are supported.",
 		},
 		{
-			description: "apply reqs with valid",
+			description: "apply reqs with approved requirement",
 			input: raw.Project{
 				Dir:               String("."),
 				ApplyRequirements: []string{"approved"},
 			},
 			expErr: "",
 		},
+		{
+			description: "apply reqs with mergeable requirement",
+			input: raw.Project{
+				Dir:               String("."),
+				ApplyRequirements: []string{"mergeable"},
+			},
+			expErr: "",
+		},
+		{
+			description: "apply reqs with mergeable and approved requirements",
+			input: raw.Project{
+				Dir:               String("."),
+				ApplyRequirements: []string{"mergeable", "approved"},
+			},
+			expErr: "",
+		},
 		{
 			description: "empty tf version string",
 			input: raw.Project{
--- a/server/events_controller_test.go
+++ b/server/events_controller_test.go
@@ -23,7 +23,6 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
-	"time"

 	"github.com/lkysow/go-gitlab"
 	. "github.com/petergtz/pegomock"
@@ -367,10 +366,10 @@ func TestPost_GitlabMergeRequestInvalid(t *testing.T) {
 	e, _, gl, p, _, _, _, _ := setup(t)
 	req, _ := http.NewRequest("GET", "", bytes.NewBuffer(nil))
 	req.Header.Set(gitlabHeader, "value")
-	When(gl.ParseAndValidate(req, secret)).ThenReturn(gitlabMergeEvent, nil)
+	When(gl.ParseAndValidate(req, secret)).ThenReturn(gitlab.MergeEvent{}, nil)
 	repo := models.Repo{}
 	pullRequest := models.PullRequest{State: models.ClosedPullState}
-	When(p.ParseGitlabMergeRequestEvent(gitlabMergeEvent)).ThenReturn(pullRequest, models.OpenedPullEvent, repo, repo, models.User{}, errors.New("err"))
+	When(p.ParseGitlabMergeRequestEvent(gitlab.MergeEvent{})).ThenReturn(pullRequest, models.OpenedPullEvent, repo, repo, models.User{}, errors.New("err"))
 	w := httptest.NewRecorder()
 	e.Post(w, req)
 	responseContains(t, w, http.StatusBadRequest, "Error parsing webhook: err")
@@ -401,10 +400,10 @@ func TestPost_GitlabMergeRequestNotWhitelisted(t *testing.T) {
 	var err error
 	e.RepoWhitelistChecker, err = events.NewRepoWhitelistChecker("github.com/nevermatch")
 	Ok(t, err)
-	When(gl.ParseAndValidate(req, secret)).ThenReturn(gitlabMergeEvent, nil)
+	When(gl.ParseAndValidate(req, secret)).ThenReturn(gitlab.MergeEvent{}, nil)
 	repo := models.Repo{}
 	pullRequest := models.PullRequest{State: models.ClosedPullState}
-	When(p.ParseGitlabMergeRequestEvent(gitlabMergeEvent)).ThenReturn(pullRequest, models.OpenedPullEvent, repo, repo, models.User{}, nil)
+	When(p.ParseGitlabMergeRequestEvent(gitlab.MergeEvent{})).ThenReturn(pullRequest, models.OpenedPullEvent, repo, repo, models.User{}, nil)

 	w := httptest.NewRecorder()
 	e.Post(w, req)
@@ -431,11 +430,12 @@ func TestPost_GitlabMergeRequestUnsupportedAction(t *testing.T) {
 	e, _, gl, p, _, _, _, _ := setup(t)
 	req, _ := http.NewRequest("GET", "", bytes.NewBuffer(nil))
 	req.Header.Set(gitlabHeader, "value")
-	gitlabMergeEvent.ObjectAttributes.Action = "unsupported"
-	When(gl.ParseAndValidate(req, secret)).ThenReturn(gitlabMergeEvent, nil)
+	var event gitlab.MergeEvent
+	event.ObjectAttributes.Action = "unsupported"
+	When(gl.ParseAndValidate(req, secret)).ThenReturn(event, nil)
 	repo := models.Repo{}
 	pullRequest := models.PullRequest{State: models.ClosedPullState}
-	When(p.ParseGitlabMergeRequestEvent(gitlabMergeEvent)).ThenReturn(pullRequest, repo, repo, models.User{}, nil)
+	When(p.ParseGitlabMergeRequestEvent(event)).ThenReturn(pullRequest, repo, repo, models.User{}, nil)

 	w := httptest.NewRecorder()
 	e.Post(w, req)
@@ -467,11 +467,12 @@ func TestPost_GitlabMergeRequestClosedErrCleaningPull(t *testing.T) {
 	e, _, gl, p, _, c, _, _ := setup(t)
 	req, _ := http.NewRequest("GET", "", bytes.NewBuffer(nil))
 	req.Header.Set(gitlabHeader, "value")
-	gitlabMergeEvent.ObjectAttributes.Action = "close"
-	When(gl.ParseAndValidate(req, secret)).ThenReturn(gitlabMergeEvent, nil)
+	var event gitlab.MergeEvent
+	event.ObjectAttributes.Action = "close"
+	When(gl.ParseAndValidate(req, secret)).ThenReturn(event, nil)
 	repo := models.Repo{}
 	pullRequest := models.PullRequest{State: models.ClosedPullState}
-	When(p.ParseGitlabMergeRequestEvent(gitlabMergeEvent)).ThenReturn(pullRequest, models.OpenedPullEvent, repo, repo, models.User{}, nil)
+	When(p.ParseGitlabMergeRequestEvent(event)).ThenReturn(pullRequest, models.OpenedPullEvent, repo, repo, models.User{}, nil)
 	When(c.CleanUpPull(repo, pullRequest)).ThenReturn(errors.New("err"))
 	w := httptest.NewRecorder()
 	e.Post(w, req)
@@ -502,10 +503,10 @@ func TestPost_GitlabMergeRequestSuccess(t *testing.T) {
 	e, _, gl, p, _, _, _, _ := setup(t)
 	req, _ := http.NewRequest("GET", "", bytes.NewBuffer(nil))
 	req.Header.Set(gitlabHeader, "value")
-	When(gl.ParseAndValidate(req, secret)).ThenReturn(gitlabMergeEvent, nil)
+	When(gl.ParseAndValidate(req, secret)).ThenReturn(gitlab.MergeEvent{}, nil)
 	repo := models.Repo{}
 	pullRequest := models.PullRequest{State: models.ClosedPullState}
-	When(p.ParseGitlabMergeRequestEvent(gitlabMergeEvent)).ThenReturn(pullRequest, models.OpenedPullEvent, repo, repo, models.User{}, nil)
+	When(p.ParseGitlabMergeRequestEvent(gitlab.MergeEvent{})).ThenReturn(pullRequest, models.OpenedPullEvent, repo, repo, models.User{}, nil)
 	w := httptest.NewRecorder()
 	e.Post(w, req)
 	responseContains(t, w, http.StatusOK, "Pull request cleaned successfully")
@@ -546,11 +547,12 @@ func TestPost_PullOpenedOrUpdated(t *testing.T) {
 			switch c.HostType {
 			case models.Gitlab:
 				req.Header.Set(gitlabHeader, "value")
-				gitlabMergeEvent.ObjectAttributes.Action = c.Action
-				When(gl.ParseAndValidate(req, secret)).ThenReturn(gitlabMergeEvent, nil)
+				var event gitlab.MergeEvent
+				event.ObjectAttributes.Action = c.Action
+				When(gl.ParseAndValidate(req, secret)).ThenReturn(event, nil)
 				repo := models.Repo{}
 				pullRequest := models.PullRequest{State: models.ClosedPullState}
-				When(p.ParseGitlabMergeRequestEvent(gitlabMergeEvent)).ThenReturn(pullRequest, models.OpenedPullEvent, repo, repo, models.User{}, nil)
+				When(p.ParseGitlabMergeRequestEvent(event)).ThenReturn(pullRequest, models.OpenedPullEvent, repo, repo, models.User{}, nil)
 			case models.Github:
 				req.Header.Set(githubHeader, "pull_request")
 				event := fmt.Sprintf(`{"action": "%s"}`, c.Action)
@@ -595,60 +597,3 @@ func setup(t *testing.T) (server.EventsController, *mocks.MockGithubRequestValid
 	}
 	return e, v, gl, p, cr, c, vcsmock, cp
 }
-
-var gitlabMergeEvent = gitlab.MergeEvent{
-	ObjectAttributes: struct {
-		ID              int              `json:"id"`
-		TargetBranch    string           `json:"target_branch"`
-		SourceBranch    string           `json:"source_branch"`
-		SourceProjectID int              `json:"source_project_id"`
-		AuthorID        int              `json:"author_id"`
-		AssigneeID      int              `json:"assignee_id"`
-		Title           string           `json:"title"`
-		CreatedAt       string           `json:"created_at"`
-		UpdatedAt       string           `json:"updated_at"`
-		StCommits       []*gitlab.Commit `json:"st_commits"`
-		StDiffs         []*gitlab.Diff   `json:"st_diffs"`
-		MilestoneID     int              `json:"milestone_id"`
-		State           string           `json:"state"`
-		MergeStatus     string           `json:"merge_status"`
-		TargetProjectID int              `json:"target_project_id"`
-		IID             int              `json:"iid"`
-		Description     string           `json:"description"`
-		Position        int              `json:"position"`
-		LockedAt        string           `json:"locked_at"`
-		UpdatedByID     int              `json:"updated_by_id"`
-		MergeError      string           `json:"merge_error"`
-		MergeParams     struct {
-			ForceRemoveSourceBranch string `json:"force_remove_source_branch"`
-		} `json:"merge_params"`
-		MergeWhenBuildSucceeds   bool               `json:"merge_when_build_succeeds"`
-		MergeUserID              int                `json:"merge_user_id"`
-		MergeCommitSha           string             `json:"merge_commit_sha"`
-		DeletedAt                string             `json:"deleted_at"`
-		ApprovalsBeforeMerge     string             `json:"approvals_before_merge"`
-		RebaseCommitSha          string             `json:"rebase_commit_sha"`
-		InProgressMergeCommitSha string             `json:"in_progress_merge_commit_sha"`
-		LockVersion              int                `json:"lock_version"`
-		TimeEstimate             int                `json:"time_estimate"`
-		Source                   *gitlab.Repository `json:"source"`
-		Target                   *gitlab.Repository `json:"target"`
-		LastCommit               struct {
-			ID        string         `json:"id"`
-			Message   string         `json:"message"`
-			Timestamp *time.Time     `json:"timestamp"`
-			URL       string         `json:"url"`
-			Author    *gitlab.Author `json:"author"`
-		} `json:"last_commit"`
-		WorkInProgress bool   `json:"work_in_progress"`
-		URL            string `json:"url"`
-		Action         string `json:"action"`
-		Assignee       struct {
-			Name      string `json:"name"`
-			Username  string `json:"username"`
-			AvatarURL string `json:"avatar_url"`
-		} `json:"assignee"`
-	}{
-		Action: "merge",
-	},
-}
--- a/server/gitlab_request_parser_validator_test.go
+++ b/server/gitlab_request_parser_validator_test.go
@@ -48,7 +48,7 @@ func TestValidate_ValidSecret(t *testing.T) {
 	req.Header.Set("X-Gitlab-Event", "Merge Request Hook")
 	b, err := parser.ParseAndValidate(req, []byte("secret"))
 	Ok(t, err)
-	Equals(t, "Gitlab Test", b.(gitlab.MergeEvent).Project.Name)
+	Equals(t, "atlantis-example", b.(gitlab.MergeEvent).Project.Name)
 }

 func TestValidate_NoSecret(t *testing.T) {
@@ -61,7 +61,7 @@ func TestValidate_NoSecret(t *testing.T) {
 	req.Header.Set("X-Gitlab-Event", "Merge Request Hook")
 	b, err := parser.ParseAndValidate(req, nil)
 	Ok(t, err)
-	Equals(t, "Gitlab Test", b.(gitlab.MergeEvent).Project.Name)
+	Equals(t, "atlantis-example", b.(gitlab.MergeEvent).Project.Name)
 }

 func TestValidate_InvalidMergeEvent(t *testing.T) {
@@ -109,7 +109,7 @@ func TestValidate_ValidMergeEvent(t *testing.T) {
 	req.Header.Set("X-Gitlab-Event", "Merge Request Hook")
 	b, err := parser.ParseAndValidate(req, nil)
 	Ok(t, err)
-	Equals(t, "Gitlab Test", b.(gitlab.MergeEvent).Project.Name)
+	Equals(t, "atlantis-example", b.(gitlab.MergeEvent).Project.Name)
 	RegisterMockTestingT(t)
 }

@@ -128,146 +128,179 @@ func TestValidate_ValidMergeCommentEvent(t *testing.T) {

 var mergeEventJSON = `{
  "object_kind": "merge_request",
+  "event_type": "merge_request",
  "user": {
-    "name": "Administrator",
-    "username": "root",
-    "avatar_url": "http://www.gravatar.com/avatar/e64c7d89f26bd1972efa854d13d7dd61?s=40\u0026d=identicon"
+    "name": "Luke Kysow",
+    "username": "lkysow",
+    "avatar_url": "https://secure.gravatar.com/avatar/25fd57e71590fe28736624ff24d41c5f?s=80&d=identicon"
  },
  "project": {
-    "id": 1,
-    "name":"Gitlab Test",
-    "description":"Aut reprehenderit ut est.",
-    "web_url":"http://example.com/gitlabhq/gitlab-test",
-    "avatar_url":null,
-    "git_ssh_url":"git@example.com:gitlabhq/gitlab-test.git",
-    "git_http_url":"https://example.com/gitlabhq/gitlab-test.git",
-    "namespace":"GitlabHQ",
-    "visibility_level":20,
-    "path_with_namespace":"gitlabhq/gitlab-test",
-    "default_branch":"master",
-    "homepage":"http://example.com/gitlabhq/gitlab-test",
-    "url":"https://example.com/gitlabhq/gitlab-test.git",
-    "ssh_url":"git@example.com:gitlabhq/gitlab-test.git",
-    "http_url":"https://example.com/gitlabhq/gitlab-test.git"
-  },
-  "repository": {
-    "name": "Gitlab Test",
-    "url": "https://example.com/gitlabhq/gitlab-test.git",
-    "description": "Aut reprehenderit ut est.",
-    "homepage": "http://example.com/gitlabhq/gitlab-test"
+    "id": 4580910,
+    "name": "atlantis-example",
+    "description": "",
+    "web_url": "https://gitlab.com/lkysow/atlantis-example",
+    "avatar_url": null,
+    "git_ssh_url": "git@gitlab.com:lkysow/atlantis-example.git",
+    "git_http_url": "https://gitlab.com/lkysow/atlantis-example.git",
+    "namespace": "lkysow",
+    "visibility_level": 20,
+    "path_with_namespace": "lkysow/atlantis-example",
+    "default_branch": "master",
+    "ci_config_path": null,
+    "homepage": "https://gitlab.com/lkysow/atlantis-example",
+    "url": "git@gitlab.com:lkysow/atlantis-example.git",
+    "ssh_url": "git@gitlab.com:lkysow/atlantis-example.git",
+    "http_url": "https://gitlab.com/lkysow/atlantis-example.git"
  },
  "object_attributes": {
-    "id": 99,
-    "target_branch": "master",
-    "source_branch": "ms-viewport",
-    "source_project_id": 14,
-    "author_id": 51,
-    "assignee_id": 6,
-    "title": "MS-Viewport",
-    "created_at": "2013-12-03T17:23:34Z",
-    "updated_at": "2013-12-03T17:23:34Z",
-    "st_commits": null,
-    "st_diffs": null,
-    "milestone_id": null,
-    "state": "opened",
-    "merge_status": "unchecked",
-    "target_project_id": 14,
-    "iid": 1,
+    "assignee_id": null,
+    "author_id": 1755902,
+    "created_at": "2018-12-12 16:15:21 UTC",
    "description": "",
+    "head_pipeline_id": null,
+    "id": 20809239,
+    "iid": 12,
+    "last_edited_at": null,
+    "last_edited_by_id": null,
+    "merge_commit_sha": null,
+    "merge_error": null,
+    "merge_params": {
+      "force_remove_source_branch": "0"
+    },
+    "merge_status": "unchecked",
+    "merge_user_id": null,
+    "merge_when_pipeline_succeeds": false,
+    "milestone_id": null,
+    "source_branch": "patch-1",
+    "source_project_id": 4580910,
+    "state": "opened",
+    "target_branch": "master",
+    "target_project_id": 4580910,
+    "time_estimate": 0,
+    "title": "Update main.tf",
+    "updated_at": "2018-12-12 16:15:21 UTC",
+    "updated_by_id": null,
+    "url": "https://gitlab.com/lkysow/atlantis-example/merge_requests/12",
    "source": {
-      "name":"Awesome Project",
-      "description":"Aut reprehenderit ut est.",
-      "web_url":"http://example.com/awesome_space/awesome_project",
-      "avatar_url":null,
-      "git_ssh_url":"git@example.com:awesome_space/awesome_project.git",
-      "git_http_url":"http://example.com/awesome_space/awesome_project.git",
-      "namespace":"Awesome Space",
-      "visibility_level":20,
-      "path_with_namespace":"awesome_space/awesome_project",
-      "default_branch":"master",
-      "homepage":"http://example.com/awesome_space/awesome_project",
-      "url":"http://example.com/awesome_space/awesome_project.git",
-      "ssh_url":"git@example.com:awesome_space/awesome_project.git",
-      "http_url":"http://example.com/awesome_space/awesome_project.git"
+      "id": 4580910,
+      "name": "atlantis-example",
+      "description": "",
+      "web_url": "https://gitlab.com/sourceorg/atlantis-example",
+      "avatar_url": null,
+      "git_ssh_url": "git@gitlab.com:sourceorg/atlantis-example.git",
+      "git_http_url": "https://gitlab.com/sourceorg/atlantis-example.git",
+      "namespace": "sourceorg",
+      "visibility_level": 20,
+      "path_with_namespace": "sourceorg/atlantis-example",
+      "default_branch": "master",
+      "ci_config_path": null,
+      "homepage": "https://gitlab.com/sourceorg/atlantis-example",
+      "url": "git@gitlab.com:sourceorg/atlantis-example.git",
+      "ssh_url": "git@gitlab.com:sourceorg/atlantis-example.git",
+      "http_url": "https://gitlab.com/sourceorg/atlantis-example.git"
    },
    "target": {
-      "name":"Awesome Project",
-      "description":"Aut reprehenderit ut est.",
-      "web_url":"http://example.com/awesome_space/awesome_project",
-      "avatar_url":null,
-      "git_ssh_url":"git@example.com:awesome_space/awesome_project.git",
-      "git_http_url":"http://example.com/awesome_space/awesome_project.git",
-      "namespace":"Awesome Space",
-      "visibility_level":20,
-      "path_with_namespace":"awesome_space/awesome_project",
-      "default_branch":"master",
-      "homepage":"http://example.com/awesome_space/awesome_project",
-      "url":"http://example.com/awesome_space/awesome_project.git",
-      "ssh_url":"git@example.com:awesome_space/awesome_project.git",
-      "http_url":"http://example.com/awesome_space/awesome_project.git"
+      "id": 4580910,
+      "name": "atlantis-example",
+      "description": "",
+      "web_url": "https://gitlab.com/lkysow/atlantis-example",
+      "avatar_url": null,
+      "git_ssh_url": "git@gitlab.com:lkysow/atlantis-example.git",
+      "git_http_url": "https://gitlab.com/lkysow/atlantis-example.git",
+      "namespace": "lkysow",
+      "visibility_level": 20,
+      "path_with_namespace": "lkysow/atlantis-example",
+      "default_branch": "master",
+      "ci_config_path": null,
+      "homepage": "https://gitlab.com/lkysow/atlantis-example",
+      "url": "git@gitlab.com:lkysow/atlantis-example.git",
+      "ssh_url": "git@gitlab.com:lkysow/atlantis-example.git",
+      "http_url": "https://gitlab.com/lkysow/atlantis-example.git"
    },
    "last_commit": {
-      "id": "da1560886d4f094c3e6c9ef40349f7d38b5d27d7",
-      "message": "fixed readme",
-      "timestamp": "2012-01-03T23:36:29+02:00",
-      "url": "http://example.com/awesome_space/awesome_project/commits/da1560886d4f094c3e6c9ef40349f7d38b5d27d7",
+      "id": "d2eae324ca26242abca45d7b49d582cddb2a4f15",
+      "message": "Update main.tf",
+      "timestamp": "2018-12-12T16:15:10Z",
+      "url": "https://gitlab.com/lkysow/atlantis-example/commit/d2eae324ca26242abca45d7b49d582cddb2a4f15",
      "author": {
-        "name": "GitLab dev user",
-        "email": "gitlabdev@dv6700.(none)"
+        "name": "Luke Kysow",
+        "email": "lkysow@gmail.com"
      }
    },
    "work_in_progress": false,
-    "url": "http://example.com/diaspora/merge_requests/1",
-    "action": "open",
-    "assignee": {
-      "name": "User1",
-      "username": "user1",
-      "avatar_url": "http://www.gravatar.com/avatar/e64c7d89f26bd1972efa854d13d7dd61?s=40\u0026d=identicon"
+    "total_time_spent": 0,
+    "human_total_time_spent": null,
+    "human_time_estimate": null,
+    "action": "open"
+  },
+  "labels": [
+
+  ],
+  "changes": {
+    "author_id": {
+      "previous": null,
+      "current": 1755902
+    },
+    "created_at": {
+      "previous": null,
+      "current": "2018-12-12 16:15:21 UTC"
+    },
+    "description": {
+      "previous": null,
+      "current": ""
+    },
+    "id": {
+      "previous": null,
+      "current": 20809239
+    },
+    "iid": {
+      "previous": null,
+      "current": 12
+    },
+    "merge_params": {
+      "previous": {
+      },
+      "current": {
+        "force_remove_source_branch": "0"
+      }
+    },
+    "source_branch": {
+      "previous": null,
+      "current": "patch-1"
+    },
+    "source_project_id": {
+      "previous": null,
+      "current": 4580910
+    },
+    "target_branch": {
+      "previous": null,
+      "current": "master"
+    },
+    "target_project_id": {
+      "previous": null,
+      "current": 4580910
+    },
+    "title": {
+      "previous": null,
+      "current": "Update main.tf"
+    },
+    "updated_at": {
+      "previous": null,
+      "current": "2018-12-12 16:15:21 UTC"
+    },
+    "total_time_spent": {
+      "previous": null,
+      "current": 0
    }
  },
-  "labels": [{
-    "id": 206,
-    "title": "API",
-    "color": "#ffffff",
-    "project_id": 14,
-    "created_at": "2013-12-03T17:15:43Z",
-    "updated_at": "2013-12-03T17:15:43Z",
-    "template": false,
-    "description": "API related issues",
-    "type": "ProjectLabel",
-    "group_id": 41
-  }],
-  "changes": {
-    "updated_by_id": [null, 1],
-    "updated_at": ["2017-09-15 16:50:55 UTC", "2017-09-15 16:52:00 UTC"],
-    "labels": {
-      "previous": [{
-        "id": 206,
-        "title": "API",
-        "color": "#ffffff",
-        "project_id": 14,
-        "created_at": "2013-12-03T17:15:43Z",
-        "updated_at": "2013-12-03T17:15:43Z",
-        "template": false,
-        "description": "API related issues",
-        "type": "ProjectLabel",
-        "group_id": 41
-      }],
-      "current": [{
-        "id": 205,
-        "title": "Platform",
-        "color": "#123123",
-        "project_id": 14,
-        "created_at": "2013-12-03T17:15:43Z",
-        "updated_at": "2013-12-03T17:15:43Z",
-        "template": false,
-        "description": "Platform related issues",
-        "type": "ProjectLabel",
-        "group_id": 41
-      }]
-    }
+  "repository": {
+    "name": "atlantis-example",
+    "url": "git@gitlab.com:lkysow/atlantis-example.git",
+    "description": "",
+    "homepage": "https://gitlab.com/lkysow/atlantis-example"
  }
-}`
+}
+`

 var mergeCommentEventJSON = `{
  "object_kind": "note",
--- a/server/server.go
+++ b/server/server.go
@@ -102,7 +102,10 @@ type UserConfig struct {
 	RepoWhitelist          string `mapstructure:"repo-whitelist"`
 	// RequireApproval is whether to require pull request approval before
 	// allowing terraform apply's to be run.
-	RequireApproval        bool            `mapstructure:"require-approval"`
+	RequireApproval bool `mapstructure:"require-approval"`
+	// RequireMergeable is whether to require pull requests to be mergeable before
+	// allowing terraform apply's to run.
+	RequireMergeable       bool            `mapstructure:"require-mergeable"`
 	SilenceWhitelistErrors bool            `mapstructure:"silence-whitelist-errors"`
 	SlackToken             string          `mapstructure:"slack-token"`
 	SSLCertFile            string          `mapstructure:"ssl-cert-file"`
@@ -291,11 +294,13 @@ func NewServer(userConfig UserConfig, config Config) (*Server, error) {
 			RunStepRunner: &runtime.RunStepRunner{
 				DefaultTFVersion: defaultTfVersion,
 			},
-			PullApprovedChecker:     vcsClient,
-			WorkingDir:              workingDir,
-			Webhooks:                webhooksManager,
-			WorkingDirLocker:        workingDirLocker,
-			RequireApprovalOverride: userConfig.RequireApproval,
+			PullApprovedChecker:      vcsClient,
+			PullMergeableChecker:     vcsClient,
+			WorkingDir:               workingDir,
+			Webhooks:                 webhooksManager,
+			WorkingDirLocker:         workingDirLocker,
+			RequireApprovalOverride:  userConfig.RequireApproval,
+			RequireMergeableOverride: userConfig.RequireMergeable,
 		},
 	}
 	repoWhitelist, err := events.NewRepoWhitelistChecker(userConfig.RepoWhitelist)
--- a/testdrive/github.go
+++ b/testdrive/github.go
@@ -56,7 +56,6 @@ func (g *Client) CheckForkSuccess(ownerName string, forkRepoName string) bool {
 // CreateWebhook creates a GitHub webhook to send requests to our local ngrok.
 func (g *Client) CreateWebhook(ownerName string, repoName string, hookURL string) error {
 	atlantisHook := &github.Hook{
-		Name:   github.String("web"),
 		Events: []string{"issue_comment", "pull_request", "pull_request_review", "push"},
 		Config: map[string]interface{}{
 			"url":          hookURL,
--- a/vendor/github.com/Masterminds/semver/benchmark_test.go
+++ b/vendor/github.com/Masterminds/semver/benchmark_test.go
@@ -1,157 +0,0 @@
-package semver_test
-
-import (
-	"testing"
-
-	"github.com/Masterminds/semver"
-)
-
-/* Constraint creation benchmarks */
-
-func benchNewConstraint(c string, b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		semver.NewConstraint(c)
-	}
-}
-
-func BenchmarkNewConstraintUnary(b *testing.B) {
-	benchNewConstraint("=2.0", b)
-}
-
-func BenchmarkNewConstraintTilde(b *testing.B) {
-	benchNewConstraint("~2.0.0", b)
-}
-
-func BenchmarkNewConstraintCaret(b *testing.B) {
-	benchNewConstraint("^2.0.0", b)
-}
-
-func BenchmarkNewConstraintWildcard(b *testing.B) {
-	benchNewConstraint("1.x", b)
-}
-
-func BenchmarkNewConstraintRange(b *testing.B) {
-	benchNewConstraint(">=2.1.x, <3.1.0", b)
-}
-
-func BenchmarkNewConstraintUnion(b *testing.B) {
-	benchNewConstraint("~2.0.0 || =3.1.0", b)
-}
-
-/* Check benchmarks */
-
-func benchCheckVersion(c, v string, b *testing.B) {
-	version, _ := semver.NewVersion(v)
-	constraint, _ := semver.NewConstraint(c)
-
-	for i := 0; i < b.N; i++ {
-		constraint.Check(version)
-	}
-}
-
-func BenchmarkCheckVersionUnary(b *testing.B) {
-	benchCheckVersion("=2.0", "2.0.0", b)
-}
-
-func BenchmarkCheckVersionTilde(b *testing.B) {
-	benchCheckVersion("~2.0.0", "2.0.5", b)
-}
-
-func BenchmarkCheckVersionCaret(b *testing.B) {
-	benchCheckVersion("^2.0.0", "2.1.0", b)
-}
-
-func BenchmarkCheckVersionWildcard(b *testing.B) {
-	benchCheckVersion("1.x", "1.4.0", b)
-}
-
-func BenchmarkCheckVersionRange(b *testing.B) {
-	benchCheckVersion(">=2.1.x, <3.1.0", "2.4.5", b)
-}
-
-func BenchmarkCheckVersionUnion(b *testing.B) {
-	benchCheckVersion("~2.0.0 || =3.1.0", "3.1.0", b)
-}
-
-func benchValidateVersion(c, v string, b *testing.B) {
-	version, _ := semver.NewVersion(v)
-	constraint, _ := semver.NewConstraint(c)
-
-	for i := 0; i < b.N; i++ {
-		constraint.Validate(version)
-	}
-}
-
-/* Validate benchmarks, including fails */
-
-func BenchmarkValidateVersionUnary(b *testing.B) {
-	benchValidateVersion("=2.0", "2.0.0", b)
-}
-
-func BenchmarkValidateVersionUnaryFail(b *testing.B) {
-	benchValidateVersion("=2.0", "2.0.1", b)
-}
-
-func BenchmarkValidateVersionTilde(b *testing.B) {
-	benchValidateVersion("~2.0.0", "2.0.5", b)
-}
-
-func BenchmarkValidateVersionTildeFail(b *testing.B) {
-	benchValidateVersion("~2.0.0", "1.0.5", b)
-}
-
-func BenchmarkValidateVersionCaret(b *testing.B) {
-	benchValidateVersion("^2.0.0", "2.1.0", b)
-}
-
-func BenchmarkValidateVersionCaretFail(b *testing.B) {
-	benchValidateVersion("^2.0.0", "4.1.0", b)
-}
-
-func BenchmarkValidateVersionWildcard(b *testing.B) {
-	benchValidateVersion("1.x", "1.4.0", b)
-}
-
-func BenchmarkValidateVersionWildcardFail(b *testing.B) {
-	benchValidateVersion("1.x", "2.4.0", b)
-}
-
-func BenchmarkValidateVersionRange(b *testing.B) {
-	benchValidateVersion(">=2.1.x, <3.1.0", "2.4.5", b)
-}
-
-func BenchmarkValidateVersionRangeFail(b *testing.B) {
-	benchValidateVersion(">=2.1.x, <3.1.0", "1.4.5", b)
-}
-
-func BenchmarkValidateVersionUnion(b *testing.B) {
-	benchValidateVersion("~2.0.0 || =3.1.0", "3.1.0", b)
-}
-
-func BenchmarkValidateVersionUnionFail(b *testing.B) {
-	benchValidateVersion("~2.0.0 || =3.1.0", "3.1.1", b)
-}
-
-/* Version creation benchmarks */
-
-func benchNewVersion(v string, b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		semver.NewVersion(v)
-	}
-}
-
-func BenchmarkNewVersionSimple(b *testing.B) {
-	benchNewVersion("1.0.0", b)
-}
-
-func BenchmarkNewVersionPre(b *testing.B) {
-	benchNewVersion("1.0.0-alpha", b)
-}
-
-func BenchmarkNewVersionMeta(b *testing.B) {
-	benchNewVersion("1.0.0+metadata", b)
-}
-
-func BenchmarkNewVersionMetaDash(b *testing.B) {
-	benchNewVersion("1.0.0+metadata-dash", b)
-}
--- a/vendor/github.com/Masterminds/semver/collection_test.go
+++ b/vendor/github.com/Masterminds/semver/collection_test.go
@@ -1,46 +0,0 @@
-package semver
-
-import (
-	"reflect"
-	"sort"
-	"testing"
-)
-
-func TestCollection(t *testing.T) {
-	raw := []string{
-		"1.2.3",
-		"1.0",
-		"1.3",
-		"2",
-		"0.4.2",
-	}
-
-	vs := make([]*Version, len(raw))
-	for i, r := range raw {
-		v, err := NewVersion(r)
-		if err != nil {
-			t.Errorf("Error parsing version: %s", err)
-		}
-
-		vs[i] = v
-	}
-
-	sort.Sort(Collection(vs))
-
-	e := []string{
-		"0.4.2",
-		"1.0.0",
-		"1.2.3",
-		"1.3.0",
-		"2.0.0",
-	}
-
-	a := make([]string, len(vs))
-	for i, v := range vs {
-		a[i] = v.String()
-	}
-
-	if !reflect.DeepEqual(a, e) {
-		t.Error("Sorting Collection failed")
-	}
-}
--- a/vendor/github.com/Masterminds/semver/constraints_test.go
+++ b/vendor/github.com/Masterminds/semver/constraints_test.go
@@ -1,465 +0,0 @@
-package semver
-
-import (
-	"reflect"
-	"testing"
-)
-
-func TestParseConstraint(t *testing.T) {
-	tests := []struct {
-		in  string
-		f   cfunc
-		v   string
-		err bool
-	}{
-		{">= 1.2", constraintGreaterThanEqual, "1.2.0", false},
-		{"1.0", constraintTildeOrEqual, "1.0.0", false},
-		{"foo", nil, "", true},
-		{"<= 1.2", constraintLessThanEqual, "1.2.0", false},
-		{"=< 1.2", constraintLessThanEqual, "1.2.0", false},
-		{"=> 1.2", constraintGreaterThanEqual, "1.2.0", false},
-		{"v1.2", constraintTildeOrEqual, "1.2.0", false},
-		{"=1.5", constraintTildeOrEqual, "1.5.0", false},
-		{"> 1.3", constraintGreaterThan, "1.3.0", false},
-		{"< 1.4.1", constraintLessThan, "1.4.1", false},
-	}
-
-	for _, tc := range tests {
-		c, err := parseConstraint(tc.in)
-		if tc.err && err == nil {
-			t.Errorf("Expected error for %s didn't occur", tc.in)
-		} else if !tc.err && err != nil {
-			t.Errorf("Unexpected error for %s", tc.in)
-		}
-
-		// If an error was expected continue the loop and don't try the other
-		// tests as they will cause errors.
-		if tc.err {
-			continue
-		}
-
-		if tc.v != c.con.String() {
-			t.Errorf("Incorrect version found on %s", tc.in)
-		}
-
-		f1 := reflect.ValueOf(tc.f)
-		f2 := reflect.ValueOf(c.function)
-		if f1 != f2 {
-			t.Errorf("Wrong constraint found for %s", tc.in)
-		}
-	}
-}
-
-func TestConstraintCheck(t *testing.T) {
-	tests := []struct {
-		constraint string
-		version    string
-		check      bool
-	}{
-		{"= 2.0", "1.2.3", false},
-		{"= 2.0", "2.0.0", true},
-		{"4.1", "4.1.0", true},
-		{"!=4.1", "4.1.0", false},
-		{"!=4.1", "5.1.0", true},
-		{">1.1", "4.1.0", true},
-		{">1.1", "1.1.0", false},
-		{"<1.1", "0.1.0", true},
-		{"<1.1", "1.1.0", false},
-		{"<1.1", "1.1.1", false},
-		{">=1.1", "4.1.0", true},
-		{">=1.1", "1.1.0", true},
-		{">=1.1", "0.0.9", false},
-		{"<=1.1", "0.1.0", true},
-		{"<=1.1", "1.1.0", true},
-		{"<=1.1", "1.1.1", false},
-		{">0", "0.0.1-alpha", true},
-		{">=0", "0.0.1-alpha", true},
-		{">0", "0", false},
-		{">=0", "0", true},
-		{"=0", "1", false},
-	}
-
-	for _, tc := range tests {
-		c, err := parseConstraint(tc.constraint)
-		if err != nil {
-			t.Errorf("err: %s", err)
-			continue
-		}
-
-		v, err := NewVersion(tc.version)
-		if err != nil {
-			t.Errorf("err: %s", err)
-			continue
-		}
-
-		a := c.check(v)
-		if a != tc.check {
-			t.Errorf("Constraint %q failing with %q", tc.constraint, tc.version)
-		}
-	}
-}
-
-func TestNewConstraint(t *testing.T) {
-	tests := []struct {
-		input string
-		ors   int
-		count int
-		err   bool
-	}{
-		{">= 1.1", 1, 1, false},
-		{"2.0", 1, 1, false},
-		{"v2.3.5-20161202202307-sha.e8fc5e5", 1, 1, false},
-		{">= bar", 0, 0, true},
-		{">= 1.2.3, < 2.0", 1, 2, false},
-		{">= 1.2.3, < 2.0 || => 3.0, < 4", 2, 2, false},
-
-		// The 3 - 4 should be broken into 2 by the range rewriting
-		{"3 - 4 || => 3.0, < 4", 2, 2, false},
-	}
-
-	for _, tc := range tests {
-		v, err := NewConstraint(tc.input)
-		if tc.err && err == nil {
-			t.Errorf("expected but did not get error for: %s", tc.input)
-			continue
-		} else if !tc.err && err != nil {
-			t.Errorf("unexpectederror for input %s: %s", tc.input, err)
-			continue
-		}
-		if tc.err {
-			continue
-		}
-
-		l := len(v.constraints)
-		if tc.ors != l {
-			t.Errorf("Expected %s to have %d ORs but got %d",
-				tc.input, tc.ors, l)
-		}
-
-		l = len(v.constraints[0])
-		if tc.count != l {
-			t.Errorf("Expected %s to have %d constraints but got %d",
-				tc.input, tc.count, l)
-		}
-	}
-}
-
-func TestConstraintsCheck(t *testing.T) {
-	tests := []struct {
-		constraint string
-		version    string
-		check      bool
-	}{
-		{"*", "1.2.3", true},
-		{"~0.0.0", "1.2.3", true},
-		{"0.x.x", "1.2.3", false},
-		{"0.0.x", "1.2.3", false},
-		{"0.0.0", "1.2.3", false},
-		{"*", "1.2.3", true},
-		{"^0.0.0", "1.2.3", false},
-		{"= 2.0", "1.2.3", false},
-		{"= 2.0", "2.0.0", true},
-		{"4.1", "4.1.0", true},
-		{"4.1.x", "4.1.3", true},
-		{"1.x", "1.4", true},
-		{"!=4.1", "4.1.0", false},
-		{"!=4.1-alpha", "4.1.0-alpha", false},
-		{"!=4.1-alpha", "4.1.0", true},
-		{"!=4.1", "5.1.0", true},
-		{"!=4.x", "5.1.0", true},
-		{"!=4.x", "4.1.0", false},
-		{"!=4.1.x", "4.2.0", true},
-		{"!=4.2.x", "4.2.3", false},
-		{">1.1", "4.1.0", true},
-		{">1.1", "1.1.0", false},
-		{"<1.1", "0.1.0", true},
-		{"<1.1", "1.1.0", false},
-		{"<1.1", "1.1.1", false},
-		{"<1.x", "1.1.1", true},
-		{"<1.x", "2.1.1", false},
-		{"<1.1.x", "1.2.1", false},
-		{"<1.1.x", "1.1.500", true},
-		{"<1.2.x", "1.1.1", true},
-		{">=1.1", "4.1.0", true},
-		{">=1.1", "4.1.0-beta", false},
-		{">=1.1", "1.1.0", true},
-		{">=1.1", "0.0.9", false},
-		{"<=1.1", "0.1.0", true},
-		{"<=1.1", "0.1.0-alpha", false},
-		{"<=1.1-a", "0.1.0-alpha", true},
-		{"<=1.1", "1.1.0", true},
-		{"<=1.x", "1.1.0", true},
-		{"<=2.x", "3.1.0", false},
-		{"<=1.1", "1.1.1", false},
-		{"<=1.1.x", "1.2.500", false},
-		{">1.1, <2", "1.1.1", true},
-		{">1.1, <3", "4.3.2", false},
-		{">=1.1, <2, !=1.2.3", "1.2.3", false},
-		{">=1.1, <2, !=1.2.3 || > 3", "3.1.2", true},
-		{">=1.1, <2, !=1.2.3 || >= 3", "3.0.0", true},
-		{">=1.1, <2, !=1.2.3 || > 3", "3.0.0", false},
-		{">=1.1, <2, !=1.2.3 || > 3", "1.2.3", false},
-		{"1.1 - 2", "1.1.1", true},
-		{"1.1-3", "4.3.2", false},
-		{"^1.1", "1.1.1", true},
-		{"^1.1", "4.3.2", false},
-		{"^1.x", "1.1.1", true},
-		{"^2.x", "1.1.1", false},
-		{"^1.x", "2.1.1", false},
-		{"^1.x", "1.1.1-beta1", false},
-		{"^1.1.2-alpha", "1.2.1-beta1", true},
-		{"^1.2.x-alpha", "1.1.1-beta1", false},
-		{"~*", "2.1.1", true},
-		{"~1", "2.1.1", false},
-		{"~1", "1.3.5", true},
-		{"~1", "1.4", true},
-		{"~1.x", "2.1.1", false},
-		{"~1.x", "1.3.5", true},
-		{"~1.x", "1.4", true},
-		{"~1.1", "1.1.1", true},
-		{"~1.1", "1.1.1-alpha", false},
-		{"~1.1-alpha", "1.1.1-beta", true},
-		{"~1.1.1-beta", "1.1.1-alpha", false},
-		{"~1.1.1-beta", "1.1.1", true},
-		{"~1.2.3", "1.2.5", true},
-		{"~1.2.3", "1.2.2", false},
-		{"~1.2.3", "1.3.2", false},
-		{"~1.1", "1.2.3", false},
-		{"~1.3", "2.4.5", false},
-	}
-
-	for _, tc := range tests {
-		c, err := NewConstraint(tc.constraint)
-		if err != nil {
-			t.Errorf("err: %s", err)
-			continue
-		}
-
-		v, err := NewVersion(tc.version)
-		if err != nil {
-			t.Errorf("err: %s", err)
-			continue
-		}
-
-		a := c.Check(v)
-		if a != tc.check {
-			t.Errorf("Constraint '%s' failing with '%s'", tc.constraint, tc.version)
-		}
-	}
-}
-
-func TestRewriteRange(t *testing.T) {
-	tests := []struct {
-		c  string
-		nc string
-	}{
-		{"2 - 3", ">= 2, <= 3"},
-		{"2 - 3, 2 - 3", ">= 2, <= 3,>= 2, <= 3"},
-		{"2 - 3, 4.0.0 - 5.1", ">= 2, <= 3,>= 4.0.0, <= 5.1"},
-	}
-
-	for _, tc := range tests {
-		o := rewriteRange(tc.c)
-
-		if o != tc.nc {
-			t.Errorf("Range %s rewritten incorrectly as '%s'", tc.c, o)
-		}
-	}
-}
-
-func TestIsX(t *testing.T) {
-	tests := []struct {
-		t string
-		c bool
-	}{
-		{"A", false},
-		{"%", false},
-		{"X", true},
-		{"x", true},
-		{"*", true},
-	}
-
-	for _, tc := range tests {
-		a := isX(tc.t)
-		if a != tc.c {
-			t.Errorf("Function isX error on %s", tc.t)
-		}
-	}
-}
-
-func TestConstraintsValidate(t *testing.T) {
-	tests := []struct {
-		constraint string
-		version    string
-		check      bool
-	}{
-		{"*", "1.2.3", true},
-		{"~0.0.0", "1.2.3", true},
-		{"= 2.0", "1.2.3", false},
-		{"= 2.0", "2.0.0", true},
-		{"4.1", "4.1.0", true},
-		{"4.1.x", "4.1.3", true},
-		{"1.x", "1.4", true},
-		{"!=4.1", "4.1.0", false},
-		{"!=4.1", "5.1.0", true},
-		{"!=4.x", "5.1.0", true},
-		{"!=4.x", "4.1.0", false},
-		{"!=4.1.x", "4.2.0", true},
-		{"!=4.2.x", "4.2.3", false},
-		{">1.1", "4.1.0", true},
-		{">1.1", "1.1.0", false},
-		{"<1.1", "0.1.0", true},
-		{"<1.1", "1.1.0", false},
-		{"<1.1", "1.1.1", false},
-		{"<1.x", "1.1.1", true},
-		{"<1.x", "2.1.1", false},
-		{"<1.1.x", "1.2.1", false},
-		{"<1.1.x", "1.1.500", true},
-		{"<1.2.x", "1.1.1", true},
-		{">=1.1", "4.1.0", true},
-		{">=1.1", "1.1.0", true},
-		{">=1.1", "0.0.9", false},
-		{"<=1.1", "0.1.0", true},
-		{"<=1.1", "1.1.0", true},
-		{"<=1.x", "1.1.0", true},
-		{"<=2.x", "3.1.0", false},
-		{"<=1.1", "1.1.1", false},
-		{"<=1.1.x", "1.2.500", false},
-		{">1.1, <2", "1.1.1", true},
-		{">1.1, <3", "4.3.2", false},
-		{">=1.1, <2, !=1.2.3", "1.2.3", false},
-		{">=1.1, <2, !=1.2.3 || > 3", "3.1.2", true},
-		{">=1.1, <2, !=1.2.3 || >= 3", "3.0.0", true},
-		{">=1.1, <2, !=1.2.3 || > 3", "3.0.0", false},
-		{">=1.1, <2, !=1.2.3 || > 3", "1.2.3", false},
-		{"1.1 - 2", "1.1.1", true},
-		{"1.1-3", "4.3.2", false},
-		{"^1.1", "1.1.1", true},
-		{"^1.1", "1.1.1-alpha", false},
-		{"^1.1.1-alpha", "1.1.1-beta", true},
-		{"^1.1.1-beta", "1.1.1-alpha", false},
-		{"^1.1", "4.3.2", false},
-		{"^1.x", "1.1.1", true},
-		{"^2.x", "1.1.1", false},
-		{"^1.x", "2.1.1", false},
-		{"~*", "2.1.1", true},
-		{"~1", "2.1.1", false},
-		{"~1", "1.3.5", true},
-		{"~1", "1.3.5-beta", false},
-		{"~1.x", "2.1.1", false},
-		{"~1.x", "1.3.5", true},
-		{"~1.x", "1.3.5-beta", false},
-		{"~1.3.6-alpha", "1.3.5-beta", false},
-		{"~1.3.5-alpha", "1.3.5-beta", true},
-		{"~1.3.5-beta", "1.3.5-alpha", false},
-		{"~1.x", "1.4", true},
-		{"~1.1", "1.1.1", true},
-		{"~1.2.3", "1.2.5", true},
-		{"~1.2.3", "1.2.2", false},
-		{"~1.2.3", "1.3.2", false},
-		{"~1.1", "1.2.3", false},
-		{"~1.3", "2.4.5", false},
-	}
-
-	for _, tc := range tests {
-		c, err := NewConstraint(tc.constraint)
-		if err != nil {
-			t.Errorf("err: %s", err)
-			continue
-		}
-
-		v, err := NewVersion(tc.version)
-		if err != nil {
-			t.Errorf("err: %s", err)
-			continue
-		}
-
-		a, msgs := c.Validate(v)
-		if a != tc.check {
-			t.Errorf("Constraint '%s' failing with '%s'", tc.constraint, tc.version)
-		} else if !a && len(msgs) == 0 {
-			t.Errorf("%q failed with %q but no errors returned", tc.constraint, tc.version)
-		}
-
-		// if a == false {
-		// 	for _, m := range msgs {
-		// 		t.Errorf("%s", m)
-		// 	}
-		// }
-	}
-
-	v, err := NewVersion("1.2.3")
-	if err != nil {
-		t.Errorf("err: %s", err)
-	}
-
-	c, err := NewConstraint("!= 1.2.5, ^2, <= 1.1.x")
-	if err != nil {
-		t.Errorf("err: %s", err)
-	}
-
-	_, msgs := c.Validate(v)
-	if len(msgs) != 2 {
-		t.Error("Invalid number of validations found")
-	}
-	e := msgs[0].Error()
-	if e != "1.2.3 does not have same major version as 2" {
-		t.Error("Did not get expected message: 1.2.3 does not have same major version as 2")
-	}
-	e = msgs[1].Error()
-	if e != "1.2.3 is greater than 1.1.x" {
-		t.Error("Did not get expected message: 1.2.3 is greater than 1.1.x")
-	}
-
-	tests2 := []struct {
-		constraint, version, msg string
-	}{
-		{"= 2.0", "1.2.3", "1.2.3 is not equal to 2.0"},
-		{"!=4.1", "4.1.0", "4.1.0 is equal to 4.1"},
-		{"!=4.x", "4.1.0", "4.1.0 is equal to 4.x"},
-		{"!=4.2.x", "4.2.3", "4.2.3 is equal to 4.2.x"},
-		{">1.1", "1.1.0", "1.1.0 is less than or equal to 1.1"},
-		{"<1.1", "1.1.0", "1.1.0 is greater than or equal to 1.1"},
-		{"<1.1", "1.1.1", "1.1.1 is greater than or equal to 1.1"},
-		{"<1.x", "2.1.1", "2.1.1 is greater than or equal to 1.x"},
-		{"<1.1.x", "1.2.1", "1.2.1 is greater than or equal to 1.1.x"},
-		{">=1.1", "0.0.9", "0.0.9 is less than 1.1"},
-		{"<=2.x", "3.1.0", "3.1.0 is greater than 2.x"},
-		{"<=1.1", "1.1.1", "1.1.1 is greater than 1.1"},
-		{"<=1.1.x", "1.2.500", "1.2.500 is greater than 1.1.x"},
-		{">1.1, <3", "4.3.2", "4.3.2 is greater than or equal to 3"},
-		{">=1.1, <2, !=1.2.3", "1.2.3", "1.2.3 is equal to 1.2.3"},
-		{">=1.1, <2, !=1.2.3 || > 3", "3.0.0", "3.0.0 is greater than or equal to 2"},
-		{">=1.1, <2, !=1.2.3 || > 3", "1.2.3", "1.2.3 is equal to 1.2.3"},
-		{"1.1 - 3", "4.3.2", "4.3.2 is greater than 3"},
-		{"^1.1", "4.3.2", "4.3.2 does not have same major version as 1.1"},
-		{"^2.x", "1.1.1", "1.1.1 does not have same major version as 2.x"},
-		{"^1.x", "2.1.1", "2.1.1 does not have same major version as 1.x"},
-		{"~1", "2.1.2", "2.1.2 does not have same major and minor version as 1"},
-		{"~1.x", "2.1.1", "2.1.1 does not have same major and minor version as 1.x"},
-		{"~1.2.3", "1.2.2", "1.2.2 does not have same major and minor version as 1.2.3"},
-		{"~1.2.3", "1.3.2", "1.3.2 does not have same major and minor version as 1.2.3"},
-		{"~1.1", "1.2.3", "1.2.3 does not have same major and minor version as 1.1"},
-		{"~1.3", "2.4.5", "2.4.5 does not have same major and minor version as 1.3"},
-	}
-
-	for _, tc := range tests2 {
-		c, err := NewConstraint(tc.constraint)
-		if err != nil {
-			t.Errorf("err: %s", err)
-			continue
-		}
-
-		v, err := NewVersion(tc.version)
-		if err != nil {
-			t.Errorf("err: %s", err)
-			continue
-		}
-
-		_, msgs := c.Validate(v)
-		e := msgs[0].Error()
-		if e != tc.msg {
-			t.Errorf("Did not get expected message %q: %s", tc.msg, e)
-		}
-	}
-}
--- a/vendor/github.com/Masterminds/semver/version_test.go
+++ b/vendor/github.com/Masterminds/semver/version_test.go
@@ -1,490 +0,0 @@
-package semver
-
-import (
-	"encoding/json"
-	"fmt"
-	"testing"
-)
-
-func TestNewVersion(t *testing.T) {
-	tests := []struct {
-		version string
-		err     bool
-	}{
-		{"1.2.3", false},
-		{"v1.2.3", false},
-		{"1.0", false},
-		{"v1.0", false},
-		{"1", false},
-		{"v1", false},
-		{"1.2.beta", true},
-		{"v1.2.beta", true},
-		{"foo", true},
-		{"1.2-5", false},
-		{"v1.2-5", false},
-		{"1.2-beta.5", false},
-		{"v1.2-beta.5", false},
-		{"\n1.2", true},
-		{"\nv1.2", true},
-		{"1.2.0-x.Y.0+metadata", false},
-		{"v1.2.0-x.Y.0+metadata", false},
-		{"1.2.0-x.Y.0+metadata-width-hypen", false},
-		{"v1.2.0-x.Y.0+metadata-width-hypen", false},
-		{"1.2.3-rc1-with-hypen", false},
-		{"v1.2.3-rc1-with-hypen", false},
-		{"1.2.3.4", true},
-		{"v1.2.3.4", true},
-		{"1.2.2147483648", false},
-		{"1.2147483648.3", false},
-		{"2147483648.3.0", false},
-	}
-
-	for _, tc := range tests {
-		_, err := NewVersion(tc.version)
-		if tc.err && err == nil {
-			t.Fatalf("expected error for version: %s", tc.version)
-		} else if !tc.err && err != nil {
-			t.Fatalf("error for version %s: %s", tc.version, err)
-		}
-	}
-}
-
-func TestOriginal(t *testing.T) {
-	tests := []string{
-		"1.2.3",
-		"v1.2.3",
-		"1.0",
-		"v1.0",
-		"1",
-		"v1",
-		"1.2-5",
-		"v1.2-5",
-		"1.2-beta.5",
-		"v1.2-beta.5",
-		"1.2.0-x.Y.0+metadata",
-		"v1.2.0-x.Y.0+metadata",
-		"1.2.0-x.Y.0+metadata-width-hypen",
-		"v1.2.0-x.Y.0+metadata-width-hypen",
-		"1.2.3-rc1-with-hypen",
-		"v1.2.3-rc1-with-hypen",
-	}
-
-	for _, tc := range tests {
-		v, err := NewVersion(tc)
-		if err != nil {
-			t.Errorf("Error parsing version %s", tc)
-		}
-
-		o := v.Original()
-		if o != tc {
-			t.Errorf("Error retrieving originl. Expected '%s' but got '%s'", tc, v)
-		}
-	}
-}
-
-func TestParts(t *testing.T) {
-	v, err := NewVersion("1.2.3-beta.1+build.123")
-	if err != nil {
-		t.Error("Error parsing version 1.2.3-beta.1+build.123")
-	}
-
-	if v.Major() != 1 {
-		t.Error("Major() returning wrong value")
-	}
-	if v.Minor() != 2 {
-		t.Error("Minor() returning wrong value")
-	}
-	if v.Patch() != 3 {
-		t.Error("Patch() returning wrong value")
-	}
-	if v.Prerelease() != "beta.1" {
-		t.Error("Prerelease() returning wrong value")
-	}
-	if v.Metadata() != "build.123" {
-		t.Error("Metadata() returning wrong value")
-	}
-}
-
-func TestString(t *testing.T) {
-	tests := []struct {
-		version  string
-		expected string
-	}{
-		{"1.2.3", "1.2.3"},
-		{"v1.2.3", "1.2.3"},
-		{"1.0", "1.0.0"},
-		{"v1.0", "1.0.0"},
-		{"1", "1.0.0"},
-		{"v1", "1.0.0"},
-		{"1.2-5", "1.2.0-5"},
-		{"v1.2-5", "1.2.0-5"},
-		{"1.2-beta.5", "1.2.0-beta.5"},
-		{"v1.2-beta.5", "1.2.0-beta.5"},
-		{"1.2.0-x.Y.0+metadata", "1.2.0-x.Y.0+metadata"},
-		{"v1.2.0-x.Y.0+metadata", "1.2.0-x.Y.0+metadata"},
-		{"1.2.0-x.Y.0+metadata-width-hypen", "1.2.0-x.Y.0+metadata-width-hypen"},
-		{"v1.2.0-x.Y.0+metadata-width-hypen", "1.2.0-x.Y.0+metadata-width-hypen"},
-		{"1.2.3-rc1-with-hypen", "1.2.3-rc1-with-hypen"},
-		{"v1.2.3-rc1-with-hypen", "1.2.3-rc1-with-hypen"},
-	}
-
-	for _, tc := range tests {
-		v, err := NewVersion(tc.version)
-		if err != nil {
-			t.Errorf("Error parsing version %s", tc)
-		}
-
-		s := v.String()
-		if s != tc.expected {
-			t.Errorf("Error generating string. Expected '%s' but got '%s'", tc.expected, s)
-		}
-	}
-}
-
-func TestCompare(t *testing.T) {
-	tests := []struct {
-		v1       string
-		v2       string
-		expected int
-	}{
-		{"1.2.3", "1.5.1", -1},
-		{"2.2.3", "1.5.1", 1},
-		{"2.2.3", "2.2.2", 1},
-		{"3.2-beta", "3.2-beta", 0},
-		{"1.3", "1.1.4", 1},
-		{"4.2", "4.2-beta", 1},
-		{"4.2-beta", "4.2", -1},
-		{"4.2-alpha", "4.2-beta", -1},
-		{"4.2-alpha", "4.2-alpha", 0},
-		{"4.2-beta.2", "4.2-beta.1", 1},
-		{"4.2-beta2", "4.2-beta1", 1},
-		{"4.2-beta", "4.2-beta.2", -1},
-		{"4.2-beta", "4.2-beta.foo", -1},
-		{"4.2-beta.2", "4.2-beta", 1},
-		{"4.2-beta.foo", "4.2-beta", 1},
-		{"1.2+bar", "1.2+baz", 0},
-	}
-
-	for _, tc := range tests {
-		v1, err := NewVersion(tc.v1)
-		if err != nil {
-			t.Errorf("Error parsing version: %s", err)
-		}
-
-		v2, err := NewVersion(tc.v2)
-		if err != nil {
-			t.Errorf("Error parsing version: %s", err)
-		}
-
-		a := v1.Compare(v2)
-		e := tc.expected
-		if a != e {
-			t.Errorf(
-				"Comparison of '%s' and '%s' failed. Expected '%d', got '%d'",
-				tc.v1, tc.v2, e, a,
-			)
-		}
-	}
-}
-
-func TestLessThan(t *testing.T) {
-	tests := []struct {
-		v1       string
-		v2       string
-		expected bool
-	}{
-		{"1.2.3", "1.5.1", true},
-		{"2.2.3", "1.5.1", false},
-		{"3.2-beta", "3.2-beta", false},
-	}
-
-	for _, tc := range tests {
-		v1, err := NewVersion(tc.v1)
-		if err != nil {
-			t.Errorf("Error parsing version: %s", err)
-		}
-
-		v2, err := NewVersion(tc.v2)
-		if err != nil {
-			t.Errorf("Error parsing version: %s", err)
-		}
-
-		a := v1.LessThan(v2)
-		e := tc.expected
-		if a != e {
-			t.Errorf(
-				"Comparison of '%s' and '%s' failed. Expected '%t', got '%t'",
-				tc.v1, tc.v2, e, a,
-			)
-		}
-	}
-}
-
-func TestGreaterThan(t *testing.T) {
-	tests := []struct {
-		v1       string
-		v2       string
-		expected bool
-	}{
-		{"1.2.3", "1.5.1", false},
-		{"2.2.3", "1.5.1", true},
-		{"3.2-beta", "3.2-beta", false},
-		{"3.2.0-beta.1", "3.2.0-beta.5", false},
-		{"3.2-beta.4", "3.2-beta.2", true},
-		{"7.43.0-SNAPSHOT.99", "7.43.0-SNAPSHOT.103", false},
-		{"7.43.0-SNAPSHOT.FOO", "7.43.0-SNAPSHOT.103", true},
-		{"7.43.0-SNAPSHOT.99", "7.43.0-SNAPSHOT.BAR", false},
-	}
-
-	for _, tc := range tests {
-		v1, err := NewVersion(tc.v1)
-		if err != nil {
-			t.Errorf("Error parsing version: %s", err)
-		}
-
-		v2, err := NewVersion(tc.v2)
-		if err != nil {
-			t.Errorf("Error parsing version: %s", err)
-		}
-
-		a := v1.GreaterThan(v2)
-		e := tc.expected
-		if a != e {
-			t.Errorf(
-				"Comparison of '%s' and '%s' failed. Expected '%t', got '%t'",
-				tc.v1, tc.v2, e, a,
-			)
-		}
-	}
-}
-
-func TestEqual(t *testing.T) {
-	tests := []struct {
-		v1       string
-		v2       string
-		expected bool
-	}{
-		{"1.2.3", "1.5.1", false},
-		{"2.2.3", "1.5.1", false},
-		{"3.2-beta", "3.2-beta", true},
-		{"3.2-beta+foo", "3.2-beta+bar", true},
-	}
-
-	for _, tc := range tests {
-		v1, err := NewVersion(tc.v1)
-		if err != nil {
-			t.Errorf("Error parsing version: %s", err)
-		}
-
-		v2, err := NewVersion(tc.v2)
-		if err != nil {
-			t.Errorf("Error parsing version: %s", err)
-		}
-
-		a := v1.Equal(v2)
-		e := tc.expected
-		if a != e {
-			t.Errorf(
-				"Comparison of '%s' and '%s' failed. Expected '%t', got '%t'",
-				tc.v1, tc.v2, e, a,
-			)
-		}
-	}
-}
-
-func TestInc(t *testing.T) {
-	tests := []struct {
-		v1               string
-		expected         string
-		how              string
-		expectedOriginal string
-	}{
-		{"1.2.3", "1.2.4", "patch", "1.2.4"},
-		{"v1.2.4", "1.2.5", "patch", "v1.2.5"},
-		{"1.2.3", "1.3.0", "minor", "1.3.0"},
-		{"v1.2.4", "1.3.0", "minor", "v1.3.0"},
-		{"1.2.3", "2.0.0", "major", "2.0.0"},
-		{"v1.2.4", "2.0.0", "major", "v2.0.0"},
-		{"1.2.3+meta", "1.2.4", "patch", "1.2.4"},
-		{"1.2.3-beta+meta", "1.2.3", "patch", "1.2.3"},
-		{"v1.2.4-beta+meta", "1.2.4", "patch", "v1.2.4"},
-		{"1.2.3-beta+meta", "1.3.0", "minor", "1.3.0"},
-		{"v1.2.4-beta+meta", "1.3.0", "minor", "v1.3.0"},
-		{"1.2.3-beta+meta", "2.0.0", "major", "2.0.0"},
-		{"v1.2.4-beta+meta", "2.0.0", "major", "v2.0.0"},
-	}
-
-	for _, tc := range tests {
-		v1, err := NewVersion(tc.v1)
-		if err != nil {
-			t.Errorf("Error parsing version: %s", err)
-		}
-		var v2 Version
-		switch tc.how {
-		case "patch":
-			v2 = v1.IncPatch()
-		case "minor":
-			v2 = v1.IncMinor()
-		case "major":
-			v2 = v1.IncMajor()
-		}
-
-		a := v2.String()
-		e := tc.expected
-		if a != e {
-			t.Errorf(
-				"Inc %q failed. Expected %q got %q",
-				tc.how, e, a,
-			)
-		}
-
-		a = v2.Original()
-		e = tc.expectedOriginal
-		if a != e {
-			t.Errorf(
-				"Inc %q failed. Expected original %q got %q",
-				tc.how, e, a,
-			)
-		}
-	}
-}
-
-func TestSetPrerelease(t *testing.T) {
-	tests := []struct {
-		v1                 string
-		prerelease         string
-		expectedVersion    string
-		expectedPrerelease string
-		expectedOriginal   string
-		expectedErr        error
-	}{
-		{"1.2.3", "**", "1.2.3", "", "1.2.3", ErrInvalidPrerelease},
-		{"1.2.3", "beta", "1.2.3-beta", "beta", "1.2.3-beta", nil},
-		{"v1.2.4", "beta", "1.2.4-beta", "beta", "v1.2.4-beta", nil},
-	}
-
-	for _, tc := range tests {
-		v1, err := NewVersion(tc.v1)
-		if err != nil {
-			t.Errorf("Error parsing version: %s", err)
-		}
-
-		v2, err := v1.SetPrerelease(tc.prerelease)
-		if err != tc.expectedErr {
-			t.Errorf("Expected to get err=%s, but got err=%s", tc.expectedErr, err)
-		}
-
-		a := v2.Prerelease()
-		e := tc.expectedPrerelease
-		if a != e {
-			t.Errorf("Expected prerelease value=%q, but got %q", e, a)
-		}
-
-		a = v2.String()
-		e = tc.expectedVersion
-		if a != e {
-			t.Errorf("Expected version string=%q, but got %q", e, a)
-		}
-
-		a = v2.Original()
-		e = tc.expectedOriginal
-		if a != e {
-			t.Errorf("Expected version original=%q, but got %q", e, a)
-		}
-	}
-}
-
-func TestSetMetadata(t *testing.T) {
-	tests := []struct {
-		v1               string
-		metadata         string
-		expectedVersion  string
-		expectedMetadata string
-		expectedOriginal string
-		expectedErr      error
-	}{
-		{"1.2.3", "**", "1.2.3", "", "1.2.3", ErrInvalidMetadata},
-		{"1.2.3", "meta", "1.2.3+meta", "meta", "1.2.3+meta", nil},
-		{"v1.2.4", "meta", "1.2.4+meta", "meta", "v1.2.4+meta", nil},
-	}
-
-	for _, tc := range tests {
-		v1, err := NewVersion(tc.v1)
-		if err != nil {
-			t.Errorf("Error parsing version: %s", err)
-		}
-
-		v2, err := v1.SetMetadata(tc.metadata)
-		if err != tc.expectedErr {
-			t.Errorf("Expected to get err=%s, but got err=%s", tc.expectedErr, err)
-		}
-
-		a := v2.Metadata()
-		e := tc.expectedMetadata
-		if a != e {
-			t.Errorf("Expected metadata value=%q, but got %q", e, a)
-		}
-
-		a = v2.String()
-		e = tc.expectedVersion
-		if e != a {
-			t.Errorf("Expected version string=%q, but got %q", e, a)
-		}
-
-		a = v2.Original()
-		e = tc.expectedOriginal
-		if a != e {
-			t.Errorf("Expected version original=%q, but got %q", e, a)
-		}
-	}
-}
-
-func TestOriginalVPrefix(t *testing.T) {
-	tests := []struct {
-		version string
-		vprefix string
-	}{
-		{"1.2.3", ""},
-		{"v1.2.4", "v"},
-	}
-
-	for _, tc := range tests {
-		v1, _ := NewVersion(tc.version)
-		a := v1.originalVPrefix()
-		e := tc.vprefix
-		if a != e {
-			t.Errorf("Expected vprefix=%q, but got %q", e, a)
-		}
-	}
-}
-
-func TestJsonMarshal(t *testing.T) {
-	sVer := "1.1.1"
-	x, err := NewVersion(sVer)
-	if err != nil {
-		t.Errorf("Error creating version: %s", err)
-	}
-	out, err2 := json.Marshal(x)
-	if err2 != nil {
-		t.Errorf("Error marshaling version: %s", err2)
-	}
-	got := string(out)
-	want := fmt.Sprintf("%q", sVer)
-	if got != want {
-		t.Errorf("Error marshaling unexpected marshaled content: got=%q want=%q", got, want)
-	}
-}
-
-func TestJsonUnmarshal(t *testing.T) {
-	sVer := "1.1.1"
-	ver := &Version{}
-	err := json.Unmarshal([]byte(fmt.Sprintf("%q", sVer)), ver)
-	if err != nil {
-		t.Errorf("Error unmarshaling version: %s", err)
-	}
-	got := ver.String()
-	want := sVer
-	if got != want {
-		t.Errorf("Error unmarshaling unexpected object content: got=%q want=%q", got, want)
-	}
-}
--- a/vendor/github.com/Masterminds/sprig/crypto_test.go
+++ b/vendor/github.com/Masterminds/sprig/crypto_test.go
@@ -1,259 +0,0 @@
-package sprig
-
-import (
-	"crypto/x509"
-	"encoding/base64"
-	"encoding/pem"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-const (
-	beginCertificate = "-----BEGIN CERTIFICATE-----"
-	endCertificate   = "-----END CERTIFICATE-----"
-)
-
-func TestSha256Sum(t *testing.T) {
-	tpl := `{{"abc" | sha256sum}}`
-	if err := runt(tpl, "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"); err != nil {
-		t.Error(err)
-	}
-}
-func TestSha1Sum(t *testing.T) {
-	tpl := `{{"abc" | sha1sum}}`
-	if err := runt(tpl, "a9993e364706816aba3e25717850c26c9cd0d89d"); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestDerivePassword(t *testing.T) {
-	expectations := map[string]string{
-		`{{derivePassword 1 "long" "password" "user" "example.com"}}`:    "ZedaFaxcZaso9*",
-		`{{derivePassword 2 "long" "password" "user" "example.com"}}`:    "Fovi2@JifpTupx",
-		`{{derivePassword 1 "maximum" "password" "user" "example.com"}}`: "pf4zS1LjCg&LjhsZ7T2~",
-		`{{derivePassword 1 "medium" "password" "user" "example.com"}}`:  "ZedJuz8$",
-		`{{derivePassword 1 "basic" "password" "user" "example.com"}}`:   "pIS54PLs",
-		`{{derivePassword 1 "short" "password" "user" "example.com"}}`:   "Zed5",
-		`{{derivePassword 1 "pin" "password" "user" "example.com"}}`:     "6685",
-	}
-
-	for tpl, result := range expectations {
-		out, err := runRaw(tpl, nil)
-		if err != nil {
-			t.Error(err)
-		}
-		if 0 != strings.Compare(out, result) {
-			t.Error("Generated password does not match for", tpl)
-		}
-	}
-}
-
-// NOTE(bacongobbler): this test is really _slow_ because of how long it takes to compute
-// and generate a new crypto key.
-func TestGenPrivateKey(t *testing.T) {
-	// test that calling by default generates an RSA private key
-	tpl := `{{genPrivateKey ""}}`
-	out, err := runRaw(tpl, nil)
-	if err != nil {
-		t.Error(err)
-	}
-	if !strings.Contains(out, "RSA PRIVATE KEY") {
-		t.Error("Expected RSA PRIVATE KEY")
-	}
-	// test all acceptable arguments
-	tpl = `{{genPrivateKey "rsa"}}`
-	out, err = runRaw(tpl, nil)
-	if err != nil {
-		t.Error(err)
-	}
-	if !strings.Contains(out, "RSA PRIVATE KEY") {
-		t.Error("Expected RSA PRIVATE KEY")
-	}
-	tpl = `{{genPrivateKey "dsa"}}`
-	out, err = runRaw(tpl, nil)
-	if err != nil {
-		t.Error(err)
-	}
-	if !strings.Contains(out, "DSA PRIVATE KEY") {
-		t.Error("Expected DSA PRIVATE KEY")
-	}
-	tpl = `{{genPrivateKey "ecdsa"}}`
-	out, err = runRaw(tpl, nil)
-	if err != nil {
-		t.Error(err)
-	}
-	if !strings.Contains(out, "EC PRIVATE KEY") {
-		t.Error("Expected EC PRIVATE KEY")
-	}
-	// test bad
-	tpl = `{{genPrivateKey "bad"}}`
-	out, err = runRaw(tpl, nil)
-	if err != nil {
-		t.Error(err)
-	}
-	if out != "Unknown type bad" {
-		t.Error("Expected type 'bad' to be an unknown crypto algorithm")
-	}
-	// ensure that we can base64 encode the string
-	tpl = `{{genPrivateKey "rsa" | b64enc}}`
-	out, err = runRaw(tpl, nil)
-	if err != nil {
-		t.Error(err)
-	}
-}
-
-func TestUUIDGeneration(t *testing.T) {
-	tpl := `{{uuidv4}}`
-	out, err := runRaw(tpl, nil)
-	if err != nil {
-		t.Error(err)
-	}
-
-	if len(out) != 36 {
-		t.Error("Expected UUID of length 36")
-	}
-
-	out2, err := runRaw(tpl, nil)
-	if err != nil {
-		t.Error(err)
-	}
-
-	if out == out2 {
-		t.Error("Expected subsequent UUID generations to be different")
-	}
-}
-
-func TestBuildCustomCert(t *testing.T) {
-	ca, _ := generateCertificateAuthority("example.com", 365)
-	tpl := fmt.Sprintf(
-		`{{- $ca := buildCustomCert "%s" "%s"}}
-{{- $ca.Cert }}`,
-		base64.StdEncoding.EncodeToString([]byte(ca.Cert)),
-		base64.StdEncoding.EncodeToString([]byte(ca.Key)),
-	)
-	out, err := runRaw(tpl, nil)
-	if err != nil {
-		t.Error(err)
-	}
-
-	tpl2 := fmt.Sprintf(
-		`{{- $ca := buildCustomCert "%s" "%s"}}
-{{- $ca.Cert }}`,
-		base64.StdEncoding.EncodeToString([]byte("fail")),
-		base64.StdEncoding.EncodeToString([]byte(ca.Key)),
-	)
-	out2, _ := runRaw(tpl2, nil)
-
-	assert.Equal(t, out, ca.Cert)
-	assert.NotEqual(t, out2, ca.Cert)
-}
-
-func TestGenCA(t *testing.T) {
-	const cn = "foo-ca"
-
-	tpl := fmt.Sprintf(
-		`{{- $ca := genCA "%s" 365 }}
-{{ $ca.Cert }}
-`,
-		cn,
-	)
-	out, err := runRaw(tpl, nil)
-	if err != nil {
-		t.Error(err)
-	}
-	assert.Contains(t, out, beginCertificate)
-	assert.Contains(t, out, endCertificate)
-
-	decodedCert, _ := pem.Decode([]byte(out))
-	assert.Nil(t, err)
-	cert, err := x509.ParseCertificate(decodedCert.Bytes)
-	assert.Nil(t, err)
-
-	assert.Equal(t, cn, cert.Subject.CommonName)
-	assert.True(t, cert.IsCA)
-}
-
-func TestGenSelfSignedCert(t *testing.T) {
-	const (
-		cn   = "foo.com"
-		ip1  = "10.0.0.1"
-		ip2  = "10.0.0.2"
-		dns1 = "bar.com"
-		dns2 = "bat.com"
-	)
-
-	tpl := fmt.Sprintf(
-		`{{- $cert := genSelfSignedCert "%s" (list "%s" "%s") (list "%s" "%s") 365 }}
-{{ $cert.Cert }}`,
-		cn,
-		ip1,
-		ip2,
-		dns1,
-		dns2,
-	)
-
-	out, err := runRaw(tpl, nil)
-	if err != nil {
-		t.Error(err)
-	}
-	assert.Contains(t, out, beginCertificate)
-	assert.Contains(t, out, endCertificate)
-
-	decodedCert, _ := pem.Decode([]byte(out))
-	assert.Nil(t, err)
-	cert, err := x509.ParseCertificate(decodedCert.Bytes)
-	assert.Nil(t, err)
-
-	assert.Equal(t, cn, cert.Subject.CommonName)
-	assert.Equal(t, 2, len(cert.IPAddresses))
-	assert.Equal(t, ip1, cert.IPAddresses[0].String())
-	assert.Equal(t, ip2, cert.IPAddresses[1].String())
-	assert.Contains(t, cert.DNSNames, dns1)
-	assert.Contains(t, cert.DNSNames, dns2)
-	assert.False(t, cert.IsCA)
-}
-
-func TestGenSignedCert(t *testing.T) {
-	const (
-		cn   = "foo.com"
-		ip1  = "10.0.0.1"
-		ip2  = "10.0.0.2"
-		dns1 = "bar.com"
-		dns2 = "bat.com"
-	)
-
-	tpl := fmt.Sprintf(
-		`{{- $ca := genCA "foo" 365 }}
-{{- $cert := genSignedCert "%s" (list "%s" "%s") (list "%s" "%s") 365 $ca }}
-{{ $cert.Cert }}
-`,
-		cn,
-		ip1,
-		ip2,
-		dns1,
-		dns2,
-	)
-	out, err := runRaw(tpl, nil)
-	if err != nil {
-		t.Error(err)
-	}
-
-	assert.Contains(t, out, beginCertificate)
-	assert.Contains(t, out, endCertificate)
-
-	decodedCert, _ := pem.Decode([]byte(out))
-	assert.Nil(t, err)
-	cert, err := x509.ParseCertificate(decodedCert.Bytes)
-	assert.Nil(t, err)
-
-	assert.Equal(t, cn, cert.Subject.CommonName)
-	assert.Equal(t, 2, len(cert.IPAddresses))
-	assert.Equal(t, ip1, cert.IPAddresses[0].String())
-	assert.Equal(t, ip2, cert.IPAddresses[1].String())
-	assert.Contains(t, cert.DNSNames, dns1)
-	assert.Contains(t, cert.DNSNames, dns2)
-	assert.False(t, cert.IsCA)
-}
--- a/vendor/github.com/Masterminds/sprig/date_test.go
+++ b/vendor/github.com/Masterminds/sprig/date_test.go
@@ -1,36 +0,0 @@
-package sprig
-
-import (
-	"testing"
-	"time"
-)
-
-func TestHtmlDate(t *testing.T) {
-	t.Skip()
-	tpl := `{{ htmlDate 0}}`
-	if err := runt(tpl, "1970-01-01"); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestAgo(t *testing.T) {
-	tpl := "{{ ago .Time }}"
-	if err := runtv(tpl, "2m5s", map[string]interface{}{"Time": time.Now().Add(-125 * time.Second)}); err != nil {
-		t.Error(err)
-	}
-
-	if err := runtv(tpl, "2h34m17s", map[string]interface{}{"Time": time.Now().Add(-(2*3600 + 34*60 + 17) * time.Second)}); err != nil {
-		t.Error(err)
-	}
-
-	if err := runtv(tpl, "-5s", map[string]interface{}{"Time": time.Now().Add(5 * time.Second)}); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestToDate(t *testing.T) {
-	tpl := `{{toDate "2006-01-02" "2017-12-31" | date "02/01/2006"}}`
-	if err := runt(tpl, "31/12/2017"); err != nil {
-		t.Error(err)
-	}
-}
--- a/vendor/github.com/Masterminds/sprig/defaults_test.go
+++ b/vendor/github.com/Masterminds/sprig/defaults_test.go
@@ -1,129 +0,0 @@
-package sprig
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestDefault(t *testing.T) {
-	tpl := `{{"" | default "foo"}}`
-	if err := runt(tpl, "foo"); err != nil {
-		t.Error(err)
-	}
-	tpl = `{{default "foo" 234}}`
-	if err := runt(tpl, "234"); err != nil {
-		t.Error(err)
-	}
-	tpl = `{{default "foo" 2.34}}`
-	if err := runt(tpl, "2.34"); err != nil {
-		t.Error(err)
-	}
-
-	tpl = `{{ .Nothing | default "123" }}`
-	if err := runt(tpl, "123"); err != nil {
-		t.Error(err)
-	}
-	tpl = `{{ default "123" }}`
-	if err := runt(tpl, "123"); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestEmpty(t *testing.T) {
-	tpl := `{{if empty 1}}1{{else}}0{{end}}`
-	if err := runt(tpl, "0"); err != nil {
-		t.Error(err)
-	}
-
-	tpl = `{{if empty 0}}1{{else}}0{{end}}`
-	if err := runt(tpl, "1"); err != nil {
-		t.Error(err)
-	}
-	tpl = `{{if empty ""}}1{{else}}0{{end}}`
-	if err := runt(tpl, "1"); err != nil {
-		t.Error(err)
-	}
-	tpl = `{{if empty 0.0}}1{{else}}0{{end}}`
-	if err := runt(tpl, "1"); err != nil {
-		t.Error(err)
-	}
-	tpl = `{{if empty false}}1{{else}}0{{end}}`
-	if err := runt(tpl, "1"); err != nil {
-		t.Error(err)
-	}
-
-	dict := map[string]interface{}{"top": map[string]interface{}{}}
-	tpl = `{{if empty .top.NoSuchThing}}1{{else}}0{{end}}`
-	if err := runtv(tpl, "1", dict); err != nil {
-		t.Error(err)
-	}
-	tpl = `{{if empty .bottom.NoSuchThing}}1{{else}}0{{end}}`
-	if err := runtv(tpl, "1", dict); err != nil {
-		t.Error(err)
-	}
-}
-func TestCoalesce(t *testing.T) {
-	tests := map[string]string{
-		`{{ coalesce 1 }}`:                            "1",
-		`{{ coalesce "" 0 nil 2 }}`:                   "2",
-		`{{ $two := 2 }}{{ coalesce "" 0 nil $two }}`: "2",
-		`{{ $two := 2 }}{{ coalesce "" $two 0 0 0 }}`: "2",
-		`{{ $two := 2 }}{{ coalesce "" $two 3 4 5 }}`: "2",
-		`{{ coalesce }}`:                              "<no value>",
-	}
-	for tpl, expect := range tests {
-		assert.NoError(t, runt(tpl, expect))
-	}
-
-	dict := map[string]interface{}{"top": map[string]interface{}{}}
-	tpl := `{{ coalesce .top.NoSuchThing .bottom .bottom.dollar "airplane"}}`
-	if err := runtv(tpl, "airplane", dict); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestToJson(t *testing.T) {
-	dict := map[string]interface{}{"Top": map[string]interface{}{"bool": true, "string": "test", "number": 42}}
-
-	tpl := `{{.Top | toJson}}`
-	expected := `{"bool":true,"number":42,"string":"test"}`
-	if err := runtv(tpl, expected, dict); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestToPrettyJson(t *testing.T) {
-	dict := map[string]interface{}{"Top": map[string]interface{}{"bool": true, "string": "test", "number": 42}}
-	tpl := `{{.Top | toPrettyJson}}`
-	expected := `{
-  "bool": true,
-  "number": 42,
-  "string": "test"
-}`
-	if err := runtv(tpl, expected, dict); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestTernary(t *testing.T) {
-	tpl := `{{true | ternary "foo" "bar"}}`
-	if err := runt(tpl, "foo"); err != nil {
-		t.Error(err)
-	}
-
-	tpl = `{{ternary "foo" "bar" true}}`
-	if err := runt(tpl, "foo"); err != nil {
-		t.Error(err)
-	}
-
-	tpl = `{{false | ternary "foo" "bar"}}`
-	if err := runt(tpl, "bar"); err != nil {
-		t.Error(err)
-	}
-
-	tpl = `{{ternary "foo" "bar" false}}`
-	if err := runt(tpl, "bar"); err != nil {
-		t.Error(err)
-	}
-}
--- a/vendor/github.com/Masterminds/sprig/dict_test.go
+++ b/vendor/github.com/Masterminds/sprig/dict_test.go
@@ -1,175 +0,0 @@
-package sprig
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestDict(t *testing.T) {
-	tpl := `{{$d := dict 1 2 "three" "four" 5}}{{range $k, $v := $d}}{{$k}}{{$v}}{{end}}`
-	out, err := runRaw(tpl, nil)
-	if err != nil {
-		t.Error(err)
-	}
-	if len(out) != 12 {
-		t.Errorf("Expected length 12, got %d", len(out))
-	}
-	// dict does not guarantee ordering because it is backed by a map.
-	if !strings.Contains(out, "12") {
-		t.Error("Expected grouping 12")
-	}
-	if !strings.Contains(out, "threefour") {
-		t.Error("Expected grouping threefour")
-	}
-	if !strings.Contains(out, "5") {
-		t.Error("Expected 5")
-	}
-	tpl = `{{$t := dict "I" "shot" "the" "albatross"}}{{$t.the}} {{$t.I}}`
-	if err := runt(tpl, "albatross shot"); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestUnset(t *testing.T) {
-	tpl := `{{- $d := dict "one" 1 "two" 222222 -}}
-	{{- $_ := unset $d "two" -}}
-	{{- range $k, $v := $d}}{{$k}}{{$v}}{{- end -}}
-	`
-
-	expect := "one1"
-	if err := runt(tpl, expect); err != nil {
-		t.Error(err)
-	}
-}
-func TestHasKey(t *testing.T) {
-	tpl := `{{- $d := dict "one" 1 "two" 222222 -}}
-	{{- if hasKey $d "one" -}}1{{- end -}}
-	`
-
-	expect := "1"
-	if err := runt(tpl, expect); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestPluck(t *testing.T) {
-	tpl := `
-	{{- $d := dict "one" 1 "two" 222222 -}}
-	{{- $d2 := dict "one" 1 "two" 33333 -}}
-	{{- $d3 := dict "one" 1 -}}
-	{{- $d4 := dict "one" 1 "two" 4444 -}}
-	{{- pluck "two" $d $d2 $d3 $d4 -}}
-	`
-
-	expect := "[222222 33333 4444]"
-	if err := runt(tpl, expect); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestKeys(t *testing.T) {
-	tests := map[string]string{
-		`{{ dict "foo" 1 "bar" 2 | keys | sortAlpha }}`: "[bar foo]",
-		`{{ dict | keys }}`:                             "[]",
-		`{{ keys (dict "foo" 1) (dict "bar" 2) (dict "bar" 3) | uniq | sortAlpha }}`: "[bar foo]",
-	}
-	for tpl, expect := range tests {
-		if err := runt(tpl, expect); err != nil {
-			t.Error(err)
-		}
-	}
-}
-
-func TestPick(t *testing.T) {
-	tests := map[string]string{
-		`{{- $d := dict "one" 1 "two" 222222 }}{{ pick $d "two" | len -}}`:               "1",
-		`{{- $d := dict "one" 1 "two" 222222 }}{{ pick $d "two" -}}`:                     "map[two:222222]",
-		`{{- $d := dict "one" 1 "two" 222222 }}{{ pick $d "one" "two" | len -}}`:         "2",
-		`{{- $d := dict "one" 1 "two" 222222 }}{{ pick $d "one" "two" "three" | len -}}`: "2",
-		`{{- $d := dict }}{{ pick $d "two" | len -}}`:                                    "0",
-	}
-	for tpl, expect := range tests {
-		if err := runt(tpl, expect); err != nil {
-			t.Error(err)
-		}
-	}
-}
-func TestOmit(t *testing.T) {
-	tests := map[string]string{
-		`{{- $d := dict "one" 1 "two" 222222 }}{{ omit $d "one" | len -}}`:         "1",
-		`{{- $d := dict "one" 1 "two" 222222 }}{{ omit $d "one" -}}`:               "map[two:222222]",
-		`{{- $d := dict "one" 1 "two" 222222 }}{{ omit $d "one" "two" | len -}}`:   "0",
-		`{{- $d := dict "one" 1 "two" 222222 }}{{ omit $d "two" "three" | len -}}`: "1",
-		`{{- $d := dict }}{{ omit $d "two" | len -}}`:                              "0",
-	}
-	for tpl, expect := range tests {
-		if err := runt(tpl, expect); err != nil {
-			t.Error(err)
-		}
-	}
-}
-
-func TestSet(t *testing.T) {
-	tpl := `{{- $d := dict "one" 1 "two" 222222 -}}
-	{{- $_ := set $d "two" 2 -}}
-	{{- $_ := set $d "three" 3 -}}
-	{{- if hasKey $d "one" -}}{{$d.one}}{{- end -}}
-	{{- if hasKey $d "two" -}}{{$d.two}}{{- end -}}
-	{{- if hasKey $d "three" -}}{{$d.three}}{{- end -}}
-	`
-
-	expect := "123"
-	if err := runt(tpl, expect); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestMerge(t *testing.T) {
-	dict := map[string]interface{}{
-		"src2": map[string]interface{}{
-			"h": 10,
-			"i": "i",
-			"j": "j",
-		},
-		"src1": map[string]interface{}{
-			"a": 1,
-			"b": 2,
-			"d": map[string]interface{}{
-				"e": "four",
-			},
-			"g": []int{6, 7},
-			"i": "aye",
-			"j": "jay",
-		},
-		"dst": map[string]interface{}{
-			"a": "one",
-			"c": 3,
-			"d": map[string]interface{}{
-				"f": 5,
-			},
-			"g": []int{8, 9},
-			"i": "eye",
-		},
-	}
-	tpl := `{{merge .dst .src1 .src2}}`
-	_, err := runRaw(tpl, dict)
-	if err != nil {
-		t.Error(err)
-	}
-	expected := map[string]interface{}{
-		"a": "one", // key overridden
-		"b": 2,     // merged from src1
-		"c": 3,     // merged from dst
-		"d": map[string]interface{}{ // deep merge
-			"e": "four",
-			"f": 5,
-		},
-		"g": []int{8, 9}, // overridden - arrays are not merged
-		"h": 10,          // merged from src2
-		"i": "eye",       // overridden twice
-		"j": "jay",       // overridden and merged
-	}
-	assert.Equal(t, expected, dict["dst"])
-}
--- a/vendor/github.com/Masterminds/sprig/docs/_config.yml
+++ b/vendor/github.com/Masterminds/sprig/docs/_config.yml
@@ -1 +0,0 @@
-theme: jekyll-theme-slate
--- a/vendor/github.com/Masterminds/sprig/docs/conversion.md
+++ b/vendor/github.com/Masterminds/sprig/docs/conversion.md
@@ -1,25 +0,0 @@
-# Type Conversion Functions
-
-The following type conversion functions are provided by Sprig:
-
- `atoi`: Convert a string to an integer
- `float64`: Convert to a float64
- `int`: Convert to an `int` at the system's width.
- `int64`: Convert to an `int64`
- `toString`: Convert to a string
- `toStrings`: Convert a list, slice, or array to a list of strings.
-
-Only `atoi` requires that the input be a specific type. The others will attempt
-to convert from any type to the destination type. For example, `int64` can convert
-floats to ints, and it can also convert strings to ints.
-
-## toStrings
-
-Given a list-like collection, produce a slice of strings.
-
-```
-list 1 2 3 | toStrings
-```
-
-The above converts `1` to `"1"`, `2` to `"2"`, and so on, and then returns
-them as a list.
--- a/vendor/github.com/Masterminds/sprig/docs/crypto.md
+++ b/vendor/github.com/Masterminds/sprig/docs/crypto.md
@@ -1,133 +0,0 @@
-# Cryptographic and Security Functions
-
-Sprig provides a couple of advanced cryptographic functions.
-
-## sha1sum
-
-The `sha1sum` function receives a string, and computes it's SHA1 digest.
-
-```
-sha1sum "Hello world!"
-```
-
-## sha256sum
-
-The `sha256sum` function receives a string, and computes it's SHA256 digest.
-
-```
-sha256sum "Hello world!"
-```
-
-The above will compute the SHA 256 sum in an "ASCII armored" format that is
-safe to print.
-
-## derivePassword
-
-The `derivePassword` function can be used to derive a specific password based on
-some shared "master password" constraints. The algorithm for this is
-[well specified](http://masterpasswordapp.com/algorithm.html).
-
-```
-derivePassword 1 "long" "password" "user" "example.com"
-```
-
-Note that it is considered insecure to store the parts directly in the template.
-
-## genPrivateKey
-
-The `genPrivateKey` function generates a new private key encoded into a PEM
-block.
-
-It takes one of the values for its first param:
-
- `ecdsa`: Generate an elyptical curve DSA key (P256)
- `dsa`: Generate a DSA key (L2048N256)
- `rsa`: Generate an RSA 4096 key
-
-## buildCustomCert
-
-The `buildCustomCert` function allows customizing the certificate.
-
-It takes the following string parameters:
-
- A base64 encoded PEM format certificate
- A base64 encoded PEM format private key
-
-It returns a certificate object with the following attributes:
-
- `Cert`: A PEM-encoded certificate
- `Key`: A PEM-encoded private key
-
-Example:
-
-```
-$ca := buildCustomCert "base64-encoded-ca-key" "base64-encoded-ca-crt"
-```
-
-Note that the returned object can be passed to the `genSignedCert` function
-to sign a certificate using this CA.
-
-## genCA
-
-The `genCA` function generates a new, self-signed x509 certificate authority.
-
-It takes the following parameters:
-
- Subject's common name (cn)
- Cert validity duration in days
-
-It returns an object with the following attributes:
-
- `Cert`: A PEM-encoded certificate
- `Key`: A PEM-encoded private key
-
-Example:
-
-```
-$ca := genCA "foo-ca" 365
-```
-
-Note that the returned object can be passed to the `genSignedCert` function
-to sign a certificate using this CA.
-
-## genSelfSignedCert
-
-The `genSelfSignedCert` function generates a new, self-signed x509 certificate.
-
-It takes the following parameters:
-
- Subject's common name (cn)
- Optional list of IPs; may be nil
- Optional list of alternate DNS names; may be nil
- Cert validity duration in days
-
-It returns an object with the following attributes:
-
- `Cert`: A PEM-encoded certificate
- `Key`: A PEM-encoded private key
-
-Example:
-
-```
-$cert := genSelfSignedCert "foo.com" (list "10.0.0.1" "10.0.0.2") (list "bar.com" "bat.com") 365
-```
-
-## genSignedCert
-
-The `genSignedCert` function generates a new, x509 certificate signed by the
-specified CA.
-
-It takes the following parameters:
-
- Subject's common name (cn)
- Optional list of IPs; may be nil
- Optional list of alternate DNS names; may be nil
- Cert validity duration in days
- CA (see `genCA`)
-
-Example:
-
-```
-$ca := genCA "foo-ca" 365
-$cert := genSignedCert "foo.com" (list "10.0.0.1" "10.0.0.2") (list "bar.com" "bat.com") 365 $ca
-```
--- a/vendor/github.com/Masterminds/sprig/docs/date.md
+++ b/vendor/github.com/Masterminds/sprig/docs/date.md
@@ -1,88 +0,0 @@
-# Date Functions
-
-## now
-
-The current date/time. Use this in conjunction with other date functions.
-
-
-## ago
-
-The `ago` function returns duration from time.Now in seconds resolution.
-
-```
-ago .CreatedAt"
-```
-returns in `time.Duration` String() format
-
-```
-2h34m7s
-```
-
-## date
-
-The `date` function formats a date.
-
-
-Format the date to YEAR-MONTH-DAY:
-```
-now | date "2006-01-02"
-```
-
-Date formatting in Go is a [little bit different](https://pauladamsmith.com/blog/2011/05/go_time.html).
-
-In short, take this as the base date:
-
-```
-Mon Jan 2 15:04:05 MST 2006
-```
-
-Write it in the format you want. Above, `2006-01-02` is the same date, but
-in the format we want.
-
-## dateInZone
-
-Same as `date`, but with a timezone.
-
-```
-date "2006-01-02" (now) "UTC"
-```
-
-## dateModify
-
-The `dateModify` takes a modification and a date and returns the timestamp.
-
-Subtract an hour and thirty minutes from the current time:
-
-```
-now | date_modify "-1.5h"
-```
-
-## htmlDate
-
-The `htmlDate` function formates a date for inserting into an HTML date picker
-input field.
-
-```
-now | htmlDate
-```
-
-## htmlDateInZone
-
-Same as htmlDate, but with a timezone.
-
-```
-htmlDate (now) "UTC"
-```
-
-## toDate
-
-`toDate` converts a string to a date. The first argument is the date layout and
-the second the date string. If the string can't be convert it returns the zero
-value.
-
-This is useful when you want to convert a string date to another format
-(using pipe). The example below converts "2017-12-31" to "31/12/2017".
-
-```
-toDate "2006-01-02" "2017-12-31" | date "02/01/2006"
-```
--- a/vendor/github.com/Masterminds/sprig/docs/defaults.md
+++ b/vendor/github.com/Masterminds/sprig/docs/defaults.md
@@ -1,113 +0,0 @@
-# Default Functions
-
-Sprig provides tools for setting default values for templates.
-
-## default
-
-To set a simple default value, use `default`:
-
-```
-default "foo" .Bar
-```
-
-In the above, if `.Bar` evaluates to a non-empty value, it will be used. But if
-it is empty, `foo` will be returned instead.
-
-The definition of "empty" depends on type:
-
- Numeric: 0
- String: ""
- Lists: `[]`
- Dicts: `{}`
- Boolean: `false`
- And always `nil` (aka null)
-
-For structs, there is no definition of empty, so a struct will never return the
-default.
-
-## empty
-
-The `empty` function returns `true` if the given value is considered empty, and
-`false` otherwise. The empty values are listed in the `default` section.
-
-```
-empty .Foo
-```
-
-Note that in Go template conditionals, emptiness is calculated for you. Thus,
-you rarely need `if empty .Foo`. Instead, just use `if .Foo`.
-
-## coalesce
-
-The `coalesce` function takes a list of values and returns the first non-empty
-one.
-
-```
-coalesce 0 1 2
-```
-
-The above returns `1`.
-
-This function is useful for scanning through multiple variables or values:
-
-```
-coalesce .name .parent.name "Matt"
-```
-
-The above will first check to see if `.name` is empty. If it is not, it will return
-that value. If it _is_ empty, `coalesce` will evaluate `.parent.name` for emptiness.
-Finally, if both `.name` and `.parent.name` are empty, it will return `Matt`.
-
-## toJson
-
-The `toJson` function encodes an item into a JSON string.
-
-```
-toJson .Item
-```
-
-The above returns JSON string representation of `.Item`.
-
-## toPrettyJson
-
-The `toPrettyJson` function encodes an item into a pretty (indented) JSON string.
-
-```
-toPrettyJson .Item
-```
-
-The above returns indented JSON string representation of `.Item`.
-
-## ternary
-
-The `ternary` function takes two values, and a test value. If the test value is
-true, the first value will be returned. If the test value is empty, the second
-value will be returned. This is similar to the c ternary operator.
-
-### true test value
-
-```
-ternary "foo" "bar" true
-```
-
-or
-
-```
-true | ternary "foo" "bar"
-```
-
-The above returns `"foo"`.
-
-### false test value
-
-```
-ternary "foo" "bar" false
-```
-
-or
-
-```
-false | ternary "foo" "bar"
-```
-
-The above returns `"bar"`.
--- a/vendor/github.com/Masterminds/sprig/docs/dicts.md
+++ b/vendor/github.com/Masterminds/sprig/docs/dicts.md
@@ -1,131 +0,0 @@
-# Dictionaries and Dict Functions
-
-Sprig provides a key/value storage type called a `dict` (short for "dictionary",
-as in Python). A `dict` is an _unorder_ type.
-
-The key to a dictionary **must be a string**. However, the value can be any
-type, even another `dict` or `list`.
-
-Unlike `list`s, `dict`s are not immutable. The `set` and `unset` functions will
-modify the contents of a dictionary.
-
-## dict
-
-Creating dictionaries is done by calling the `dict` function and passing it a
-list of pairs.
-
-The following creates a dictionary with three items:
-
-```
-$myDict := dict "name1" "value1" "name2" "value2" "name3" "value 3"
-```
-
-## set
-
-Use `set` to add a new key/value pair to a dictionary.
-
-```
-$_ := set $myDict "name4" "value4"
-```
-
-Note that `set` _returns the dictionary_ (a requirement of Go template functions),
-so you may need to trap the value as done above with the `$_` assignment.
-
-## unset
-
-Given a map and a key, delete the key from the map.
-
-```
-$_ := unset $myDict "name4"
-```
-
-As with `set`, this returns the dictionary.
-
-Note that if the key is not found, this operation will simply return. No error
-will be generated.
-
-## hasKey
-
-The `hasKey` function returns `true` if the given dict contains the given key.
-
-```
-hasKey $myDict "name1"
-```
-
-If the key is not found, this returns `false`.
-
-## pluck
-
-The `pluck` function makes it possible to give one key and multiple maps, and
-get a list of all of the matches:
-
-```
-pluck "name1" $myDict $myOtherDict
-```
-
-The above will return a `list` containing every found value (`[value1 otherValue1]`).
-
-If the give key is _not found_ in a map, that map will not have an item in the
-list (and the length of the returned list will be less than the number of dicts
-in the call to `pluck`.
-
-If the key is _found_ but the value is an empty value, that value will be
-inserted.
-
-A common idiom in Sprig templates is to uses `pluck... | first` to get the first
-matching key out of a collection of dictionaries.
-
-## merge
-
-Merge two or more dictionaries into one, giving precedence to the dest dictionary:
-
-```
-$newdict := merge $dest $source1 $source2
-```
-
-This is a deep merge operation.
-
-## keys
-
-The `keys` function will return a `list` of all of the keys in one or more `dict`
-types. Since a dictionary is _unordered_, the keys will not be in a predictable order.
-They can be sorted with `sortAlpha`.
-
-```
-keys $myDict | sortAlpha
-```
-
-When supplying multiple dictionaries, the keys will be concatenated. Use the `uniq`
-function along with `sortAlpha` to get a unqiue, sorted list of keys.
-
-```
-keys $myDict $myOtherDict | uniq | sortAlpha
-```
-
-## pick
-
-The `pick` function selects just the given keys out of a dictionary, creating a
-new `dict`.
-
-```
-$new := pick $myDict "name1" "name3"
-```
-
-The above returns `{name1: value1, name2: value2}`
-
-## omit
-
-The `omit` function is similar to `pick`, except it returns a new `dict` with all
-the keys that _do not_ match the given keys.
-
-```
-$new := omit $myDict "name1" "name3"
-```
-
-The above returns `{name2: value2}`
-
-## A Note on Dict Internals
-
-A `dict` is implemented in Go as a `map[string]interface{}`. Go developers can
-pass `map[string]interface{}` values into the context to make them available
-to templates as `dict`s.
--- a/vendor/github.com/Masterminds/sprig/docs/encoding.md
+++ b/vendor/github.com/Masterminds/sprig/docs/encoding.md
@@ -1,6 +0,0 @@
-# Encoding Functions
-
-Sprig has the following encoding and decoding functions:
-
- `b64enc`/`b64dec`: Encode or decode with Base64
- `b32enc`/`b32dec`: Encode or decode with Base32
--- a/vendor/github.com/Masterminds/sprig/docs/flow_control.md
+++ b/vendor/github.com/Masterminds/sprig/docs/flow_control.md
@@ -1,11 +0,0 @@
-# Flow Control Functions
-
-## fail
-
-Unconditionally returns an empty `string` and an `error` with the specified
-text. This is useful in scenarios where other conditionals have determined that
-template rendering should fail.
-
-```
-fail "Please accept the end user license agreement"
-```
--- a/vendor/github.com/Masterminds/sprig/docs/index.md
+++ b/vendor/github.com/Masterminds/sprig/docs/index.md
@@ -1,23 +0,0 @@
-# Sprig Function Documentation
-
-The Sprig library provides over 70 template functions for Go's template language.
-
- [String Functions](strings.md): `trim`, `wrap`, `randAlpha`, `plural`, etc.
-  - [String List Functions](string_slice.md): `splitList`, `sortAlpha`, etc.
- [Math Functions](math.md): `add`, `max`, `mul`, etc.
-  - [Integer Slice Functions](integer_slice.md): `until`, `untilStep`
- [Date Functions](date.md): `now`, `date`, etc.
- [Defaults Functions](defaults.md): `default`, `empty`, `coalesce`, `toJson`, `toPrettyJson`
- [Encoding Functions](encoding.md): `b64enc`, `b64dec`, etc.
- [Lists and List Functions](lists.md): `list`, `first`, `uniq`, etc.
- [Dictionaries and Dict Functions](dicts.md): `dict`, `hasKey`, `pluck`, etc.
- [Type Conversion Functions](conversion.md): `atoi`, `int64`, `toString`, etc.
- [File Path Functions](paths.md): `base`, `dir`, `ext`, `clean`, `isAbs`
- [Flow Control Functions](flow_control.md): `fail`
- Advanced Functions
-  - [UUID Functions](uuid.md): `uuidv4`
-  - [OS Functions](os.md): `env`, `expandenv`
-  - [Version Comparison Functions](semver.md): `semver`, `semverCompare`
-  - [Reflection](reflection.md): `typeOf`, `kindIs`, `typeIsLike`, etc.
-  - [Cryptographic and Security Functions](crypto.md): `derivePassword`, `sha256sum`, `genPrivateKey`
-
--- a/vendor/github.com/Masterminds/sprig/docs/integer_slice.md
+++ b/vendor/github.com/Masterminds/sprig/docs/integer_slice.md
@@ -1,25 +0,0 @@
-# Integer Slice Functions
-
-## until
-
-The `until` function builds a range of integers.
-
-```
-until 5
-```
-
-The above generates the list `[0, 1, 2, 3, 4]`.
-
-This is useful for looping with `range $i, $e := until 5`.
-
-## untilStep
-
-Like `until`, `untilStep` generates a list of counting integers. But it allows
-you to define a start, stop, and step:
-
-```
-untilStep 3 6 2
-```
-
-The above will produce `[3 5]` by starting with 3, and adding 2 until it is equal
-or greater than 6. This is similar to Python's `range` function.
--- a/vendor/github.com/Masterminds/sprig/docs/lists.md
+++ b/vendor/github.com/Masterminds/sprig/docs/lists.md
@@ -1,111 +0,0 @@
-# Lists and List Functions
-
-Sprig provides a simple `list` type that can contain arbitrary sequential lists
-of data. This is similar to arrays or slices, but lists are designed to be used
-as immutable data types.
-
-Create a list of integers:
-
-```
-$myList := list 1 2 3 4 5
-```
-
-The above creates a list of `[1 2 3 4 5]`.
-
-## first
-
-To get the head item on a list, use `first`.
-
-`first $myList` returns `1`
-
-## rest
-
-To get the tail of the list (everything but the first item), use `rest`.
-
-`rest $myList` returns `[2 3 4 5]`
-
-## last
-
-To get the last item on a list, use `last`:
-
-`last $myList` returns `5`. This is roughly analogous to reversing a list and
-then calling `first`.
-
-## initial
-
-This compliments `last` by returning all _but_ the last element.
-`initial $myList` returns `[1 2 3 4]`.
-
-## append
-
-Append a new item to an existing list, creating a new list.
-
-```
-$new = append $myList 6
-```
-
-The above would set `$new` to `[1 2 3 4 5 6]`. `$myList` would remain unaltered.
-
-## prepend
-
-Push an alement onto the front of a list, creating a new list.
-
-```
-prepend $myList 0
-```
-
-The above would produce `[0 1 2 3 4 5]`. `$myList` would remain unaltered.
-
-## reverse
-
-Produce a new list with the reversed elements of the given list.
-
-```
-reverse $myList
-```
-
-The above would generate the list `[5 4 3 2 1]`.
-
-## uniq
-
-Generate a list with all of the duplicates removed.
-
-```
-list 1 1 1 2 | uniq
-```
-
-The above would produce `[1 2]`
-
-## without
-
-The `without` function filters items out of a list.
-
-```
-without $myList 3
-```
-
-The above would produce `[1 2 4 5]`
-
-Without can take more than one filter:
-
-```
-without $myList 1 3 5
-```
-
-That would produce `[2 4]`
-
-##  has
-
-Test to see if a list has a particular element.
-
-```
-has $myList 4
-```
-
-The above would return `true`, while `has $myList "hello"` would return false.
-
-## A Note on List Internals
-
-A list is implemented in Go as a `[]interface{}`. For Go developers embedding
-Sprig, you may pass `[]interface{}` items into your template context and be
-able to use all of the `list` functions on those items.
--- a/vendor/github.com/Masterminds/sprig/docs/math.md
+++ b/vendor/github.com/Masterminds/sprig/docs/math.md
@@ -1,63 +0,0 @@
-# Math Functions
-
-All math functions operate on `int64` values unless specified otherwise.
-
-(In the future, these will be extended to handle floats as well)
-
-## add
-
-Sum numbers with `add`
-
-## add1
-
-To increment by 1, use `add1`
-
-## sub
-
-To subtract, use `sub`
-
-## div
-
-Perform integer division with `div`
-
-## mod
-
-Modulo with `mod`
-
-## mul
-
-Multiply with `mul`
-
-## max
-
-Return the largest of a series of integers:
-
-This will return `3`:
-
-```
-max 1 2 3
-```
-
-## min
-
-Return the smallest of a series of integers.
-
-`min 1 2 3` will return `1`.
-
-## floor
-
-Returns the greatest float value less than or equal to input value
-
-`floor 123.9999` will return `123.0`
-
-## ceil
-
-Returns the greatest float value greater than or equal to input value
-
-`ceil 123.001` will return `124.0`
-
-## round
-
-Returns a float value with the remainder rounded to the given number to digits after the decimal point.
-
-`round 123.555555` will return `123.556`
--- a/vendor/github.com/Masterminds/sprig/docs/os.md
+++ b/vendor/github.com/Masterminds/sprig/docs/os.md
@@ -1,24 +0,0 @@
-# OS Functions
-
-_WARNING:_ These functions can lead to information leakage if not used
-appropriately.
-
-_WARNING:_ Some notable implementations of Sprig (such as 
-[Kubernetes Helm](http://helm.sh) _do not provide these functions for security
-reasons_.
-
-## env
-
-The `env` function reads an environment variable:
-
-```
-env "HOME"
-```
-
-## expandenv
-
-To substitute environment variables in a string, use `expandenv`:
-
-```
-expandenv "Your path is set to $PATH"
-```
--- a/vendor/github.com/Masterminds/sprig/docs/paths.md
+++ b/vendor/github.com/Masterminds/sprig/docs/paths.md
@@ -1,43 +0,0 @@
-# File Path Functions
-
-While Sprig does not grant access to the filesystem, it does provide functions
-for working with strings that follow file path conventions.
-
-# base
-
-Return the last element of a path.
-
-```
-base "foo/bar/baz"
-```
-
-The above prints "baz"
-
-# dir
-
-Return the directory, stripping the last part of the path. So `dir "foo/bar/baz"`
-returns `foo/bar`
-
-# clean
-
-Clean up a path.
-
-```
-clean "foo/bar/../baz"
-```
-
-The above resolves the `..` and returns `foo/baz`
-
-# ext
-
-Return the file extension.
-
-```
-ext "foo.bar"
-```
-
-The above returns `.bar`.
-
-# isAbs
-
-To check whether a file path is absolute, use `isAbs`.
--- a/vendor/github.com/Masterminds/sprig/docs/reflection.md
+++ b/vendor/github.com/Masterminds/sprig/docs/reflection.md
@@ -1,38 +0,0 @@
-# Reflection Functions
-
-Sprig provides rudimentary reflection tools. These help advanced template
-developers understand the underlying Go type information for a particular value.
-
-Go has several primitive _kinds_, like `string`, `slice`, `int64`, and `bool`.
-
-Go has an open _type_ system that allows developers to create their own types.
-
-Sprig provides a set of functions for each.
-
-## Kind Functions
-
-There are two Kind functions: `kindOf` returns the kind of an object.
-
-```
-kindOf "hello"
-```
-
-The above would return `string`. For simple tests (like in `if` blocks), the
-`isKind` function will let you verify that a value is a particular kind:
-
-```
-kindIs "int" 123
-```
-
-The above will return `true`
-
-## Type Functions
-
-Types are slightly harder to work with, so there are three different functions:
-
- `typeOf` returns the underlying type of a value: `typeOf $foo`
- `typeIs` is like `kindIs`, but for types: `typeIs "*io.Buffer" $myVal`
- `typeIsLike` works as `kindIs`, except that it also dereferences pointers.
-
-**Note:** None of these can test whether or not something implements a given
-interface, since doing so would require compiling the interface in ahead of time.
--- a/vendor/github.com/Masterminds/sprig/docs/semver.md
+++ b/vendor/github.com/Masterminds/sprig/docs/semver.md
@@ -1,124 +0,0 @@
-# Semantic Version Functions
-
-Some version schemes are easily parseable and comparable. Sprig provides functions
-for working with [SemVer 2](http://semver.org) versions.
-
-## semver
-
-The `semver` function parses a string into a Semantic Version:
-
-```
-$version := semver "1.2.3-alpha.1+123"
-```
-
-_If the parser fails, it will cause template execution to halt with an error._
-
-At this point, `$version` is a pointer to a `Version` object with the following
-properties:
-
- `$version.Major`: The major number (`1` above)
- `$version.Minor`: The minor number (`2` above)
- `$version.Patch`: The patch number (`3` above)
- `$version.Prerelease`: The prerelease (`alpha.1` above)
- `$version.Metadata`: The build metadata (`123` above)
- `$version.Original`: The original version as a string
-
-Additionally, you can compare a `Version` to another `version` using the `Compare`
-function:
-
-```
-semver "1.4.3" | (semver "1.2.3").Compare
-```
-
-The above will return `-1`.
-
-The return values are:
-
- `-1` if the given semver is greater than the semver whose `Compare` method was called
- `1` if the version who's `Compare` function was called is greater.
- `0` if they are the same version
-
-(Note that in SemVer, the `Metadata` field is not compared during version
-comparison operations.)
-
-
-## semverCompare
-
-A more robust comparison function is provided as `semverCompare`. This version
-supports version ranges:
-
- `semverCompare "1.2.3" "1.2.3"` checks for an exact match
- `semverCompare "^1.2.0" "1.2.3"` checks that the major and minor versions match, and that the patch 
-  number of the second version is _greater than or equal to_ the first parameter.
-
-The SemVer functions use the [Masterminds semver library](https://github.com/Masterminds/semver),
-from the creators of Sprig.
-
-
-## Basic Comparisons
-
-There are two elements to the comparisons. First, a comparison string is a list
-of comma separated and comparisons. These are then separated by || separated or
-comparisons. For example, `">= 1.2, < 3.0.0 || >= 4.2.3"` is looking for a
-comparison that's greater than or equal to 1.2 and less than 3.0.0 or is
-greater than or equal to 4.2.3.
-
-The basic comparisons are:
-
-* `=`: equal (aliased to no operator)
-* `!=`: not equal
-* `>`: greater than
-* `<`: less than
-* `>=`: greater than or equal to
-* `<=`: less than or equal to
-
-_Note, according to the Semantic Version specification pre-releases may not be
-API compliant with their release counterpart. It says,_
-
-> _A pre-release version indicates that the version is unstable and might not satisfy the intended compatibility requirements as denoted by its associated normal version._
-
-_SemVer comparisons without a pre-release value will skip pre-release versions.
-For example, `>1.2.3` will skip pre-releases when looking at a list of values
-while `>1.2.3-alpha.1` will evaluate pre-releases._
-
-## Hyphen Range Comparisons
-
-There are multiple methods to handle ranges and the first is hyphens ranges.
-These look like:
-
-* `1.2 - 1.4.5` which is equivalent to `>= 1.2, <= 1.4.5`
-* `2.3.4 - 4.5` which is equivalent to `>= 2.3.4, <= 4.5`
-
-## Wildcards In Comparisons
-
-The `x`, `X`, and `*` characters can be used as a wildcard character. This works
-for all comparison operators. When used on the `=` operator it falls
-back to the pack level comparison (see tilde below). For example,
-
-* `1.2.x` is equivalent to `>= 1.2.0, < 1.3.0`
-* `>= 1.2.x` is equivalent to `>= 1.2.0`
-* `<= 2.x` is equivalent to `<= 3`
-* `*` is equivalent to `>= 0.0.0`
-
-## Tilde Range Comparisons (Patch)
-
-The tilde (`~`) comparison operator is for patch level ranges when a minor
-version is specified and major level changes when the minor number is missing.
-For example,
-
-* `~1.2.3` is equivalent to `>= 1.2.3, < 1.3.0`
-* `~1` is equivalent to `>= 1, < 2`
-* `~2.3` is equivalent to `>= 2.3, < 2.4`
-* `~1.2.x` is equivalent to `>= 1.2.0, < 1.3.0`
-* `~1.x` is equivalent to `>= 1, < 2`
-
-## Caret Range Comparisons (Major)
-
-The caret (`^`) comparison operator is for major level changes. This is useful
-when comparisons of API versions as a major change is API breaking. For example,
-
-* `^1.2.3` is equivalent to `>= 1.2.3, < 2.0.0`
-* `^1.2.x` is equivalent to `>= 1.2.0, < 2.0.0`
-* `^2.3` is equivalent to `>= 2.3, < 3`
-* `^2.x` is equivalent to `>= 2.0.0, < 3`
-
--- a/vendor/github.com/Masterminds/sprig/docs/string_slice.md
+++ b/vendor/github.com/Masterminds/sprig/docs/string_slice.md
@@ -1,55 +0,0 @@
-# String Slice Functions
-
-These function operate on or generate slices of strings. In Go, a slice is a
-growable array. In Sprig, it's a special case of a `list`.
-
-## join
-
-Join a list of strings into a single string, with the given separator.
-
-```
-list "hello" "world" | join "_"
-```
-
-The above will produce `hello_world`
-
-`join` will try to convert non-strings to a string value:
-
-```
-list 1 2 3 | join "+"
-```
-
-The above will produce `1+2+3`
-
-## splitList and split
-
-Split a string into a list of strings:
-
-```
-splitList "$" "foo$bar$baz"
-```
-
-The above will return `[foo bar baz]`
-
-The older `split` function splits a string into a `dict`. It is designed to make
-it easy to use template dot notation for accessing members:
-
-```
-$a := split "$" "foo$bar$baz"
-```
-
-The above produces a map with index keys. `{_0: foo, _1: bar, _2: baz}`
-
-```
-$a._0
-```
-
-The above produces `foo`
-
-## sortAlpha
-
-The `sortAlpha` function sorts a list of strings into alphabetical (lexicographical)
-order.
-
-It does _not_ sort in place, but returns a sorted copy of the list, in keeping
-with the immutability of lists.
--- a/vendor/github.com/Masterminds/sprig/docs/strings.md
+++ b/vendor/github.com/Masterminds/sprig/docs/strings.md
@@ -1,397 +0,0 @@
-# String Functions
-
-Sprig has a number of string manipulation functions.
-
-## trim
-
-The `trim` function removes space from either side of a string:
-
-```
-trim "   hello    "
-```
-
-The above produces `hello`
-
-## trimAll
-
-Remove given characters from the front or back of a string:
-
-```
-trimAll "$" "$5.00"
-```
-
-The above returns `5.00` (as a string).
-
-## trimSuffix
-
-Trim just the suffix from a string:
-
-```
-trimSuffix "-" "hello-"
-```
-
-The above returns `hello`
-
-## upper
-
-Convert the entire string to uppercase:
-
-```
-upper "hello"
-```
-
-The above returns `HELLO`
-
-## lower
-
-Convert the entire string to lowercase:
-
-```
-lower "HELLO"
-```
-
-The above returns `hello`
-
-## title
-
-Convert to title case:
-
-```
-title "hello world"
-```
-
-The above returns `Hello World`
-
-## untitle
-
-Remove title casing. `untitle "Hello World"` produces `hello world`.
-
-## repeat
-
-Repeat a string multiple times:
-
-```
-repeat 3 "hello"
-```
-
-The above returns `hellohellohello`
-
-## substr
-
-Get a substring from a string. It takes three parameters:
-
- start (int)
- length (int)
- string (string)
-
-```
-substr 0 5 "hello world"
-```
-
-The above returns `hello`
-
-## nospace
-
-Remove all whitespace from a string.
-
-```
-nospace "hello w o r l d"
-```
-
-The above returns `helloworld`
-
-## trunc
-
-Truncate a string (and add no suffix)
-
-```
-trunc 5 "hello world"
-```
-
-The above produces `hello`.
-
-## abbrev
-
-Truncate a string with ellipses (`...`)
-
-Parameters: 
- max length
- the string
-
-```
-abbrev 5 "hello world"
-```
-
-The above returns `he...`, since it counts the width of the ellipses against the
-maximum length.
-
-## abbrevboth
-
-Abbreviate both sides:
-
-```
-abbrevboth 5 10 "1234 5678 9123"
-```
-
-the above produces `...5678...`
-
-It takes:
-
- left offset
- max length
- the string
-
-## initials
-
-Given multiple words, take the first letter of each word and combine.
-
-```
-initials "First Try"
-```
-
-The above returns `FT`
-
-## randAlphaNum, randAlpha, randNumeric, and randAscii
-
-These four functions generate random strings, but with different base character
-sets:
-
- `randAlphaNum` uses `0-9a-zA-Z`
- `randAlpha` uses `a-zA-Z`
- `randNumeric` uses `0-9`
- `randAscii` uses all printable ASCII characters
-
-Each of them takes one parameter: the integer length of the string.
-
-```
-randNumeric 3
-```
-
-The above will produce a random string with three digits.
-
-## wrap
-
-Wrap text at a given column count:
-
-```
-wrap 80 $someText
-```
-
-The above will wrap the string in `$someText` at 80 columns.
-
-## wrapWith
-
-`wrapWith` works as `wrap`, but lets you specify the string to wrap with.
-(`wrap` uses `\n`)
-
-```
-wrapWith 5 "\t" "Hello World"
-```
-
-The above produces `hello world` (where the whitespace is an ASCII tab
-character)
-
-## contains
-
-Test to see if one string is contained inside of another:
-
-```
-contains "cat" "catch"
-```
-
-The above returns `true` because `catch` contains `cat`.
-
-## hasPrefix and hasSuffix
-
-The `hasPrefix` and `hasSuffix` functions test whether a string has a given
-prefix or suffix:
-
-```
-hasPrefix "cat" "catch"
-```
-
-The above returns `true` because `catch` has the prefix `cat`.
-
-## quote and squote
-
-These functions wrap a string in double quotes (`quote`) or single quotes
-(`squote`).
-
-## cat
-
-The `cat` function concatenates multiple strings together into one, separating
-them with spaces:
-
-```
-cat "hello" "beautiful" "world"
-```
-
-The above produces `hello beautiful world`
-
-## indent
-
-The `indent` function indents every line in a given string to the specified
-indent width. This is useful when aligning multi-line strings:
-
-```
-indent 4 $lots_of_text
-```
-
-The above will indent every line of text by 4 space characters.
-
-## nindent
-
-The `nindent` function is the same as the indent function, but prepends a new
-line to the beginning of the string.
-
-```
-nindent 4 $lots_of_text
-```
-
-The above will indent every line of text by 4 space characters and add a new
-line to the beginning.
-
-## replace
-
-Perform simple string replacement.
-
-It takes three arguments:
-
- string to replace
- string to replace with
- source string
-
-```
-"I Am Henry VIII" | replace " " "-"
-```
-
-The above will produce `I-Am-Henry-VIII`
-
-## plural
-
-Pluralize a string.
-
-```
-len $fish | plural "one anchovy" "many anchovies"
-```
-
-In the above, if the length of the string is 1, the first argument will be
-printed (`one anchovy`). Otherwise, the second argument will be printed 
-(`many anchovies`).
-
-The arguments are:
-
- singular string
- plural string
- length integer
-
-NOTE: Sprig does not currently support languages with more complex pluralization
-rules. And `0` is considered a plural because the English language treats it
-as such (`zero anchovies`). The Sprig developers are working on a solution for
-better internationalization.
-
-## snakecase
-
-Convert string from camelCase to snake_case.
-
-Introduced in 2.12.0.
-
-```
-snakecase "FirstName"
-```
-
-This above will produce `first_name`.
-
-## camelcase
-
-Convert string from snake_case to CamelCase
-
-Introduced in 2.12.0.
-
-```
-camelcase "http_server"
-```
-
-This above will produce `HttpServer`.
-
-## shuffle
-
-Shuffle a string.
-
-Introduced in 2.12.0.
-
-
-```
-shuffle "hello"
-```
-
-The above will randomize the letters in `hello`, perhaps producing `oelhl`.
-
-## regexMatch
-
-Returns true if the input string mratches the regular expression.
-
-```
-regexMatch "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}" "test@acme.com"
-```
-
-The above produces `true`
-
-## regexFindAll
-
-Returns a slice of all matches of the regular expression in the input string
-
-```
-regexFindAll "[2,4,6,8]" "123456789 
-```
-
-The above produces `[2 4 6 8]`
-
-## regexFind
-
-Return the first (left most) match of the regular expression in the input string
-
-```
-regexFind "[a-zA-Z][1-9]" "abcd1234"
-```
-
-The above produces `d1`
-
-## regexReplaceAll
-
-Returns a copy of the input string, replacing matches of the Regexp with the replacement string replacement.
-Inside string replacement, $ signs are interpreted as in Expand, so for instance $1 represents the text of the first submatch
-
-```
-regexReplaceAll "a(x*)b" "-ab-axxb-" "${1}W"
-```
-
-The above produces `-W-xxW-`
-
-## regexReplaceAllLiteral
-
-Returns a copy of the input string, replacing matches of the Regexp with the replacement string replacement
-The replacement string is substituted directly, without using Expand
-
-```
-regexReplaceAllLiteral "a(x*)b" "-ab-axxb-" "${1}"
-```
-
-The above produces `-${1}-${1}-`
-
-## regexSplit
-
-Slices the input string into substrings separated by the expression and returns a slice of the substrings between those expression matches. The last parameter `n` determines the number of substrings to return, where `-1` means return all matches
-
-```
-regexSplit "z+" "pizza" -1
-```
-
-The above produces `[pi a]`
-
-## See Also...
-
-The [Conversion Functions](conversion.html) contain functions for converting
-strings. The [String Slice Functions](string_slice.html) contains functions
-for working with an array of strings.
-
--- a/vendor/github.com/Masterminds/sprig/docs/uuid.md
+++ b/vendor/github.com/Masterminds/sprig/docs/uuid.md
@@ -1,9 +0,0 @@
-# UUID Functions
-
-Sprig can generate UUID v4 universally unique IDs.
-
-```
-uuidv4
-```
-
-The above returns a new UUID of the v4 (randomly generated) type.
--- a/vendor/github.com/Masterminds/sprig/example_test.go
+++ b/vendor/github.com/Masterminds/sprig/example_test.go
@@ -1,25 +0,0 @@
-package sprig
-
-import (
-	"fmt"
-	"os"
-	"text/template"
-)
-
-func Example() {
-	// Set up variables and template.
-	vars := map[string]interface{}{"Name": "  John Jacob Jingleheimer Schmidt "}
-	tpl := `Hello {{.Name | trim | lower}}`
-
-	// Get the Sprig function map.
-	fmap := TxtFuncMap()
-	t := template.Must(template.New("test").Funcs(fmap).Parse(tpl))
-
-	err := t.Execute(os.Stdout, vars)
-	if err != nil {
-		fmt.Printf("Error during template execution: %s", err)
-		return
-	}
-	// Output:
-	// Hello john jacob jingleheimer schmidt
-}
--- a/vendor/github.com/Masterminds/sprig/flow_control_test.go
+++ b/vendor/github.com/Masterminds/sprig/flow_control_test.go
@@ -1,16 +0,0 @@
-package sprig
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestFail(t *testing.T) {
-	const msg = "This is an error!"
-	tpl := fmt.Sprintf(`{{fail "%s"}}`, msg)
-	_, err := runRaw(tpl, nil)
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), msg)
-}
--- a/vendor/github.com/Masterminds/sprig/functions_test.go
+++ b/vendor/github.com/Masterminds/sprig/functions_test.go
@@ -1,108 +0,0 @@
-package sprig
-
-import (
-	"bytes"
-	"fmt"
-	"math/rand"
-	"os"
-	"testing"
-	"text/template"
-
-	"github.com/aokoli/goutils"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestEnv(t *testing.T) {
-	os.Setenv("FOO", "bar")
-	tpl := `{{env "FOO"}}`
-	if err := runt(tpl, "bar"); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestExpandEnv(t *testing.T) {
-	os.Setenv("FOO", "bar")
-	tpl := `{{expandenv "Hello $FOO"}}`
-	if err := runt(tpl, "Hello bar"); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestBase(t *testing.T) {
-	assert.NoError(t, runt(`{{ base "foo/bar" }}`, "bar"))
-}
-
-func TestDir(t *testing.T) {
-	assert.NoError(t, runt(`{{ dir "foo/bar/baz" }}`, "foo/bar"))
-}
-
-func TestIsAbs(t *testing.T) {
-	assert.NoError(t, runt(`{{ isAbs "/foo" }}`, "true"))
-	assert.NoError(t, runt(`{{ isAbs "foo" }}`, "false"))
-}
-
-func TestClean(t *testing.T) {
-	assert.NoError(t, runt(`{{ clean "/foo/../foo/../bar" }}`, "/bar"))
-}
-
-func TestExt(t *testing.T) {
-	assert.NoError(t, runt(`{{ ext "/foo/bar/baz.txt" }}`, ".txt"))
-}
-
-func TestSnakeCase(t *testing.T) {
-	assert.NoError(t, runt(`{{ snakecase "FirstName" }}`, "first_name"))
-	assert.NoError(t, runt(`{{ snakecase "HTTPServer" }}`, "http_server"))
-	assert.NoError(t, runt(`{{ snakecase "NoHTTPS" }}`, "no_https"))
-	assert.NoError(t, runt(`{{ snakecase "GO_PATH" }}`, "go_path"))
-	assert.NoError(t, runt(`{{ snakecase "GO PATH" }}`, "go_path"))
-	assert.NoError(t, runt(`{{ snakecase "GO-PATH" }}`, "go_path"))
-}
-
-func TestCamelCase(t *testing.T) {
-	assert.NoError(t, runt(`{{ camelcase "http_server" }}`, "HttpServer"))
-	assert.NoError(t, runt(`{{ camelcase "_camel_case" }}`, "_CamelCase"))
-	assert.NoError(t, runt(`{{ camelcase "no_https" }}`, "NoHttps"))
-	assert.NoError(t, runt(`{{ camelcase "_complex__case_" }}`, "_Complex_Case_"))
-	assert.NoError(t, runt(`{{ camelcase "all" }}`, "All"))
-}
-
-func TestShuffle(t *testing.T) {
-	goutils.RANDOM = rand.New(rand.NewSource(1))
-	// Because we're using a random number generator, we need these to go in
-	// a predictable sequence:
-	assert.NoError(t, runt(`{{ shuffle "Hello World" }}`, "rldo HWlloe"))
-}
-
-// runt runs a template and checks that the output exactly matches the expected string.
-func runt(tpl, expect string) error {
-	return runtv(tpl, expect, map[string]string{})
-}
-
-// runtv takes a template, and expected return, and values for substitution.
-//
-// It runs the template and verifies that the output is an exact match.
-func runtv(tpl, expect string, vars interface{}) error {
-	fmap := TxtFuncMap()
-	t := template.Must(template.New("test").Funcs(fmap).Parse(tpl))
-	var b bytes.Buffer
-	err := t.Execute(&b, vars)
-	if err != nil {
-		return err
-	}
-	if expect != b.String() {
-		return fmt.Errorf("Expected '%s', got '%s'", expect, b.String())
-	}
-	return nil
-}
-
-// runRaw runs a template with the given variables and returns the result.
-func runRaw(tpl string, vars interface{}) (string, error) {
-	fmap := TxtFuncMap()
-	t := template.Must(template.New("test").Funcs(fmap).Parse(tpl))
-	var b bytes.Buffer
-	err := t.Execute(&b, vars)
-	if err != nil {
-		return "", err
-	}
-	return b.String(), nil
-}
--- a/vendor/github.com/Masterminds/sprig/list_test.go
+++ b/vendor/github.com/Masterminds/sprig/list_test.go
@@ -1,157 +0,0 @@
-package sprig
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestTuple(t *testing.T) {
-	tpl := `{{$t := tuple 1 "a" "foo"}}{{index $t 2}}{{index $t 0 }}{{index $t 1}}`
-	if err := runt(tpl, "foo1a"); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestList(t *testing.T) {
-	tpl := `{{$t := list 1 "a" "foo"}}{{index $t 2}}{{index $t 0 }}{{index $t 1}}`
-	if err := runt(tpl, "foo1a"); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestPush(t *testing.T) {
-	// Named `append` in the function map
-	tests := map[string]string{
-		`{{ $t := tuple 1 2 3  }}{{ append $t 4 | len }}`:                             "4",
-		`{{ $t := tuple 1 2 3 4  }}{{ append $t 5 | join "-" }}`:                      "1-2-3-4-5",
-		`{{ $t := regexSplit "/" "foo/bar/baz" -1 }}{{ append $t "qux" | join "-" }}`: "foo-bar-baz-qux",
-	}
-	for tpl, expect := range tests {
-		assert.NoError(t, runt(tpl, expect))
-	}
-}
-func TestPrepend(t *testing.T) {
-	tests := map[string]string{
-		`{{ $t := tuple 1 2 3  }}{{ prepend $t 0 | len }}`:                             "4",
-		`{{ $t := tuple 1 2 3 4  }}{{ prepend $t 0 | join "-" }}`:                      "0-1-2-3-4",
-		`{{ $t := regexSplit "/" "foo/bar/baz" -1 }}{{ prepend $t "qux" | join "-" }}`: "qux-foo-bar-baz",
-	}
-	for tpl, expect := range tests {
-		assert.NoError(t, runt(tpl, expect))
-	}
-}
-
-func TestFirst(t *testing.T) {
-	tests := map[string]string{
-		`{{ list 1 2 3 | first }}`:                          "1",
-		`{{ list | first }}`:                                "<no value>",
-		`{{ regexSplit "/src/" "foo/src/bar" -1 | first }}`: "foo",
-	}
-	for tpl, expect := range tests {
-		assert.NoError(t, runt(tpl, expect))
-	}
-}
-func TestLast(t *testing.T) {
-	tests := map[string]string{
-		`{{ list 1 2 3 | last }}`:                          "3",
-		`{{ list | last }}`:                                "<no value>",
-		`{{ regexSplit "/src/" "foo/src/bar" -1 | last }}`: "bar",
-	}
-	for tpl, expect := range tests {
-		assert.NoError(t, runt(tpl, expect))
-	}
-}
-
-func TestInitial(t *testing.T) {
-	tests := map[string]string{
-		`{{ list 1 2 3 | initial | len }}`:                "2",
-		`{{ list 1 2 3 | initial | last }}`:               "2",
-		`{{ list 1 2 3 | initial | first }}`:              "1",
-		`{{ list | initial }}`:                            "[]",
-		`{{ regexSplit "/" "foo/bar/baz" -1 | initial }}`: "[foo bar]",
-	}
-	for tpl, expect := range tests {
-		assert.NoError(t, runt(tpl, expect))
-	}
-}
-
-func TestRest(t *testing.T) {
-	tests := map[string]string{
-		`{{ list 1 2 3 | rest | len }}`:                "2",
-		`{{ list 1 2 3 | rest | last }}`:               "3",
-		`{{ list 1 2 3 | rest | first }}`:              "2",
-		`{{ list | rest }}`:                            "[]",
-		`{{ regexSplit "/" "foo/bar/baz" -1 | rest }}`: "[bar baz]",
-	}
-	for tpl, expect := range tests {
-		assert.NoError(t, runt(tpl, expect))
-	}
-}
-
-func TestReverse(t *testing.T) {
-	tests := map[string]string{
-		`{{ list 1 2 3 | reverse | first }}`:              "3",
-		`{{ list 1 2 3 | reverse | rest | first }}`:       "2",
-		`{{ list 1 2 3 | reverse | last }}`:               "1",
-		`{{ list 1 2 3 4 | reverse }}`:                    "[4 3 2 1]",
-		`{{ list 1 | reverse }}`:                          "[1]",
-		`{{ list | reverse }}`:                            "[]",
-		`{{ regexSplit "/" "foo/bar/baz" -1 | reverse }}`: "[baz bar foo]",
-	}
-	for tpl, expect := range tests {
-		assert.NoError(t, runt(tpl, expect))
-	}
-}
-
-func TestCompact(t *testing.T) {
-	tests := map[string]string{
-		`{{ list 1 0 "" "hello" | compact }}`:          `[1 hello]`,
-		`{{ list "" "" | compact }}`:                   `[]`,
-		`{{ list | compact }}`:                         `[]`,
-		`{{ regexSplit "/" "foo//bar" -1 | compact }}`: "[foo bar]",
-	}
-	for tpl, expect := range tests {
-		assert.NoError(t, runt(tpl, expect))
-	}
-}
-
-func TestUniq(t *testing.T) {
-	tests := map[string]string{
-		`{{ list 1 2 3 4 | uniq }}`:                    `[1 2 3 4]`,
-		`{{ list "a" "b" "c" "d" | uniq }}`:            `[a b c d]`,
-		`{{ list 1 1 1 1 2 2 2 2 | uniq }}`:            `[1 2]`,
-		`{{ list "foo" 1 1 1 1 "foo" "foo" | uniq }}`:  `[foo 1]`,
-		`{{ list | uniq }}`:                            `[]`,
-		`{{ regexSplit "/" "foo/foo/bar" -1 | uniq }}`: "[foo bar]",
-	}
-	for tpl, expect := range tests {
-		assert.NoError(t, runt(tpl, expect))
-	}
-}
-
-func TestWithout(t *testing.T) {
-	tests := map[string]string{
-		`{{ without (list 1 2 3 4) 1 }}`:                         `[2 3 4]`,
-		`{{ without (list "a" "b" "c" "d") "a" }}`:               `[b c d]`,
-		`{{ without (list 1 1 1 1 2) 1 }}`:                       `[2]`,
-		`{{ without (list) 1 }}`:                                 `[]`,
-		`{{ without (list 1 2 3) }}`:                             `[1 2 3]`,
-		`{{ without list }}`:                                     `[]`,
-		`{{ without (regexSplit "/" "foo/bar/baz" -1 ) "foo" }}`: "[bar baz]",
-	}
-	for tpl, expect := range tests {
-		assert.NoError(t, runt(tpl, expect))
-	}
-}
-
-func TestHas(t *testing.T) {
-	tests := map[string]string{
-		`{{ list 1 2 3 | has 1 }}`:                          `true`,
-		`{{ list 1 2 3 | has 4 }}`:                          `false`,
-		`{{ regexSplit "/" "foo/bar/baz" -1 | has "bar" }}`: `true`,
-	}
-	for tpl, expect := range tests {
-		assert.NoError(t, runt(tpl, expect))
-	}
-}
--- a/vendor/github.com/Masterminds/sprig/numeric_test.go
+++ b/vendor/github.com/Masterminds/sprig/numeric_test.go
@@ -1,205 +0,0 @@
-package sprig
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestUntil(t *testing.T) {
-	tests := map[string]string{
-		`{{range $i, $e := until 5}}{{$i}}{{$e}}{{end}}`:   "0011223344",
-		`{{range $i, $e := until -5}}{{$i}}{{$e}} {{end}}`: "00 1-1 2-2 3-3 4-4 ",
-	}
-	for tpl, expect := range tests {
-		if err := runt(tpl, expect); err != nil {
-			t.Error(err)
-		}
-	}
-}
-func TestUntilStep(t *testing.T) {
-	tests := map[string]string{
-		`{{range $i, $e := untilStep 0 5 1}}{{$i}}{{$e}}{{end}}`:     "0011223344",
-		`{{range $i, $e := untilStep 3 6 1}}{{$i}}{{$e}}{{end}}`:     "031425",
-		`{{range $i, $e := untilStep 0 -10 -2}}{{$i}}{{$e}} {{end}}`: "00 1-2 2-4 3-6 4-8 ",
-		`{{range $i, $e := untilStep 3 0 1}}{{$i}}{{$e}}{{end}}`:     "",
-		`{{range $i, $e := untilStep 3 99 0}}{{$i}}{{$e}}{{end}}`:    "",
-		`{{range $i, $e := untilStep 3 99 -1}}{{$i}}{{$e}}{{end}}`:   "",
-		`{{range $i, $e := untilStep 3 0 0}}{{$i}}{{$e}}{{end}}`:     "",
-	}
-	for tpl, expect := range tests {
-		if err := runt(tpl, expect); err != nil {
-			t.Error(err)
-		}
-	}
-
-}
-func TestBiggest(t *testing.T) {
-	tpl := `{{ biggest 1 2 3 345 5 6 7}}`
-	if err := runt(tpl, `345`); err != nil {
-		t.Error(err)
-	}
-
-	tpl = `{{ max 345}}`
-	if err := runt(tpl, `345`); err != nil {
-		t.Error(err)
-	}
-}
-func TestMin(t *testing.T) {
-	tpl := `{{ min 1 2 3 345 5 6 7}}`
-	if err := runt(tpl, `1`); err != nil {
-		t.Error(err)
-	}
-
-	tpl = `{{ min 345}}`
-	if err := runt(tpl, `345`); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestToFloat64(t *testing.T) {
-	target := float64(102)
-	if target != toFloat64(int8(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toFloat64(int(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toFloat64(int32(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toFloat64(int16(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toFloat64(int64(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toFloat64("102") {
-		t.Errorf("Expected 102")
-	}
-	if 0 != toFloat64("frankie") {
-		t.Errorf("Expected 0")
-	}
-	if target != toFloat64(uint16(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toFloat64(uint64(102)) {
-		t.Errorf("Expected 102")
-	}
-	if 102.1234 != toFloat64(float64(102.1234)) {
-		t.Errorf("Expected 102.1234")
-	}
-	if 1 != toFloat64(true) {
-		t.Errorf("Expected 102")
-	}
-}
-func TestToInt64(t *testing.T) {
-	target := int64(102)
-	if target != toInt64(int8(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toInt64(int(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toInt64(int32(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toInt64(int16(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toInt64(int64(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toInt64("102") {
-		t.Errorf("Expected 102")
-	}
-	if 0 != toInt64("frankie") {
-		t.Errorf("Expected 0")
-	}
-	if target != toInt64(uint16(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toInt64(uint64(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toInt64(float64(102.1234)) {
-		t.Errorf("Expected 102")
-	}
-	if 1 != toInt64(true) {
-		t.Errorf("Expected 102")
-	}
-}
-
-func TestToInt(t *testing.T) {
-	target := int(102)
-	if target != toInt(int8(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toInt(int(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toInt(int32(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toInt(int16(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toInt(int64(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toInt("102") {
-		t.Errorf("Expected 102")
-	}
-	if 0 != toInt("frankie") {
-		t.Errorf("Expected 0")
-	}
-	if target != toInt(uint16(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toInt(uint64(102)) {
-		t.Errorf("Expected 102")
-	}
-	if target != toInt(float64(102.1234)) {
-		t.Errorf("Expected 102")
-	}
-	if 1 != toInt(true) {
-		t.Errorf("Expected 102")
-	}
-}
-
-func TestAdd(t *testing.T) {
-	tpl := `{{ 3 | add 1 2}}`
-	if err := runt(tpl, `6`); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestMul(t *testing.T) {
-	tpl := `{{ 1 | mul "2" 3 "4"}}`
-	if err := runt(tpl, `24`); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestCeil(t *testing.T){
-	assert.Equal(t, 123.0, ceil(123))
-	assert.Equal(t, 123.0, ceil("123"))
-	assert.Equal(t, 124.0, ceil(123.01))
-	assert.Equal(t, 124.0, ceil("123.01"))
-}
-
-func TestFloor(t *testing.T){
-	assert.Equal(t, 123.0, floor(123))
-	assert.Equal(t, 123.0, floor("123"))
-	assert.Equal(t, 123.0, floor(123.9999))
-	assert.Equal(t, 123.0, floor("123.9999"))
-}
-
-func TestRound(t *testing.T){
-	assert.Equal(t, 123.556, round(123.5555, 3))
-	assert.Equal(t, 123.556, round("123.55555", 3))
-	assert.Equal(t, 124.0, round(123.500001, 0))
-	assert.Equal(t, 123.0, round(123.49999999, 0))
-	assert.Equal(t, 123.23, round(123.2329999, 2, .3))
-	assert.Equal(t, 123.24, round(123.233, 2, .3))
-}
--- a/vendor/github.com/Masterminds/sprig/reflect_test.go
+++ b/vendor/github.com/Masterminds/sprig/reflect_test.go
@@ -1,73 +0,0 @@
-package sprig
-
-import (
-	"testing"
-)
-
-type fixtureTO struct {
-	Name, Value string
-}
-
-func TestTypeOf(t *testing.T) {
-	f := &fixtureTO{"hello", "world"}
-	tpl := `{{typeOf .}}`
-	if err := runtv(tpl, "*sprig.fixtureTO", f); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestKindOf(t *testing.T) {
-	tpl := `{{kindOf .}}`
-
-	f := fixtureTO{"hello", "world"}
-	if err := runtv(tpl, "struct", f); err != nil {
-		t.Error(err)
-	}
-
-	f2 := []string{"hello"}
-	if err := runtv(tpl, "slice", f2); err != nil {
-		t.Error(err)
-	}
-
-	var f3 *fixtureTO = nil
-	if err := runtv(tpl, "ptr", f3); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestTypeIs(t *testing.T) {
-	f := &fixtureTO{"hello", "world"}
-	tpl := `{{if typeIs "*sprig.fixtureTO" .}}t{{else}}f{{end}}`
-	if err := runtv(tpl, "t", f); err != nil {
-		t.Error(err)
-	}
-
-	f2 := "hello"
-	if err := runtv(tpl, "f", f2); err != nil {
-		t.Error(err)
-	}
-}
-func TestTypeIsLike(t *testing.T) {
-	f := "foo"
-	tpl := `{{if typeIsLike "string" .}}t{{else}}f{{end}}`
-	if err := runtv(tpl, "t", f); err != nil {
-		t.Error(err)
-	}
-
-	// Now make a pointer. Should still match.
-	f2 := &f
-	if err := runtv(tpl, "t", f2); err != nil {
-		t.Error(err)
-	}
-}
-func TestKindIs(t *testing.T) {
-	f := &fixtureTO{"hello", "world"}
-	tpl := `{{if kindIs "ptr" .}}t{{else}}f{{end}}`
-	if err := runtv(tpl, "t", f); err != nil {
-		t.Error(err)
-	}
-	f2 := "hello"
-	if err := runtv(tpl, "f", f2); err != nil {
-		t.Error(err)
-	}
-}
--- a/vendor/github.com/Masterminds/sprig/regex_test.go
+++ b/vendor/github.com/Masterminds/sprig/regex_test.go
@@ -1,61 +0,0 @@
-package sprig
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestRegexMatch(t *testing.T) {
-	regex := "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}"
-
-	assert.True(t, regexMatch(regex, "test@acme.com"))
-	assert.True(t, regexMatch(regex, "Test@Acme.Com"))
-	assert.False(t, regexMatch(regex, "test"))
-	assert.False(t, regexMatch(regex, "test.com"))
-	assert.False(t, regexMatch(regex, "test@acme"))
-}
-
-func TestRegexFindAll(t *testing.T){
-	regex := "a{2}"
-	assert.Equal(t, 1, len(regexFindAll(regex, "aa", -1)))
-	assert.Equal(t, 1, len(regexFindAll(regex, "aaaaaaaa", 1)))
-	assert.Equal(t, 2, len(regexFindAll(regex, "aaaa", -1)))
-	assert.Equal(t, 0, len(regexFindAll(regex, "none", -1)))
-}
-
-func TestRegexFindl(t *testing.T){
-	regex := "fo.?"
-	assert.Equal(t, "foo", regexFind(regex, "foorbar"))
-	assert.Equal(t, "foo", regexFind(regex, "foo foe fome"))
-	assert.Equal(t, "", regexFind(regex, "none"))
-}
-
-func TestRegexReplaceAll(t *testing.T){
-	regex := "a(x*)b"
-	assert.Equal(t, "-T-T-", regexReplaceAll(regex,"-ab-axxb-", "T"))
-	assert.Equal(t, "--xx-", regexReplaceAll(regex,"-ab-axxb-", "$1"))
-	assert.Equal(t, "---", regexReplaceAll(regex,"-ab-axxb-", "$1W"))
-	assert.Equal(t, "-W-xxW-", regexReplaceAll(regex,"-ab-axxb-", "${1}W"))
-}
-
-func TestRegexReplaceAllLiteral(t *testing.T){
-	regex := "a(x*)b"
-	assert.Equal(t, "-T-T-", regexReplaceAllLiteral(regex,"-ab-axxb-", "T"))
-	assert.Equal(t, "-$1-$1-", regexReplaceAllLiteral(regex,"-ab-axxb-", "$1"))
-	assert.Equal(t, "-${1}-${1}-", regexReplaceAllLiteral(regex,"-ab-axxb-", "${1}"))
-}
-
-func TestRegexSplit(t *testing.T){
-	regex := "a"
-	assert.Equal(t, 4, len(regexSplit(regex,"banana", -1)))
-	assert.Equal(t, 0, len(regexSplit(regex,"banana", 0)))
-	assert.Equal(t, 1, len(regexSplit(regex,"banana", 1)))
-	assert.Equal(t, 2, len(regexSplit(regex,"banana", 2)))
-
-	regex = "z+"
-	assert.Equal(t, 2, len(regexSplit(regex,"pizza", -1)))
-	assert.Equal(t, 0, len(regexSplit(regex,"pizza", 0)))
-	assert.Equal(t, 1, len(regexSplit(regex,"pizza", 1)))
-	assert.Equal(t, 2, len(regexSplit(regex,"pizza", 2)))
-}
--- a/vendor/github.com/Masterminds/sprig/semver_test.go
+++ b/vendor/github.com/Masterminds/sprig/semver_test.go
@@ -1,31 +0,0 @@
-package sprig
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestSemverCompare(t *testing.T) {
-	tests := map[string]string{
-		`{{ semverCompare "1.2.3" "1.2.3" }}`:  `true`,
-		`{{ semverCompare "^1.2.0" "1.2.3" }}`: `true`,
-		`{{ semverCompare "^1.2.0" "2.2.3" }}`: `false`,
-	}
-	for tpl, expect := range tests {
-		assert.NoError(t, runt(tpl, expect))
-	}
-}
-
-func TestSemver(t *testing.T) {
-	tests := map[string]string{
-		`{{ $s := semver "1.2.3-beta.1+c0ff33" }}{{ $s.Prerelease }}`: "beta.1",
-		`{{ $s := semver "1.2.3-beta.1+c0ff33" }}{{ $s.Major}}`:       "1",
-		`{{ semver "1.2.3" | (semver "1.2.3").Compare }}`:             `0`,
-		`{{ semver "1.2.3" | (semver "1.3.3").Compare }}`:             `1`,
-		`{{ semver "1.4.3" | (semver "1.2.3").Compare }}`:             `-1`,
-	}
-	for tpl, expect := range tests {
-		assert.NoError(t, runt(tpl, expect))
-	}
-}
--- a/vendor/github.com/Masterminds/sprig/strings_test.go
+++ b/vendor/github.com/Masterminds/sprig/strings_test.go
@@ -1,227 +0,0 @@
-package sprig
-
-import (
-	"encoding/base32"
-	"encoding/base64"
-	"fmt"
-	"math/rand"
-	"testing"
-
-	"github.com/aokoli/goutils"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestSubstr(t *testing.T) {
-	tpl := `{{"fooo" | substr 0 3 }}`
-	if err := runt(tpl, "foo"); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestTrunc(t *testing.T) {
-	tpl := `{{ "foooooo" | trunc 3 }}`
-	if err := runt(tpl, "foo"); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestQuote(t *testing.T) {
-	tpl := `{{quote "a" "b" "c"}}`
-	if err := runt(tpl, `"a" "b" "c"`); err != nil {
-		t.Error(err)
-	}
-	tpl = `{{quote "\"a\"" "b" "c"}}`
-	if err := runt(tpl, `"\"a\"" "b" "c"`); err != nil {
-		t.Error(err)
-	}
-	tpl = `{{quote 1 2 3 }}`
-	if err := runt(tpl, `"1" "2" "3"`); err != nil {
-		t.Error(err)
-	}
-}
-func TestSquote(t *testing.T) {
-	tpl := `{{squote "a" "b" "c"}}`
-	if err := runt(tpl, `'a' 'b' 'c'`); err != nil {
-		t.Error(err)
-	}
-	tpl = `{{squote 1 2 3 }}`
-	if err := runt(tpl, `'1' '2' '3'`); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestContains(t *testing.T) {
-	// Mainly, we're just verifying the paramater order swap.
-	tests := []string{
-		`{{if contains "cat" "fair catch"}}1{{end}}`,
-		`{{if hasPrefix "cat" "catch"}}1{{end}}`,
-		`{{if hasSuffix "cat" "ducat"}}1{{end}}`,
-	}
-	for _, tt := range tests {
-		if err := runt(tt, "1"); err != nil {
-			t.Error(err)
-		}
-	}
-}
-
-func TestTrim(t *testing.T) {
-	tests := []string{
-		`{{trim "   5.00   "}}`,
-		`{{trimAll "$" "$5.00$"}}`,
-		`{{trimPrefix "$" "$5.00"}}`,
-		`{{trimSuffix "$" "5.00$"}}`,
-	}
-	for _, tt := range tests {
-		if err := runt(tt, "5.00"); err != nil {
-			t.Error(err)
-		}
-	}
-}
-
-func TestSplit(t *testing.T) {
-	tpl := `{{$v := "foo$bar$baz" | split "$"}}{{$v._0}}`
-	if err := runt(tpl, "foo"); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestToString(t *testing.T) {
-	tpl := `{{ toString 1 | kindOf }}`
-	assert.NoError(t, runt(tpl, "string"))
-}
-
-func TestToStrings(t *testing.T) {
-	tpl := `{{ $s := list 1 2 3 | toStrings }}{{ index $s 1 | kindOf }}`
-	assert.NoError(t, runt(tpl, "string"))
-}
-
-func TestJoin(t *testing.T) {
-	assert.NoError(t, runt(`{{ tuple "a" "b" "c" | join "-" }}`, "a-b-c"))
-	assert.NoError(t, runt(`{{ tuple 1 2 3 | join "-" }}`, "1-2-3"))
-	assert.NoError(t, runtv(`{{ join "-" .V }}`, "a-b-c", map[string]interface{}{"V": []string{"a", "b", "c"}}))
-	assert.NoError(t, runtv(`{{ join "-" .V }}`, "abc", map[string]interface{}{"V": "abc"}))
-	assert.NoError(t, runtv(`{{ join "-" .V }}`, "1-2-3", map[string]interface{}{"V": []int{1, 2, 3}}))
-}
-
-func TestSortAlpha(t *testing.T) {
-	// Named `append` in the function map
-	tests := map[string]string{
-		`{{ list "c" "a" "b" | sortAlpha | join "" }}`: "abc",
-		`{{ list 2 1 4 3 | sortAlpha | join "" }}`:     "1234",
-	}
-	for tpl, expect := range tests {
-		assert.NoError(t, runt(tpl, expect))
-	}
-}
-func TestBase64EncodeDecode(t *testing.T) {
-	magicWord := "coffee"
-	expect := base64.StdEncoding.EncodeToString([]byte(magicWord))
-
-	if expect == magicWord {
-		t.Fatal("Encoder doesn't work.")
-	}
-
-	tpl := `{{b64enc "coffee"}}`
-	if err := runt(tpl, expect); err != nil {
-		t.Error(err)
-	}
-	tpl = fmt.Sprintf("{{b64dec %q}}", expect)
-	if err := runt(tpl, magicWord); err != nil {
-		t.Error(err)
-	}
-}
-func TestBase32EncodeDecode(t *testing.T) {
-	magicWord := "coffee"
-	expect := base32.StdEncoding.EncodeToString([]byte(magicWord))
-
-	if expect == magicWord {
-		t.Fatal("Encoder doesn't work.")
-	}
-
-	tpl := `{{b32enc "coffee"}}`
-	if err := runt(tpl, expect); err != nil {
-		t.Error(err)
-	}
-	tpl = fmt.Sprintf("{{b32dec %q}}", expect)
-	if err := runt(tpl, magicWord); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestGoutils(t *testing.T) {
-	tests := map[string]string{
-		`{{abbrev 5 "hello world"}}`:           "he...",
-		`{{abbrevboth 5 10 "1234 5678 9123"}}`: "...5678...",
-		`{{nospace "h e l l o "}}`:             "hello",
-		`{{untitle "First Try"}}`:              "first try", //https://youtu.be/44-RsrF_V_w
-		`{{initials "First Try"}}`:             "FT",
-		`{{wrap 5 "Hello World"}}`:             "Hello\nWorld",
-		`{{wrapWith 5 "\t" "Hello World"}}`:    "Hello\tWorld",
-	}
-	for k, v := range tests {
-		t.Log(k)
-		if err := runt(k, v); err != nil {
-			t.Errorf("Error on tpl %q: %s", k, err)
-		}
-	}
-}
-
-func TestRandom(t *testing.T) {
-	// One of the things I love about Go:
-	goutils.RANDOM = rand.New(rand.NewSource(1))
-
-	// Because we're using a random number generator, we need these to go in
-	// a predictable sequence:
-	if err := runt(`{{randAlphaNum 5}}`, "9bzRv"); err != nil {
-		t.Errorf("Error on tpl: %s", err)
-	}
-	if err := runt(`{{randAlpha 5}}`, "VjwGe"); err != nil {
-		t.Errorf("Error on tpl: %s", err)
-	}
-	if err := runt(`{{randAscii 5}}`, "1KA5p"); err != nil {
-		t.Errorf("Error on tpl: %s", err)
-	}
-	if err := runt(`{{randNumeric 5}}`, "26018"); err != nil {
-		t.Errorf("Error on tpl: %s", err)
-	}
-
-}
-
-func TestCat(t *testing.T) {
-	tpl := `{{$b := "b"}}{{"c" | cat "a" $b}}`
-	if err := runt(tpl, "a b c"); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestIndent(t *testing.T) {
-	tpl := `{{indent 4 "a\nb\nc"}}`
-	if err := runt(tpl, "    a\n    b\n    c"); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestNindent(t *testing.T) {
-	tpl := `{{nindent 4 "a\nb\nc"}}`
-	if err := runt(tpl, "\n    a\n    b\n    c"); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestReplace(t *testing.T) {
-	tpl := `{{"I Am Henry VIII" | replace " " "-"}}`
-	if err := runt(tpl, "I-Am-Henry-VIII"); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestPlural(t *testing.T) {
-	tpl := `{{$num := len "two"}}{{$num}} {{$num | plural "1 char" "chars"}}`
-	if err := runt(tpl, "3 chars"); err != nil {
-		t.Error(err)
-	}
-	tpl = `{{len "t" | plural "cheese" "%d chars"}}`
-	if err := runt(tpl, "cheese"); err != nil {
-		t.Error(err)
-	}
-}
--- a/vendor/github.com/aokoli/goutils/randomstringutils_test.go
+++ b/vendor/github.com/aokoli/goutils/randomstringutils_test.go
@@ -1,78 +0,0 @@
-package goutils
-
-import (
-	"fmt"
-	"math/rand"
-	"testing"
-)
-
-// ****************************** TESTS ********************************************
-
-func TestRandomSeed(t *testing.T) {
-
-	// count, start, end, letters, numbers := 5, 0, 0, true, true
-	random := rand.New(rand.NewSource(10))
-	out := "3ip9v"
-
-	// Test 1: Simulating RandomAlphaNumeric(count int)
-	if x, _ := RandomSeed(5, 0, 0, true, true, nil, random); x != out {
-		t.Errorf("RandomSeed(%v, %v, %v, %v, %v, %v, %v) = %v, want %v", 5, 0, 0, true, true, nil, random, x, out)
-	}
-
-	// Test 2: Simulating RandomAlphabetic(count int)
-	out = "MBrbj"
-
-	if x, _ := RandomSeed(5, 0, 0, true, false, nil, random); x != out {
-		t.Errorf("RandomSeed(%v, %v, %v, %v, %v, %v, %v) = %v, want %v", 5, 0, 0, true, false, nil, random, x, out)
-	}
-
-	// Test 3: Simulating RandomNumeric(count int)
-	out = "88935"
-
-	if x, _ := RandomSeed(5, 0, 0, false, true, nil, random); x != out {
-		t.Errorf("RandomSeed(%v, %v, %v, %v, %v, %v, %v) = %v, want %v", 5, 0, 0, false, true, nil, random, x, out)
-	}
-
-	// Test 4: Simulating RandomAscii(count int)
-	out = "H_I;E"
-
-	if x, _ := RandomSeed(5, 32, 127, false, false, nil, random); x != out {
-		t.Errorf("RandomSeed(%v, %v, %v, %v, %v, %v, %v) = %v, want %v", 5, 32, 127, false, false, nil, random, x, out)
-	}
-
-	// Test 5: Simulating RandomSeed(...) with custom chars
-	chars := []rune{'1', '2', '3', 'a', 'b', 'c'}
-	out = "2b2ca"
-
-	if x, _ := RandomSeed(5, 0, 0, false, false, chars, random); x != out {
-		t.Errorf("RandomSeed(%v, %v, %v, %v, %v, %v, %v) = %v, want %v", 5, 0, 0, false, false, chars, random, x, out)
-	}
-
-}
-
-// ****************************** EXAMPLES ********************************************
-
-func ExampleRandomSeed() {
-
-	var seed int64 = 10 // If you change this seed #, the random sequence below will change
-	random := rand.New(rand.NewSource(seed))
-	chars := []rune{'1', '2', '3', 'a', 'b', 'c'}
-
-	rand1, _ := RandomSeed(5, 0, 0, true, true, nil, random)      // RandomAlphaNumeric (Alphabets and numbers possible)
-	rand2, _ := RandomSeed(5, 0, 0, true, false, nil, random)     // RandomAlphabetic (Only alphabets)
-	rand3, _ := RandomSeed(5, 0, 0, false, true, nil, random)     // RandomNumeric (Only numbers)
-	rand4, _ := RandomSeed(5, 32, 127, false, false, nil, random) // RandomAscii (Alphabets, numbers, and other ASCII chars)
-	rand5, _ := RandomSeed(5, 0, 0, true, true, chars, random)    // RandomSeed with custom characters
-
-	fmt.Println(rand1)
-	fmt.Println(rand2)
-	fmt.Println(rand3)
-	fmt.Println(rand4)
-	fmt.Println(rand5)
-	// Output:
-	// 3ip9v
-	// MBrbj
-	// 88935
-	// H_I;E
-	// 2b2ca
-}
--- a/vendor/github.com/aokoli/goutils/stringutils_test.go
+++ b/vendor/github.com/aokoli/goutils/stringutils_test.go
@@ -1,309 +0,0 @@
-package goutils
-
-import (
-	"fmt"
-	"testing"
-)
-
-// ****************************** TESTS ********************************************
-
-func TestAbbreviate(t *testing.T) {
-
-	// Test 1
-	in := "abcdefg"
-	out := "abc..."
-	maxWidth := 6
-
-	if x, _ := Abbreviate(in, maxWidth); x != out {
-		t.Errorf("Abbreviate(%v, %v) = %v, want %v", in, maxWidth, x, out)
-	}
-
-	// Test 2
-	out = "abcdefg"
-	maxWidth = 7
-
-	if x, _ := Abbreviate(in, maxWidth); x != out {
-		t.Errorf("Abbreviate(%v, %v) = %v, want %v", in, maxWidth, x, out)
-	}
-
-	// Test 3
-	out = "a..."
-	maxWidth = 4
-
-	if x, _ := Abbreviate(in, maxWidth); x != out {
-		t.Errorf("Abbreviate(%v, %v) = %v, want %v", in, maxWidth, x, out)
-	}
-}
-
-func TestAbbreviateFull(t *testing.T) {
-
-	// Test 1
-	in := "abcdefghijklmno"
-	out := "abcdefg..."
-	offset := -1
-	maxWidth := 10
-
-	if x, _ := AbbreviateFull(in, offset, maxWidth); x != out {
-		t.Errorf("AbbreviateFull(%v, %v, %v) = %v, want %v", in, offset, maxWidth, x, out)
-	}
-
-	// Test 2
-	out = "...fghi..."
-	offset = 5
-	maxWidth = 10
-
-	if x, _ := AbbreviateFull(in, offset, maxWidth); x != out {
-		t.Errorf("AbbreviateFull(%v, %v, %v) = %v, want %v", in, offset, maxWidth, x, out)
-	}
-
-	// Test 3
-	out = "...ijklmno"
-	offset = 12
-	maxWidth = 10
-
-	if x, _ := AbbreviateFull(in, offset, maxWidth); x != out {
-		t.Errorf("AbbreviateFull(%v, %v, %v) = %v, want %v", in, offset, maxWidth, x, out)
-	}
-}
-
-func TestIndexOf(t *testing.T) {
-
-	// Test 1
-	str := "abcafgka"
-	sub := "a"
-	start := 0
-	out := 0
-
-	if x := IndexOf(str, sub, start); x != out {
-		t.Errorf("IndexOf(%v, %v, %v) = %v, want %v", str, sub, start, x, out)
-	}
-
-	// Test 2
-	start = 1
-	out = 3
-
-	if x := IndexOf(str, sub, start); x != out {
-		t.Errorf("IndexOf(%v, %v, %v) = %v, want %v", str, sub, start, x, out)
-	}
-
-	// Test 3
-	start = 4
-	out = 7
-
-	if x := IndexOf(str, sub, start); x != out {
-		t.Errorf("IndexOf(%v, %v, %v) = %v, want %v", str, sub, start, x, out)
-	}
-
-	// Test 4
-	sub = "z"
-	out = -1
-
-	if x := IndexOf(str, sub, start); x != out {
-		t.Errorf("IndexOf(%v, %v, %v) = %v, want %v", str, sub, start, x, out)
-	}
-
-}
-
-func TestIsBlank(t *testing.T) {
-
-	// Test 1
-	str := ""
-	out := true
-
-	if x := IsBlank(str); x != out {
-		t.Errorf("IndexOf(%v) = %v, want %v", str, x, out)
-	}
-
-	// Test 2
-	str = "   "
-	out = true
-
-	if x := IsBlank(str); x != out {
-		t.Errorf("IndexOf(%v) = %v, want %v", str, x, out)
-	}
-
-	// Test 3
-	str = " abc "
-	out = false
-
-	if x := IsBlank(str); x != out {
-		t.Errorf("IndexOf(%v) = %v, want %v", str, x, out)
-	}
-}
-
-func TestDeleteWhiteSpace(t *testing.T) {
-
-	// Test 1
-	str := " a b c "
-	out := "abc"
-
-	if x := DeleteWhiteSpace(str); x != out {
-		t.Errorf("IndexOf(%v) = %v, want %v", str, x, out)
-	}
-
-	// Test 2
-	str = "    "
-	out = ""
-
-	if x := DeleteWhiteSpace(str); x != out {
-		t.Errorf("IndexOf(%v) = %v, want %v", str, x, out)
-	}
-}
-
-func TestIndexOfDifference(t *testing.T) {
-
-	str1 := "abc"
-	str2 := "a_c"
-	out := 1
-
-	if x := IndexOfDifference(str1, str2); x != out {
-		t.Errorf("IndexOfDifference(%v, %v) = %v, want %v", str1, str2, x, out)
-	}
-}
-
-// ****************************** EXAMPLES ********************************************
-
-func ExampleAbbreviate() {
-
-	str := "abcdefg"
-	out1, _ := Abbreviate(str, 6)
-	out2, _ := Abbreviate(str, 7)
-	out3, _ := Abbreviate(str, 8)
-	out4, _ := Abbreviate(str, 4)
-	_, err1 := Abbreviate(str, 3)
-
-	fmt.Println(out1)
-	fmt.Println(out2)
-	fmt.Println(out3)
-	fmt.Println(out4)
-	fmt.Println(err1)
-	// Output:
-	// abc...
-	// abcdefg
-	// abcdefg
-	// a...
-	// stringutils illegal argument: Minimum abbreviation width is 4
-}
-
-func ExampleAbbreviateFull() {
-
-	str := "abcdefghijklmno"
-	str2 := "abcdefghij"
-	out1, _ := AbbreviateFull(str, -1, 10)
-	out2, _ := AbbreviateFull(str, 0, 10)
-	out3, _ := AbbreviateFull(str, 1, 10)
-	out4, _ := AbbreviateFull(str, 4, 10)
-	out5, _ := AbbreviateFull(str, 5, 10)
-	out6, _ := AbbreviateFull(str, 6, 10)
-	out7, _ := AbbreviateFull(str, 8, 10)
-	out8, _ := AbbreviateFull(str, 10, 10)
-	out9, _ := AbbreviateFull(str, 12, 10)
-	_, err1 := AbbreviateFull(str2, 0, 3)
-	_, err2 := AbbreviateFull(str2, 5, 6)
-
-	fmt.Println(out1)
-	fmt.Println(out2)
-	fmt.Println(out3)
-	fmt.Println(out4)
-	fmt.Println(out5)
-	fmt.Println(out6)
-	fmt.Println(out7)
-	fmt.Println(out8)
-	fmt.Println(out9)
-	fmt.Println(err1)
-	fmt.Println(err2)
-	// Output:
-	// abcdefg...
-	// abcdefg...
-	// abcdefg...
-	// abcdefg...
-	// ...fghi...
-	// ...ghij...
-	// ...ijklmno
-	// ...ijklmno
-	// ...ijklmno
-	// stringutils illegal argument: Minimum abbreviation width is 4
-	// stringutils illegal argument: Minimum abbreviation width with offset is 7
-}
-
-func ExampleIsBlank() {
-
-	out1 := IsBlank("")
-	out2 := IsBlank(" ")
-	out3 := IsBlank("bob")
-	out4 := IsBlank("  bob  ")
-
-	fmt.Println(out1)
-	fmt.Println(out2)
-	fmt.Println(out3)
-	fmt.Println(out4)
-	// Output:
-	// true
-	// true
-	// false
-	// false
-}
-
-func ExampleDeleteWhiteSpace() {
-
-	out1 := DeleteWhiteSpace(" ")
-	out2 := DeleteWhiteSpace("bob")
-	out3 := DeleteWhiteSpace("bob   ")
-	out4 := DeleteWhiteSpace("  b  o    b  ")
-
-	fmt.Println(out1)
-	fmt.Println(out2)
-	fmt.Println(out3)
-	fmt.Println(out4)
-	// Output:
-	//
-	// bob
-	// bob
-	// bob
-}
-
-func ExampleIndexOf() {
-
-	str := "abcdefgehije"
-	out1 := IndexOf(str, "e", 0)
-	out2 := IndexOf(str, "e", 5)
-	out3 := IndexOf(str, "e", 8)
-	out4 := IndexOf(str, "eh", 0)
-	out5 := IndexOf(str, "eh", 22)
-	out6 := IndexOf(str, "z", 0)
-	out7 := IndexOf(str, "", 0)
-
-	fmt.Println(out1)
-	fmt.Println(out2)
-	fmt.Println(out3)
-	fmt.Println(out4)
-	fmt.Println(out5)
-	fmt.Println(out6)
-	fmt.Println(out7)
-	// Output:
-	// 4
-	// 7
-	// 11
-	// 7
-	// -1
-	// -1
-	// -1
-}
-
-func ExampleIndexOfDifference() {
-
-	out1 := IndexOfDifference("abc", "abc")
-	out2 := IndexOfDifference("ab", "abxyz")
-	out3 := IndexOfDifference("", "abc")
-	out4 := IndexOfDifference("abcde", "abxyz")
-
-	fmt.Println(out1)
-	fmt.Println(out2)
-	fmt.Println(out3)
-	fmt.Println(out4)
-	// Output:
-	// -1
-	// 2
-	// 0
-	// 2
-}
--- a/vendor/github.com/aokoli/goutils/wordutils_test.go
+++ b/vendor/github.com/aokoli/goutils/wordutils_test.go
@@ -1,225 +0,0 @@
-package goutils
-
-import (
-	"fmt"
-	"testing"
-)
-
-// ****************************** TESTS ********************************************
-
-func TestWrapNormalWord(t *testing.T) {
-
-	in := "Bob Manuel Bob Manuel"
-	out := "Bob Manuel\nBob Manuel"
-	wrapLength := 10
-
-	if x := Wrap(in, wrapLength); x != out {
-		t.Errorf("Wrap(%v) = %v, want %v", in, x, out)
-	}
-}
-
-func TestWrapCustomLongWordFalse(t *testing.T) {
-
-	in := "BobManuelBob Bob"
-	out := "BobManuelBob<br\\>Bob"
-	wrapLength := 10
-	newLineStr := "<br\\>"
-	wrapLongWords := false
-
-	if x := WrapCustom(in, wrapLength, newLineStr, wrapLongWords); x != out {
-		t.Errorf("Wrap(%v) = %v, want %v", in, x, out)
-	}
-}
-
-func TestWrapCustomLongWordTrue(t *testing.T) {
-
-	in := "BobManuelBob Bob"
-	out := "BobManuelB<br\\>ob Bob"
-	wrapLength := 10
-	newLineStr := "<br\\>"
-	wrapLongWords := true
-
-	if x := WrapCustom(in, wrapLength, newLineStr, wrapLongWords); x != out {
-		t.Errorf("WrapCustom(%v) = %v, want %v", in, x, out)
-	}
-}
-
-func TestCapitalize(t *testing.T) {
-
-	// Test 1: Checks if function works with 1 parameter, and default whitespace delimiter
-	in := "test is going.well.thank.you.for inquiring"
-	out := "Test Is Going.well.thank.you.for Inquiring"
-
-	if x := Capitalize(in); x != out {
-		t.Errorf("Capitalize(%v) = %v, want %v", in, x, out)
-	}
-
-	// Test 2: Checks if function works with both parameters, with param 2 containing whitespace and '.'
-	out = "Test Is Going.Well.Thank.You.For Inquiring"
-	delimiters := []rune{' ', '.'}
-
-	if x := Capitalize(in, delimiters...); x != out {
-		t.Errorf("Capitalize(%v) = %v, want %v", in, x, out)
-	}
-}
-
-func TestCapitalizeFully(t *testing.T) {
-
-	// Test 1
-	in := "tEsT iS goiNG.wELL.tHaNk.yOU.for inqUIrING"
-	out := "Test Is Going.well.thank.you.for Inquiring"
-
-	if x := CapitalizeFully(in); x != out {
-		t.Errorf("CapitalizeFully(%v) = %v, want %v", in, x, out)
-	}
-
-	// Test 2
-	out = "Test Is Going.Well.Thank.You.For Inquiring"
-	delimiters := []rune{' ', '.'}
-
-	if x := CapitalizeFully(in, delimiters...); x != out {
-		t.Errorf("CapitalizeFully(%v) = %v, want %v", in, x, out)
-	}
-}
-
-func TestUncapitalize(t *testing.T) {
-
-	// Test 1: Checks if function works with 1 parameter, and default whitespace delimiter
-	in := "This Is A.Test"
-	out := "this is a.Test"
-
-	if x := Uncapitalize(in); x != out {
-		t.Errorf("Uncapitalize(%v) = %v, want %v", in, x, out)
-	}
-
-	// Test 2: Checks if function works with both parameters, with param 2 containing whitespace and '.'
-	out = "this is a.test"
-	delimiters := []rune{' ', '.'}
-
-	if x := Uncapitalize(in, delimiters...); x != out {
-		t.Errorf("Uncapitalize(%v) = %v, want %v", in, x, out)
-	}
-}
-
-func TestSwapCase(t *testing.T) {
-
-	in := "This Is A.Test"
-	out := "tHIS iS a.tEST"
-
-	if x := SwapCase(in); x != out {
-		t.Errorf("SwapCase(%v) = %v, want %v", in, x, out)
-	}
-}
-
-func TestInitials(t *testing.T) {
-
-	// Test 1
-	in := "John Doe.Ray"
-	out := "JD"
-
-	if x := Initials(in); x != out {
-		t.Errorf("Initials(%v) = %v, want %v", in, x, out)
-	}
-
-	// Test 2
-	out = "JDR"
-	delimiters := []rune{' ', '.'}
-
-	if x := Initials(in, delimiters...); x != out {
-		t.Errorf("Initials(%v) = %v, want %v", in, x, out)
-	}
-
-}
-
-// ****************************** EXAMPLES ********************************************
-
-func ExampleWrap() {
-
-	in := "Bob Manuel Bob Manuel"
-	wrapLength := 10
-
-	fmt.Println(Wrap(in, wrapLength))
-	// Output:
-	// Bob Manuel
-	// Bob Manuel
-}
-
-func ExampleWrapCustom_1() {
-
-	in := "BobManuelBob Bob"
-	wrapLength := 10
-	newLineStr := "<br\\>"
-	wrapLongWords := false
-
-	fmt.Println(WrapCustom(in, wrapLength, newLineStr, wrapLongWords))
-	// Output:
-	// BobManuelBob<br\>Bob
-}
-
-func ExampleWrapCustom_2() {
-
-	in := "BobManuelBob Bob"
-	wrapLength := 10
-	newLineStr := "<br\\>"
-	wrapLongWords := true
-
-	fmt.Println(WrapCustom(in, wrapLength, newLineStr, wrapLongWords))
-	// Output:
-	// BobManuelB<br\>ob Bob
-}
-
-func ExampleCapitalize() {
-
-	in := "test is going.well.thank.you.for inquiring" // Compare input to CapitalizeFully example
-	delimiters := []rune{' ', '.'}
-
-	fmt.Println(Capitalize(in))
-	fmt.Println(Capitalize(in, delimiters...))
-	// Output:
-	// Test Is Going.well.thank.you.for Inquiring
-	// Test Is Going.Well.Thank.You.For Inquiring
-}
-
-func ExampleCapitalizeFully() {
-
-	in := "tEsT iS goiNG.wELL.tHaNk.yOU.for inqUIrING" // Notice scattered capitalization
-	delimiters := []rune{' ', '.'}
-
-	fmt.Println(CapitalizeFully(in))
-	fmt.Println(CapitalizeFully(in, delimiters...))
-	// Output:
-	// Test Is Going.well.thank.you.for Inquiring
-	// Test Is Going.Well.Thank.You.For Inquiring
-}
-
-func ExampleUncapitalize() {
-
-	in := "This Is A.Test"
-	delimiters := []rune{' ', '.'}
-
-	fmt.Println(Uncapitalize(in))
-	fmt.Println(Uncapitalize(in, delimiters...))
-	// Output:
-	// this is a.Test
-	// this is a.test
-}
-
-func ExampleSwapCase() {
-
-	in := "This Is A.Test"
-	fmt.Println(SwapCase(in))
-	// Output:
-	// tHIS iS a.tEST
-}
-
-func ExampleInitials() {
-
-	in := "John Doe.Ray"
-	delimiters := []rune{' ', '.'}
-
-	fmt.Println(Initials(in))
-	fmt.Println(Initials(in, delimiters...))
-	// Output:
-	// JD
-	// JDR
-}
--- a/vendor/github.com/boltdb/bolt/bucket_test.go
+++ b/vendor/github.com/boltdb/bolt/bucket_test.go
--- a/vendor/github.com/boltdb/bolt/cmd/bolt/main.go
+++ b/vendor/github.com/boltdb/bolt/cmd/bolt/main.go
--- a/vendor/github.com/boltdb/bolt/cmd/bolt/main_test.go
+++ b/vendor/github.com/boltdb/bolt/cmd/bolt/main_test.go
@@ -1,356 +0,0 @@
-package main_test
-
-import (
-	"bytes"
-	crypto "crypto/rand"
-	"encoding/binary"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"math/rand"
-	"os"
-	"strconv"
-	"testing"
-
-	"github.com/boltdb/bolt"
-	"github.com/boltdb/bolt/cmd/bolt"
-)
-
-// Ensure the "info" command can print information about a database.
-func TestInfoCommand_Run(t *testing.T) {
-	db := MustOpen(0666, nil)
-	db.DB.Close()
-	defer db.Close()
-
-	// Run the info command.
-	m := NewMain()
-	if err := m.Run("info", db.Path); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure the "stats" command executes correctly with an empty database.
-func TestStatsCommand_Run_EmptyDatabase(t *testing.T) {
-	// Ignore
-	if os.Getpagesize() != 4096 {
-		t.Skip("system does not use 4KB page size")
-	}
-
-	db := MustOpen(0666, nil)
-	defer db.Close()
-	db.DB.Close()
-
-	// Generate expected result.
-	exp := "Aggregate statistics for 0 buckets\n\n" +
-		"Page count statistics\n" +
-		"\tNumber of logical branch pages: 0\n" +
-		"\tNumber of physical branch overflow pages: 0\n" +
-		"\tNumber of logical leaf pages: 0\n" +
-		"\tNumber of physical leaf overflow pages: 0\n" +
-		"Tree statistics\n" +
-		"\tNumber of keys/value pairs: 0\n" +
-		"\tNumber of levels in B+tree: 0\n" +
-		"Page size utilization\n" +
-		"\tBytes allocated for physical branch pages: 0\n" +
-		"\tBytes actually used for branch data: 0 (0%)\n" +
-		"\tBytes allocated for physical leaf pages: 0\n" +
-		"\tBytes actually used for leaf data: 0 (0%)\n" +
-		"Bucket statistics\n" +
-		"\tTotal number of buckets: 0\n" +
-		"\tTotal number on inlined buckets: 0 (0%)\n" +
-		"\tBytes used for inlined buckets: 0 (0%)\n"
-
-	// Run the command.
-	m := NewMain()
-	if err := m.Run("stats", db.Path); err != nil {
-		t.Fatal(err)
-	} else if m.Stdout.String() != exp {
-		t.Fatalf("unexpected stdout:\n\n%s", m.Stdout.String())
-	}
-}
-
-// Ensure the "stats" command can execute correctly.
-func TestStatsCommand_Run(t *testing.T) {
-	// Ignore
-	if os.Getpagesize() != 4096 {
-		t.Skip("system does not use 4KB page size")
-	}
-
-	db := MustOpen(0666, nil)
-	defer db.Close()
-
-	if err := db.Update(func(tx *bolt.Tx) error {
-		// Create "foo" bucket.
-		b, err := tx.CreateBucket([]byte("foo"))
-		if err != nil {
-			return err
-		}
-		for i := 0; i < 10; i++ {
-			if err := b.Put([]byte(strconv.Itoa(i)), []byte(strconv.Itoa(i))); err != nil {
-				return err
-			}
-		}
-
-		// Create "bar" bucket.
-		b, err = tx.CreateBucket([]byte("bar"))
-		if err != nil {
-			return err
-		}
-		for i := 0; i < 100; i++ {
-			if err := b.Put([]byte(strconv.Itoa(i)), []byte(strconv.Itoa(i))); err != nil {
-				return err
-			}
-		}
-
-		// Create "baz" bucket.
-		b, err = tx.CreateBucket([]byte("baz"))
-		if err != nil {
-			return err
-		}
-		if err := b.Put([]byte("key"), []byte("value")); err != nil {
-			return err
-		}
-
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-	db.DB.Close()
-
-	// Generate expected result.
-	exp := "Aggregate statistics for 3 buckets\n\n" +
-		"Page count statistics\n" +
-		"\tNumber of logical branch pages: 0\n" +
-		"\tNumber of physical branch overflow pages: 0\n" +
-		"\tNumber of logical leaf pages: 1\n" +
-		"\tNumber of physical leaf overflow pages: 0\n" +
-		"Tree statistics\n" +
-		"\tNumber of keys/value pairs: 111\n" +
-		"\tNumber of levels in B+tree: 1\n" +
-		"Page size utilization\n" +
-		"\tBytes allocated for physical branch pages: 0\n" +
-		"\tBytes actually used for branch data: 0 (0%)\n" +
-		"\tBytes allocated for physical leaf pages: 4096\n" +
-		"\tBytes actually used for leaf data: 1996 (48%)\n" +
-		"Bucket statistics\n" +
-		"\tTotal number of buckets: 3\n" +
-		"\tTotal number on inlined buckets: 2 (66%)\n" +
-		"\tBytes used for inlined buckets: 236 (11%)\n"
-
-	// Run the command.
-	m := NewMain()
-	if err := m.Run("stats", db.Path); err != nil {
-		t.Fatal(err)
-	} else if m.Stdout.String() != exp {
-		t.Fatalf("unexpected stdout:\n\n%s", m.Stdout.String())
-	}
-}
-
-// Main represents a test wrapper for main.Main that records output.
-type Main struct {
-	*main.Main
-	Stdin  bytes.Buffer
-	Stdout bytes.Buffer
-	Stderr bytes.Buffer
-}
-
-// NewMain returns a new instance of Main.
-func NewMain() *Main {
-	m := &Main{Main: main.NewMain()}
-	m.Main.Stdin = &m.Stdin
-	m.Main.Stdout = &m.Stdout
-	m.Main.Stderr = &m.Stderr
-	return m
-}
-
-// MustOpen creates a Bolt database in a temporary location.
-func MustOpen(mode os.FileMode, options *bolt.Options) *DB {
-	// Create temporary path.
-	f, _ := ioutil.TempFile("", "bolt-")
-	f.Close()
-	os.Remove(f.Name())
-
-	db, err := bolt.Open(f.Name(), mode, options)
-	if err != nil {
-		panic(err.Error())
-	}
-	return &DB{DB: db, Path: f.Name()}
-}
-
-// DB is a test wrapper for bolt.DB.
-type DB struct {
-	*bolt.DB
-	Path string
-}
-
-// Close closes and removes the database.
-func (db *DB) Close() error {
-	defer os.Remove(db.Path)
-	return db.DB.Close()
-}
-
-func TestCompactCommand_Run(t *testing.T) {
-	var s int64
-	if err := binary.Read(crypto.Reader, binary.BigEndian, &s); err != nil {
-		t.Fatal(err)
-	}
-	rand.Seed(s)
-
-	dstdb := MustOpen(0666, nil)
-	dstdb.Close()
-
-	// fill the db
-	db := MustOpen(0666, nil)
-	if err := db.Update(func(tx *bolt.Tx) error {
-		n := 2 + rand.Intn(5)
-		for i := 0; i < n; i++ {
-			k := []byte(fmt.Sprintf("b%d", i))
-			b, err := tx.CreateBucketIfNotExists(k)
-			if err != nil {
-				return err
-			}
-			if err := b.SetSequence(uint64(i)); err != nil {
-				return err
-			}
-			if err := fillBucket(b, append(k, '.')); err != nil {
-				return err
-			}
-		}
-		return nil
-	}); err != nil {
-		db.Close()
-		t.Fatal(err)
-	}
-
-	// make the db grow by adding large values, and delete them.
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucketIfNotExists([]byte("large_vals"))
-		if err != nil {
-			return err
-		}
-		n := 5 + rand.Intn(5)
-		for i := 0; i < n; i++ {
-			v := make([]byte, 1000*1000*(1+rand.Intn(5)))
-			_, err := crypto.Read(v)
-			if err != nil {
-				return err
-			}
-			if err := b.Put([]byte(fmt.Sprintf("l%d", i)), v); err != nil {
-				return err
-			}
-		}
-		return nil
-	}); err != nil {
-		db.Close()
-		t.Fatal(err)
-	}
-	if err := db.Update(func(tx *bolt.Tx) error {
-		c := tx.Bucket([]byte("large_vals")).Cursor()
-		for k, _ := c.First(); k != nil; k, _ = c.Next() {
-			if err := c.Delete(); err != nil {
-				return err
-			}
-		}
-		return tx.DeleteBucket([]byte("large_vals"))
-	}); err != nil {
-		db.Close()
-		t.Fatal(err)
-	}
-	db.DB.Close()
-	defer db.Close()
-	defer dstdb.Close()
-
-	dbChk, err := chkdb(db.Path)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	m := NewMain()
-	if err := m.Run("compact", "-o", dstdb.Path, db.Path); err != nil {
-		t.Fatal(err)
-	}
-
-	dbChkAfterCompact, err := chkdb(db.Path)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	dstdbChk, err := chkdb(dstdb.Path)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if !bytes.Equal(dbChk, dbChkAfterCompact) {
-		t.Error("the original db has been touched")
-	}
-	if !bytes.Equal(dbChk, dstdbChk) {
-		t.Error("the compacted db data isn't the same than the original db")
-	}
-}
-
-func fillBucket(b *bolt.Bucket, prefix []byte) error {
-	n := 10 + rand.Intn(50)
-	for i := 0; i < n; i++ {
-		v := make([]byte, 10*(1+rand.Intn(4)))
-		_, err := crypto.Read(v)
-		if err != nil {
-			return err
-		}
-		k := append(prefix, []byte(fmt.Sprintf("k%d", i))...)
-		if err := b.Put(k, v); err != nil {
-			return err
-		}
-	}
-	// limit depth of subbuckets
-	s := 2 + rand.Intn(4)
-	if len(prefix) > (2*s + 1) {
-		return nil
-	}
-	n = 1 + rand.Intn(3)
-	for i := 0; i < n; i++ {
-		k := append(prefix, []byte(fmt.Sprintf("b%d", i))...)
-		sb, err := b.CreateBucket(k)
-		if err != nil {
-			return err
-		}
-		if err := fillBucket(sb, append(k, '.')); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func chkdb(path string) ([]byte, error) {
-	db, err := bolt.Open(path, 0666, nil)
-	if err != nil {
-		return nil, err
-	}
-	defer db.Close()
-	var buf bytes.Buffer
-	err = db.View(func(tx *bolt.Tx) error {
-		return tx.ForEach(func(name []byte, b *bolt.Bucket) error {
-			return walkBucket(b, name, nil, &buf)
-		})
-	})
-	if err != nil {
-		return nil, err
-	}
-	return buf.Bytes(), nil
-}
-
-func walkBucket(parent *bolt.Bucket, k []byte, v []byte, w io.Writer) error {
-	if _, err := fmt.Fprintf(w, "%d:%x=%x\n", parent.Sequence(), k, v); err != nil {
-		return err
-	}
-
-	// not a bucket, exit.
-	if v != nil {
-		return nil
-	}
-	return parent.ForEach(func(k, v []byte) error {
-		if v == nil {
-			return walkBucket(parent.Bucket(k), k, nil, w)
-		}
-		return walkBucket(parent, k, v, w)
-	})
-}
--- a/vendor/github.com/boltdb/bolt/cursor_test.go
+++ b/vendor/github.com/boltdb/bolt/cursor_test.go
@@ -1,817 +0,0 @@
-package bolt_test
-
-import (
-	"bytes"
-	"encoding/binary"
-	"fmt"
-	"log"
-	"os"
-	"reflect"
-	"sort"
-	"testing"
-	"testing/quick"
-
-	"github.com/boltdb/bolt"
-)
-
-// Ensure that a cursor can return a reference to the bucket that created it.
-func TestCursor_Bucket(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if cb := b.Cursor().Bucket(); !reflect.DeepEqual(cb, b) {
-			t.Fatal("cursor bucket mismatch")
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that a Tx cursor can seek to the appropriate keys.
-func TestCursor_Seek(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("foo"), []byte("0001")); err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("bar"), []byte("0002")); err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("baz"), []byte("0003")); err != nil {
-			t.Fatal(err)
-		}
-
-		if _, err := b.CreateBucket([]byte("bkt")); err != nil {
-			t.Fatal(err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := db.View(func(tx *bolt.Tx) error {
-		c := tx.Bucket([]byte("widgets")).Cursor()
-
-		// Exact match should go to the key.
-		if k, v := c.Seek([]byte("bar")); !bytes.Equal(k, []byte("bar")) {
-			t.Fatalf("unexpected key: %v", k)
-		} else if !bytes.Equal(v, []byte("0002")) {
-			t.Fatalf("unexpected value: %v", v)
-		}
-
-		// Inexact match should go to the next key.
-		if k, v := c.Seek([]byte("bas")); !bytes.Equal(k, []byte("baz")) {
-			t.Fatalf("unexpected key: %v", k)
-		} else if !bytes.Equal(v, []byte("0003")) {
-			t.Fatalf("unexpected value: %v", v)
-		}
-
-		// Low key should go to the first key.
-		if k, v := c.Seek([]byte("")); !bytes.Equal(k, []byte("bar")) {
-			t.Fatalf("unexpected key: %v", k)
-		} else if !bytes.Equal(v, []byte("0002")) {
-			t.Fatalf("unexpected value: %v", v)
-		}
-
-		// High key should return no key.
-		if k, v := c.Seek([]byte("zzz")); k != nil {
-			t.Fatalf("expected nil key: %v", k)
-		} else if v != nil {
-			t.Fatalf("expected nil value: %v", v)
-		}
-
-		// Buckets should return their key but no value.
-		if k, v := c.Seek([]byte("bkt")); !bytes.Equal(k, []byte("bkt")) {
-			t.Fatalf("unexpected key: %v", k)
-		} else if v != nil {
-			t.Fatalf("expected nil value: %v", v)
-		}
-
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestCursor_Delete(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-
-	const count = 1000
-
-	// Insert every other key between 0 and $count.
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		for i := 0; i < count; i += 1 {
-			k := make([]byte, 8)
-			binary.BigEndian.PutUint64(k, uint64(i))
-			if err := b.Put(k, make([]byte, 100)); err != nil {
-				t.Fatal(err)
-			}
-		}
-		if _, err := b.CreateBucket([]byte("sub")); err != nil {
-			t.Fatal(err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := db.Update(func(tx *bolt.Tx) error {
-		c := tx.Bucket([]byte("widgets")).Cursor()
-		bound := make([]byte, 8)
-		binary.BigEndian.PutUint64(bound, uint64(count/2))
-		for key, _ := c.First(); bytes.Compare(key, bound) < 0; key, _ = c.Next() {
-			if err := c.Delete(); err != nil {
-				t.Fatal(err)
-			}
-		}
-
-		c.Seek([]byte("sub"))
-		if err := c.Delete(); err != bolt.ErrIncompatibleValue {
-			t.Fatalf("unexpected error: %s", err)
-		}
-
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := db.View(func(tx *bolt.Tx) error {
-		stats := tx.Bucket([]byte("widgets")).Stats()
-		if stats.KeyN != count/2+1 {
-			t.Fatalf("unexpected KeyN: %d", stats.KeyN)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that a Tx cursor can seek to the appropriate keys when there are a
-// large number of keys. This test also checks that seek will always move
-// forward to the next key.
-//
-// Related: https://github.com/boltdb/bolt/pull/187
-func TestCursor_Seek_Large(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-
-	var count = 10000
-
-	// Insert every other key between 0 and $count.
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		for i := 0; i < count; i += 100 {
-			for j := i; j < i+100; j += 2 {
-				k := make([]byte, 8)
-				binary.BigEndian.PutUint64(k, uint64(j))
-				if err := b.Put(k, make([]byte, 100)); err != nil {
-					t.Fatal(err)
-				}
-			}
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := db.View(func(tx *bolt.Tx) error {
-		c := tx.Bucket([]byte("widgets")).Cursor()
-		for i := 0; i < count; i++ {
-			seek := make([]byte, 8)
-			binary.BigEndian.PutUint64(seek, uint64(i))
-
-			k, _ := c.Seek(seek)
-
-			// The last seek is beyond the end of the the range so
-			// it should return nil.
-			if i == count-1 {
-				if k != nil {
-					t.Fatal("expected nil key")
-				}
-				continue
-			}
-
-			// Otherwise we should seek to the exact key or the next key.
-			num := binary.BigEndian.Uint64(k)
-			if i%2 == 0 {
-				if num != uint64(i) {
-					t.Fatalf("unexpected num: %d", num)
-				}
-			} else {
-				if num != uint64(i+1) {
-					t.Fatalf("unexpected num: %d", num)
-				}
-			}
-		}
-
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that a cursor can iterate over an empty bucket without error.
-func TestCursor_EmptyBucket(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	if err := db.Update(func(tx *bolt.Tx) error {
-		_, err := tx.CreateBucket([]byte("widgets"))
-		return err
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := db.View(func(tx *bolt.Tx) error {
-		c := tx.Bucket([]byte("widgets")).Cursor()
-		k, v := c.First()
-		if k != nil {
-			t.Fatalf("unexpected key: %v", k)
-		} else if v != nil {
-			t.Fatalf("unexpected value: %v", v)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that a Tx cursor can reverse iterate over an empty bucket without error.
-func TestCursor_EmptyBucketReverse(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-
-	if err := db.Update(func(tx *bolt.Tx) error {
-		_, err := tx.CreateBucket([]byte("widgets"))
-		return err
-	}); err != nil {
-		t.Fatal(err)
-	}
-	if err := db.View(func(tx *bolt.Tx) error {
-		c := tx.Bucket([]byte("widgets")).Cursor()
-		k, v := c.Last()
-		if k != nil {
-			t.Fatalf("unexpected key: %v", k)
-		} else if v != nil {
-			t.Fatalf("unexpected value: %v", v)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that a Tx cursor can iterate over a single root with a couple elements.
-func TestCursor_Iterate_Leaf(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("baz"), []byte{}); err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("foo"), []byte{0}); err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("bar"), []byte{1}); err != nil {
-			t.Fatal(err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-	tx, err := db.Begin(false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer func() { _ = tx.Rollback() }()
-
-	c := tx.Bucket([]byte("widgets")).Cursor()
-
-	k, v := c.First()
-	if !bytes.Equal(k, []byte("bar")) {
-		t.Fatalf("unexpected key: %v", k)
-	} else if !bytes.Equal(v, []byte{1}) {
-		t.Fatalf("unexpected value: %v", v)
-	}
-
-	k, v = c.Next()
-	if !bytes.Equal(k, []byte("baz")) {
-		t.Fatalf("unexpected key: %v", k)
-	} else if !bytes.Equal(v, []byte{}) {
-		t.Fatalf("unexpected value: %v", v)
-	}
-
-	k, v = c.Next()
-	if !bytes.Equal(k, []byte("foo")) {
-		t.Fatalf("unexpected key: %v", k)
-	} else if !bytes.Equal(v, []byte{0}) {
-		t.Fatalf("unexpected value: %v", v)
-	}
-
-	k, v = c.Next()
-	if k != nil {
-		t.Fatalf("expected nil key: %v", k)
-	} else if v != nil {
-		t.Fatalf("expected nil value: %v", v)
-	}
-
-	k, v = c.Next()
-	if k != nil {
-		t.Fatalf("expected nil key: %v", k)
-	} else if v != nil {
-		t.Fatalf("expected nil value: %v", v)
-	}
-
-	if err := tx.Rollback(); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that a Tx cursor can iterate in reverse over a single root with a couple elements.
-func TestCursor_LeafRootReverse(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("baz"), []byte{}); err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("foo"), []byte{0}); err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("bar"), []byte{1}); err != nil {
-			t.Fatal(err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-	tx, err := db.Begin(false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	c := tx.Bucket([]byte("widgets")).Cursor()
-
-	if k, v := c.Last(); !bytes.Equal(k, []byte("foo")) {
-		t.Fatalf("unexpected key: %v", k)
-	} else if !bytes.Equal(v, []byte{0}) {
-		t.Fatalf("unexpected value: %v", v)
-	}
-
-	if k, v := c.Prev(); !bytes.Equal(k, []byte("baz")) {
-		t.Fatalf("unexpected key: %v", k)
-	} else if !bytes.Equal(v, []byte{}) {
-		t.Fatalf("unexpected value: %v", v)
-	}
-
-	if k, v := c.Prev(); !bytes.Equal(k, []byte("bar")) {
-		t.Fatalf("unexpected key: %v", k)
-	} else if !bytes.Equal(v, []byte{1}) {
-		t.Fatalf("unexpected value: %v", v)
-	}
-
-	if k, v := c.Prev(); k != nil {
-		t.Fatalf("expected nil key: %v", k)
-	} else if v != nil {
-		t.Fatalf("expected nil value: %v", v)
-	}
-
-	if k, v := c.Prev(); k != nil {
-		t.Fatalf("expected nil key: %v", k)
-	} else if v != nil {
-		t.Fatalf("expected nil value: %v", v)
-	}
-
-	if err := tx.Rollback(); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that a Tx cursor can restart from the beginning.
-func TestCursor_Restart(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("bar"), []byte{}); err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("foo"), []byte{}); err != nil {
-			t.Fatal(err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	tx, err := db.Begin(false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	c := tx.Bucket([]byte("widgets")).Cursor()
-
-	if k, _ := c.First(); !bytes.Equal(k, []byte("bar")) {
-		t.Fatalf("unexpected key: %v", k)
-	}
-	if k, _ := c.Next(); !bytes.Equal(k, []byte("foo")) {
-		t.Fatalf("unexpected key: %v", k)
-	}
-
-	if k, _ := c.First(); !bytes.Equal(k, []byte("bar")) {
-		t.Fatalf("unexpected key: %v", k)
-	}
-	if k, _ := c.Next(); !bytes.Equal(k, []byte("foo")) {
-		t.Fatalf("unexpected key: %v", k)
-	}
-
-	if err := tx.Rollback(); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that a cursor can skip over empty pages that have been deleted.
-func TestCursor_First_EmptyPages(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-
-	// Create 1000 keys in the "widgets" bucket.
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		for i := 0; i < 1000; i++ {
-			if err := b.Put(u64tob(uint64(i)), []byte{}); err != nil {
-				t.Fatal(err)
-			}
-		}
-
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	// Delete half the keys and then try to iterate.
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b := tx.Bucket([]byte("widgets"))
-		for i := 0; i < 600; i++ {
-			if err := b.Delete(u64tob(uint64(i))); err != nil {
-				t.Fatal(err)
-			}
-		}
-
-		c := b.Cursor()
-		var n int
-		for k, _ := c.First(); k != nil; k, _ = c.Next() {
-			n++
-		}
-		if n != 400 {
-			t.Fatalf("unexpected key count: %d", n)
-		}
-
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that a Tx can iterate over all elements in a bucket.
-func TestCursor_QuickCheck(t *testing.T) {
-	f := func(items testdata) bool {
-		db := MustOpenDB()
-		defer db.MustClose()
-
-		// Bulk insert all values.
-		tx, err := db.Begin(true)
-		if err != nil {
-			t.Fatal(err)
-		}
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		for _, item := range items {
-			if err := b.Put(item.Key, item.Value); err != nil {
-				t.Fatal(err)
-			}
-		}
-		if err := tx.Commit(); err != nil {
-			t.Fatal(err)
-		}
-
-		// Sort test data.
-		sort.Sort(items)
-
-		// Iterate over all items and check consistency.
-		var index = 0
-		tx, err = db.Begin(false)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		c := tx.Bucket([]byte("widgets")).Cursor()
-		for k, v := c.First(); k != nil && index < len(items); k, v = c.Next() {
-			if !bytes.Equal(k, items[index].Key) {
-				t.Fatalf("unexpected key: %v", k)
-			} else if !bytes.Equal(v, items[index].Value) {
-				t.Fatalf("unexpected value: %v", v)
-			}
-			index++
-		}
-		if len(items) != index {
-			t.Fatalf("unexpected item count: %v, expected %v", len(items), index)
-		}
-
-		if err := tx.Rollback(); err != nil {
-			t.Fatal(err)
-		}
-
-		return true
-	}
-	if err := quick.Check(f, qconfig()); err != nil {
-		t.Error(err)
-	}
-}
-
-// Ensure that a transaction can iterate over all elements in a bucket in reverse.
-func TestCursor_QuickCheck_Reverse(t *testing.T) {
-	f := func(items testdata) bool {
-		db := MustOpenDB()
-		defer db.MustClose()
-
-		// Bulk insert all values.
-		tx, err := db.Begin(true)
-		if err != nil {
-			t.Fatal(err)
-		}
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		for _, item := range items {
-			if err := b.Put(item.Key, item.Value); err != nil {
-				t.Fatal(err)
-			}
-		}
-		if err := tx.Commit(); err != nil {
-			t.Fatal(err)
-		}
-
-		// Sort test data.
-		sort.Sort(revtestdata(items))
-
-		// Iterate over all items and check consistency.
-		var index = 0
-		tx, err = db.Begin(false)
-		if err != nil {
-			t.Fatal(err)
-		}
-		c := tx.Bucket([]byte("widgets")).Cursor()
-		for k, v := c.Last(); k != nil && index < len(items); k, v = c.Prev() {
-			if !bytes.Equal(k, items[index].Key) {
-				t.Fatalf("unexpected key: %v", k)
-			} else if !bytes.Equal(v, items[index].Value) {
-				t.Fatalf("unexpected value: %v", v)
-			}
-			index++
-		}
-		if len(items) != index {
-			t.Fatalf("unexpected item count: %v, expected %v", len(items), index)
-		}
-
-		if err := tx.Rollback(); err != nil {
-			t.Fatal(err)
-		}
-
-		return true
-	}
-	if err := quick.Check(f, qconfig()); err != nil {
-		t.Error(err)
-	}
-}
-
-// Ensure that a Tx cursor can iterate over subbuckets.
-func TestCursor_QuickCheck_BucketsOnly(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if _, err := b.CreateBucket([]byte("foo")); err != nil {
-			t.Fatal(err)
-		}
-		if _, err := b.CreateBucket([]byte("bar")); err != nil {
-			t.Fatal(err)
-		}
-		if _, err := b.CreateBucket([]byte("baz")); err != nil {
-			t.Fatal(err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := db.View(func(tx *bolt.Tx) error {
-		var names []string
-		c := tx.Bucket([]byte("widgets")).Cursor()
-		for k, v := c.First(); k != nil; k, v = c.Next() {
-			names = append(names, string(k))
-			if v != nil {
-				t.Fatalf("unexpected value: %v", v)
-			}
-		}
-		if !reflect.DeepEqual(names, []string{"bar", "baz", "foo"}) {
-			t.Fatalf("unexpected names: %+v", names)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that a Tx cursor can reverse iterate over subbuckets.
-func TestCursor_QuickCheck_BucketsOnly_Reverse(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if _, err := b.CreateBucket([]byte("foo")); err != nil {
-			t.Fatal(err)
-		}
-		if _, err := b.CreateBucket([]byte("bar")); err != nil {
-			t.Fatal(err)
-		}
-		if _, err := b.CreateBucket([]byte("baz")); err != nil {
-			t.Fatal(err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := db.View(func(tx *bolt.Tx) error {
-		var names []string
-		c := tx.Bucket([]byte("widgets")).Cursor()
-		for k, v := c.Last(); k != nil; k, v = c.Prev() {
-			names = append(names, string(k))
-			if v != nil {
-				t.Fatalf("unexpected value: %v", v)
-			}
-		}
-		if !reflect.DeepEqual(names, []string{"foo", "baz", "bar"}) {
-			t.Fatalf("unexpected names: %+v", names)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func ExampleCursor() {
-	// Open the database.
-	db, err := bolt.Open(tempfile(), 0666, nil)
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer os.Remove(db.Path())
-
-	// Start a read-write transaction.
-	if err := db.Update(func(tx *bolt.Tx) error {
-		// Create a new bucket.
-		b, err := tx.CreateBucket([]byte("animals"))
-		if err != nil {
-			return err
-		}
-
-		// Insert data into a bucket.
-		if err := b.Put([]byte("dog"), []byte("fun")); err != nil {
-			log.Fatal(err)
-		}
-		if err := b.Put([]byte("cat"), []byte("lame")); err != nil {
-			log.Fatal(err)
-		}
-		if err := b.Put([]byte("liger"), []byte("awesome")); err != nil {
-			log.Fatal(err)
-		}
-
-		// Create a cursor for iteration.
-		c := b.Cursor()
-
-		// Iterate over items in sorted key order. This starts from the
-		// first key/value pair and updates the k/v variables to the
-		// next key/value on each iteration.
-		//
-		// The loop finishes at the end of the cursor when a nil key is returned.
-		for k, v := c.First(); k != nil; k, v = c.Next() {
-			fmt.Printf("A %s is %s.\n", k, v)
-		}
-
-		return nil
-	}); err != nil {
-		log.Fatal(err)
-	}
-
-	if err := db.Close(); err != nil {
-		log.Fatal(err)
-	}
-
-	// Output:
-	// A cat is lame.
-	// A dog is fun.
-	// A liger is awesome.
-}
-
-func ExampleCursor_reverse() {
-	// Open the database.
-	db, err := bolt.Open(tempfile(), 0666, nil)
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer os.Remove(db.Path())
-
-	// Start a read-write transaction.
-	if err := db.Update(func(tx *bolt.Tx) error {
-		// Create a new bucket.
-		b, err := tx.CreateBucket([]byte("animals"))
-		if err != nil {
-			return err
-		}
-
-		// Insert data into a bucket.
-		if err := b.Put([]byte("dog"), []byte("fun")); err != nil {
-			log.Fatal(err)
-		}
-		if err := b.Put([]byte("cat"), []byte("lame")); err != nil {
-			log.Fatal(err)
-		}
-		if err := b.Put([]byte("liger"), []byte("awesome")); err != nil {
-			log.Fatal(err)
-		}
-
-		// Create a cursor for iteration.
-		c := b.Cursor()
-
-		// Iterate over items in reverse sorted key order. This starts
-		// from the last key/value pair and updates the k/v variables to
-		// the previous key/value on each iteration.
-		//
-		// The loop finishes at the beginning of the cursor when a nil key
-		// is returned.
-		for k, v := c.Last(); k != nil; k, v = c.Prev() {
-			fmt.Printf("A %s is %s.\n", k, v)
-		}
-
-		return nil
-	}); err != nil {
-		log.Fatal(err)
-	}
-
-	// Close the database to release the file lock.
-	if err := db.Close(); err != nil {
-		log.Fatal(err)
-	}
-
-	// Output:
-	// A liger is awesome.
-	// A dog is fun.
-	// A cat is lame.
-}
--- a/vendor/github.com/boltdb/bolt/db_test.go
+++ b/vendor/github.com/boltdb/bolt/db_test.go
--- a/vendor/github.com/boltdb/bolt/freelist_test.go
+++ b/vendor/github.com/boltdb/bolt/freelist_test.go
@@ -1,158 +0,0 @@
-package bolt
-
-import (
-	"math/rand"
-	"reflect"
-	"sort"
-	"testing"
-	"unsafe"
-)
-
-// Ensure that a page is added to a transaction's freelist.
-func TestFreelist_free(t *testing.T) {
-	f := newFreelist()
-	f.free(100, &page{id: 12})
-	if !reflect.DeepEqual([]pgid{12}, f.pending[100]) {
-		t.Fatalf("exp=%v; got=%v", []pgid{12}, f.pending[100])
-	}
-}
-
-// Ensure that a page and its overflow is added to a transaction's freelist.
-func TestFreelist_free_overflow(t *testing.T) {
-	f := newFreelist()
-	f.free(100, &page{id: 12, overflow: 3})
-	if exp := []pgid{12, 13, 14, 15}; !reflect.DeepEqual(exp, f.pending[100]) {
-		t.Fatalf("exp=%v; got=%v", exp, f.pending[100])
-	}
-}
-
-// Ensure that a transaction's free pages can be released.
-func TestFreelist_release(t *testing.T) {
-	f := newFreelist()
-	f.free(100, &page{id: 12, overflow: 1})
-	f.free(100, &page{id: 9})
-	f.free(102, &page{id: 39})
-	f.release(100)
-	f.release(101)
-	if exp := []pgid{9, 12, 13}; !reflect.DeepEqual(exp, f.ids) {
-		t.Fatalf("exp=%v; got=%v", exp, f.ids)
-	}
-
-	f.release(102)
-	if exp := []pgid{9, 12, 13, 39}; !reflect.DeepEqual(exp, f.ids) {
-		t.Fatalf("exp=%v; got=%v", exp, f.ids)
-	}
-}
-
-// Ensure that a freelist can find contiguous blocks of pages.
-func TestFreelist_allocate(t *testing.T) {
-	f := &freelist{ids: []pgid{3, 4, 5, 6, 7, 9, 12, 13, 18}}
-	if id := int(f.allocate(3)); id != 3 {
-		t.Fatalf("exp=3; got=%v", id)
-	}
-	if id := int(f.allocate(1)); id != 6 {
-		t.Fatalf("exp=6; got=%v", id)
-	}
-	if id := int(f.allocate(3)); id != 0 {
-		t.Fatalf("exp=0; got=%v", id)
-	}
-	if id := int(f.allocate(2)); id != 12 {
-		t.Fatalf("exp=12; got=%v", id)
-	}
-	if id := int(f.allocate(1)); id != 7 {
-		t.Fatalf("exp=7; got=%v", id)
-	}
-	if id := int(f.allocate(0)); id != 0 {
-		t.Fatalf("exp=0; got=%v", id)
-	}
-	if id := int(f.allocate(0)); id != 0 {
-		t.Fatalf("exp=0; got=%v", id)
-	}
-	if exp := []pgid{9, 18}; !reflect.DeepEqual(exp, f.ids) {
-		t.Fatalf("exp=%v; got=%v", exp, f.ids)
-	}
-
-	if id := int(f.allocate(1)); id != 9 {
-		t.Fatalf("exp=9; got=%v", id)
-	}
-	if id := int(f.allocate(1)); id != 18 {
-		t.Fatalf("exp=18; got=%v", id)
-	}
-	if id := int(f.allocate(1)); id != 0 {
-		t.Fatalf("exp=0; got=%v", id)
-	}
-	if exp := []pgid{}; !reflect.DeepEqual(exp, f.ids) {
-		t.Fatalf("exp=%v; got=%v", exp, f.ids)
-	}
-}
-
-// Ensure that a freelist can deserialize from a freelist page.
-func TestFreelist_read(t *testing.T) {
-	// Create a page.
-	var buf [4096]byte
-	page := (*page)(unsafe.Pointer(&buf[0]))
-	page.flags = freelistPageFlag
-	page.count = 2
-
-	// Insert 2 page ids.
-	ids := (*[3]pgid)(unsafe.Pointer(&page.ptr))
-	ids[0] = 23
-	ids[1] = 50
-
-	// Deserialize page into a freelist.
-	f := newFreelist()
-	f.read(page)
-
-	// Ensure that there are two page ids in the freelist.
-	if exp := []pgid{23, 50}; !reflect.DeepEqual(exp, f.ids) {
-		t.Fatalf("exp=%v; got=%v", exp, f.ids)
-	}
-}
-
-// Ensure that a freelist can serialize into a freelist page.
-func TestFreelist_write(t *testing.T) {
-	// Create a freelist and write it to a page.
-	var buf [4096]byte
-	f := &freelist{ids: []pgid{12, 39}, pending: make(map[txid][]pgid)}
-	f.pending[100] = []pgid{28, 11}
-	f.pending[101] = []pgid{3}
-	p := (*page)(unsafe.Pointer(&buf[0]))
-	if err := f.write(p); err != nil {
-		t.Fatal(err)
-	}
-
-	// Read the page back out.
-	f2 := newFreelist()
-	f2.read(p)
-
-	// Ensure that the freelist is correct.
-	// All pages should be present and in reverse order.
-	if exp := []pgid{3, 11, 12, 28, 39}; !reflect.DeepEqual(exp, f2.ids) {
-		t.Fatalf("exp=%v; got=%v", exp, f2.ids)
-	}
-}
-
-func Benchmark_FreelistRelease10K(b *testing.B)    { benchmark_FreelistRelease(b, 10000) }
-func Benchmark_FreelistRelease100K(b *testing.B)   { benchmark_FreelistRelease(b, 100000) }
-func Benchmark_FreelistRelease1000K(b *testing.B)  { benchmark_FreelistRelease(b, 1000000) }
-func Benchmark_FreelistRelease10000K(b *testing.B) { benchmark_FreelistRelease(b, 10000000) }
-
-func benchmark_FreelistRelease(b *testing.B, size int) {
-	ids := randomPgids(size)
-	pending := randomPgids(len(ids) / 400)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		f := &freelist{ids: ids, pending: map[txid][]pgid{1: pending}}
-		f.release(1)
-	}
-}
-
-func randomPgids(n int) []pgid {
-	rand.Seed(42)
-	pgids := make(pgids, n)
-	for i := range pgids {
-		pgids[i] = pgid(rand.Int63())
-	}
-	sort.Sort(pgids)
-	return pgids
-}
--- a/vendor/github.com/boltdb/bolt/node_test.go
+++ b/vendor/github.com/boltdb/bolt/node_test.go
@@ -1,156 +0,0 @@
-package bolt
-
-import (
-	"testing"
-	"unsafe"
-)
-
-// Ensure that a node can insert a key/value.
-func TestNode_put(t *testing.T) {
-	n := &node{inodes: make(inodes, 0), bucket: &Bucket{tx: &Tx{meta: &meta{pgid: 1}}}}
-	n.put([]byte("baz"), []byte("baz"), []byte("2"), 0, 0)
-	n.put([]byte("foo"), []byte("foo"), []byte("0"), 0, 0)
-	n.put([]byte("bar"), []byte("bar"), []byte("1"), 0, 0)
-	n.put([]byte("foo"), []byte("foo"), []byte("3"), 0, leafPageFlag)
-
-	if len(n.inodes) != 3 {
-		t.Fatalf("exp=3; got=%d", len(n.inodes))
-	}
-	if k, v := n.inodes[0].key, n.inodes[0].value; string(k) != "bar" || string(v) != "1" {
-		t.Fatalf("exp=<bar,1>; got=<%s,%s>", k, v)
-	}
-	if k, v := n.inodes[1].key, n.inodes[1].value; string(k) != "baz" || string(v) != "2" {
-		t.Fatalf("exp=<baz,2>; got=<%s,%s>", k, v)
-	}
-	if k, v := n.inodes[2].key, n.inodes[2].value; string(k) != "foo" || string(v) != "3" {
-		t.Fatalf("exp=<foo,3>; got=<%s,%s>", k, v)
-	}
-	if n.inodes[2].flags != uint32(leafPageFlag) {
-		t.Fatalf("not a leaf: %d", n.inodes[2].flags)
-	}
-}
-
-// Ensure that a node can deserialize from a leaf page.
-func TestNode_read_LeafPage(t *testing.T) {
-	// Create a page.
-	var buf [4096]byte
-	page := (*page)(unsafe.Pointer(&buf[0]))
-	page.flags = leafPageFlag
-	page.count = 2
-
-	// Insert 2 elements at the beginning. sizeof(leafPageElement) == 16
-	nodes := (*[3]leafPageElement)(unsafe.Pointer(&page.ptr))
-	nodes[0] = leafPageElement{flags: 0, pos: 32, ksize: 3, vsize: 4}  // pos = sizeof(leafPageElement) * 2
-	nodes[1] = leafPageElement{flags: 0, pos: 23, ksize: 10, vsize: 3} // pos = sizeof(leafPageElement) + 3 + 4
-
-	// Write data for the nodes at the end.
-	data := (*[4096]byte)(unsafe.Pointer(&nodes[2]))
-	copy(data[:], []byte("barfooz"))
-	copy(data[7:], []byte("helloworldbye"))
-
-	// Deserialize page into a leaf.
-	n := &node{}
-	n.read(page)
-
-	// Check that there are two inodes with correct data.
-	if !n.isLeaf {
-		t.Fatal("expected leaf")
-	}
-	if len(n.inodes) != 2 {
-		t.Fatalf("exp=2; got=%d", len(n.inodes))
-	}
-	if k, v := n.inodes[0].key, n.inodes[0].value; string(k) != "bar" || string(v) != "fooz" {
-		t.Fatalf("exp=<bar,fooz>; got=<%s,%s>", k, v)
-	}
-	if k, v := n.inodes[1].key, n.inodes[1].value; string(k) != "helloworld" || string(v) != "bye" {
-		t.Fatalf("exp=<helloworld,bye>; got=<%s,%s>", k, v)
-	}
-}
-
-// Ensure that a node can serialize into a leaf page.
-func TestNode_write_LeafPage(t *testing.T) {
-	// Create a node.
-	n := &node{isLeaf: true, inodes: make(inodes, 0), bucket: &Bucket{tx: &Tx{db: &DB{}, meta: &meta{pgid: 1}}}}
-	n.put([]byte("susy"), []byte("susy"), []byte("que"), 0, 0)
-	n.put([]byte("ricki"), []byte("ricki"), []byte("lake"), 0, 0)
-	n.put([]byte("john"), []byte("john"), []byte("johnson"), 0, 0)
-
-	// Write it to a page.
-	var buf [4096]byte
-	p := (*page)(unsafe.Pointer(&buf[0]))
-	n.write(p)
-
-	// Read the page back in.
-	n2 := &node{}
-	n2.read(p)
-
-	// Check that the two pages are the same.
-	if len(n2.inodes) != 3 {
-		t.Fatalf("exp=3; got=%d", len(n2.inodes))
-	}
-	if k, v := n2.inodes[0].key, n2.inodes[0].value; string(k) != "john" || string(v) != "johnson" {
-		t.Fatalf("exp=<john,johnson>; got=<%s,%s>", k, v)
-	}
-	if k, v := n2.inodes[1].key, n2.inodes[1].value; string(k) != "ricki" || string(v) != "lake" {
-		t.Fatalf("exp=<ricki,lake>; got=<%s,%s>", k, v)
-	}
-	if k, v := n2.inodes[2].key, n2.inodes[2].value; string(k) != "susy" || string(v) != "que" {
-		t.Fatalf("exp=<susy,que>; got=<%s,%s>", k, v)
-	}
-}
-
-// Ensure that a node can split into appropriate subgroups.
-func TestNode_split(t *testing.T) {
-	// Create a node.
-	n := &node{inodes: make(inodes, 0), bucket: &Bucket{tx: &Tx{db: &DB{}, meta: &meta{pgid: 1}}}}
-	n.put([]byte("00000001"), []byte("00000001"), []byte("0123456701234567"), 0, 0)
-	n.put([]byte("00000002"), []byte("00000002"), []byte("0123456701234567"), 0, 0)
-	n.put([]byte("00000003"), []byte("00000003"), []byte("0123456701234567"), 0, 0)
-	n.put([]byte("00000004"), []byte("00000004"), []byte("0123456701234567"), 0, 0)
-	n.put([]byte("00000005"), []byte("00000005"), []byte("0123456701234567"), 0, 0)
-
-	// Split between 2 & 3.
-	n.split(100)
-
-	var parent = n.parent
-	if len(parent.children) != 2 {
-		t.Fatalf("exp=2; got=%d", len(parent.children))
-	}
-	if len(parent.children[0].inodes) != 2 {
-		t.Fatalf("exp=2; got=%d", len(parent.children[0].inodes))
-	}
-	if len(parent.children[1].inodes) != 3 {
-		t.Fatalf("exp=3; got=%d", len(parent.children[1].inodes))
-	}
-}
-
-// Ensure that a page with the minimum number of inodes just returns a single node.
-func TestNode_split_MinKeys(t *testing.T) {
-	// Create a node.
-	n := &node{inodes: make(inodes, 0), bucket: &Bucket{tx: &Tx{db: &DB{}, meta: &meta{pgid: 1}}}}
-	n.put([]byte("00000001"), []byte("00000001"), []byte("0123456701234567"), 0, 0)
-	n.put([]byte("00000002"), []byte("00000002"), []byte("0123456701234567"), 0, 0)
-
-	// Split.
-	n.split(20)
-	if n.parent != nil {
-		t.Fatalf("expected nil parent")
-	}
-}
-
-// Ensure that a node that has keys that all fit on a page just returns one leaf.
-func TestNode_split_SinglePage(t *testing.T) {
-	// Create a node.
-	n := &node{inodes: make(inodes, 0), bucket: &Bucket{tx: &Tx{db: &DB{}, meta: &meta{pgid: 1}}}}
-	n.put([]byte("00000001"), []byte("00000001"), []byte("0123456701234567"), 0, 0)
-	n.put([]byte("00000002"), []byte("00000002"), []byte("0123456701234567"), 0, 0)
-	n.put([]byte("00000003"), []byte("00000003"), []byte("0123456701234567"), 0, 0)
-	n.put([]byte("00000004"), []byte("00000004"), []byte("0123456701234567"), 0, 0)
-	n.put([]byte("00000005"), []byte("00000005"), []byte("0123456701234567"), 0, 0)
-
-	// Split.
-	n.split(4096)
-	if n.parent != nil {
-		t.Fatalf("expected nil parent")
-	}
-}
--- a/vendor/github.com/boltdb/bolt/page_test.go
+++ b/vendor/github.com/boltdb/bolt/page_test.go
@@ -1,72 +0,0 @@
-package bolt
-
-import (
-	"reflect"
-	"sort"
-	"testing"
-	"testing/quick"
-)
-
-// Ensure that the page type can be returned in human readable format.
-func TestPage_typ(t *testing.T) {
-	if typ := (&page{flags: branchPageFlag}).typ(); typ != "branch" {
-		t.Fatalf("exp=branch; got=%v", typ)
-	}
-	if typ := (&page{flags: leafPageFlag}).typ(); typ != "leaf" {
-		t.Fatalf("exp=leaf; got=%v", typ)
-	}
-	if typ := (&page{flags: metaPageFlag}).typ(); typ != "meta" {
-		t.Fatalf("exp=meta; got=%v", typ)
-	}
-	if typ := (&page{flags: freelistPageFlag}).typ(); typ != "freelist" {
-		t.Fatalf("exp=freelist; got=%v", typ)
-	}
-	if typ := (&page{flags: 20000}).typ(); typ != "unknown<4e20>" {
-		t.Fatalf("exp=unknown<4e20>; got=%v", typ)
-	}
-}
-
-// Ensure that the hexdump debugging function doesn't blow up.
-func TestPage_dump(t *testing.T) {
-	(&page{id: 256}).hexdump(16)
-}
-
-func TestPgids_merge(t *testing.T) {
-	a := pgids{4, 5, 6, 10, 11, 12, 13, 27}
-	b := pgids{1, 3, 8, 9, 25, 30}
-	c := a.merge(b)
-	if !reflect.DeepEqual(c, pgids{1, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 25, 27, 30}) {
-		t.Errorf("mismatch: %v", c)
-	}
-
-	a = pgids{4, 5, 6, 10, 11, 12, 13, 27, 35, 36}
-	b = pgids{8, 9, 25, 30}
-	c = a.merge(b)
-	if !reflect.DeepEqual(c, pgids{4, 5, 6, 8, 9, 10, 11, 12, 13, 25, 27, 30, 35, 36}) {
-		t.Errorf("mismatch: %v", c)
-	}
-}
-
-func TestPgids_merge_quick(t *testing.T) {
-	if err := quick.Check(func(a, b pgids) bool {
-		// Sort incoming lists.
-		sort.Sort(a)
-		sort.Sort(b)
-
-		// Merge the two lists together.
-		got := a.merge(b)
-
-		// The expected value should be the two lists combined and sorted.
-		exp := append(a, b...)
-		sort.Sort(exp)
-
-		if !reflect.DeepEqual(exp, got) {
-			t.Errorf("\nexp=%+v\ngot=%+v\n", exp, got)
-			return false
-		}
-
-		return true
-	}, nil); err != nil {
-		t.Fatal(err)
-	}
-}
--- a/vendor/github.com/boltdb/bolt/quick_test.go
+++ b/vendor/github.com/boltdb/bolt/quick_test.go
@@ -1,87 +0,0 @@
-package bolt_test
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"math/rand"
-	"os"
-	"reflect"
-	"testing/quick"
-	"time"
-)
-
-// testing/quick defaults to 5 iterations and a random seed.
-// You can override these settings from the command line:
-//
-//   -quick.count     The number of iterations to perform.
-//   -quick.seed      The seed to use for randomizing.
-//   -quick.maxitems  The maximum number of items to insert into a DB.
-//   -quick.maxksize  The maximum size of a key.
-//   -quick.maxvsize  The maximum size of a value.
-//
-
-var qcount, qseed, qmaxitems, qmaxksize, qmaxvsize int
-
-func init() {
-	flag.IntVar(&qcount, "quick.count", 5, "")
-	flag.IntVar(&qseed, "quick.seed", int(time.Now().UnixNano())%100000, "")
-	flag.IntVar(&qmaxitems, "quick.maxitems", 1000, "")
-	flag.IntVar(&qmaxksize, "quick.maxksize", 1024, "")
-	flag.IntVar(&qmaxvsize, "quick.maxvsize", 1024, "")
-	flag.Parse()
-	fmt.Fprintln(os.Stderr, "seed:", qseed)
-	fmt.Fprintf(os.Stderr, "quick settings: count=%v, items=%v, ksize=%v, vsize=%v\n", qcount, qmaxitems, qmaxksize, qmaxvsize)
-}
-
-func qconfig() *quick.Config {
-	return &quick.Config{
-		MaxCount: qcount,
-		Rand:     rand.New(rand.NewSource(int64(qseed))),
-	}
-}
-
-type testdata []testdataitem
-
-func (t testdata) Len() int           { return len(t) }
-func (t testdata) Swap(i, j int)      { t[i], t[j] = t[j], t[i] }
-func (t testdata) Less(i, j int) bool { return bytes.Compare(t[i].Key, t[j].Key) == -1 }
-
-func (t testdata) Generate(rand *rand.Rand, size int) reflect.Value {
-	n := rand.Intn(qmaxitems-1) + 1
-	items := make(testdata, n)
-	used := make(map[string]bool)
-	for i := 0; i < n; i++ {
-		item := &items[i]
-		// Ensure that keys are unique by looping until we find one that we have not already used.
-		for {
-			item.Key = randByteSlice(rand, 1, qmaxksize)
-			if !used[string(item.Key)] {
-				used[string(item.Key)] = true
-				break
-			}
-		}
-		item.Value = randByteSlice(rand, 0, qmaxvsize)
-	}
-	return reflect.ValueOf(items)
-}
-
-type revtestdata []testdataitem
-
-func (t revtestdata) Len() int           { return len(t) }
-func (t revtestdata) Swap(i, j int)      { t[i], t[j] = t[j], t[i] }
-func (t revtestdata) Less(i, j int) bool { return bytes.Compare(t[i].Key, t[j].Key) == 1 }
-
-type testdataitem struct {
-	Key   []byte
-	Value []byte
-}
-
-func randByteSlice(rand *rand.Rand, minSize, maxSize int) []byte {
-	n := rand.Intn(maxSize-minSize) + minSize
-	b := make([]byte, n)
-	for i := 0; i < n; i++ {
-		b[i] = byte(rand.Intn(255))
-	}
-	return b
-}
--- a/vendor/github.com/boltdb/bolt/simulation_test.go
+++ b/vendor/github.com/boltdb/bolt/simulation_test.go
@@ -1,329 +0,0 @@
-package bolt_test
-
-import (
-	"bytes"
-	"fmt"
-	"math/rand"
-	"sync"
-	"testing"
-
-	"github.com/boltdb/bolt"
-)
-
-func TestSimulate_1op_1p(t *testing.T)     { testSimulate(t, 1, 1) }
-func TestSimulate_10op_1p(t *testing.T)    { testSimulate(t, 10, 1) }
-func TestSimulate_100op_1p(t *testing.T)   { testSimulate(t, 100, 1) }
-func TestSimulate_1000op_1p(t *testing.T)  { testSimulate(t, 1000, 1) }
-func TestSimulate_10000op_1p(t *testing.T) { testSimulate(t, 10000, 1) }
-
-func TestSimulate_10op_10p(t *testing.T)    { testSimulate(t, 10, 10) }
-func TestSimulate_100op_10p(t *testing.T)   { testSimulate(t, 100, 10) }
-func TestSimulate_1000op_10p(t *testing.T)  { testSimulate(t, 1000, 10) }
-func TestSimulate_10000op_10p(t *testing.T) { testSimulate(t, 10000, 10) }
-
-func TestSimulate_100op_100p(t *testing.T)   { testSimulate(t, 100, 100) }
-func TestSimulate_1000op_100p(t *testing.T)  { testSimulate(t, 1000, 100) }
-func TestSimulate_10000op_100p(t *testing.T) { testSimulate(t, 10000, 100) }
-
-func TestSimulate_10000op_1000p(t *testing.T) { testSimulate(t, 10000, 1000) }
-
-// Randomly generate operations on a given database with multiple clients to ensure consistency and thread safety.
-func testSimulate(t *testing.T, threadCount, parallelism int) {
-	if testing.Short() {
-		t.Skip("skipping test in short mode.")
-	}
-
-	rand.Seed(int64(qseed))
-
-	// A list of operations that readers and writers can perform.
-	var readerHandlers = []simulateHandler{simulateGetHandler}
-	var writerHandlers = []simulateHandler{simulateGetHandler, simulatePutHandler}
-
-	var versions = make(map[int]*QuickDB)
-	versions[1] = NewQuickDB()
-
-	db := MustOpenDB()
-	defer db.MustClose()
-
-	var mutex sync.Mutex
-
-	// Run n threads in parallel, each with their own operation.
-	var wg sync.WaitGroup
-	var threads = make(chan bool, parallelism)
-	var i int
-	for {
-		threads <- true
-		wg.Add(1)
-		writable := ((rand.Int() % 100) < 20) // 20% writers
-
-		// Choose an operation to execute.
-		var handler simulateHandler
-		if writable {
-			handler = writerHandlers[rand.Intn(len(writerHandlers))]
-		} else {
-			handler = readerHandlers[rand.Intn(len(readerHandlers))]
-		}
-
-		// Execute a thread for the given operation.
-		go func(writable bool, handler simulateHandler) {
-			defer wg.Done()
-
-			// Start transaction.
-			tx, err := db.Begin(writable)
-			if err != nil {
-				t.Fatal("tx begin: ", err)
-			}
-
-			// Obtain current state of the dataset.
-			mutex.Lock()
-			var qdb = versions[tx.ID()]
-			if writable {
-				qdb = versions[tx.ID()-1].Copy()
-			}
-			mutex.Unlock()
-
-			// Make sure we commit/rollback the tx at the end and update the state.
-			if writable {
-				defer func() {
-					mutex.Lock()
-					versions[tx.ID()] = qdb
-					mutex.Unlock()
-
-					if err := tx.Commit(); err != nil {
-						t.Fatal(err)
-					}
-				}()
-			} else {
-				defer func() { _ = tx.Rollback() }()
-			}
-
-			// Ignore operation if we don't have data yet.
-			if qdb == nil {
-				return
-			}
-
-			// Execute handler.
-			handler(tx, qdb)
-
-			// Release a thread back to the scheduling loop.
-			<-threads
-		}(writable, handler)
-
-		i++
-		if i > threadCount {
-			break
-		}
-	}
-
-	// Wait until all threads are done.
-	wg.Wait()
-}
-
-type simulateHandler func(tx *bolt.Tx, qdb *QuickDB)
-
-// Retrieves a key from the database and verifies that it is what is expected.
-func simulateGetHandler(tx *bolt.Tx, qdb *QuickDB) {
-	// Randomly retrieve an existing exist.
-	keys := qdb.Rand()
-	if len(keys) == 0 {
-		return
-	}
-
-	// Retrieve root bucket.
-	b := tx.Bucket(keys[0])
-	if b == nil {
-		panic(fmt.Sprintf("bucket[0] expected: %08x\n", trunc(keys[0], 4)))
-	}
-
-	// Drill into nested buckets.
-	for _, key := range keys[1 : len(keys)-1] {
-		b = b.Bucket(key)
-		if b == nil {
-			panic(fmt.Sprintf("bucket[n] expected: %v -> %v\n", keys, key))
-		}
-	}
-
-	// Verify key/value on the final bucket.
-	expected := qdb.Get(keys)
-	actual := b.Get(keys[len(keys)-1])
-	if !bytes.Equal(actual, expected) {
-		fmt.Println("=== EXPECTED ===")
-		fmt.Println(expected)
-		fmt.Println("=== ACTUAL ===")
-		fmt.Println(actual)
-		fmt.Println("=== END ===")
-		panic("value mismatch")
-	}
-}
-
-// Inserts a key into the database.
-func simulatePutHandler(tx *bolt.Tx, qdb *QuickDB) {
-	var err error
-	keys, value := randKeys(), randValue()
-
-	// Retrieve root bucket.
-	b := tx.Bucket(keys[0])
-	if b == nil {
-		b, err = tx.CreateBucket(keys[0])
-		if err != nil {
-			panic("create bucket: " + err.Error())
-		}
-	}
-
-	// Create nested buckets, if necessary.
-	for _, key := range keys[1 : len(keys)-1] {
-		child := b.Bucket(key)
-		if child != nil {
-			b = child
-		} else {
-			b, err = b.CreateBucket(key)
-			if err != nil {
-				panic("create bucket: " + err.Error())
-			}
-		}
-	}
-
-	// Insert into database.
-	if err := b.Put(keys[len(keys)-1], value); err != nil {
-		panic("put: " + err.Error())
-	}
-
-	// Insert into in-memory database.
-	qdb.Put(keys, value)
-}
-
-// QuickDB is an in-memory database that replicates the functionality of the
-// Bolt DB type except that it is entirely in-memory. It is meant for testing
-// that the Bolt database is consistent.
-type QuickDB struct {
-	sync.RWMutex
-	m map[string]interface{}
-}
-
-// NewQuickDB returns an instance of QuickDB.
-func NewQuickDB() *QuickDB {
-	return &QuickDB{m: make(map[string]interface{})}
-}
-
-// Get retrieves the value at a key path.
-func (db *QuickDB) Get(keys [][]byte) []byte {
-	db.RLock()
-	defer db.RUnlock()
-
-	m := db.m
-	for _, key := range keys[:len(keys)-1] {
-		value := m[string(key)]
-		if value == nil {
-			return nil
-		}
-		switch value := value.(type) {
-		case map[string]interface{}:
-			m = value
-		case []byte:
-			return nil
-		}
-	}
-
-	// Only return if it's a simple value.
-	if value, ok := m[string(keys[len(keys)-1])].([]byte); ok {
-		return value
-	}
-	return nil
-}
-
-// Put inserts a value into a key path.
-func (db *QuickDB) Put(keys [][]byte, value []byte) {
-	db.Lock()
-	defer db.Unlock()
-
-	// Build buckets all the way down the key path.
-	m := db.m
-	for _, key := range keys[:len(keys)-1] {
-		if _, ok := m[string(key)].([]byte); ok {
-			return // Keypath intersects with a simple value. Do nothing.
-		}
-
-		if m[string(key)] == nil {
-			m[string(key)] = make(map[string]interface{})
-		}
-		m = m[string(key)].(map[string]interface{})
-	}
-
-	// Insert value into the last key.
-	m[string(keys[len(keys)-1])] = value
-}
-
-// Rand returns a random key path that points to a simple value.
-func (db *QuickDB) Rand() [][]byte {
-	db.RLock()
-	defer db.RUnlock()
-	if len(db.m) == 0 {
-		return nil
-	}
-	var keys [][]byte
-	db.rand(db.m, &keys)
-	return keys
-}
-
-func (db *QuickDB) rand(m map[string]interface{}, keys *[][]byte) {
-	i, index := 0, rand.Intn(len(m))
-	for k, v := range m {
-		if i == index {
-			*keys = append(*keys, []byte(k))
-			if v, ok := v.(map[string]interface{}); ok {
-				db.rand(v, keys)
-			}
-			return
-		}
-		i++
-	}
-	panic("quickdb rand: out-of-range")
-}
-
-// Copy copies the entire database.
-func (db *QuickDB) Copy() *QuickDB {
-	db.RLock()
-	defer db.RUnlock()
-	return &QuickDB{m: db.copy(db.m)}
-}
-
-func (db *QuickDB) copy(m map[string]interface{}) map[string]interface{} {
-	clone := make(map[string]interface{}, len(m))
-	for k, v := range m {
-		switch v := v.(type) {
-		case map[string]interface{}:
-			clone[k] = db.copy(v)
-		default:
-			clone[k] = v
-		}
-	}
-	return clone
-}
-
-func randKey() []byte {
-	var min, max = 1, 1024
-	n := rand.Intn(max-min) + min
-	b := make([]byte, n)
-	for i := 0; i < n; i++ {
-		b[i] = byte(rand.Intn(255))
-	}
-	return b
-}
-
-func randKeys() [][]byte {
-	var keys [][]byte
-	var count = rand.Intn(2) + 2
-	for i := 0; i < count; i++ {
-		keys = append(keys, randKey())
-	}
-	return keys
-}
-
-func randValue() []byte {
-	n := rand.Intn(8192)
-	b := make([]byte, n)
-	for i := 0; i < n; i++ {
-		b[i] = byte(rand.Intn(255))
-	}
-	return b
-}
--- a/vendor/github.com/boltdb/bolt/tx_test.go
+++ b/vendor/github.com/boltdb/bolt/tx_test.go
@@ -1,716 +0,0 @@
-package bolt_test
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"log"
-	"os"
-	"testing"
-
-	"github.com/boltdb/bolt"
-)
-
-// Ensure that committing a closed transaction returns an error.
-func TestTx_Commit_ErrTxClosed(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	tx, err := db.Begin(true)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := tx.CreateBucket([]byte("foo")); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := tx.Commit(); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := tx.Commit(); err != bolt.ErrTxClosed {
-		t.Fatalf("unexpected error: %s", err)
-	}
-}
-
-// Ensure that rolling back a closed transaction returns an error.
-func TestTx_Rollback_ErrTxClosed(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-
-	tx, err := db.Begin(true)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := tx.Rollback(); err != nil {
-		t.Fatal(err)
-	}
-	if err := tx.Rollback(); err != bolt.ErrTxClosed {
-		t.Fatalf("unexpected error: %s", err)
-	}
-}
-
-// Ensure that committing a read-only transaction returns an error.
-func TestTx_Commit_ErrTxNotWritable(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	tx, err := db.Begin(false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := tx.Commit(); err != bolt.ErrTxNotWritable {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that a transaction can retrieve a cursor on the root bucket.
-func TestTx_Cursor(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	if err := db.Update(func(tx *bolt.Tx) error {
-		if _, err := tx.CreateBucket([]byte("widgets")); err != nil {
-			t.Fatal(err)
-		}
-
-		if _, err := tx.CreateBucket([]byte("woojits")); err != nil {
-			t.Fatal(err)
-		}
-
-		c := tx.Cursor()
-		if k, v := c.First(); !bytes.Equal(k, []byte("widgets")) {
-			t.Fatalf("unexpected key: %v", k)
-		} else if v != nil {
-			t.Fatalf("unexpected value: %v", v)
-		}
-
-		if k, v := c.Next(); !bytes.Equal(k, []byte("woojits")) {
-			t.Fatalf("unexpected key: %v", k)
-		} else if v != nil {
-			t.Fatalf("unexpected value: %v", v)
-		}
-
-		if k, v := c.Next(); k != nil {
-			t.Fatalf("unexpected key: %v", k)
-		} else if v != nil {
-			t.Fatalf("unexpected value: %v", k)
-		}
-
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that creating a bucket with a read-only transaction returns an error.
-func TestTx_CreateBucket_ErrTxNotWritable(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	if err := db.View(func(tx *bolt.Tx) error {
-		_, err := tx.CreateBucket([]byte("foo"))
-		if err != bolt.ErrTxNotWritable {
-			t.Fatalf("unexpected error: %s", err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that creating a bucket on a closed transaction returns an error.
-func TestTx_CreateBucket_ErrTxClosed(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	tx, err := db.Begin(true)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := tx.Commit(); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := tx.CreateBucket([]byte("foo")); err != bolt.ErrTxClosed {
-		t.Fatalf("unexpected error: %s", err)
-	}
-}
-
-// Ensure that a Tx can retrieve a bucket.
-func TestTx_Bucket(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	if err := db.Update(func(tx *bolt.Tx) error {
-		if _, err := tx.CreateBucket([]byte("widgets")); err != nil {
-			t.Fatal(err)
-		}
-		if tx.Bucket([]byte("widgets")) == nil {
-			t.Fatal("expected bucket")
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that a Tx retrieving a non-existent key returns nil.
-func TestTx_Get_NotFound(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
-			t.Fatal(err)
-		}
-		if b.Get([]byte("no_such_key")) != nil {
-			t.Fatal("expected nil value")
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that a bucket can be created and retrieved.
-func TestTx_CreateBucket(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-
-	// Create a bucket.
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		} else if b == nil {
-			t.Fatal("expected bucket")
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	// Read the bucket through a separate transaction.
-	if err := db.View(func(tx *bolt.Tx) error {
-		if tx.Bucket([]byte("widgets")) == nil {
-			t.Fatal("expected bucket")
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that a bucket can be created if it doesn't already exist.
-func TestTx_CreateBucketIfNotExists(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	if err := db.Update(func(tx *bolt.Tx) error {
-		// Create bucket.
-		if b, err := tx.CreateBucketIfNotExists([]byte("widgets")); err != nil {
-			t.Fatal(err)
-		} else if b == nil {
-			t.Fatal("expected bucket")
-		}
-
-		// Create bucket again.
-		if b, err := tx.CreateBucketIfNotExists([]byte("widgets")); err != nil {
-			t.Fatal(err)
-		} else if b == nil {
-			t.Fatal("expected bucket")
-		}
-
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	// Read the bucket through a separate transaction.
-	if err := db.View(func(tx *bolt.Tx) error {
-		if tx.Bucket([]byte("widgets")) == nil {
-			t.Fatal("expected bucket")
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure transaction returns an error if creating an unnamed bucket.
-func TestTx_CreateBucketIfNotExists_ErrBucketNameRequired(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	if err := db.Update(func(tx *bolt.Tx) error {
-		if _, err := tx.CreateBucketIfNotExists([]byte{}); err != bolt.ErrBucketNameRequired {
-			t.Fatalf("unexpected error: %s", err)
-		}
-
-		if _, err := tx.CreateBucketIfNotExists(nil); err != bolt.ErrBucketNameRequired {
-			t.Fatalf("unexpected error: %s", err)
-		}
-
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that a bucket cannot be created twice.
-func TestTx_CreateBucket_ErrBucketExists(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-
-	// Create a bucket.
-	if err := db.Update(func(tx *bolt.Tx) error {
-		if _, err := tx.CreateBucket([]byte("widgets")); err != nil {
-			t.Fatal(err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	// Create the same bucket again.
-	if err := db.Update(func(tx *bolt.Tx) error {
-		if _, err := tx.CreateBucket([]byte("widgets")); err != bolt.ErrBucketExists {
-			t.Fatalf("unexpected error: %s", err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that a bucket is created with a non-blank name.
-func TestTx_CreateBucket_ErrBucketNameRequired(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	if err := db.Update(func(tx *bolt.Tx) error {
-		if _, err := tx.CreateBucket(nil); err != bolt.ErrBucketNameRequired {
-			t.Fatalf("unexpected error: %s", err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that a bucket can be deleted.
-func TestTx_DeleteBucket(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-
-	// Create a bucket and add a value.
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
-			t.Fatal(err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	// Delete the bucket and make sure we can't get the value.
-	if err := db.Update(func(tx *bolt.Tx) error {
-		if err := tx.DeleteBucket([]byte("widgets")); err != nil {
-			t.Fatal(err)
-		}
-		if tx.Bucket([]byte("widgets")) != nil {
-			t.Fatal("unexpected bucket")
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := db.Update(func(tx *bolt.Tx) error {
-		// Create the bucket again and make sure there's not a phantom value.
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if v := b.Get([]byte("foo")); v != nil {
-			t.Fatalf("unexpected phantom value: %v", v)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that deleting a bucket on a closed transaction returns an error.
-func TestTx_DeleteBucket_ErrTxClosed(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	tx, err := db.Begin(true)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := tx.Commit(); err != nil {
-		t.Fatal(err)
-	}
-	if err := tx.DeleteBucket([]byte("foo")); err != bolt.ErrTxClosed {
-		t.Fatalf("unexpected error: %s", err)
-	}
-}
-
-// Ensure that deleting a bucket with a read-only transaction returns an error.
-func TestTx_DeleteBucket_ReadOnly(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	if err := db.View(func(tx *bolt.Tx) error {
-		if err := tx.DeleteBucket([]byte("foo")); err != bolt.ErrTxNotWritable {
-			t.Fatalf("unexpected error: %s", err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that nothing happens when deleting a bucket that doesn't exist.
-func TestTx_DeleteBucket_NotFound(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	if err := db.Update(func(tx *bolt.Tx) error {
-		if err := tx.DeleteBucket([]byte("widgets")); err != bolt.ErrBucketNotFound {
-			t.Fatalf("unexpected error: %s", err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that no error is returned when a tx.ForEach function does not return
-// an error.
-func TestTx_ForEach_NoError(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
-			t.Fatal(err)
-		}
-
-		if err := tx.ForEach(func(name []byte, b *bolt.Bucket) error {
-			return nil
-		}); err != nil {
-			t.Fatal(err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that an error is returned when a tx.ForEach function returns an error.
-func TestTx_ForEach_WithError(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
-			t.Fatal(err)
-		}
-
-		marker := errors.New("marker")
-		if err := tx.ForEach(func(name []byte, b *bolt.Bucket) error {
-			return marker
-		}); err != marker {
-			t.Fatalf("unexpected error: %s", err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Ensure that Tx commit handlers are called after a transaction successfully commits.
-func TestTx_OnCommit(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-
-	var x int
-	if err := db.Update(func(tx *bolt.Tx) error {
-		tx.OnCommit(func() { x += 1 })
-		tx.OnCommit(func() { x += 2 })
-		if _, err := tx.CreateBucket([]byte("widgets")); err != nil {
-			t.Fatal(err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	} else if x != 3 {
-		t.Fatalf("unexpected x: %d", x)
-	}
-}
-
-// Ensure that Tx commit handlers are NOT called after a transaction rolls back.
-func TestTx_OnCommit_Rollback(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-
-	var x int
-	if err := db.Update(func(tx *bolt.Tx) error {
-		tx.OnCommit(func() { x += 1 })
-		tx.OnCommit(func() { x += 2 })
-		if _, err := tx.CreateBucket([]byte("widgets")); err != nil {
-			t.Fatal(err)
-		}
-		return errors.New("rollback this commit")
-	}); err == nil || err.Error() != "rollback this commit" {
-		t.Fatalf("unexpected error: %s", err)
-	} else if x != 0 {
-		t.Fatalf("unexpected x: %d", x)
-	}
-}
-
-// Ensure that the database can be copied to a file path.
-func TestTx_CopyFile(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-
-	path := tempfile()
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("baz"), []byte("bat")); err != nil {
-			t.Fatal(err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := db.View(func(tx *bolt.Tx) error {
-		return tx.CopyFile(path, 0600)
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	db2, err := bolt.Open(path, 0600, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := db2.View(func(tx *bolt.Tx) error {
-		if v := tx.Bucket([]byte("widgets")).Get([]byte("foo")); !bytes.Equal(v, []byte("bar")) {
-			t.Fatalf("unexpected value: %v", v)
-		}
-		if v := tx.Bucket([]byte("widgets")).Get([]byte("baz")); !bytes.Equal(v, []byte("bat")) {
-			t.Fatalf("unexpected value: %v", v)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := db2.Close(); err != nil {
-		t.Fatal(err)
-	}
-}
-
-type failWriterError struct{}
-
-func (failWriterError) Error() string {
-	return "error injected for tests"
-}
-
-type failWriter struct {
-	// fail after this many bytes
-	After int
-}
-
-func (f *failWriter) Write(p []byte) (n int, err error) {
-	n = len(p)
-	if n > f.After {
-		n = f.After
-		err = failWriterError{}
-	}
-	f.After -= n
-	return n, err
-}
-
-// Ensure that Copy handles write errors right.
-func TestTx_CopyFile_Error_Meta(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("baz"), []byte("bat")); err != nil {
-			t.Fatal(err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := db.View(func(tx *bolt.Tx) error {
-		return tx.Copy(&failWriter{})
-	}); err == nil || err.Error() != "meta 0 copy: error injected for tests" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-// Ensure that Copy handles write errors right.
-func TestTx_CopyFile_Error_Normal(t *testing.T) {
-	db := MustOpenDB()
-	defer db.MustClose()
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
-			t.Fatal(err)
-		}
-		if err := b.Put([]byte("baz"), []byte("bat")); err != nil {
-			t.Fatal(err)
-		}
-		return nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := db.View(func(tx *bolt.Tx) error {
-		return tx.Copy(&failWriter{3 * db.Info().PageSize})
-	}); err == nil || err.Error() != "error injected for tests" {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func ExampleTx_Rollback() {
-	// Open the database.
-	db, err := bolt.Open(tempfile(), 0666, nil)
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer os.Remove(db.Path())
-
-	// Create a bucket.
-	if err := db.Update(func(tx *bolt.Tx) error {
-		_, err := tx.CreateBucket([]byte("widgets"))
-		return err
-	}); err != nil {
-		log.Fatal(err)
-	}
-
-	// Set a value for a key.
-	if err := db.Update(func(tx *bolt.Tx) error {
-		return tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar"))
-	}); err != nil {
-		log.Fatal(err)
-	}
-
-	// Update the key but rollback the transaction so it never saves.
-	tx, err := db.Begin(true)
-	if err != nil {
-		log.Fatal(err)
-	}
-	b := tx.Bucket([]byte("widgets"))
-	if err := b.Put([]byte("foo"), []byte("baz")); err != nil {
-		log.Fatal(err)
-	}
-	if err := tx.Rollback(); err != nil {
-		log.Fatal(err)
-	}
-
-	// Ensure that our original value is still set.
-	if err := db.View(func(tx *bolt.Tx) error {
-		value := tx.Bucket([]byte("widgets")).Get([]byte("foo"))
-		fmt.Printf("The value for 'foo' is still: %s\n", value)
-		return nil
-	}); err != nil {
-		log.Fatal(err)
-	}
-
-	// Close database to release file lock.
-	if err := db.Close(); err != nil {
-		log.Fatal(err)
-	}
-
-	// Output:
-	// The value for 'foo' is still: bar
-}
-
-func ExampleTx_CopyFile() {
-	// Open the database.
-	db, err := bolt.Open(tempfile(), 0666, nil)
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer os.Remove(db.Path())
-
-	// Create a bucket and a key.
-	if err := db.Update(func(tx *bolt.Tx) error {
-		b, err := tx.CreateBucket([]byte("widgets"))
-		if err != nil {
-			return err
-		}
-		if err := b.Put([]byte("foo"), []byte("bar")); err != nil {
-			return err
-		}
-		return nil
-	}); err != nil {
-		log.Fatal(err)
-	}
-
-	// Copy the database to another file.
-	toFile := tempfile()
-	if err := db.View(func(tx *bolt.Tx) error {
-		return tx.CopyFile(toFile, 0666)
-	}); err != nil {
-		log.Fatal(err)
-	}
-	defer os.Remove(toFile)
-
-	// Open the cloned database.
-	db2, err := bolt.Open(toFile, 0666, nil)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	// Ensure that the key exists in the copy.
-	if err := db2.View(func(tx *bolt.Tx) error {
-		value := tx.Bucket([]byte("widgets")).Get([]byte("foo"))
-		fmt.Printf("The value for 'foo' in the clone is: %s\n", value)
-		return nil
-	}); err != nil {
-		log.Fatal(err)
-	}
-
-	// Close database to release file lock.
-	if err := db.Close(); err != nil {
-		log.Fatal(err)
-	}
-
-	if err := db2.Close(); err != nil {
-		log.Fatal(err)
-	}
-
-	// Output:
-	// The value for 'foo' in the clone is: bar
-}
--- a/vendor/github.com/briandowns/spinner/_example/main.go
+++ b/vendor/github.com/briandowns/spinner/_example/main.go
@@ -1,113 +0,0 @@
-// Example application that uses all of the available API options.
-package main
-import (
-	"log"
-	"time"
-
-	"github.com/briandowns/spinner"
-)
-
-func main() {
-	s := spinner.New(spinner.CharSets[9], 100*time.Millisecond) // Build our new spinner
-	s.Color("red")                                              // Set the spinner color to red
-	s.Start()                                                   // Start the spinner
-	time.Sleep(4 * time.Second)                                 // Run for some time to simulate work
-
-	s.UpdateCharSet(spinner.CharSets[9])  // Update spinner to use a different character set
-	s.UpdateSpeed(100 * time.Millisecond) // Update the speed the spinner spins at
-
-	s.Prefix = "prefixed text: " // Prefix text before the spinner
-	time.Sleep(4 * time.Second)
-	s.Prefix = ""
-	s.Suffix = "  :appended text" // Append text after the spinner
-	time.Sleep(4 * time.Second)
-
-	s.Prefix = "Colors: "
-
-	if err := s.Color("yellow"); err != nil {
-		log.Fatalln(err)
-	}
-
-	s.Start()
-
-	time.Sleep(4 * time.Second) // Run for some time to simulate work
-
-	if err := s.Color("red"); err != nil {
-		log.Fatalln(err)
-	}
-
-	s.UpdateCharSet(spinner.CharSets[20])
-
-	s.Reverse()
-
-	s.Restart()
-
-	time.Sleep(4 * time.Second) // Run for some time to simulate work
-
-	if err := s.Color("blue"); err != nil {
-		log.Fatalln(err)
-	}
-
-	s.UpdateCharSet(spinner.CharSets[3])
-
-	s.Restart()
-
-	time.Sleep(4 * time.Second) // Run for some time to simulate work
-
-	if err := s.Color("cyan"); err != nil {
-		log.Fatalln(err)
-	}
-
-	s.UpdateCharSet(spinner.CharSets[28])
-
-	s.Reverse()
-
-	s.Restart()
-
-	time.Sleep(4 * time.Second) // Run for some time to simulate work
-
-	if err := s.Color("green"); err != nil {
-		log.Fatalln(err)
-	}
-
-	s.UpdateCharSet(spinner.CharSets[25])
-
-	s.Restart()
-
-	time.Sleep(4 * time.Second) // Run for some time to simulate work
-
-	if err := s.Color("magenta"); err != nil {
-		log.Fatalln(err)
-	}
-
-	s.UpdateCharSet(spinner.CharSets[32])
-
-	s.Restart()
-
-	time.Sleep(4 * time.Second) // Run for some time to simulate work
-
-	if err := s.Color("white"); err != nil {
-		log.Fatalln(err)
-	}
-
-	s.FinalMSG = "Complete!\nNew line!\nAnother one!\n"
-
-	s.UpdateCharSet(spinner.CharSets[31])
-
-	s.Restart()
-
-	time.Sleep(4 * time.Second) // Run for some time to simulate work
-
-	s.Stop() // Stop the spinner
-
-	s.Prefix = "Earth! "
-	s.UpdateCharSet(spinner.CharSets[39])
-
-	s.Restart()
-
-	time.Sleep(4 * time.Second) // Run for some time to simulate work
-
-	s.Stop() // Stop the spinner
-
-	println("")
-}
--- a/vendor/github.com/briandowns/spinner/spinner_test.go
+++ b/vendor/github.com/briandowns/spinner/spinner_test.go
@@ -1,217 +0,0 @@
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package spinner
-
-import (
-	"bytes"
-	"fmt"
-	"reflect"
-	"sync"
-	"testing"
-	"time"
-)
-
-const baseWait = 3
-
-// syncBuffer
-type syncBuffer struct {
-	sync.Mutex
-	bytes.Buffer
-}
-
-// Write
-func (b *syncBuffer) Write(data []byte) (int, error) {
-	b.Lock()
-	defer b.Unlock()
-	return b.Buffer.Write(data)
-}
-
-// withOutput
-func withOutput(a []string, d time.Duration) (*Spinner, *syncBuffer) {
-	var out syncBuffer
-	s := New(a, d)
-	s.Writer = &out
-	return s, &out
-}
-
-// TestNew verifies that the returned instance is of the proper type
-func TestNew(t *testing.T) {
-	for i := 0; i < len(CharSets); i++ {
-		s := New(CharSets[i], 1*time.Second)
-		if reflect.TypeOf(s).String() != "*spinner.Spinner" {
-			t.Errorf("New returned incorrect type kind=%d", i)
-		}
-	}
-}
-
-// TestStart will verify a spinner can be started
-func TestStart(t *testing.T) {
-	s := New(CharSets[1], 100*time.Millisecond)
-	s.Color("red")
-	s.Start()
-	time.Sleep(baseWait * time.Second)
-	s.Stop()
-	time.Sleep(100 * time.Millisecond)
-}
-
-// TestStop will verify a spinner can be stopped
-func TestStop(t *testing.T) {
-	p, out := withOutput(CharSets[14], 100*time.Millisecond)
-	p.Color("yellow")
-	p.Start()
-	time.Sleep(500 * time.Millisecond)
-	p.Stop()
-	// because the spinner will print an appropriate number of backspaces before stopping,
-	// let it complete that sleep
-	time.Sleep(100 * time.Millisecond)
-	out.Lock()
-	len1 := out.Len()
-	out.Unlock()
-	time.Sleep(300 * time.Millisecond)
-	out.Lock()
-	defer out.Unlock()
-	len2 := out.Len()
-	if len1 != len2 {
-		t.Errorf("expected equal, got %v != %v", len1, len2)
-	}
-	p = nil
-}
-
-// TestRestart will verify a spinner can be stopped and started again
-func TestRestart(t *testing.T) {
-	s := New(CharSets[4], 50*time.Millisecond)
-	var out syncBuffer
-	s.Writer = &out
-	s.Start()
-	s.Color("cyan")
-	time.Sleep(200 * time.Millisecond)
-	s.Restart()
-	time.Sleep(200 * time.Millisecond)
-	s.Stop()
-	time.Sleep(50 * time.Millisecond)
-	out.Lock()
-	defer out.Unlock()
-	result := out.Bytes()
-	first := result[:len(result)/2]
-	secnd := result[len(result)/2:]
-	if string(first) != string(secnd) {
-		t.Errorf("Expected ==, got \n%#v != \n%#v", first, secnd)
-	}
-	s = nil
-}
-
-// TestReverse will verify that the given spinner can stop and start again reversed
-func TestReverse(t *testing.T) {
-	a := New(CharSets[10], 1*time.Second)
-	a.Color("red")
-	a.Start()
-	time.Sleep(baseWait * time.Second)
-	a.Reverse()
-	a.Restart()
-	time.Sleep(baseWait * time.Second)
-	a.Reverse()
-	a.Restart()
-	time.Sleep(baseWait * time.Second)
-	a.Stop()
-	a = nil
-}
-
-// TestUpdateSpeed verifies that the delay can be updated
-func TestUpdateSpeed(t *testing.T) {
-	s := New(CharSets[10], 1*time.Second)
-	delay1 := s.Delay
-	s.UpdateSpeed(baseWait * time.Second)
-	delay2 := s.Delay
-	if delay1 == delay2 {
-		t.Error("update of speed failed")
-	}
-	s = nil
-}
-
-// TestUpdateCharSet verifies that character sets can be updated
-func TestUpdateCharSet(t *testing.T) {
-	s := New(CharSets[14], 1*time.Second)
-	charSet1 := s.chars
-	s.UpdateCharSet(CharSets[1])
-	charSet2 := s.chars
-	for i := range charSet1 {
-		if charSet1[i] == charSet2[i] {
-			t.Error("update of char set failed")
-		}
-	}
-	s = nil
-}
-
-// TestGenerateNumberSequence verifies that a string slice of a spefic size is returned
-func TestGenerateNumberSequence(t *testing.T) {
-	elementCount := 100
-	seq := GenerateNumberSequence(elementCount)
-	if reflect.TypeOf(seq).String() != "[]string" {
-		t.Error("received incorrect type in return from GenerateNumberSequence")
-	}
-	t.Log("In: ", elementCount)
-	t.Log("Out: ", len(seq))
-	if len(seq) != elementCount {
-		t.Error("number of elements in slice doesn't match expected count")
-	}
-}
-
-// TestBackspace proves that the correct number of characters are removed.
-func TestBackspace(t *testing.T) {
-	// Because of buffering of output and time weirdness, somethings
-	// are broken for an indeterminant reason without a wait
-	time.Sleep(75 * time.Millisecond)
-	fmt.Println()
-	s := New(CharSets[0], 100*time.Millisecond)
-	s.Color("blue")
-	s.Start()
-	fmt.Print("This is on the same line as the spinner: ")
-	time.Sleep(baseWait * time.Second)
-	s.Stop()
-}
-
-// TestColorError tests that if an invalid color string is passed to the Color
-// function, the invalid color error is returned
-func TestColorError(t *testing.T) {
-	s := New(CharSets[0], 100*time.Millisecond)
-
-	invalidColorName := "bluez"
-	validColorName := "green"
-
-	if s.Color(invalidColorName) != errInvalidColor {
-		t.Error("Color method did not return an error when given an invalid color.")
-	}
-
-	if s.Color(validColorName) != nil {
-		t.Error("Color method did not return nil when given a valid color name.")
-	}
-}
-
-/*
-Benchmarks
-*/
-
-// BenchmarkNew runs a benchmark for the New() function
-func BenchmarkNew(b *testing.B) {
-	for n := 0; n < b.N; n++ {
-		New(CharSets[1], 1*time.Second)
-	}
-}
-
-func BenchmarkNewStartStop(b *testing.B) {
-	for n := 0; n < b.N; n++ {
-		s := New(CharSets[1], 1*time.Second)
-		s.Start()
-		s.Stop()
-	}
-}
--- a/vendor/github.com/davecgh/go-spew/.gitignore
+++ b/vendor/github.com/davecgh/go-spew/.gitignore
@@ -1,22 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
--- a/vendor/github.com/davecgh/go-spew/.travis.yml
+++ b/vendor/github.com/davecgh/go-spew/.travis.yml
@@ -1,14 +0,0 @@
-language: go
-go:
-    - 1.5.4
-    - 1.6.3
-    - 1.7
-install:
-    - go get -v golang.org/x/tools/cmd/cover
-script:
-    - go test -v -tags=safe ./spew
-    - go test -v -tags=testcgo ./spew -covermode=count -coverprofile=profile.cov
-after_success:
-    - go get -v github.com/mattn/goveralls
-    - export PATH=$PATH:$HOME/gopath/bin
-    - goveralls -coverprofile=profile.cov -service=travis-ci
--- a/vendor/github.com/davecgh/go-spew/README.md
+++ b/vendor/github.com/davecgh/go-spew/README.md
@@ -1,205 +0,0 @@
-go-spew
-=======
-
-[![Build Status](https://img.shields.io/travis/davecgh/go-spew.svg)]
-(https://travis-ci.org/davecgh/go-spew) [![ISC License]
-(http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org) [![Coverage Status]
-(https://img.shields.io/coveralls/davecgh/go-spew.svg)]
-(https://coveralls.io/r/davecgh/go-spew?branch=master)
-
-
-Go-spew implements a deep pretty printer for Go data structures to aid in
-debugging.  A comprehensive suite of tests with 100% test coverage is provided
-to ensure proper functionality.  See `test_coverage.txt` for the gocov coverage
-report.  Go-spew is licensed under the liberal ISC license, so it may be used in
-open source or commercial projects.
-
-If you're interested in reading about how this package came to life and some
-of the challenges involved in providing a deep pretty printer, there is a blog
-post about it
-[here](https://web.archive.org/web/20160304013555/https://blog.cyphertite.com/go-spew-a-journey-into-dumping-go-data-structures/).
-
-## Documentation
-
-[![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)]
-(http://godoc.org/github.com/davecgh/go-spew/spew)
-
-Full `go doc` style documentation for the project can be viewed online without
-installing this package by using the excellent GoDoc site here:
-http://godoc.org/github.com/davecgh/go-spew/spew
-
-You can also view the documentation locally once the package is installed with
-the `godoc` tool by running `godoc -http=":6060"` and pointing your browser to
-http://localhost:6060/pkg/github.com/davecgh/go-spew/spew
-
-## Installation
-
-```bash
-$ go get -u github.com/davecgh/go-spew/spew
-```
-
-## Quick Start
-
-Add this import line to the file you're working in:
-
-```Go
-import "github.com/davecgh/go-spew/spew"
-```
-
-To dump a variable with full newlines, indentation, type, and pointer
-information use Dump, Fdump, or Sdump:
-
-```Go
-spew.Dump(myVar1, myVar2, ...)
-spew.Fdump(someWriter, myVar1, myVar2, ...)
-str := spew.Sdump(myVar1, myVar2, ...)
-```
-
-Alternatively, if you would prefer to use format strings with a compacted inline
-printing style, use the convenience wrappers Printf, Fprintf, etc with %v (most
-compact), %+v (adds pointer addresses), %#v (adds types), or %#+v (adds types
-and pointer addresses): 
-
-```Go
-spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
-spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
-```
-
-## Debugging a Web Application Example
-
-Here is an example of how you can use `spew.Sdump()` to help debug a web application. Please be sure to wrap your output using the `html.EscapeString()` function for safety reasons. You should also only use this debugging technique in a development environment, never in production.
-
-```Go
-package main
-
-import (
-    "fmt"
-    "html"
-    "net/http"
-
-    "github.com/davecgh/go-spew/spew"
-)
-
-func handler(w http.ResponseWriter, r *http.Request) {
-    w.Header().Set("Content-Type", "text/html")
-    fmt.Fprintf(w, "Hi there, %s!", r.URL.Path[1:])
-    fmt.Fprintf(w, "<!--\n" + html.EscapeString(spew.Sdump(w)) + "\n-->")
-}
-
-func main() {
-    http.HandleFunc("/", handler)
-    http.ListenAndServe(":8080", nil)
-}
-```
-
-## Sample Dump Output
-
-```
-(main.Foo) {
- unexportedField: (*main.Bar)(0xf84002e210)({
-  flag: (main.Flag) flagTwo,
-  data: (uintptr) <nil>
- }),
- ExportedField: (map[interface {}]interface {}) {
-  (string) "one": (bool) true
- }
-}
-([]uint8) {
- 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |
- 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|
- 00000020  31 32                                             |12|
-}
-```
-
-## Sample Formatter Output
-
-Double pointer to a uint8:
-```
-	  %v: <**>5
-	 %+v: <**>(0xf8400420d0->0xf8400420c8)5
-	 %#v: (**uint8)5
-	%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
-```
-
-Pointer to circular struct with a uint8 field and a pointer to itself:
-```
-	  %v: <*>{1 <*><shown>}
-	 %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
-	 %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
-	%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
-```
-
-## Configuration Options
-
-Configuration of spew is handled by fields in the ConfigState type. For
-convenience, all of the top-level functions use a global state available via the
-spew.Config global.
-
-It is also possible to create a ConfigState instance that provides methods
-equivalent to the top-level functions. This allows concurrent configuration
-options. See the ConfigState documentation for more details.
-
-```
-* Indent
-	String to use for each indentation level for Dump functions.
-	It is a single space by default.  A popular alternative is "\t".
-
-* MaxDepth
-	Maximum number of levels to descend into nested data structures.
-	There is no limit by default.
-
-* DisableMethods
-	Disables invocation of error and Stringer interface methods.
-	Method invocation is enabled by default.
-
-* DisablePointerMethods
-	Disables invocation of error and Stringer interface methods on types
-	which only accept pointer receivers from non-pointer variables.  This option
-	relies on access to the unsafe package, so it will not have any effect when
-	running in environments without access to the unsafe package such as Google
-	App Engine or with the "safe" build tag specified.
-	Pointer method invocation is enabled by default.
-
-* DisablePointerAddresses
-	DisablePointerAddresses specifies whether to disable the printing of
-	pointer addresses. This is useful when diffing data structures in tests.
-
-* DisableCapacities
-	DisableCapacities specifies whether to disable the printing of capacities
-	for arrays, slices, maps and channels. This is useful when diffing data
-	structures in tests.
-
-* ContinueOnMethod
-	Enables recursion into types after invoking error and Stringer interface
-	methods. Recursion after method invocation is disabled by default.
-
-* SortKeys
-	Specifies map keys should be sorted before being printed. Use
-	this to have a more deterministic, diffable output.  Note that
-	only native types (bool, int, uint, floats, uintptr and string)
-	and types which implement error or Stringer interfaces are supported,
-	with other types sorted according to the reflect.Value.String() output
-	which guarantees display stability.  Natural map order is used by
-	default.
-
-* SpewKeys
-	SpewKeys specifies that, as a last resort attempt, map keys should be
-	spewed to strings and sorted by those strings.  This is only considered
-	if SortKeys is true.
-
-```
-
-## Unsafe Package Dependency
-
-This package relies on the unsafe package to perform some of the more advanced
-features, however it also supports a "limited" mode which allows it to work in
-environments where the unsafe package is not available.  By default, it will
-operate in this mode on Google App Engine and when compiled with GopherJS.  The
-"safe" build tag may also be specified to force the package to build without
-using the unsafe package.
-
-## License
-
-Go-spew is licensed under the [copyfree](http://copyfree.org) ISC License.
--- a/vendor/github.com/davecgh/go-spew/cov_report.sh
+++ b/vendor/github.com/davecgh/go-spew/cov_report.sh
@@ -1,22 +0,0 @@
-#!/bin/sh
-
-# This script uses gocov to generate a test coverage report.
-# The gocov tool my be obtained with the following command:
-#   go get github.com/axw/gocov/gocov
-#
-# It will be installed to $GOPATH/bin, so ensure that location is in your $PATH.
-
-# Check for gocov.
-if ! type gocov >/dev/null 2>&1; then
-	echo >&2 "This script requires the gocov tool."
-	echo >&2 "You may obtain it with the following command:"
-	echo >&2 "go get github.com/axw/gocov/gocov"
-	exit 1
-fi
-
-# Only run the cgo tests if gcc is installed.
-if type gcc >/dev/null 2>&1; then
-	(cd spew && gocov test -tags testcgo | gocov report)
-else
-	(cd spew && gocov test | gocov report)
-fi
--- a/vendor/github.com/davecgh/go-spew/spew/common_test.go
+++ b/vendor/github.com/davecgh/go-spew/spew/common_test.go
@@ -1,298 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew_test
-
-import (
-	"fmt"
-	"reflect"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-)
-
-// custom type to test Stinger interface on non-pointer receiver.
-type stringer string
-
-// String implements the Stringer interface for testing invocation of custom
-// stringers on types with non-pointer receivers.
-func (s stringer) String() string {
-	return "stringer " + string(s)
-}
-
-// custom type to test Stinger interface on pointer receiver.
-type pstringer string
-
-// String implements the Stringer interface for testing invocation of custom
-// stringers on types with only pointer receivers.
-func (s *pstringer) String() string {
-	return "stringer " + string(*s)
-}
-
-// xref1 and xref2 are cross referencing structs for testing circular reference
-// detection.
-type xref1 struct {
-	ps2 *xref2
-}
-type xref2 struct {
-	ps1 *xref1
-}
-
-// indirCir1, indirCir2, and indirCir3 are used to generate an indirect circular
-// reference for testing detection.
-type indirCir1 struct {
-	ps2 *indirCir2
-}
-type indirCir2 struct {
-	ps3 *indirCir3
-}
-type indirCir3 struct {
-	ps1 *indirCir1
-}
-
-// embed is used to test embedded structures.
-type embed struct {
-	a string
-}
-
-// embedwrap is used to test embedded structures.
-type embedwrap struct {
-	*embed
-	e *embed
-}
-
-// panicer is used to intentionally cause a panic for testing spew properly
-// handles them
-type panicer int
-
-func (p panicer) String() string {
-	panic("test panic")
-}
-
-// customError is used to test custom error interface invocation.
-type customError int
-
-func (e customError) Error() string {
-	return fmt.Sprintf("error: %d", int(e))
-}
-
-// stringizeWants converts a slice of wanted test output into a format suitable
-// for a test error message.
-func stringizeWants(wants []string) string {
-	s := ""
-	for i, want := range wants {
-		if i > 0 {
-			s += fmt.Sprintf("want%d: %s", i+1, want)
-		} else {
-			s += "want: " + want
-		}
-	}
-	return s
-}
-
-// testFailed returns whether or not a test failed by checking if the result
-// of the test is in the slice of wanted strings.
-func testFailed(result string, wants []string) bool {
-	for _, want := range wants {
-		if result == want {
-			return false
-		}
-	}
-	return true
-}
-
-type sortableStruct struct {
-	x int
-}
-
-func (ss sortableStruct) String() string {
-	return fmt.Sprintf("ss.%d", ss.x)
-}
-
-type unsortableStruct struct {
-	x int
-}
-
-type sortTestCase struct {
-	input    []reflect.Value
-	expected []reflect.Value
-}
-
-func helpTestSortValues(tests []sortTestCase, cs *spew.ConfigState, t *testing.T) {
-	getInterfaces := func(values []reflect.Value) []interface{} {
-		interfaces := []interface{}{}
-		for _, v := range values {
-			interfaces = append(interfaces, v.Interface())
-		}
-		return interfaces
-	}
-
-	for _, test := range tests {
-		spew.SortValues(test.input, cs)
-		// reflect.DeepEqual cannot really make sense of reflect.Value,
-		// probably because of all the pointer tricks. For instance,
-		// v(2.0) != v(2.0) on a 32-bits system. Turn them into interface{}
-		// instead.
-		input := getInterfaces(test.input)
-		expected := getInterfaces(test.expected)
-		if !reflect.DeepEqual(input, expected) {
-			t.Errorf("Sort mismatch:\n %v != %v", input, expected)
-		}
-	}
-}
-
-// TestSortValues ensures the sort functionality for relect.Value based sorting
-// works as intended.
-func TestSortValues(t *testing.T) {
-	v := reflect.ValueOf
-
-	a := v("a")
-	b := v("b")
-	c := v("c")
-	embedA := v(embed{"a"})
-	embedB := v(embed{"b"})
-	embedC := v(embed{"c"})
-	tests := []sortTestCase{
-		// No values.
-		{
-			[]reflect.Value{},
-			[]reflect.Value{},
-		},
-		// Bools.
-		{
-			[]reflect.Value{v(false), v(true), v(false)},
-			[]reflect.Value{v(false), v(false), v(true)},
-		},
-		// Ints.
-		{
-			[]reflect.Value{v(2), v(1), v(3)},
-			[]reflect.Value{v(1), v(2), v(3)},
-		},
-		// Uints.
-		{
-			[]reflect.Value{v(uint8(2)), v(uint8(1)), v(uint8(3))},
-			[]reflect.Value{v(uint8(1)), v(uint8(2)), v(uint8(3))},
-		},
-		// Floats.
-		{
-			[]reflect.Value{v(2.0), v(1.0), v(3.0)},
-			[]reflect.Value{v(1.0), v(2.0), v(3.0)},
-		},
-		// Strings.
-		{
-			[]reflect.Value{b, a, c},
-			[]reflect.Value{a, b, c},
-		},
-		// Array
-		{
-			[]reflect.Value{v([3]int{3, 2, 1}), v([3]int{1, 3, 2}), v([3]int{1, 2, 3})},
-			[]reflect.Value{v([3]int{1, 2, 3}), v([3]int{1, 3, 2}), v([3]int{3, 2, 1})},
-		},
-		// Uintptrs.
-		{
-			[]reflect.Value{v(uintptr(2)), v(uintptr(1)), v(uintptr(3))},
-			[]reflect.Value{v(uintptr(1)), v(uintptr(2)), v(uintptr(3))},
-		},
-		// SortableStructs.
-		{
-			// Note: not sorted - DisableMethods is set.
-			[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
-			[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
-		},
-		// UnsortableStructs.
-		{
-			// Note: not sorted - SpewKeys is false.
-			[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
-			[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
-		},
-		// Invalid.
-		{
-			[]reflect.Value{embedB, embedA, embedC},
-			[]reflect.Value{embedB, embedA, embedC},
-		},
-	}
-	cs := spew.ConfigState{DisableMethods: true, SpewKeys: false}
-	helpTestSortValues(tests, &cs, t)
-}
-
-// TestSortValuesWithMethods ensures the sort functionality for relect.Value
-// based sorting works as intended when using string methods.
-func TestSortValuesWithMethods(t *testing.T) {
-	v := reflect.ValueOf
-
-	a := v("a")
-	b := v("b")
-	c := v("c")
-	tests := []sortTestCase{
-		// Ints.
-		{
-			[]reflect.Value{v(2), v(1), v(3)},
-			[]reflect.Value{v(1), v(2), v(3)},
-		},
-		// Strings.
-		{
-			[]reflect.Value{b, a, c},
-			[]reflect.Value{a, b, c},
-		},
-		// SortableStructs.
-		{
-			[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
-			[]reflect.Value{v(sortableStruct{1}), v(sortableStruct{2}), v(sortableStruct{3})},
-		},
-		// UnsortableStructs.
-		{
-			// Note: not sorted - SpewKeys is false.
-			[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
-			[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
-		},
-	}
-	cs := spew.ConfigState{DisableMethods: false, SpewKeys: false}
-	helpTestSortValues(tests, &cs, t)
-}
-
-// TestSortValuesWithSpew ensures the sort functionality for relect.Value
-// based sorting works as intended when using spew to stringify keys.
-func TestSortValuesWithSpew(t *testing.T) {
-	v := reflect.ValueOf
-
-	a := v("a")
-	b := v("b")
-	c := v("c")
-	tests := []sortTestCase{
-		// Ints.
-		{
-			[]reflect.Value{v(2), v(1), v(3)},
-			[]reflect.Value{v(1), v(2), v(3)},
-		},
-		// Strings.
-		{
-			[]reflect.Value{b, a, c},
-			[]reflect.Value{a, b, c},
-		},
-		// SortableStructs.
-		{
-			[]reflect.Value{v(sortableStruct{2}), v(sortableStruct{1}), v(sortableStruct{3})},
-			[]reflect.Value{v(sortableStruct{1}), v(sortableStruct{2}), v(sortableStruct{3})},
-		},
-		// UnsortableStructs.
-		{
-			[]reflect.Value{v(unsortableStruct{2}), v(unsortableStruct{1}), v(unsortableStruct{3})},
-			[]reflect.Value{v(unsortableStruct{1}), v(unsortableStruct{2}), v(unsortableStruct{3})},
-		},
-	}
-	cs := spew.ConfigState{DisableMethods: true, SpewKeys: true}
-	helpTestSortValues(tests, &cs, t)
-}
--- a/vendor/github.com/davecgh/go-spew/spew/dump_test.go
+++ b/vendor/github.com/davecgh/go-spew/spew/dump_test.go
--- a/vendor/github.com/davecgh/go-spew/spew/dumpcgo_test.go
+++ b/vendor/github.com/davecgh/go-spew/spew/dumpcgo_test.go
@@ -1,99 +0,0 @@
-// Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
-//
-// Permission to use, copy, modify, and distribute this software for any
-// purpose with or without fee is hereby granted, provided that the above
-// copyright notice and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-// NOTE: Due to the following build constraints, this file will only be compiled
-// when both cgo is supported and "-tags testcgo" is added to the go test
-// command line.  This means the cgo tests are only added (and hence run) when
-// specifially requested.  This configuration is used because spew itself
-// does not require cgo to run even though it does handle certain cgo types
-// specially.  Rather than forcing all clients to require cgo and an external
-// C compiler just to run the tests, this scheme makes them optional.
-// +build cgo,testcgo
-
-package spew_test
-
-import (
-	"fmt"
-
-	"github.com/davecgh/go-spew/spew/testdata"
-)
-
-func addCgoDumpTests() {
-	// C char pointer.
-	v := testdata.GetCgoCharPointer()
-	nv := testdata.GetCgoNullCharPointer()
-	pv := &v
-	vcAddr := fmt.Sprintf("%p", v)
-	vAddr := fmt.Sprintf("%p", pv)
-	pvAddr := fmt.Sprintf("%p", &pv)
-	vt := "*testdata._Ctype_char"
-	vs := "116"
-	addDumpTest(v, "("+vt+")("+vcAddr+")("+vs+")\n")
-	addDumpTest(pv, "(*"+vt+")("+vAddr+"->"+vcAddr+")("+vs+")\n")
-	addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+"->"+vcAddr+")("+vs+")\n")
-	addDumpTest(nv, "("+vt+")(<nil>)\n")
-
-	// C char array.
-	v2, v2l, v2c := testdata.GetCgoCharArray()
-	v2Len := fmt.Sprintf("%d", v2l)
-	v2Cap := fmt.Sprintf("%d", v2c)
-	v2t := "[6]testdata._Ctype_char"
-	v2s := "(len=" + v2Len + " cap=" + v2Cap + ") " +
-		"{\n 00000000  74 65 73 74 32 00                               " +
-		"  |test2.|\n}"
-	addDumpTest(v2, "("+v2t+") "+v2s+"\n")
-
-	// C unsigned char array.
-	v3, v3l, v3c := testdata.GetCgoUnsignedCharArray()
-	v3Len := fmt.Sprintf("%d", v3l)
-	v3Cap := fmt.Sprintf("%d", v3c)
-	v3t := "[6]testdata._Ctype_unsignedchar"
-	v3t2 := "[6]testdata._Ctype_uchar"
-	v3s := "(len=" + v3Len + " cap=" + v3Cap + ") " +
-		"{\n 00000000  74 65 73 74 33 00                               " +
-		"  |test3.|\n}"
-	addDumpTest(v3, "("+v3t+") "+v3s+"\n", "("+v3t2+") "+v3s+"\n")
-
-	// C signed char array.
-	v4, v4l, v4c := testdata.GetCgoSignedCharArray()
-	v4Len := fmt.Sprintf("%d", v4l)
-	v4Cap := fmt.Sprintf("%d", v4c)
-	v4t := "[6]testdata._Ctype_schar"
-	v4t2 := "testdata._Ctype_schar"
-	v4s := "(len=" + v4Len + " cap=" + v4Cap + ") " +
-		"{\n (" + v4t2 + ") 116,\n (" + v4t2 + ") 101,\n (" + v4t2 +
-		") 115,\n (" + v4t2 + ") 116,\n (" + v4t2 + ") 52,\n (" + v4t2 +
-		") 0\n}"
-	addDumpTest(v4, "("+v4t+") "+v4s+"\n")
-
-	// C uint8_t array.
-	v5, v5l, v5c := testdata.GetCgoUint8tArray()
-	v5Len := fmt.Sprintf("%d", v5l)
-	v5Cap := fmt.Sprintf("%d", v5c)
-	v5t := "[6]testdata._Ctype_uint8_t"
-	v5s := "(len=" + v5Len + " cap=" + v5Cap + ") " +
-		"{\n 00000000  74 65 73 74 35 00                               " +
-		"  |test5.|\n}"
-	addDumpTest(v5, "("+v5t+") "+v5s+"\n")
-
-	// C typedefed unsigned char array.
-	v6, v6l, v6c := testdata.GetCgoTypdefedUnsignedCharArray()
-	v6Len := fmt.Sprintf("%d", v6l)
-	v6Cap := fmt.Sprintf("%d", v6c)
-	v6t := "[6]testdata._Ctype_custom_uchar_t"
-	v6s := "(len=" + v6Len + " cap=" + v6Cap + ") " +
-		"{\n 00000000  74 65 73 74 36 00                               " +
-		"  |test6.|\n}"
-	addDumpTest(v6, "("+v6t+") "+v6s+"\n")
-}
--- a/vendor/github.com/davecgh/go-spew/spew/dumpnocgo_test.go
+++ b/vendor/github.com/davecgh/go-spew/spew/dumpnocgo_test.go
@@ -1,26 +0,0 @@
-// Copyright (c) 2013 Dave Collins <dave@davec.name>
-//
-// Permission to use, copy, modify, and distribute this software for any
-// purpose with or without fee is hereby granted, provided that the above
-// copyright notice and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-// NOTE: Due to the following build constraints, this file will only be compiled
-// when either cgo is not supported or "-tags testcgo" is not added to the go
-// test command line.  This file intentionally does not setup any cgo tests in
-// this scenario.
-// +build !cgo !testcgo
-
-package spew_test
-
-func addCgoDumpTests() {
-	// Don't add any tests for cgo since this file is only compiled when
-	// there should not be any cgo tests.
-}
--- a/vendor/github.com/davecgh/go-spew/spew/example_test.go
+++ b/vendor/github.com/davecgh/go-spew/spew/example_test.go
@@ -1,226 +0,0 @@
-/*
- * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-package spew_test
-
-import (
-	"fmt"
-
-	"github.com/davecgh/go-spew/spew"
-)
-
-type Flag int
-
-const (
-	flagOne Flag = iota
-	flagTwo
-)
-
-var flagStrings = map[Flag]string{
-	flagOne: "flagOne",
-	flagTwo: "flagTwo",
-}
-
-func (f Flag) String() string {
-	if s, ok := flagStrings[f]; ok {
-		return s
-	}
-	return fmt.Sprintf("Unknown flag (%d)", int(f))
-}
-
-type Bar struct {
-	data uintptr
-}
-
-type Foo struct {
-	unexportedField Bar
-	ExportedField   map[interface{}]interface{}
-}
-
-// This example demonstrates how to use Dump to dump variables to stdout.
-func ExampleDump() {
-	// The following package level declarations are assumed for this example:
-	/*
-		type Flag int
-
-		const (
-			flagOne Flag = iota
-			flagTwo
-		)
-
-		var flagStrings = map[Flag]string{
-			flagOne: "flagOne",
-			flagTwo: "flagTwo",
-		}
-
-		func (f Flag) String() string {
-			if s, ok := flagStrings[f]; ok {
-				return s
-			}
-			return fmt.Sprintf("Unknown flag (%d)", int(f))
-		}
-
-		type Bar struct {
-			data uintptr
-		}
-
-		type Foo struct {
-			unexportedField Bar
-			ExportedField   map[interface{}]interface{}
-		}
-	*/
-
-	// Setup some sample data structures for the example.
-	bar := Bar{uintptr(0)}
-	s1 := Foo{bar, map[interface{}]interface{}{"one": true}}
-	f := Flag(5)
-	b := []byte{
-		0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
-		0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
-		0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
-		0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
-		0x31, 0x32,
-	}
-
-	// Dump!
-	spew.Dump(s1, f, b)
-
-	// Output:
-	// (spew_test.Foo) {
-	//  unexportedField: (spew_test.Bar) {
-	//   data: (uintptr) <nil>
-	//  },
-	//  ExportedField: (map[interface {}]interface {}) (len=1) {
-	//   (string) (len=3) "one": (bool) true
-	//  }
-	// }
-	// (spew_test.Flag) Unknown flag (5)
-	// ([]uint8) (len=34 cap=34) {
-	//  00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |
-	//  00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|
-	//  00000020  31 32                                             |12|
-	// }
-	//
-}
-
-// This example demonstrates how to use Printf to display a variable with a
-// format string and inline formatting.
-func ExamplePrintf() {
-	// Create a double pointer to a uint 8.
-	ui8 := uint8(5)
-	pui8 := &ui8
-	ppui8 := &pui8
-
-	// Create a circular data type.
-	type circular struct {
-		ui8 uint8
-		c   *circular
-	}
-	c := circular{ui8: 1}
-	c.c = &c
-
-	// Print!
-	spew.Printf("ppui8: %v\n", ppui8)
-	spew.Printf("circular: %v\n", c)
-
-	// Output:
-	// ppui8: <**>5
-	// circular: {1 <*>{1 <*><shown>}}
-}
-
-// This example demonstrates how to use a ConfigState.
-func ExampleConfigState() {
-	// Modify the indent level of the ConfigState only.  The global
-	// configuration is not modified.
-	scs := spew.ConfigState{Indent: "\t"}
-
-	// Output using the ConfigState instance.
-	v := map[string]int{"one": 1}
-	scs.Printf("v: %v\n", v)
-	scs.Dump(v)
-
-	// Output:
-	// v: map[one:1]
-	// (map[string]int) (len=1) {
-	// 	(string) (len=3) "one": (int) 1
-	// }
-}
-
-// This example demonstrates how to use ConfigState.Dump to dump variables to
-// stdout
-func ExampleConfigState_Dump() {
-	// See the top-level Dump example for details on the types used in this
-	// example.
-
-	// Create two ConfigState instances with different indentation.
-	scs := spew.ConfigState{Indent: "\t"}
-	scs2 := spew.ConfigState{Indent: " "}
-
-	// Setup some sample data structures for the example.
-	bar := Bar{uintptr(0)}
-	s1 := Foo{bar, map[interface{}]interface{}{"one": true}}
-
-	// Dump using the ConfigState instances.
-	scs.Dump(s1)
-	scs2.Dump(s1)
-
-	// Output:
-	// (spew_test.Foo) {
-	// 	unexportedField: (spew_test.Bar) {
-	// 		data: (uintptr) <nil>
-	// 	},
-	// 	ExportedField: (map[interface {}]interface {}) (len=1) {
-	//		(string) (len=3) "one": (bool) true
-	// 	}
-	// }
-	// (spew_test.Foo) {
-	//  unexportedField: (spew_test.Bar) {
-	//   data: (uintptr) <nil>
-	//  },
-	//  ExportedField: (map[interface {}]interface {}) (len=1) {
-	//   (string) (len=3) "one": (bool) true
-	//  }
-	// }
-	//
-}
-
-// This example demonstrates how to use ConfigState.Printf to display a variable
-// with a format string and inline formatting.
-func ExampleConfigState_Printf() {
-	// See the top-level Dump example for details on the types used in this
-	// example.
-
-	// Create two ConfigState instances and modify the method handling of the
-	// first ConfigState only.
-	scs := spew.NewDefaultConfig()
-	scs2 := spew.NewDefaultConfig()
-	scs.DisableMethods = true
-
-	// Alternatively
-	// scs := spew.ConfigState{Indent: " ", DisableMethods: true}
-	// scs2 := spew.ConfigState{Indent: " "}
-
-	// This is of type Flag which implements a Stringer and has raw value 1.
-	f := flagTwo
-
-	// Dump using the ConfigState instances.
-	scs.Printf("f: %v\n", f)
-	scs2.Printf("f: %v\n", f)
-
-	// Output:
-	// f: 1
-	// f: flagTwo
-}
--- a/Show More
+++ b/Show More