Drop viper dependency (#550)

* Removed viper dependency.

* removed from glide files

api/agent/agent_test.go

@@ -315,7 +315,7 @@ func TestSubmitError(t *testing.T) {
 	appName := "myapp"
 	path := "/error"
 	image := "fnproject/error"
-	const timeout = 1
+	const timeout = 10
 	const idleTimeout = 20
 	const memory = 256
 	method := "GET"

api/server/init.go

@@ -2,34 +2,25 @@ package server
 
 import (
 	"context"
-	"fmt"
 	"os"
 	"os/signal"
+	"strconv"
 	"strings"
 
 	"github.com/gin-gonic/gin"
 	"github.com/sirupsen/logrus"
-	"github.com/spf13/viper"
 )
 
 func init() {
-	viper.AutomaticEnv() // picks up env vars automatically
+	var err error
-	cwd, err := os.Getwd()
+	currDir, err = os.Getwd()
 	if err != nil {
 		logrus.WithError(err).Fatalln("")
 	}
 	// Replace forward slashes in case this is windows, URL parser errors
-	cwd = strings.Replace(cwd, "\\", "/", -1)
+	currDir = strings.Replace(currDir, "\\", "/", -1)
-	viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
+
-	viper.SetDefault(EnvLogLevel, "info")
+	logLevel, err := logrus.ParseLevel(getEnv(EnvLogLevel, DefaultLogLevel))
-	viper.SetDefault(EnvMQURL, fmt.Sprintf("bolt://%s/data/worker_mq.db", cwd))
-	viper.SetDefault(EnvDBURL, fmt.Sprintf("sqlite3://%s/data/fn.db", cwd))
-	viper.SetDefault(EnvLOGDBURL, "") // default to just using DB url
-	viper.SetDefault(EnvPort, 8080)
-	viper.SetDefault(EnvZipkinURL, "") // off default
-	viper.SetDefault(EnvAPIURL, fmt.Sprintf("http://127.0.0.1:%d", viper.GetInt(EnvPort)))
-	viper.AutomaticEnv() // picks up env vars automatically
-	logLevel, err := logrus.ParseLevel(viper.GetString(EnvLogLevel))
 	if err != nil {
 		logrus.WithError(err).Fatalln("Invalid log level.")
 	}
@@ -41,6 +32,26 @@ func init() {
 	}
 }
 
+func getEnv(key, fallback string) string {
+	if value, ok := os.LookupEnv(key); ok {
+		return value
+	}
+	return fallback
+}
+
+func getEnvInt(key string, fallback int) int {
+	if value, ok := os.LookupEnv(key); ok {
+		// linter liked this better than if/else
+		var err error
+		var i int
+		if i, err = strconv.Atoi(value); err != nil {
+			panic(err) // not sure how to handle this
+		}
+		return i
+	}
+	return fallback
+}
+
 func contextWithSignal(ctx context.Context, signals ...os.Signal) (context.Context, context.CancelFunc) {
 	newCTX, halt := context.WithCancel(ctx)
 	c := make(chan os.Signal, 1)

api/server/runner_test.go

@@ -243,7 +243,7 @@ func TestRouteRunnerTimeout(t *testing.T) {
 		},
 		[]*models.Route{
 			{Path: "/pull", AppName: "myapp", Image: "fnproject/sleeper", Type: "sync", Memory: 128, Timeout: 30, IdleTimeout: 30},
-			{Path: "/sleeper", AppName: "myapp", Image: "fnproject/sleeper", Type: "sync", Memory: 128, Timeout: 1, IdleTimeout: 30},
+			{Path: "/sleeper", AppName: "myapp", Image: "fnproject/sleeper", Type: "sync", Memory: 128, Timeout: 2, IdleTimeout: 30},
 			{Path: "/waitmemory", AppName: "myapp", Image: "fnproject/sleeper", Type: "sync", Memory: hugeMem, Timeout: 1, IdleTimeout: 30},
 		}, nil,
 	)

api/server/server.go

@@ -30,18 +30,24 @@ import (
 	"github.com/opentracing/opentracing-go/ext"
 	"github.com/openzipkin/zipkin-go-opentracing"
 	"github.com/sirupsen/logrus"
-	"github.com/spf13/viper"
+)
+
+var (
+	currDir string
 )
 
 const (
-	EnvLogLevel  = "log_level"
+	EnvLogLevel  = "LOG_LEVEL"
-	EnvMQURL     = "mq_url"
+	EnvMQURL     = "MQ_URL"
-	EnvDBURL     = "db_url"
+	EnvDBURL     = "DB_URL"
-	EnvLOGDBURL  = "logstore_url"
+	EnvLOGDBURL  = "LOGSTORE_URL"
-	EnvPort      = "port" // be careful, Gin expects this variable to be "port"
+	EnvPort      = "PORT" // be careful, Gin expects this variable to be "port"
-	EnvAPIURL    = "api_url"
+	EnvAPICORS   = "API_CORS"
-	EnvAPICORS   = "api_cors"
+	EnvZipkinURL = "ZIPKIN_URL"
-	EnvZipkinURL = "zipkin_url"
+
+	// Defaults
+	DefaultLogLevel = "info"
+	DefaultPort     = 8080
 )
 
 type Server struct {
@@ -57,19 +63,30 @@ type Server struct {
 
 // NewFromEnv creates a new Functions server based on env vars.
 func NewFromEnv(ctx context.Context, opts ...ServerOption) *Server {
-	ds, err := datastore.New(viper.GetString(EnvDBURL))
+	return NewFromURLs(ctx,
+		getEnv(EnvDBURL, fmt.Sprintf("sqlite3://%s/data/fn.db", currDir)),
+		getEnv(EnvMQURL, fmt.Sprintf("bolt://%s/data/fn.mq", currDir)),
+		getEnv(EnvLOGDBURL, ""),
+		opts...,
+	)
+}
+
+// Create a new server based on the string URLs for each service.
+// Sits in the middle of NewFromEnv and New
+func NewFromURLs(ctx context.Context, dbURL, mqURL, logstoreURL string, opts ...ServerOption) *Server {
+	ds, err := datastore.New(dbURL)
 	if err != nil {
 		logrus.WithError(err).Fatalln("Error initializing datastore.")
 	}
 
-	mq, err := mqs.New(viper.GetString(EnvMQURL))
+	mq, err := mqs.New(mqURL)
 	if err != nil {
 		logrus.WithError(err).Fatal("Error initializing message queue.")
 	}
 
 	var logDB models.LogStore = ds
-	if ldb := viper.GetString(EnvLOGDBURL); ldb != "" && ldb != viper.GetString(EnvDBURL) {
+	if ldb := logstoreURL; ldb != "" && ldb != dbURL {
-		logDB, err = logs.New(viper.GetString(EnvLOGDBURL))
+		logDB, err = logs.New(logstoreURL)
 		if err != nil {
 			logrus.WithError(err).Fatal("Error initializing logs store.")
 		}
@@ -82,8 +99,9 @@ func optionalCorsWrap(r *gin.Engine) {
 	// By default no CORS are allowed unless one
 	// or more Origins are defined by the API_CORS
 	// environment variable.
-	if len(viper.GetString(EnvAPICORS)) > 0 {
+	corsStr := getEnv(EnvAPICORS, "")
-		origins := strings.Split(strings.Replace(viper.GetString(EnvAPICORS), " ", "", -1), ",")
+	if len(corsStr) > 0 {
+		origins := strings.Split(strings.Replace(corsStr, " ", "", -1), ",")
 
 		corsConfig := cors.DefaultConfig()
 		corsConfig.AllowOrigins = origins
@@ -146,7 +164,7 @@ func setTracer() {
 		debugMode          = false
 		serviceName        = "fnserver"
 		serviceHostPort    = "localhost:8080" // meh
-		zipkinHTTPEndpoint = viper.GetString(EnvZipkinURL)
+		zipkinHTTPEndpoint = getEnv(EnvZipkinURL, "")
 		// ex: "http://zipkin:9411/api/v1/spans"
 	)
 
@@ -188,7 +206,7 @@ func setTracer() {
 }
 
 func setMachineID() {
-	port := uint16(viper.GetInt(EnvPort))
+	port := uint16(getEnvInt(EnvPort, DefaultPort))
 	addr := whoAmI().To4()
 	if addr == nil {
 		addr = net.ParseIP("127.0.0.1").To4()
@@ -281,7 +299,7 @@ func (s *Server) Start(ctx context.Context) {
 func (s *Server) startGears(ctx context.Context, cancel context.CancelFunc) {
 	// By default it serves on :8080 unless a
 	// PORT environment variable was defined.
-	listen := fmt.Sprintf(":%d", viper.GetInt(EnvPort))
+	listen := fmt.Sprintf(":%d", getEnvInt(EnvPort, DefaultPort))
 
 	const runHeader = `
         ______

docs/operating/options.md

@@ -21,15 +21,14 @@ docker run -e VAR_NAME=VALUE ...
 
 | Env Variables | Description | Default values |
 | --------------|-------------|----------------|
-| DB_URL | The database URL to use in URL format. See [Databases](databases/README.md) for more information. | sqlite3:///app/data/fn.db |
+| `DB_URL` | The database URL to use in URL format. See [Databases](databases/README.md) for more information. | sqlite3:///app/data/fn.db |
-| MQ_URL | The message queue to use in URL format. See [Message Queues](mqs/README.md) for more information. | bolt:///app/data/worker_mq.db |
+| `MQ_URL` | The message queue to use in URL format. See [Message Queues](mqs/README.md) for more information. | bolt:///app/data/worker_mq.db |
-| API_URL | The primary Fn API URL to that this instance will talk to. In a production environment, this would be your load balancer URL. | N/A |
+| `PORT` | Sets the port to run on | 8080 |
-| PORT | Sets the port to run on | 8080 |
+| `LOG_LEVEL` | Set to DEBUG to enable debugging | INFO |
-| LOG_LEVEL | Set to DEBUG to enable debugging | INFO |
+| `DOCKER_HOST` | Docker remote API URL | /var/run/docker.sock:/var/run/docker.sock |
-| DOCKER_HOST | Docker remote API URL | /var/run/docker.sock:/var/run/docker.sock |
+| `DOCKER_API_VERSION` | Docker remote API version | 1.24 |
-| DOCKER_API_VERSION | Docker remote API version | 1.24 |
+| `DOCKER_TLS_VERIFY` | Set this option to enable/disable Docker remote API over TLS/SSL. | 0 |
-| DOCKER_TLS_VERIFY | Set this option to enable/disable Docker remote API over TLS/SSL. | 0 |
+| `DOCKER_CERT_PATH` | Set this option to specify where CA cert placeholder | ~/.docker/cert.pem |
-| DOCKER_CERT_PATH | Set this option to specify where CA cert placeholder | ~/.docker/cert.pem |
 
 ## Starting without Docker in Docker
 
@@ -55,4 +54,3 @@ docker run --rm --name functions -it -v /var/run/docker.sock:/var/run/docker.soc
 You can of course just run the binary directly, you'll just have to change how you set the environment variables above.
 
 See [contributing doc](../CONTRIBUTING.md) for information on how to build and run.
-

glide.lock

@@ -411,18 +411,6 @@ imports:
   version: 89742aefa4b206dcf400792f3bd35b542998eb3b
   subpackages:
   - hooks/syslog
-- name: github.com/spf13/afero
-  version: ee1bd8ee15a1306d1f9201acc41ef39cd9f99a1b
-  subpackages:
-  - mem
-- name: github.com/spf13/cast
-  version: acbeb36b902d72a7a4c18e8f3241075e7ab763e4
-- name: github.com/spf13/jwalterweatherman
-  version: 12bd96e66386c1960ab0f74ced1362f66f552f7b
-- name: github.com/spf13/pflag
-  version: 7aff26db30c1be810f9de5038ec5ef96ac41fd7c
-- name: github.com/spf13/viper
-  version: 25b30aa063fc18e48662b86996252eabdcf2f0c7
 - name: github.com/ugorji/go
   version: 54210f4e076c57f351166f0ed60e67d3fca57a36
   subpackages:

glide.yaml

@@ -56,7 +56,6 @@ import:
 - package: github.com/docker/docker
   version: cdf870bd0b5fa678b10ef2708cca7ad776b4913c
 - package: github.com/pkg/errors
-- package: github.com/spf13/viper
 - package: gopkg.in/mgo.v2
   subpackages:
   - bson

test/fn-api-tests/utils.go

@@ -2,13 +2,6 @@ package tests
 
 import (
 	"context"
-	"runtime"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/fnproject/fn/api/server"
-
 	"fmt"
 	"io"
 	"log"
@@ -16,20 +9,22 @@ import (
 	"net/http"
 	"net/url"
 	"os"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
 
+	"github.com/fnproject/fn/api/common"
+	"github.com/fnproject/fn/api/server"
 	"github.com/fnproject/fn_go/client"
 	httptransport "github.com/go-openapi/runtime/client"
 	"github.com/go-openapi/strfmt"
-	"github.com/spf13/viper"
 )
 
 const lBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 
 func Host() string {
-	apiURL := os.Getenv("API_URL")
+	apiURL := "http://localhost:8080"
-	if apiURL == "" {
-		apiURL = "http://localhost:8080"
-	}
 
 	u, err := url.Parse(apiURL)
 	if err != nil {
@@ -60,21 +55,20 @@ func getServerWithCancel() (*server.Server, context.CancelFunc) {
 	getServer.Do(func() {
 		ctx, cancel := context.WithCancel(context.Background())
 
-		viper.Set(server.EnvPort, "8080")
+		apiURL := "http://localhost:8080"
-		viper.Set(server.EnvAPIURL, "http://localhost:8080")
+
-		viper.Set(server.EnvLogLevel, "fatal")
+		common.SetLogLevel("fatal")
 		timeString := time.Now().Format("2006_01_02_15_04_05")
-		db_url := os.Getenv("DB_URL")
+		dbURL := os.Getenv("DB_URL")
 		tmpDir := os.TempDir()
 		tmpMq := fmt.Sprintf("%s/fn_integration_test_%s_worker_mq.db", tmpDir, timeString)
 		tmpDb := fmt.Sprintf("%s/fn_integration_test_%s_fn.db", tmpDir, timeString)
-		viper.Set(server.EnvMQURL, fmt.Sprintf("bolt://%s", tmpMq))
+		mqURL := fmt.Sprintf("bolt://%s", tmpMq)
-		if db_url == "" {
+		if dbURL == "" {
-			db_url = fmt.Sprintf("sqlite3://%s", tmpDb)
+			dbURL = fmt.Sprintf("sqlite3://%s", tmpDb)
 		}
-		viper.Set(server.EnvDBURL, db_url)
 
-		s = server.NewFromEnv(ctx)
+		s = server.NewFromURLs(ctx, dbURL, mqURL, "")
 
 		go s.Start(ctx)
 		started := false
@@ -83,10 +77,10 @@ func getServerWithCancel() (*server.Server, context.CancelFunc) {
 				panic("Failed to start server.")
 			}
 		})
-		log.Println(server.EnvAPIURL)
+		log.Println("apiURL:", apiURL)
-		_, err := http.Get(viper.GetString(server.EnvAPIURL) + "/version")
+		_, err := http.Get(apiURL + "/version")
 		for err != nil {
-			_, err = http.Get(viper.GetString(server.EnvAPIURL) + "/version")
+			_, err = http.Get(apiURL + "/version")
 		}
 		started = true
 		cancel2 = context.CancelFunc(func() {

vendor/github.com/spf13/afero/.travis.yml

@@ -1,20 +0,0 @@
-sudo: false
-language: go
-
-go:
-  - 1.7.5
-  - 1.8
-  - tip
-
-os:
-  - linux
-  - osx
-
-matrix:
-  allow_failures:
-    - go: tip
-  fast_finish: true
-
-script:
-  - go test -v ./...
-  - go build

vendor/github.com/spf13/afero/LICENSE.txt

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

vendor/github.com/spf13/afero/README.md

@@ -1,449 +0,0 @@
-![afero logo-sm](https://cloud.githubusercontent.com/assets/173412/11490338/d50e16dc-97a5-11e5-8b12-019a300d0fcb.png)
-
-A FileSystem Abstraction System for Go
-
-[![Build Status](https://travis-ci.org/spf13/afero.svg)](https://travis-ci.org/spf13/afero) [![Build status](https://ci.appveyor.com/api/projects/status/github/spf13/afero?branch=master&svg=true)](https://ci.appveyor.com/project/spf13/afero) [![GoDoc](https://godoc.org/github.com/spf13/afero?status.svg)](https://godoc.org/github.com/spf13/afero) [![Join the chat at https://gitter.im/spf13/afero](https://badges.gitter.im/Dev%20Chat.svg)](https://gitter.im/spf13/afero?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
-# Overview
-
-Afero is an filesystem framework providing a simple, uniform and universal API
-interacting with any filesystem, as an abstraction layer providing interfaces,
-types and methods. Afero has an exceptionally clean interface and simple design
-without needless constructors or initialization methods.
-
-Afero is also a library providing a base set of interoperable backend
-filesystems that make it easy to work with afero while retaining all the power
-and benefit of the os and ioutil packages.
-
-Afero provides significant improvements over using the os package alone, most
-notably the ability to create mock and testing filesystems without relying on the disk.
-
-It is suitable for use in a any situation where you would consider using the OS
-package as it provides an additional abstraction that makes it easy to use a
-memory backed file system during testing. It also adds support for the http
-filesystem for full interoperability.
-
-
-## Afero Features
-
-* A single consistent API for accessing a variety of filesystems
-* Interoperation between a variety of file system types
-* A set of interfaces to encourage and enforce interoperability between backends
-* An atomic cross platform memory backed file system
-* Support for compositional (union) file systems by combining multiple file systems acting as one
-* Specialized backends which modify existing filesystems (Read Only, Regexp filtered)
-* A set of utility functions ported from io, ioutil & hugo to be afero aware
-
-
-# Using Afero
-
-Afero is easy to use and easier to adopt.
-
-A few different ways you could use Afero:
-
-* Use the interfaces alone to define you own file system.
-* Wrap for the OS packages.
-* Define different filesystems for different parts of your application.
-* Use Afero for mock filesystems while testing
-
-## Step 1: Install Afero
-
-First use go get to install the latest version of the library.
-
-    $ go get github.com/spf13/afero
-
-Next include Afero in your application.
-```go
-import "github.com/spf13/afero"
-```
-
-## Step 2: Declare a backend
-
-First define a package variable and set it to a pointer to a filesystem.
-```go
-var AppFs afero.Fs = afero.NewMemMapFs()
-
-or
-
-var AppFs afero.Fs = afero.NewOsFs()
-```
-It is important to note that if you repeat the composite literal you
-will be using a completely new and isolated filesystem. In the case of
-OsFs it will still use the same underlying filesystem but will reduce
-the ability to drop in other filesystems as desired.
-
-## Step 3: Use it like you would the OS package
-
-Throughout your application use any function and method like you normally
-would.
-
-So if my application before had:
-```go
-os.Open('/tmp/foo')
-```
-We would replace it with a call to `AppFs.Open('/tmp/foo')`.
-
-`AppFs` being the variable we defined above.
-
-
-## List of all available functions
-
-File System Methods Available:
-```go
-Chmod(name string, mode os.FileMode) : error
-Chtimes(name string, atime time.Time, mtime time.Time) : error
-Create(name string) : File, error
-Mkdir(name string, perm os.FileMode) : error
-MkdirAll(path string, perm os.FileMode) : error
-Name() : string
-Open(name string) : File, error
-OpenFile(name string, flag int, perm os.FileMode) : File, error
-Remove(name string) : error
-RemoveAll(path string) : error
-Rename(oldname, newname string) : error
-Stat(name string) : os.FileInfo, error
-```
-File Interfaces and Methods Available:
-```go
-io.Closer
-io.Reader
-io.ReaderAt
-io.Seeker
-io.Writer
-io.WriterAt
-
-Name() : string
-Readdir(count int) : []os.FileInfo, error
-Readdirnames(n int) : []string, error
-Stat() : os.FileInfo, error
-Sync() : error
-Truncate(size int64) : error
-WriteString(s string) : ret int, err error
-```
-In some applications it may make sense to define a new package that
-simply exports the file system variable for easy access from anywhere.
-
-## Using Afero's utility functions
-
-Afero provides a set of functions to make it easier to use the underlying file systems.
-These functions have been primarily ported from io & ioutil with some developed for Hugo.
-
-The afero utilities support all afero compatible backends.
-
-The list of utilities includes:
-
-```go
-DirExists(path string) (bool, error)
-Exists(path string) (bool, error)
-FileContainsBytes(filename string, subslice []byte) (bool, error)
-GetTempDir(subPath string) string
-IsDir(path string) (bool, error)
-IsEmpty(path string) (bool, error)
-ReadDir(dirname string) ([]os.FileInfo, error)
-ReadFile(filename string) ([]byte, error)
-SafeWriteReader(path string, r io.Reader) (err error)
-TempDir(dir, prefix string) (name string, err error)
-TempFile(dir, prefix string) (f File, err error)
-Walk(root string, walkFn filepath.WalkFunc) error
-WriteFile(filename string, data []byte, perm os.FileMode) error
-WriteReader(path string, r io.Reader) (err error)
-```
-For a complete list see [Afero's GoDoc](https://godoc.org/github.com/spf13/afero)
-
-They are available under two different approaches to use. You can either call
-them directly where the first parameter of each function will be the file
-system, or you can declare a new `Afero`, a custom type used to bind these
-functions as methods to a given filesystem.
-
-### Calling utilities directly
-
-```go
-fs := new(afero.MemMapFs)
-f, err := afero.TempFile(fs,"", "ioutil-test")
-
-```
-
-### Calling via Afero
-
-```go
-fs := afero.NewMemMapFs
-afs := &Afero{Fs: fs}
-f, err := afs.TempFile("", "ioutil-test")
-```
-
-## Using Afero for Testing
-
-There is a large benefit to using a mock filesystem for testing. It has a
-completely blank state every time it is initialized and can be easily
-reproducible regardless of OS. You could create files to your heart’s content
-and the file access would be fast while also saving you from all the annoying
-issues with deleting temporary files, Windows file locking, etc. The MemMapFs
-backend is perfect for testing.
-
-* Much faster than performing I/O operations on disk
-* Avoid security issues and permissions
-* Far more control. 'rm -rf /' with confidence
-* Test setup is far more easier to do
-* No test cleanup needed
-
-One way to accomplish this is to define a variable as mentioned above.
-In your application this will be set to afero.NewOsFs() during testing you
-can set it to afero.NewMemMapFs().
-
-It wouldn't be uncommon to have each test initialize a blank slate memory
-backend. To do this I would define my `appFS = afero.NewOsFs()` somewhere
-appropriate in my application code. This approach ensures that Tests are order
-independent, with no test relying on the state left by an earlier test.
-
-Then in my tests I would initialize a new MemMapFs for each test:
-```go
-func TestExist(t *testing.T) {
-	appFS := afero.NewMemMapFs()
-	// create test files and directories
-	appFS.MkdirAll("src/a", 0755)
-	afero.WriteFile(appFS, "src/a/b", []byte("file b"), 0644)
-	afero.WriteFile(appFS, "src/c", []byte("file c"), 0644)
-	name := "src/c"
-	_, err := appFS.Stat(name)
-	if os.IsNotExist(err) {
-		t.Errorf("file \"%s\" does not exist.\n", name)
-	}
-}
-```
-
-# Available Backends
-
-## Operating System Native
-
-### OsFs
-
-The first is simply a wrapper around the native OS calls. This makes it
-very easy to use as all of the calls are the same as the existing OS
-calls. It also makes it trivial to have your code use the OS during
-operation and a mock filesystem during testing or as needed.
-
-```go
-appfs := afero.NewOsFs()
-appfs.MkdirAll("src/a", 0755))
-```
-
-## Memory Backed Storage
-
-### MemMapFs
-
-Afero also provides a fully atomic memory backed filesystem perfect for use in
-mocking and to speed up unnecessary disk io when persistence isn’t
-necessary. It is fully concurrent and will work within go routines
-safely.
-
-```go
-mm := afero.NewMemMapFs()
-mm.MkdirAll("src/a", 0755))
-```
-
-#### InMemoryFile
-
-As part of MemMapFs, Afero also provides an atomic, fully concurrent memory
-backed file implementation. This can be used in other memory backed file
-systems with ease. Plans are to add a radix tree memory stored file
-system using InMemoryFile.
-
-## Network Interfaces
-
-### SftpFs
-
-Afero has experimental support for secure file transfer protocol (sftp). Which can
-be used to perform file operations over a encrypted channel.
-
-## Filtering Backends
-
-### BasePathFs
-
-The BasePathFs restricts all operations to a given path within an Fs.
-The given file name to the operations on this Fs will be prepended with
-the base path before calling the source Fs.
-
-```go
-bp := afero.NewBasePathFs(afero.NewOsFs(), "/base/path")
-```
-
-### ReadOnlyFs
-
-A thin wrapper around the source Fs providing a read only view.
-
-```go
-fs := afero.NewReadOnlyFs(afero.NewOsFs())
-_, err := fs.Create("/file.txt")
-// err = syscall.EPERM
-```
-
-# RegexpFs
-
-A filtered view on file names, any file NOT matching
-the passed regexp will be treated as non-existing.
-Files not matching the regexp provided will not be created.
-Directories are not filtered.
-
-```go
-fs := afero.NewRegexpFs(afero.NewMemMapFs(), regexp.MustCompile(`\.txt$`))
-_, err := fs.Create("/file.html")
-// err = syscall.ENOENT
-```
-
-### HttpFs
-
-Afero provides an http compatible backend which can wrap any of the existing
-backends.
-
-The Http package requires a slightly specific version of Open which
-returns an http.File type.
-
-Afero provides an httpFs file system which satisfies this requirement.
-Any Afero FileSystem can be used as an httpFs.
-
-```go
-httpFs := afero.NewHttpFs(<ExistingFS>)
-fileserver := http.FileServer(httpFs.Dir(<PATH>)))
-http.Handle("/", fileserver)
-```
-
-## Composite Backends
-
-Afero provides the ability have two filesystems (or more) act as a single
-file system.
-
-### CacheOnReadFs
-
-The CacheOnReadFs will lazily make copies of any accessed files from the base
-layer into the overlay. Subsequent reads will be pulled from the overlay
-directly permitting the request is within the cache duration of when it was
-created in the overlay.
-
-If the base filesystem is writeable, any changes to files will be
-done first to the base, then to the overlay layer. Write calls to open file
-handles like `Write()` or `Truncate()` to the overlay first.
-
-To writing files to the overlay only, you can use the overlay Fs directly (not
-via the union Fs).
-
-Cache files in the layer for the given time.Duration, a cache duration of 0
-means "forever" meaning the file will not be re-requested from the base ever.
-
-A read-only base will make the overlay also read-only but still copy files
-from the base to the overlay when they're not present (or outdated) in the
-caching layer.
-
-```go
-base := afero.NewOsFs()
-layer := afero.NewMemMapFs()
-ufs := afero.NewCacheOnReadFs(base, layer, 100 * time.Second)
-```
-
-### CopyOnWriteFs()
-
-The CopyOnWriteFs is a read only base file system with a potentially
-writeable layer on top.
-
-Read operations will first look in the overlay and if not found there, will
-serve the file from the base.
-
-Changes to the file system will only be made in the overlay.
-
-Any attempt to modify a file found only in the base will copy the file to the
-overlay layer before modification (including opening a file with a writable
-handle).
-
-Removing and Renaming files present only in the base layer is not currently
-permitted. If a file is present in the base layer and the overlay, only the
-overlay will be removed/renamed.
-
-```go
-	base := afero.NewOsFs()
-	roBase := afero.NewReadOnlyFs(base)
-	ufs := afero.NewCopyOnWriteFs(roBase, afero.NewMemMapFs())
-
-	fh, _ = ufs.Create("/home/test/file2.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-```
-
-In this example all write operations will only occur in memory (MemMapFs)
-leaving the base filesystem (OsFs) untouched.
-
-
-## Desired/possible backends
-
-The following is a short list of possible backends we hope someone will
-implement:
-
-* SSH
-* ZIP
-* TAR
-* S3
-
-# About the project
-
-## What's in the name
-
-Afero comes from the latin roots Ad-Facere.
-
-**"Ad"** is a prefix meaning "to".
-
-**"Facere"** is a form of the root "faciō" making "make or do".
-
-The literal meaning of afero is "to make" or "to do" which seems very fitting
-for a library that allows one to make files and directories and do things with them.
-
-The English word that shares the same roots as Afero is "affair". Affair shares
-the same concept but as a noun it means "something that is made or done" or "an
-object of a particular type".
-
-It's also nice that unlike some of my other libraries (hugo, cobra, viper) it
-Googles very well.
-
-## Release Notes
-
-* **0.10.0** 2015.12.10
-  * Full compatibility with Windows
-  * Introduction of afero utilities
-  * Test suite rewritten to work cross platform
-  * Normalize paths for MemMapFs
-  * Adding Sync to the file interface
-  * **Breaking Change** Walk and ReadDir have changed parameter order
-  * Moving types used by MemMapFs to a subpackage
-  * General bugfixes and improvements
-* **0.9.0** 2015.11.05
-  * New Walk function similar to filepath.Walk
-  * MemMapFs.OpenFile handles O_CREATE, O_APPEND, O_TRUNC
-  * MemMapFs.Remove now really deletes the file
-  * InMemoryFile.Readdir and Readdirnames work correctly
-  * InMemoryFile functions lock it for concurrent access
-  * Test suite improvements
-* **0.8.0** 2014.10.28
-  * First public version
-  * Interfaces feel ready for people to build using
-  * Interfaces satisfy all known uses
-  * MemMapFs passes the majority of the OS test suite
-  * OsFs passes the majority of the OS test suite
-
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
-
-## Contributors
-
-Names in no particular order:
-
-* [spf13](https://github.com/spf13)
-* [jaqx0r](https://github.com/jaqx0r)
-* [mbertschler](https://github.com/mbertschler)
-* [xor-gate](https://github.com/xor-gate)
-
-## License
-
-Afero is released under the Apache 2.0 license. See
-[LICENSE.txt](https://github.com/spf13/afero/blob/master/LICENSE.txt)

vendor/github.com/spf13/afero/afero.go

@@ -1,108 +0,0 @@
-// Copyright © 2014 Steve Francia <spf@spf13.com>.
-// Copyright 2013 tsuru authors. All rights reserved.
-//
-// 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 afero provides types and methods for interacting with the filesystem,
-// as an abstraction layer.
-
-// Afero also provides a few implementations that are mostly interoperable. One that
-// uses the operating system filesystem, one that uses memory to store files
-// (cross platform) and an interface that should be implemented if you want to
-// provide your own filesystem.
-
-package afero
-
-import (
-	"errors"
-	"io"
-	"os"
-	"time"
-)
-
-type Afero struct {
-	Fs
-}
-
-// File represents a file in the filesystem.
-type File interface {
-	io.Closer
-	io.Reader
-	io.ReaderAt
-	io.Seeker
-	io.Writer
-	io.WriterAt
-
-	Name() string
-	Readdir(count int) ([]os.FileInfo, error)
-	Readdirnames(n int) ([]string, error)
-	Stat() (os.FileInfo, error)
-	Sync() error
-	Truncate(size int64) error
-	WriteString(s string) (ret int, err error)
-}
-
-// Fs is the filesystem interface.
-//
-// Any simulated or real filesystem should implement this interface.
-type Fs interface {
-	// Create creates a file in the filesystem, returning the file and an
-	// error, if any happens.
-	Create(name string) (File, error)
-
-	// Mkdir creates a directory in the filesystem, return an error if any
-	// happens.
-	Mkdir(name string, perm os.FileMode) error
-
-	// MkdirAll creates a directory path and all parents that does not exist
-	// yet.
-	MkdirAll(path string, perm os.FileMode) error
-
-	// Open opens a file, returning it or an error, if any happens.
-	Open(name string) (File, error)
-
-	// OpenFile opens a file using the given flags and the given mode.
-	OpenFile(name string, flag int, perm os.FileMode) (File, error)
-
-	// Remove removes a file identified by name, returning an error, if any
-	// happens.
-	Remove(name string) error
-
-	// RemoveAll removes a directory path and any children it contains. It
-	// does not fail if the path does not exist (return nil).
-	RemoveAll(path string) error
-
-	// Rename renames a file.
-	Rename(oldname, newname string) error
-
-	// Stat returns a FileInfo describing the named file, or an error, if any
-	// happens.
-	Stat(name string) (os.FileInfo, error)
-
-	// The name of this FileSystem
-	Name() string
-
-	//Chmod changes the mode of the named file to mode.
-	Chmod(name string, mode os.FileMode) error
-
-	//Chtimes changes the access and modification times of the named file
-	Chtimes(name string, atime time.Time, mtime time.Time) error
-}
-
-var (
-	ErrFileClosed        = errors.New("File is closed")
-	ErrOutOfRange        = errors.New("Out of range")
-	ErrTooLarge          = errors.New("Too large")
-	ErrFileNotFound      = os.ErrNotExist
-	ErrFileExists        = os.ErrExist
-	ErrDestinationExists = os.ErrExist
-)

vendor/github.com/spf13/afero/afero_test.go

@@ -1,699 +0,0 @@
-// Copyright © 2014 Steve Francia <spf@spf13.com>.
-// Copyright 2009 The Go Authors. All rights reserved.
-//
-// 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 afero
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"syscall"
-	"testing"
-)
-
-var testName = "test.txt"
-var Fss = []Fs{&MemMapFs{}, &OsFs{}}
-
-var testRegistry map[Fs][]string = make(map[Fs][]string)
-
-func testDir(fs Fs) string {
-	name, err := TempDir(fs, "", "afero")
-	if err != nil {
-		panic(fmt.Sprint("unable to work with test dir", err))
-	}
-	testRegistry[fs] = append(testRegistry[fs], name)
-
-	return name
-}
-
-func tmpFile(fs Fs) File {
-	x, err := TempFile(fs, "", "afero")
-
-	if err != nil {
-		panic(fmt.Sprint("unable to work with temp file", err))
-	}
-
-	testRegistry[fs] = append(testRegistry[fs], x.Name())
-
-	return x
-}
-
-//Read with length 0 should not return EOF.
-func TestRead0(t *testing.T) {
-	for _, fs := range Fss {
-		f := tmpFile(fs)
-		defer f.Close()
-		f.WriteString("Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.")
-
-		var b []byte
-		// b := make([]byte, 0)
-		n, err := f.Read(b)
-		if n != 0 || err != nil {
-			t.Errorf("%v: Read(0) = %d, %v, want 0, nil", fs.Name(), n, err)
-		}
-		f.Seek(0, 0)
-		b = make([]byte, 100)
-		n, err = f.Read(b)
-		if n <= 0 || err != nil {
-			t.Errorf("%v: Read(100) = %d, %v, want >0, nil", fs.Name(), n, err)
-		}
-	}
-}
-
-func TestOpenFile(t *testing.T) {
-	defer removeAllTestFiles(t)
-	for _, fs := range Fss {
-		tmp := testDir(fs)
-		path := filepath.Join(tmp, testName)
-
-		f, err := fs.OpenFile(path, os.O_RDWR|os.O_CREATE, 0600)
-		if err != nil {
-			t.Error(fs.Name(), "OpenFile (O_CREATE) failed:", err)
-			continue
-		}
-		io.WriteString(f, "initial")
-		f.Close()
-
-		f, err = fs.OpenFile(path, os.O_WRONLY|os.O_APPEND, 0600)
-		if err != nil {
-			t.Error(fs.Name(), "OpenFile (O_APPEND) failed:", err)
-			continue
-		}
-		io.WriteString(f, "|append")
-		f.Close()
-
-		f, err = fs.OpenFile(path, os.O_RDONLY, 0600)
-		contents, _ := ioutil.ReadAll(f)
-		expectedContents := "initial|append"
-		if string(contents) != expectedContents {
-			t.Errorf("%v: appending, expected '%v', got: '%v'", fs.Name(), expectedContents, string(contents))
-		}
-		f.Close()
-
-		f, err = fs.OpenFile(path, os.O_RDWR|os.O_TRUNC, 0600)
-		if err != nil {
-			t.Error(fs.Name(), "OpenFile (O_TRUNC) failed:", err)
-			continue
-		}
-		contents, _ = ioutil.ReadAll(f)
-		if string(contents) != "" {
-			t.Errorf("%v: expected truncated file, got: '%v'", fs.Name(), string(contents))
-		}
-		f.Close()
-	}
-}
-
-func TestCreate(t *testing.T) {
-	defer removeAllTestFiles(t)
-	for _, fs := range Fss {
-		tmp := testDir(fs)
-		path := filepath.Join(tmp, testName)
-
-		f, err := fs.Create(path)
-		if err != nil {
-			t.Error(fs.Name(), "Create failed:", err)
-			f.Close()
-			continue
-		}
-		io.WriteString(f, "initial")
-		f.Close()
-
-		f, err = fs.Create(path)
-		if err != nil {
-			t.Error(fs.Name(), "Create failed:", err)
-			f.Close()
-			continue
-		}
-		secondContent := "second create"
-		io.WriteString(f, secondContent)
-		f.Close()
-
-		f, err = fs.Open(path)
-		if err != nil {
-			t.Error(fs.Name(), "Open failed:", err)
-			f.Close()
-			continue
-		}
-		buf, err := ReadAll(f)
-		if err != nil {
-			t.Error(fs.Name(), "ReadAll failed:", err)
-			f.Close()
-			continue
-		}
-		if string(buf) != secondContent {
-			t.Error(fs.Name(), "Content should be", "\""+secondContent+"\" but is \""+string(buf)+"\"")
-			f.Close()
-			continue
-		}
-		f.Close()
-	}
-}
-
-func TestMemFileRead(t *testing.T) {
-	f := tmpFile(new(MemMapFs))
-	// f := MemFileCreate("testfile")
-	f.WriteString("abcd")
-	f.Seek(0, 0)
-	b := make([]byte, 8)
-	n, err := f.Read(b)
-	if n != 4 {
-		t.Errorf("didn't read all bytes: %v %v %v", n, err, b)
-	}
-	if err != nil {
-		t.Errorf("err is not nil: %v %v %v", n, err, b)
-	}
-	n, err = f.Read(b)
-	if n != 0 {
-		t.Errorf("read more bytes: %v %v %v", n, err, b)
-	}
-	if err != io.EOF {
-		t.Errorf("error is not EOF: %v %v %v", n, err, b)
-	}
-}
-
-func TestRename(t *testing.T) {
-	defer removeAllTestFiles(t)
-	for _, fs := range Fss {
-		tDir := testDir(fs)
-		from := filepath.Join(tDir, "/renamefrom")
-		to := filepath.Join(tDir, "/renameto")
-		exists := filepath.Join(tDir, "/renameexists")
-		file, err := fs.Create(from)
-		if err != nil {
-			t.Fatalf("%s: open %q failed: %v", fs.Name(), to, err)
-		}
-		if err = file.Close(); err != nil {
-			t.Errorf("%s: close %q failed: %v", fs.Name(), to, err)
-		}
-		file, err = fs.Create(exists)
-		if err != nil {
-			t.Fatalf("%s: open %q failed: %v", fs.Name(), to, err)
-		}
-		if err = file.Close(); err != nil {
-			t.Errorf("%s: close %q failed: %v", fs.Name(), to, err)
-		}
-		err = fs.Rename(from, to)
-		if err != nil {
-			t.Fatalf("%s: rename %q, %q failed: %v", fs.Name(), to, from, err)
-		}
-		file, err = fs.Create(from)
-		if err != nil {
-			t.Fatalf("%s: open %q failed: %v", fs.Name(), to, err)
-		}
-		if err = file.Close(); err != nil {
-			t.Errorf("%s: close %q failed: %v", fs.Name(), to, err)
-		}
-		err = fs.Rename(from, exists)
-		if err != nil {
-			t.Errorf("%s: rename %q, %q failed: %v", fs.Name(), exists, from, err)
-		}
-		names, err := readDirNames(fs, tDir)
-		if err != nil {
-			t.Errorf("%s: readDirNames error: %v", fs.Name(), err)
-		}
-		found := false
-		for _, e := range names {
-			if e == "renamefrom" {
-				t.Error("File is still called renamefrom")
-			}
-			if e == "renameto" {
-				found = true
-			}
-		}
-		if !found {
-			t.Error("File was not renamed to renameto")
-		}
-
-		_, err = fs.Stat(to)
-		if err != nil {
-			t.Errorf("%s: stat %q failed: %v", fs.Name(), to, err)
-		}
-	}
-}
-
-func TestRemove(t *testing.T) {
-	for _, fs := range Fss {
-
-		x, err := TempFile(fs, "", "afero")
-		if err != nil {
-			t.Error(fmt.Sprint("unable to work with temp file", err))
-		}
-
-		path := x.Name()
-		x.Close()
-
-		tDir := filepath.Dir(path)
-
-		err = fs.Remove(path)
-		if err != nil {
-			t.Errorf("%v: Remove() failed: %v", fs.Name(), err)
-			continue
-		}
-
-		_, err = fs.Stat(path)
-		if !os.IsNotExist(err) {
-			t.Errorf("%v: Remove() didn't remove file", fs.Name())
-			continue
-		}
-
-		// Deleting non-existent file should raise error
-		err = fs.Remove(path)
-		if !os.IsNotExist(err) {
-			t.Errorf("%v: Remove() didn't raise error for non-existent file", fs.Name())
-		}
-
-		f, err := fs.Open(tDir)
-		if err != nil {
-			t.Error("TestDir should still exist:", err)
-		}
-
-		names, err := f.Readdirnames(-1)
-		if err != nil {
-			t.Error("Readdirnames failed:", err)
-		}
-
-		for _, e := range names {
-			if e == testName {
-				t.Error("File was not removed from parent directory")
-			}
-		}
-	}
-}
-
-func TestTruncate(t *testing.T) {
-	defer removeAllTestFiles(t)
-	for _, fs := range Fss {
-		f := tmpFile(fs)
-		defer f.Close()
-
-		checkSize(t, f, 0)
-		f.Write([]byte("hello, world\n"))
-		checkSize(t, f, 13)
-		f.Truncate(10)
-		checkSize(t, f, 10)
-		f.Truncate(1024)
-		checkSize(t, f, 1024)
-		f.Truncate(0)
-		checkSize(t, f, 0)
-		_, err := f.Write([]byte("surprise!"))
-		if err == nil {
-			checkSize(t, f, 13+9) // wrote at offset past where hello, world was.
-		}
-	}
-}
-
-func TestSeek(t *testing.T) {
-	defer removeAllTestFiles(t)
-	for _, fs := range Fss {
-		f := tmpFile(fs)
-		defer f.Close()
-
-		const data = "hello, world\n"
-		io.WriteString(f, data)
-
-		type test struct {
-			in     int64
-			whence int
-			out    int64
-		}
-		var tests = []test{
-			{0, 1, int64(len(data))},
-			{0, 0, 0},
-			{5, 0, 5},
-			{0, 2, int64(len(data))},
-			{0, 0, 0},
-			{-1, 2, int64(len(data)) - 1},
-			{1 << 33, 0, 1 << 33},
-			{1 << 33, 2, 1<<33 + int64(len(data))},
-		}
-		for i, tt := range tests {
-			off, err := f.Seek(tt.in, tt.whence)
-			if off != tt.out || err != nil {
-				if e, ok := err.(*os.PathError); ok && e.Err == syscall.EINVAL && tt.out > 1<<32 {
-					// Reiserfs rejects the big seeks.
-					// http://code.google.com/p/go/issues/detail?id=91
-					break
-				}
-				t.Errorf("#%d: Seek(%v, %v) = %v, %v want %v, nil", i, tt.in, tt.whence, off, err, tt.out)
-			}
-		}
-	}
-}
-
-func TestReadAt(t *testing.T) {
-	defer removeAllTestFiles(t)
-	for _, fs := range Fss {
-		f := tmpFile(fs)
-		defer f.Close()
-
-		const data = "hello, world\n"
-		io.WriteString(f, data)
-
-		b := make([]byte, 5)
-		n, err := f.ReadAt(b, 7)
-		if err != nil || n != len(b) {
-			t.Fatalf("ReadAt 7: %d, %v", n, err)
-		}
-		if string(b) != "world" {
-			t.Fatalf("ReadAt 7: have %q want %q", string(b), "world")
-		}
-	}
-}
-
-func TestWriteAt(t *testing.T) {
-	defer removeAllTestFiles(t)
-	for _, fs := range Fss {
-		f := tmpFile(fs)
-		defer f.Close()
-
-		const data = "hello, world\n"
-		io.WriteString(f, data)
-
-		n, err := f.WriteAt([]byte("WORLD"), 7)
-		if err != nil || n != 5 {
-			t.Fatalf("WriteAt 7: %d, %v", n, err)
-		}
-
-		f2, err := fs.Open(f.Name())
-		if err != nil {
-			t.Fatalf("%v: ReadFile %s: %v", fs.Name(), f.Name(), err)
-		}
-		defer f2.Close()
-		buf := new(bytes.Buffer)
-		buf.ReadFrom(f2)
-		b := buf.Bytes()
-		if string(b) != "hello, WORLD\n" {
-			t.Fatalf("after write: have %q want %q", string(b), "hello, WORLD\n")
-		}
-
-	}
-}
-
-func setupTestDir(t *testing.T, fs Fs) string {
-	path := testDir(fs)
-	return setupTestFiles(t, fs, path)
-}
-
-func setupTestDirRoot(t *testing.T, fs Fs) string {
-	path := testDir(fs)
-	setupTestFiles(t, fs, path)
-	return path
-}
-
-func setupTestDirReusePath(t *testing.T, fs Fs, path string) string {
-	testRegistry[fs] = append(testRegistry[fs], path)
-	return setupTestFiles(t, fs, path)
-}
-
-func setupTestFiles(t *testing.T, fs Fs, path string) string {
-	testSubDir := filepath.Join(path, "more", "subdirectories", "for", "testing", "we")
-	err := fs.MkdirAll(testSubDir, 0700)
-	if err != nil && !os.IsExist(err) {
-		t.Fatal(err)
-	}
-
-	f, err := fs.Create(filepath.Join(testSubDir, "testfile1"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	f.WriteString("Testfile 1 content")
-	f.Close()
-
-	f, err = fs.Create(filepath.Join(testSubDir, "testfile2"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	f.WriteString("Testfile 2 content")
-	f.Close()
-
-	f, err = fs.Create(filepath.Join(testSubDir, "testfile3"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	f.WriteString("Testfile 3 content")
-	f.Close()
-
-	f, err = fs.Create(filepath.Join(testSubDir, "testfile4"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	f.WriteString("Testfile 4 content")
-	f.Close()
-	return testSubDir
-}
-
-func TestReaddirnames(t *testing.T) {
-	defer removeAllTestFiles(t)
-	for _, fs := range Fss {
-		testSubDir := setupTestDir(t, fs)
-		tDir := filepath.Dir(testSubDir)
-
-		root, err := fs.Open(tDir)
-		if err != nil {
-			t.Fatal(fs.Name(), tDir, err)
-		}
-		defer root.Close()
-
-		namesRoot, err := root.Readdirnames(-1)
-		if err != nil {
-			t.Fatal(fs.Name(), namesRoot, err)
-		}
-
-		sub, err := fs.Open(testSubDir)
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer sub.Close()
-
-		namesSub, err := sub.Readdirnames(-1)
-		if err != nil {
-			t.Fatal(fs.Name(), namesSub, err)
-		}
-
-		findNames(fs, t, tDir, testSubDir, namesRoot, namesSub)
-	}
-}
-
-func TestReaddirSimple(t *testing.T) {
-	defer removeAllTestFiles(t)
-	for _, fs := range Fss {
-		testSubDir := setupTestDir(t, fs)
-		tDir := filepath.Dir(testSubDir)
-
-		root, err := fs.Open(tDir)
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer root.Close()
-
-		rootInfo, err := root.Readdir(1)
-		if err != nil {
-			t.Log(myFileInfo(rootInfo))
-			t.Error(err)
-		}
-
-		rootInfo, err = root.Readdir(5)
-		if err != io.EOF {
-			t.Log(myFileInfo(rootInfo))
-			t.Error(err)
-		}
-
-		sub, err := fs.Open(testSubDir)
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer sub.Close()
-
-		subInfo, err := sub.Readdir(5)
-		if err != nil {
-			t.Log(myFileInfo(subInfo))
-			t.Error(err)
-		}
-	}
-}
-
-func TestReaddir(t *testing.T) {
-	defer removeAllTestFiles(t)
-	for num := 0; num < 6; num++ {
-		outputs := make([]string, len(Fss))
-		infos := make([]string, len(Fss))
-		for i, fs := range Fss {
-			testSubDir := setupTestDir(t, fs)
-			//tDir := filepath.Dir(testSubDir)
-			root, err := fs.Open(testSubDir)
-			if err != nil {
-				t.Fatal(err)
-			}
-			defer root.Close()
-
-			for j := 0; j < 6; j++ {
-				info, err := root.Readdir(num)
-				outputs[i] += fmt.Sprintf("%v  Error: %v\n", myFileInfo(info), err)
-				infos[i] += fmt.Sprintln(len(info), err)
-			}
-		}
-
-		fail := false
-		for i, o := range infos {
-			if i == 0 {
-				continue
-			}
-			if o != infos[i-1] {
-				fail = true
-				break
-			}
-		}
-		if fail {
-			t.Log("Readdir outputs not equal for Readdir(", num, ")")
-			for i, o := range outputs {
-				t.Log(Fss[i].Name())
-				t.Log(o)
-			}
-			t.Fail()
-		}
-	}
-}
-
-type myFileInfo []os.FileInfo
-
-func (m myFileInfo) String() string {
-	out := "Fileinfos:\n"
-	for _, e := range m {
-		out += "  " + e.Name() + "\n"
-	}
-	return out
-}
-
-func TestReaddirAll(t *testing.T) {
-	defer removeAllTestFiles(t)
-	for _, fs := range Fss {
-		testSubDir := setupTestDir(t, fs)
-		tDir := filepath.Dir(testSubDir)
-
-		root, err := fs.Open(tDir)
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer root.Close()
-
-		rootInfo, err := root.Readdir(-1)
-		if err != nil {
-			t.Fatal(err)
-		}
-		var namesRoot = []string{}
-		for _, e := range rootInfo {
-			namesRoot = append(namesRoot, e.Name())
-		}
-
-		sub, err := fs.Open(testSubDir)
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer sub.Close()
-
-		subInfo, err := sub.Readdir(-1)
-		if err != nil {
-			t.Fatal(err)
-		}
-		var namesSub = []string{}
-		for _, e := range subInfo {
-			namesSub = append(namesSub, e.Name())
-		}
-
-		findNames(fs, t, tDir, testSubDir, namesRoot, namesSub)
-	}
-}
-
-func findNames(fs Fs, t *testing.T, tDir, testSubDir string, root, sub []string) {
-	var foundRoot bool
-	for _, e := range root {
-		f, err := fs.Open(filepath.Join(tDir, e))
-		if err != nil {
-			t.Error("Open", filepath.Join(tDir, e), ":", err)
-		}
-		defer f.Close()
-
-		if equal(e, "we") {
-			foundRoot = true
-		}
-	}
-	if !foundRoot {
-		t.Logf("Names root: %v", root)
-		t.Logf("Names sub: %v", sub)
-		t.Error("Didn't find subdirectory we")
-	}
-
-	var found1, found2 bool
-	for _, e := range sub {
-		f, err := fs.Open(filepath.Join(testSubDir, e))
-		if err != nil {
-			t.Error("Open", filepath.Join(testSubDir, e), ":", err)
-		}
-		defer f.Close()
-
-		if equal(e, "testfile1") {
-			found1 = true
-		}
-		if equal(e, "testfile2") {
-			found2 = true
-		}
-	}
-
-	if !found1 {
-		t.Logf("Names root: %v", root)
-		t.Logf("Names sub: %v", sub)
-		t.Error("Didn't find testfile1")
-	}
-	if !found2 {
-		t.Logf("Names root: %v", root)
-		t.Logf("Names sub: %v", sub)
-		t.Error("Didn't find testfile2")
-	}
-}
-
-func removeAllTestFiles(t *testing.T) {
-	for fs, list := range testRegistry {
-		for _, path := range list {
-			if err := fs.RemoveAll(path); err != nil {
-				t.Error(fs.Name(), err)
-			}
-		}
-	}
-	testRegistry = make(map[Fs][]string)
-}
-
-func equal(name1, name2 string) (r bool) {
-	switch runtime.GOOS {
-	case "windows":
-		r = strings.ToLower(name1) == strings.ToLower(name2)
-	default:
-		r = name1 == name2
-	}
-	return
-}
-
-func checkSize(t *testing.T, f File, size int64) {
-	dir, err := f.Stat()
-	if err != nil {
-		t.Fatalf("Stat %q (looking for size %d): %s", f.Name(), size, err)
-	}
-	if dir.Size() != size {
-		t.Errorf("Stat %q: size %d want %d", f.Name(), dir.Size(), size)
-	}
-}

vendor/github.com/spf13/afero/appveyor.yml

@@ -1,15 +0,0 @@
-version: '{build}'
-clone_folder: C:\gopath\src\github.com\spf13\afero
-environment:
-  GOPATH: C:\gopath
-build_script:
-- cmd: >-
-    go version
-
-    go env
-
-    go get -v github.com/spf13/afero/...
-
-    go build github.com/spf13/afero
-test_script:
-- cmd: go test -v github.com/spf13/afero

vendor/github.com/spf13/afero/basepath.go

@@ -1,145 +0,0 @@
-package afero
-
-import (
-	"errors"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"time"
-)
-
-// The BasePathFs restricts all operations to a given path within an Fs.
-// The given file name to the operations on this Fs will be prepended with
-// the base path before calling the base Fs.
-// Any file name (after filepath.Clean()) outside this base path will be
-// treated as non existing file.
-//
-// Note that it does not clean the error messages on return, so you may
-// reveal the real path on errors.
-type BasePathFs struct {
-	source Fs
-	path   string
-}
-
-func NewBasePathFs(source Fs, path string) Fs {
-	return &BasePathFs{source: source, path: path}
-}
-
-// on a file outside the base path it returns the given file name and an error,
-// else the given file with the base path prepended
-func (b *BasePathFs) RealPath(name string) (path string, err error) {
-	if err := validateBasePathName(name); err != nil {
-		return "", err
-	}
-
-	bpath := filepath.Clean(b.path)
-	path = filepath.Clean(filepath.Join(bpath, name))
-	if !strings.HasPrefix(path, bpath) {
-		return name, os.ErrNotExist
-	}
-
-	return path, nil
-}
-
-func validateBasePathName(name string) error {
-	if runtime.GOOS != "windows" {
-		// Not much to do here;
-		// the virtual file paths all look absolute on *nix.
-		return nil
-	}
-
-	// On Windows a common mistake would be to provide an absolute OS path
-	// We could strip out the base part, but that would not be very portable.
-	if filepath.IsAbs(name) {
-		return &os.PathError{Op: "realPath", Path: name, Err: errors.New("got a real OS path instead of a virtual")}
-	}
-
-	return nil
-}
-
-func (b *BasePathFs) Chtimes(name string, atime, mtime time.Time) (err error) {
-	if name, err = b.RealPath(name); err != nil {
-		return &os.PathError{Op: "chtimes", Path: name, Err: err}
-	}
-	return b.source.Chtimes(name, atime, mtime)
-}
-
-func (b *BasePathFs) Chmod(name string, mode os.FileMode) (err error) {
-	if name, err = b.RealPath(name); err != nil {
-		return &os.PathError{Op: "chmod", Path: name, Err: err}
-	}
-	return b.source.Chmod(name, mode)
-}
-
-func (b *BasePathFs) Name() string {
-	return "BasePathFs"
-}
-
-func (b *BasePathFs) Stat(name string) (fi os.FileInfo, err error) {
-	if name, err = b.RealPath(name); err != nil {
-		return nil, &os.PathError{Op: "stat", Path: name, Err: err}
-	}
-	return b.source.Stat(name)
-}
-
-func (b *BasePathFs) Rename(oldname, newname string) (err error) {
-	if oldname, err = b.RealPath(oldname); err != nil {
-		return &os.PathError{Op: "rename", Path: oldname, Err: err}
-	}
-	if newname, err = b.RealPath(newname); err != nil {
-		return &os.PathError{Op: "rename", Path: newname, Err: err}
-	}
-	return b.source.Rename(oldname, newname)
-}
-
-func (b *BasePathFs) RemoveAll(name string) (err error) {
-	if name, err = b.RealPath(name); err != nil {
-		return &os.PathError{Op: "remove_all", Path: name, Err: err}
-	}
-	return b.source.RemoveAll(name)
-}
-
-func (b *BasePathFs) Remove(name string) (err error) {
-	if name, err = b.RealPath(name); err != nil {
-		return &os.PathError{Op: "remove", Path: name, Err: err}
-	}
-	return b.source.Remove(name)
-}
-
-func (b *BasePathFs) OpenFile(name string, flag int, mode os.FileMode) (f File, err error) {
-	if name, err = b.RealPath(name); err != nil {
-		return nil, &os.PathError{Op: "openfile", Path: name, Err: err}
-	}
-	return b.source.OpenFile(name, flag, mode)
-}
-
-func (b *BasePathFs) Open(name string) (f File, err error) {
-	if name, err = b.RealPath(name); err != nil {
-		return nil, &os.PathError{Op: "open", Path: name, Err: err}
-	}
-	return b.source.Open(name)
-}
-
-func (b *BasePathFs) Mkdir(name string, mode os.FileMode) (err error) {
-	if name, err = b.RealPath(name); err != nil {
-		return &os.PathError{Op: "mkdir", Path: name, Err: err}
-	}
-	return b.source.Mkdir(name, mode)
-}
-
-func (b *BasePathFs) MkdirAll(name string, mode os.FileMode) (err error) {
-	if name, err = b.RealPath(name); err != nil {
-		return &os.PathError{Op: "mkdir", Path: name, Err: err}
-	}
-	return b.source.MkdirAll(name, mode)
-}
-
-func (b *BasePathFs) Create(name string) (f File, err error) {
-	if name, err = b.RealPath(name); err != nil {
-		return nil, &os.PathError{Op: "create", Path: name, Err: err}
-	}
-	return b.source.Create(name)
-}
-
-// vim: ts=4 sw=4 noexpandtab nolist syn=go

vendor/github.com/spf13/afero/basepath_test.go

@@ -1,142 +0,0 @@
-package afero
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-)
-
-func TestBasePath(t *testing.T) {
-	baseFs := &MemMapFs{}
-	baseFs.MkdirAll("/base/path/tmp", 0777)
-	bp := NewBasePathFs(baseFs, "/base/path")
-
-	if _, err := bp.Create("/tmp/foo"); err != nil {
-		t.Errorf("Failed to set real path")
-	}
-
-	if fh, err := bp.Create("../tmp/bar"); err == nil {
-		t.Errorf("succeeded in creating %s ...", fh.Name())
-	}
-}
-
-func TestBasePathRoot(t *testing.T) {
-	baseFs := &MemMapFs{}
-	baseFs.MkdirAll("/base/path/foo/baz", 0777)
-	baseFs.MkdirAll("/base/path/boo/", 0777)
-	bp := NewBasePathFs(baseFs, "/base/path")
-
-	rd, err := ReadDir(bp, string(os.PathSeparator))
-
-	if len(rd) != 2 {
-		t.Errorf("base path doesn't respect root")
-	}
-
-	if err != nil {
-		t.Error(err)
-	}
-}
-
-func TestRealPath(t *testing.T) {
-	fs := NewOsFs()
-	baseDir, err := TempDir(fs, "", "base")
-	if err != nil {
-		t.Fatal("error creating tempDir", err)
-	}
-	defer fs.RemoveAll(baseDir)
-	anotherDir, err := TempDir(fs, "", "another")
-	if err != nil {
-		t.Fatal("error creating tempDir", err)
-	}
-	defer fs.RemoveAll(anotherDir)
-
-	bp := NewBasePathFs(fs, baseDir).(*BasePathFs)
-
-	subDir := filepath.Join(baseDir, "s1")
-
-	realPath, err := bp.RealPath("/s1")
-
-	if err != nil {
-		t.Errorf("Got error %s", err)
-	}
-
-	if realPath != subDir {
-		t.Errorf("Expected \n%s got \n%s", subDir, realPath)
-	}
-
-	if runtime.GOOS == "windows" {
-		_, err = bp.RealPath(anotherDir)
-
-		if err == nil {
-			t.Errorf("Expected error")
-		}
-
-	} else {
-		// on *nix we have no way of just looking at the path and tell that anotherDir
-		// is not inside the base file system.
-		// The user will receive an os.ErrNotExist later.
-		surrealPath, err := bp.RealPath(anotherDir)
-
-		if err != nil {
-			t.Errorf("Got error %s", err)
-		}
-
-		excpected := filepath.Join(baseDir, anotherDir)
-
-		if surrealPath != excpected {
-			t.Errorf("Expected \n%s got \n%s", excpected, surrealPath)
-		}
-	}
-
-}
-
-func TestNestedBasePaths(t *testing.T) {
-	type dirSpec struct {
-		Dir1, Dir2, Dir3 string
-	}
-	dirSpecs := []dirSpec{
-		dirSpec{Dir1: "/", Dir2: "/", Dir3: "/"},
-		dirSpec{Dir1: "/", Dir2: "/path2", Dir3: "/"},
-		dirSpec{Dir1: "/path1/dir", Dir2: "/path2/dir/", Dir3: "/path3/dir"},
-		dirSpec{Dir1: "C:/path1", Dir2: "path2/dir", Dir3: "/path3/dir/"},
-	}
-
-	for _, ds := range dirSpecs {
-		memFs := NewMemMapFs()
-		level1Fs := NewBasePathFs(memFs, ds.Dir1)
-		level2Fs := NewBasePathFs(level1Fs, ds.Dir2)
-		level3Fs := NewBasePathFs(level2Fs, ds.Dir3)
-
-		type spec struct {
-			BaseFs   Fs
-			FileName string
-		}
-		specs := []spec{
-			spec{BaseFs: level3Fs, FileName: "f.txt"},
-			spec{BaseFs: level2Fs, FileName: "f.txt"},
-			spec{BaseFs: level1Fs, FileName: "f.txt"},
-		}
-
-		for _, s := range specs {
-			if err := s.BaseFs.MkdirAll(s.FileName, 0755); err != nil {
-				t.Errorf("Got error %s", err.Error())
-			}
-			if _, err := s.BaseFs.Stat(s.FileName); err != nil {
-				t.Errorf("Got error %s", err.Error())
-			}
-
-			if s.BaseFs == level3Fs {
-				pathToExist := filepath.Join(ds.Dir3, s.FileName)
-				if _, err := level2Fs.Stat(pathToExist); err != nil {
-					t.Errorf("Got error %s (path %s)", err.Error(), pathToExist)
-				}
-			} else if s.BaseFs == level2Fs {
-				pathToExist := filepath.Join(ds.Dir2, ds.Dir3, s.FileName)
-				if _, err := level1Fs.Stat(pathToExist); err != nil {
-					t.Errorf("Got error %s (path %s)", err.Error(), pathToExist)
-				}
-			}
-		}
-	}
-}

vendor/github.com/spf13/afero/cacheOnReadFs.go

@@ -1,295 +0,0 @@
-package afero
-
-import (
-	"os"
-	"syscall"
-	"time"
-)
-
-// If the cache duration is 0, cache time will be unlimited, i.e. once
-// a file is in the layer, the base will never be read again for this file.
-//
-// For cache times greater than 0, the modification time of a file is
-// checked. Note that a lot of file system implementations only allow a
-// resolution of a second for timestamps... or as the godoc for os.Chtimes()
-// states: "The underlying filesystem may truncate or round the values to a
-// less precise time unit."
-//
-// This caching union will forward all write calls also to the base file
-// system first. To prevent writing to the base Fs, wrap it in a read-only
-// filter - Note: this will also make the overlay read-only, for writing files
-// in the overlay, use the overlay Fs directly, not via the union Fs.
-type CacheOnReadFs struct {
-	base      Fs
-	layer     Fs
-	cacheTime time.Duration
-}
-
-func NewCacheOnReadFs(base Fs, layer Fs, cacheTime time.Duration) Fs {
-	return &CacheOnReadFs{base: base, layer: layer, cacheTime: cacheTime}
-}
-
-type cacheState int
-
-const (
-	// not present in the overlay, unknown if it exists in the base:
-	cacheMiss cacheState = iota
-	// present in the overlay and in base, base file is newer:
-	cacheStale
-	// present in the overlay - with cache time == 0 it may exist in the base,
-	// with cacheTime > 0 it exists in the base and is same age or newer in the
-	// overlay
-	cacheHit
-	// happens if someone writes directly to the overlay without
-	// going through this union
-	cacheLocal
-)
-
-func (u *CacheOnReadFs) cacheStatus(name string) (state cacheState, fi os.FileInfo, err error) {
-	var lfi, bfi os.FileInfo
-	lfi, err = u.layer.Stat(name)
-	if err == nil {
-		if u.cacheTime == 0 {
-			return cacheHit, lfi, nil
-		}
-		if lfi.ModTime().Add(u.cacheTime).Before(time.Now()) {
-			bfi, err = u.base.Stat(name)
-			if err != nil {
-				return cacheLocal, lfi, nil
-			}
-			if bfi.ModTime().After(lfi.ModTime()) {
-				return cacheStale, bfi, nil
-			}
-		}
-		return cacheHit, lfi, nil
-	}
-
-	if err == syscall.ENOENT {
-		return cacheMiss, nil, nil
-	}
-	var ok bool
-	if err, ok = err.(*os.PathError); ok {
-		if err == os.ErrNotExist {
-			return cacheMiss, nil, nil
-		}
-	}
-	return cacheMiss, nil, err
-}
-
-func (u *CacheOnReadFs) copyToLayer(name string) error {
-	return copyToLayer(u.base, u.layer, name)
-}
-
-func (u *CacheOnReadFs) Chtimes(name string, atime, mtime time.Time) error {
-	st, _, err := u.cacheStatus(name)
-	if err != nil {
-		return err
-	}
-	switch st {
-	case cacheLocal:
-	case cacheHit:
-		err = u.base.Chtimes(name, atime, mtime)
-	case cacheStale, cacheMiss:
-		if err := u.copyToLayer(name); err != nil {
-			return err
-		}
-		err = u.base.Chtimes(name, atime, mtime)
-	}
-	if err != nil {
-		return err
-	}
-	return u.layer.Chtimes(name, atime, mtime)
-}
-
-func (u *CacheOnReadFs) Chmod(name string, mode os.FileMode) error {
-	st, _, err := u.cacheStatus(name)
-	if err != nil {
-		return err
-	}
-	switch st {
-	case cacheLocal:
-	case cacheHit:
-		err = u.base.Chmod(name, mode)
-	case cacheStale, cacheMiss:
-		if err := u.copyToLayer(name); err != nil {
-			return err
-		}
-		err = u.base.Chmod(name, mode)
-	}
-	if err != nil {
-		return err
-	}
-	return u.layer.Chmod(name, mode)
-}
-
-func (u *CacheOnReadFs) Stat(name string) (os.FileInfo, error) {
-	st, fi, err := u.cacheStatus(name)
-	if err != nil {
-		return nil, err
-	}
-	switch st {
-	case cacheMiss:
-		return u.base.Stat(name)
-	default: // cacheStale has base, cacheHit and cacheLocal the layer os.FileInfo
-		return fi, nil
-	}
-}
-
-func (u *CacheOnReadFs) Rename(oldname, newname string) error {
-	st, _, err := u.cacheStatus(oldname)
-	if err != nil {
-		return err
-	}
-	switch st {
-	case cacheLocal:
-	case cacheHit:
-		err = u.base.Rename(oldname, newname)
-	case cacheStale, cacheMiss:
-		if err := u.copyToLayer(oldname); err != nil {
-			return err
-		}
-		err = u.base.Rename(oldname, newname)
-	}
-	if err != nil {
-		return err
-	}
-	return u.layer.Rename(oldname, newname)
-}
-
-func (u *CacheOnReadFs) Remove(name string) error {
-	st, _, err := u.cacheStatus(name)
-	if err != nil {
-		return err
-	}
-	switch st {
-	case cacheLocal:
-	case cacheHit, cacheStale, cacheMiss:
-		err = u.base.Remove(name)
-	}
-	if err != nil {
-		return err
-	}
-	return u.layer.Remove(name)
-}
-
-func (u *CacheOnReadFs) RemoveAll(name string) error {
-	st, _, err := u.cacheStatus(name)
-	if err != nil {
-		return err
-	}
-	switch st {
-	case cacheLocal:
-	case cacheHit, cacheStale, cacheMiss:
-		err = u.base.RemoveAll(name)
-	}
-	if err != nil {
-		return err
-	}
-	return u.layer.RemoveAll(name)
-}
-
-func (u *CacheOnReadFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
-	st, _, err := u.cacheStatus(name)
-	if err != nil {
-		return nil, err
-	}
-	switch st {
-	case cacheLocal, cacheHit:
-	default:
-		if err := u.copyToLayer(name); err != nil {
-			return nil, err
-		}
-	}
-	if flag&(os.O_WRONLY|syscall.O_RDWR|os.O_APPEND|os.O_CREATE|os.O_TRUNC) != 0 {
-		bfi, err := u.base.OpenFile(name, flag, perm)
-		if err != nil {
-			return nil, err
-		}
-		lfi, err := u.layer.OpenFile(name, flag, perm)
-		if err != nil {
-			bfi.Close() // oops, what if O_TRUNC was set and file opening in the layer failed...?
-			return nil, err
-		}
-		return &UnionFile{base: bfi, layer: lfi}, nil
-	}
-	return u.layer.OpenFile(name, flag, perm)
-}
-
-func (u *CacheOnReadFs) Open(name string) (File, error) {
-	st, fi, err := u.cacheStatus(name)
-	if err != nil {
-		return nil, err
-	}
-
-	switch st {
-	case cacheLocal:
-		return u.layer.Open(name)
-
-	case cacheMiss:
-		bfi, err := u.base.Stat(name)
-		if err != nil {
-			return nil, err
-		}
-		if bfi.IsDir() {
-			return u.base.Open(name)
-		}
-		if err := u.copyToLayer(name); err != nil {
-			return nil, err
-		}
-		return u.layer.Open(name)
-
-	case cacheStale:
-		if !fi.IsDir() {
-			if err := u.copyToLayer(name); err != nil {
-				return nil, err
-			}
-			return u.layer.Open(name)
-		}
-	case cacheHit:
-		if !fi.IsDir() {
-			return u.layer.Open(name)
-		}
-	}
-	// the dirs from cacheHit, cacheStale fall down here:
-	bfile, _ := u.base.Open(name)
-	lfile, err := u.layer.Open(name)
-	if err != nil && bfile == nil {
-		return nil, err
-	}
-	return &UnionFile{base: bfile, layer: lfile}, nil
-}
-
-func (u *CacheOnReadFs) Mkdir(name string, perm os.FileMode) error {
-	err := u.base.Mkdir(name, perm)
-	if err != nil {
-		return err
-	}
-	return u.layer.MkdirAll(name, perm) // yes, MkdirAll... we cannot assume it exists in the cache
-}
-
-func (u *CacheOnReadFs) Name() string {
-	return "CacheOnReadFs"
-}
-
-func (u *CacheOnReadFs) MkdirAll(name string, perm os.FileMode) error {
-	err := u.base.MkdirAll(name, perm)
-	if err != nil {
-		return err
-	}
-	return u.layer.MkdirAll(name, perm)
-}
-
-func (u *CacheOnReadFs) Create(name string) (File, error) {
-	bfh, err := u.base.Create(name)
-	if err != nil {
-		return nil, err
-	}
-	lfh, err := u.layer.Create(name)
-	if err != nil {
-		// oops, see comment about OS_TRUNC above, should we remove? then we have to
-		// remember if the file did not exist before
-		bfh.Close()
-		return nil, err
-	}
-	return &UnionFile{base: bfh, layer: lfh}, nil
-}

vendor/github.com/spf13/afero/composite_test.go

@@ -1,368 +0,0 @@
-package afero
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"testing"
-	"time"
-)
-
-var tempDirs []string
-
-func NewTempOsBaseFs(t *testing.T) Fs {
-	name, err := TempDir(NewOsFs(), "", "")
-	if err != nil {
-		t.Error("error creating tempDir", err)
-	}
-
-	tempDirs = append(tempDirs, name)
-
-	return NewBasePathFs(NewOsFs(), name)
-}
-
-func CleanupTempDirs(t *testing.T) {
-	osfs := NewOsFs()
-	type ev struct {
-		path string
-		e    error
-	}
-
-	errs := []ev{}
-
-	for _, x := range tempDirs {
-		err := osfs.RemoveAll(x)
-		if err != nil {
-			errs = append(errs, ev{path: x, e: err})
-		}
-	}
-
-	for _, e := range errs {
-		fmt.Println("error removing tempDir", e.path, e.e)
-	}
-
-	if len(errs) > 0 {
-		t.Error("error cleaning up tempDirs")
-	}
-	tempDirs = []string{}
-}
-
-func TestUnionCreateExisting(t *testing.T) {
-	base := &MemMapFs{}
-	roBase := &ReadOnlyFs{source: base}
-
-	ufs := NewCopyOnWriteFs(roBase, &MemMapFs{})
-
-	base.MkdirAll("/home/test", 0777)
-	fh, _ := base.Create("/home/test/file.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-
-	fh, err := ufs.OpenFile("/home/test/file.txt", os.O_RDWR, 0666)
-	if err != nil {
-		t.Errorf("Failed to open file r/w: %s", err)
-	}
-
-	_, err = fh.Write([]byte("####"))
-	if err != nil {
-		t.Errorf("Failed to write file: %s", err)
-	}
-	fh.Seek(0, 0)
-	data, err := ioutil.ReadAll(fh)
-	if err != nil {
-		t.Errorf("Failed to read file: %s", err)
-	}
-	if string(data) != "#### is a test" {
-		t.Errorf("Got wrong data")
-	}
-	fh.Close()
-
-	fh, _ = base.Open("/home/test/file.txt")
-	data, err = ioutil.ReadAll(fh)
-	if string(data) != "This is a test" {
-		t.Errorf("Got wrong data in base file")
-	}
-	fh.Close()
-
-	fh, err = ufs.Create("/home/test/file.txt")
-	switch err {
-	case nil:
-		if fi, _ := fh.Stat(); fi.Size() != 0 {
-			t.Errorf("Create did not truncate file")
-		}
-		fh.Close()
-	default:
-		t.Errorf("Create failed on existing file")
-	}
-
-}
-
-func TestUnionMergeReaddir(t *testing.T) {
-	base := &MemMapFs{}
-	roBase := &ReadOnlyFs{source: base}
-
-	ufs := &CopyOnWriteFs{base: roBase, layer: &MemMapFs{}}
-
-	base.MkdirAll("/home/test", 0777)
-	fh, _ := base.Create("/home/test/file.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-
-	fh, _ = ufs.Create("/home/test/file2.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-
-	fh, _ = ufs.Open("/home/test")
-	files, err := fh.Readdirnames(-1)
-	if err != nil {
-		t.Errorf("Readdirnames failed")
-	}
-	if len(files) != 2 {
-		t.Errorf("Got wrong number of files: %v", files)
-	}
-}
-
-func TestExistingDirectoryCollisionReaddir(t *testing.T) {
-	base := &MemMapFs{}
-	roBase := &ReadOnlyFs{source: base}
-	overlay := &MemMapFs{}
-
-	ufs := &CopyOnWriteFs{base: roBase, layer: overlay}
-
-	base.MkdirAll("/home/test", 0777)
-	fh, _ := base.Create("/home/test/file.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-
-	overlay.MkdirAll("home/test", 0777)
-	fh, _ = overlay.Create("/home/test/file2.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-
-	fh, _ = ufs.Create("/home/test/file3.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-
-	fh, _ = ufs.Open("/home/test")
-	files, err := fh.Readdirnames(-1)
-	if err != nil {
-		t.Errorf("Readdirnames failed")
-	}
-	if len(files) != 3 {
-		t.Errorf("Got wrong number of files in union: %v", files)
-	}
-
-	fh, _ = overlay.Open("/home/test")
-	files, err = fh.Readdirnames(-1)
-	if err != nil {
-		t.Errorf("Readdirnames failed")
-	}
-	if len(files) != 2 {
-		t.Errorf("Got wrong number of files in overlay: %v", files)
-	}
-}
-
-func TestNestedDirBaseReaddir(t *testing.T) {
-	base := &MemMapFs{}
-	roBase := &ReadOnlyFs{source: base}
-	overlay := &MemMapFs{}
-
-	ufs := &CopyOnWriteFs{base: roBase, layer: overlay}
-
-	base.MkdirAll("/home/test/foo/bar", 0777)
-	fh, _ := base.Create("/home/test/file.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-
-	fh, _ = base.Create("/home/test/foo/file2.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-	fh, _ = base.Create("/home/test/foo/bar/file3.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-
-	overlay.MkdirAll("/", 0777)
-
-	// Opening something only in the base
-	fh, _ = ufs.Open("/home/test/foo")
-	list, err := fh.Readdir(-1)
-	if err != nil {
-		t.Errorf("Readdir failed %s", err)
-	}
-	if len(list) != 2 {
-		for _, x := range list {
-			fmt.Println(x.Name())
-		}
-		t.Errorf("Got wrong number of files in union: %v", len(list))
-	}
-}
-
-func TestNestedDirOverlayReaddir(t *testing.T) {
-	base := &MemMapFs{}
-	roBase := &ReadOnlyFs{source: base}
-	overlay := &MemMapFs{}
-
-	ufs := &CopyOnWriteFs{base: roBase, layer: overlay}
-
-	base.MkdirAll("/", 0777)
-	overlay.MkdirAll("/home/test/foo/bar", 0777)
-	fh, _ := overlay.Create("/home/test/file.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-	fh, _ = overlay.Create("/home/test/foo/file2.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-	fh, _ = overlay.Create("/home/test/foo/bar/file3.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-
-	// Opening nested dir only in the overlay
-	fh, _ = ufs.Open("/home/test/foo")
-	list, err := fh.Readdir(-1)
-	if err != nil {
-		t.Errorf("Readdir failed %s", err)
-	}
-	if len(list) != 2 {
-		for _, x := range list {
-			fmt.Println(x.Name())
-		}
-		t.Errorf("Got wrong number of files in union: %v", len(list))
-	}
-}
-
-func TestNestedDirOverlayOsFsReaddir(t *testing.T) {
-	defer CleanupTempDirs(t)
-	base := NewTempOsBaseFs(t)
-	roBase := &ReadOnlyFs{source: base}
-	overlay := NewTempOsBaseFs(t)
-
-	ufs := &CopyOnWriteFs{base: roBase, layer: overlay}
-
-	base.MkdirAll("/", 0777)
-	overlay.MkdirAll("/home/test/foo/bar", 0777)
-	fh, _ := overlay.Create("/home/test/file.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-	fh, _ = overlay.Create("/home/test/foo/file2.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-	fh, _ = overlay.Create("/home/test/foo/bar/file3.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-
-	// Opening nested dir only in the overlay
-	fh, _ = ufs.Open("/home/test/foo")
-	list, err := fh.Readdir(-1)
-	fh.Close()
-	if err != nil {
-		t.Errorf("Readdir failed %s", err)
-	}
-	if len(list) != 2 {
-		for _, x := range list {
-			fmt.Println(x.Name())
-		}
-		t.Errorf("Got wrong number of files in union: %v", len(list))
-	}
-}
-
-func TestCopyOnWriteFsWithOsFs(t *testing.T) {
-	defer CleanupTempDirs(t)
-	base := NewTempOsBaseFs(t)
-	roBase := &ReadOnlyFs{source: base}
-	overlay := NewTempOsBaseFs(t)
-
-	ufs := &CopyOnWriteFs{base: roBase, layer: overlay}
-
-	base.MkdirAll("/home/test", 0777)
-	fh, _ := base.Create("/home/test/file.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-
-	overlay.MkdirAll("home/test", 0777)
-	fh, _ = overlay.Create("/home/test/file2.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-
-	fh, _ = ufs.Create("/home/test/file3.txt")
-	fh.WriteString("This is a test")
-	fh.Close()
-
-	fh, _ = ufs.Open("/home/test")
-	files, err := fh.Readdirnames(-1)
-	fh.Close()
-	if err != nil {
-		t.Errorf("Readdirnames failed")
-	}
-	if len(files) != 3 {
-		t.Errorf("Got wrong number of files in union: %v", files)
-	}
-
-	fh, _ = overlay.Open("/home/test")
-	files, err = fh.Readdirnames(-1)
-	fh.Close()
-	if err != nil {
-		t.Errorf("Readdirnames failed")
-	}
-	if len(files) != 2 {
-		t.Errorf("Got wrong number of files in overlay: %v", files)
-	}
-}
-
-func TestUnionCacheWrite(t *testing.T) {
-	base := &MemMapFs{}
-	layer := &MemMapFs{}
-
-	ufs := NewCacheOnReadFs(base, layer, 0)
-
-	base.Mkdir("/data", 0777)
-
-	fh, err := ufs.Create("/data/file.txt")
-	if err != nil {
-		t.Errorf("Failed to create file")
-	}
-	_, err = fh.Write([]byte("This is a test"))
-	if err != nil {
-		t.Errorf("Failed to write file")
-	}
-
-	fh.Seek(0, os.SEEK_SET)
-	buf := make([]byte, 4)
-	_, err = fh.Read(buf)
-	fh.Write([]byte(" IS A"))
-	fh.Close()
-
-	baseData, _ := ReadFile(base, "/data/file.txt")
-	layerData, _ := ReadFile(layer, "/data/file.txt")
-	if string(baseData) != string(layerData) {
-		t.Errorf("Different data: %s <=> %s", baseData, layerData)
-	}
-}
-
-func TestUnionCacheExpire(t *testing.T) {
-	base := &MemMapFs{}
-	layer := &MemMapFs{}
-	ufs := &CacheOnReadFs{base: base, layer: layer, cacheTime: 1 * time.Second}
-
-	base.Mkdir("/data", 0777)
-
-	fh, err := ufs.Create("/data/file.txt")
-	if err != nil {
-		t.Errorf("Failed to create file")
-	}
-	_, err = fh.Write([]byte("This is a test"))
-	if err != nil {
-		t.Errorf("Failed to write file")
-	}
-	fh.Close()
-
-	fh, _ = base.Create("/data/file.txt")
-	// sleep some time, so we really get a different time.Now() on write...
-	time.Sleep(2 * time.Second)
-	fh.WriteString("Another test")
-	fh.Close()
-
-	data, _ := ReadFile(ufs, "/data/file.txt")
-	if string(data) != "Another test" {
-		t.Errorf("cache time failed: <%s>", data)
-	}
-}

vendor/github.com/spf13/afero/const_bsds.go

@@ -1,22 +0,0 @@
-// Copyright © 2016 Steve Francia <spf@spf13.com>.
-//
-// 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.
-
-// +build darwin openbsd freebsd netbsd dragonfly
-
-package afero
-
-import (
-	"syscall"
-)
-
-const BADFD = syscall.EBADF

vendor/github.com/spf13/afero/const_win_unix.go

@@ -1,25 +0,0 @@
-// Copyright © 2016 Steve Francia <spf@spf13.com>.
-//
-// 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.
-// +build !darwin
-// +build !openbsd
-// +build !freebsd
-// +build !dragonfly
-// +build !netbsd
-
-package afero
-
-import (
-	"syscall"
-)
-
-const BADFD = syscall.EBADFD

vendor/github.com/spf13/afero/copyOnWriteFs.go

@@ -1,253 +0,0 @@
-package afero
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"syscall"
-	"time"
-)
-
-// The CopyOnWriteFs is a union filesystem: a read only base file system with
-// a possibly writeable layer on top. Changes to the file system will only
-// be made in the overlay: Changing an existing file in the base layer which
-// is not present in the overlay will copy the file to the overlay ("changing"
-// includes also calls to e.g. Chtimes() and Chmod()).
-//
-// Reading directories is currently only supported via Open(), not OpenFile().
-type CopyOnWriteFs struct {
-	base  Fs
-	layer Fs
-}
-
-func NewCopyOnWriteFs(base Fs, layer Fs) Fs {
-	return &CopyOnWriteFs{base: base, layer: layer}
-}
-
-// Returns true if the file is not in the overlay
-func (u *CopyOnWriteFs) isBaseFile(name string) (bool, error) {
-	if _, err := u.layer.Stat(name); err == nil {
-		return false, nil
-	}
-	_, err := u.base.Stat(name)
-	if err != nil {
-		if oerr, ok := err.(*os.PathError); ok {
-			if oerr.Err == os.ErrNotExist || oerr.Err == syscall.ENOENT || oerr.Err == syscall.ENOTDIR {
-				return false, nil
-			}
-		}
-		if err == syscall.ENOENT {
-			return false, nil
-		}
-	}
-	return true, err
-}
-
-func (u *CopyOnWriteFs) copyToLayer(name string) error {
-	return copyToLayer(u.base, u.layer, name)
-}
-
-func (u *CopyOnWriteFs) Chtimes(name string, atime, mtime time.Time) error {
-	b, err := u.isBaseFile(name)
-	if err != nil {
-		return err
-	}
-	if b {
-		if err := u.copyToLayer(name); err != nil {
-			return err
-		}
-	}
-	return u.layer.Chtimes(name, atime, mtime)
-}
-
-func (u *CopyOnWriteFs) Chmod(name string, mode os.FileMode) error {
-	b, err := u.isBaseFile(name)
-	if err != nil {
-		return err
-	}
-	if b {
-		if err := u.copyToLayer(name); err != nil {
-			return err
-		}
-	}
-	return u.layer.Chmod(name, mode)
-}
-
-func (u *CopyOnWriteFs) Stat(name string) (os.FileInfo, error) {
-	fi, err := u.layer.Stat(name)
-	if err != nil {
-		origErr := err
-		if e, ok := err.(*os.PathError); ok {
-			err = e.Err
-		}
-		if err == syscall.ENOENT || err == syscall.ENOTDIR {
-			return u.base.Stat(name)
-		}
-		return nil, origErr
-	}
-	return fi, nil
-}
-
-// Renaming files present only in the base layer is not permitted
-func (u *CopyOnWriteFs) Rename(oldname, newname string) error {
-	b, err := u.isBaseFile(oldname)
-	if err != nil {
-		return err
-	}
-	if b {
-		return syscall.EPERM
-	}
-	return u.layer.Rename(oldname, newname)
-}
-
-// Removing files present only in the base layer is not permitted. If
-// a file is present in the base layer and the overlay, only the overlay
-// will be removed.
-func (u *CopyOnWriteFs) Remove(name string) error {
-	err := u.layer.Remove(name)
-	switch err {
-	case syscall.ENOENT:
-		_, err = u.base.Stat(name)
-		if err == nil {
-			return syscall.EPERM
-		}
-		return syscall.ENOENT
-	default:
-		return err
-	}
-}
-
-func (u *CopyOnWriteFs) RemoveAll(name string) error {
-	err := u.layer.RemoveAll(name)
-	switch err {
-	case syscall.ENOENT:
-		_, err = u.base.Stat(name)
-		if err == nil {
-			return syscall.EPERM
-		}
-		return syscall.ENOENT
-	default:
-		return err
-	}
-}
-
-func (u *CopyOnWriteFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
-	b, err := u.isBaseFile(name)
-	if err != nil {
-		return nil, err
-	}
-
-	if flag&(os.O_WRONLY|os.O_RDWR|os.O_APPEND|os.O_CREATE|os.O_TRUNC) != 0 {
-		if b {
-			if err = u.copyToLayer(name); err != nil {
-				return nil, err
-			}
-			return u.layer.OpenFile(name, flag, perm)
-		}
-
-		dir := filepath.Dir(name)
-		isaDir, err := IsDir(u.base, dir)
-		if err != nil && !os.IsNotExist(err) {
-			return nil, err
-		}
-		if isaDir {
-			if err = u.layer.MkdirAll(dir, 0777); err != nil {
-				return nil, err
-			}
-			return u.layer.OpenFile(name, flag, perm)
-		}
-
-		isaDir, err = IsDir(u.layer, dir)
-		if err != nil {
-			return nil, err
-		}
-		if isaDir {
-			return u.layer.OpenFile(name, flag, perm)
-		}
-
-		return nil, &os.PathError{Op: "open", Path: name, Err: syscall.ENOTDIR} // ...or os.ErrNotExist?
-	}
-	if b {
-		return u.base.OpenFile(name, flag, perm)
-	}
-	return u.layer.OpenFile(name, flag, perm)
-}
-
-// This function handles the 9 different possibilities caused
-// by the union which are the intersection of the following...
-//  layer: doesn't exist, exists as a file, and exists as a directory
-//  base:  doesn't exist, exists as a file, and exists as a directory
-func (u *CopyOnWriteFs) Open(name string) (File, error) {
-	// Since the overlay overrides the base we check that first
-	b, err := u.isBaseFile(name)
-	if err != nil {
-		return nil, err
-	}
-
-	// If overlay doesn't exist, return the base (base state irrelevant)
-	if b {
-		return u.base.Open(name)
-	}
-
-	// If overlay is a file, return it (base state irrelevant)
-	dir, err := IsDir(u.layer, name)
-	if err != nil {
-		return nil, err
-	}
-	if !dir {
-		return u.layer.Open(name)
-	}
-
-	// Overlay is a directory, base state now matters.
-	// Base state has 3 states to check but 2 outcomes:
-	// A. It's a file or non-readable in the base (return just the overlay)
-	// B. It's an accessible directory in the base (return a UnionFile)
-
-	// If base is file or nonreadable, return overlay
-	dir, err = IsDir(u.base, name)
-	if !dir || err != nil {
-		return u.layer.Open(name)
-	}
-
-	// Both base & layer are directories
-	// Return union file (if opens are without error)
-	bfile, bErr := u.base.Open(name)
-	lfile, lErr := u.layer.Open(name)
-
-	// If either have errors at this point something is very wrong. Return nil and the errors
-	if bErr != nil || lErr != nil {
-		return nil, fmt.Errorf("BaseErr: %v\nOverlayErr: %v", bErr, lErr)
-	}
-
-	return &UnionFile{base: bfile, layer: lfile}, nil
-}
-
-func (u *CopyOnWriteFs) Mkdir(name string, perm os.FileMode) error {
-	dir, err := IsDir(u.base, name)
-	if err != nil {
-		return u.layer.MkdirAll(name, perm)
-	}
-	if dir {
-		return syscall.EEXIST
-	}
-	return u.layer.MkdirAll(name, perm)
-}
-
-func (u *CopyOnWriteFs) Name() string {
-	return "CopyOnWriteFs"
-}
-
-func (u *CopyOnWriteFs) MkdirAll(name string, perm os.FileMode) error {
-	dir, err := IsDir(u.base, name)
-	if err != nil {
-		return u.layer.MkdirAll(name, perm)
-	}
-	if dir {
-		return syscall.EEXIST
-	}
-	return u.layer.MkdirAll(name, perm)
-}
-
-func (u *CopyOnWriteFs) Create(name string) (File, error) {
-	return u.OpenFile(name, os.O_CREATE|os.O_TRUNC|os.O_RDWR, 0666)
-}

vendor/github.com/spf13/afero/copyOnWriteFs_test.go

@@ -1,23 +0,0 @@
-package afero
-
-import "testing"
-
-func TestCopyOnWrite(t *testing.T) {
-	var fs Fs
-	var err error
-	base := NewOsFs()
-	roBase := NewReadOnlyFs(base)
-	ufs := NewCopyOnWriteFs(roBase, NewMemMapFs())
-	fs = ufs
-	err = fs.MkdirAll("nonexistent/directory/", 0744)
-	if err != nil {
-		t.Error(err)
-		return
-	}
-	_, err = fs.Create("nonexistent/directory/newfile")
-	if err != nil {
-		t.Error(err)
-		return
-	}
-
-}

vendor/github.com/spf13/afero/httpFs.go

@@ -1,110 +0,0 @@
-// Copyright © 2014 Steve Francia <spf@spf13.com>.
-//
-// 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 afero
-
-import (
-	"errors"
-	"net/http"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-	"time"
-)
-
-type httpDir struct {
-	basePath string
-	fs       HttpFs
-}
-
-func (d httpDir) Open(name string) (http.File, error) {
-	if filepath.Separator != '/' && strings.IndexRune(name, filepath.Separator) >= 0 ||
-		strings.Contains(name, "\x00") {
-		return nil, errors.New("http: invalid character in file path")
-	}
-	dir := string(d.basePath)
-	if dir == "" {
-		dir = "."
-	}
-
-	f, err := d.fs.Open(filepath.Join(dir, filepath.FromSlash(path.Clean("/"+name))))
-	if err != nil {
-		return nil, err
-	}
-	return f, nil
-}
-
-type HttpFs struct {
-	source Fs
-}
-
-func NewHttpFs(source Fs) *HttpFs {
-	return &HttpFs{source: source}
-}
-
-func (h HttpFs) Dir(s string) *httpDir {
-	return &httpDir{basePath: s, fs: h}
-}
-
-func (h HttpFs) Name() string { return "h HttpFs" }
-
-func (h HttpFs) Create(name string) (File, error) {
-	return h.source.Create(name)
-}
-
-func (h HttpFs) Chmod(name string, mode os.FileMode) error {
-	return h.source.Chmod(name, mode)
-}
-
-func (h HttpFs) Chtimes(name string, atime time.Time, mtime time.Time) error {
-	return h.source.Chtimes(name, atime, mtime)
-}
-
-func (h HttpFs) Mkdir(name string, perm os.FileMode) error {
-	return h.source.Mkdir(name, perm)
-}
-
-func (h HttpFs) MkdirAll(path string, perm os.FileMode) error {
-	return h.source.MkdirAll(path, perm)
-}
-
-func (h HttpFs) Open(name string) (http.File, error) {
-	f, err := h.source.Open(name)
-	if err == nil {
-		if httpfile, ok := f.(http.File); ok {
-			return httpfile, nil
-		}
-	}
-	return nil, err
-}
-
-func (h HttpFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
-	return h.source.OpenFile(name, flag, perm)
-}
-
-func (h HttpFs) Remove(name string) error {
-	return h.source.Remove(name)
-}
-
-func (h HttpFs) RemoveAll(path string) error {
-	return h.source.RemoveAll(path)
-}
-
-func (h HttpFs) Rename(oldname, newname string) error {
-	return h.source.Rename(oldname, newname)
-}
-
-func (h HttpFs) Stat(name string) (os.FileInfo, error) {
-	return h.source.Stat(name)
-}

vendor/github.com/spf13/afero/ioutil.go

@@ -1,230 +0,0 @@
-// Copyright ©2015 The Go Authors
-// Copyright ©2015 Steve Francia <spf@spf13.com>
-//
-// 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 afero
-
-import (
-	"bytes"
-	"io"
-	"os"
-	"path/filepath"
-	"sort"
-	"strconv"
-	"sync"
-	"time"
-)
-
-// byName implements sort.Interface.
-type byName []os.FileInfo
-
-func (f byName) Len() int           { return len(f) }
-func (f byName) Less(i, j int) bool { return f[i].Name() < f[j].Name() }
-func (f byName) Swap(i, j int)      { f[i], f[j] = f[j], f[i] }
-
-// ReadDir reads the directory named by dirname and returns
-// a list of sorted directory entries.
-func (a Afero) ReadDir(dirname string) ([]os.FileInfo, error) {
-	return ReadDir(a.Fs, dirname)
-}
-
-func ReadDir(fs Fs, dirname string) ([]os.FileInfo, error) {
-	f, err := fs.Open(dirname)
-	if err != nil {
-		return nil, err
-	}
-	list, err := f.Readdir(-1)
-	f.Close()
-	if err != nil {
-		return nil, err
-	}
-	sort.Sort(byName(list))
-	return list, nil
-}
-
-// ReadFile reads the file named by filename and returns the contents.
-// A successful call returns err == nil, not err == EOF. Because ReadFile
-// reads the whole file, it does not treat an EOF from Read as an error
-// to be reported.
-func (a Afero) ReadFile(filename string) ([]byte, error) {
-	return ReadFile(a.Fs, filename)
-}
-
-func ReadFile(fs Fs, filename string) ([]byte, error) {
-	f, err := fs.Open(filename)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-	// It's a good but not certain bet that FileInfo will tell us exactly how much to
-	// read, so let's try it but be prepared for the answer to be wrong.
-	var n int64
-
-	if fi, err := f.Stat(); err == nil {
-		// Don't preallocate a huge buffer, just in case.
-		if size := fi.Size(); size < 1e9 {
-			n = size
-		}
-	}
-	// As initial capacity for readAll, use n + a little extra in case Size is zero,
-	// and to avoid another allocation after Read has filled the buffer.  The readAll
-	// call will read into its allocated internal buffer cheaply.  If the size was
-	// wrong, we'll either waste some space off the end or reallocate as needed, but
-	// in the overwhelmingly common case we'll get it just right.
-	return readAll(f, n+bytes.MinRead)
-}
-
-// readAll reads from r until an error or EOF and returns the data it read
-// from the internal buffer allocated with a specified capacity.
-func readAll(r io.Reader, capacity int64) (b []byte, err error) {
-	buf := bytes.NewBuffer(make([]byte, 0, capacity))
-	// If the buffer overflows, we will get bytes.ErrTooLarge.
-	// Return that as an error. Any other panic remains.
-	defer func() {
-		e := recover()
-		if e == nil {
-			return
-		}
-		if panicErr, ok := e.(error); ok && panicErr == bytes.ErrTooLarge {
-			err = panicErr
-		} else {
-			panic(e)
-		}
-	}()
-	_, err = buf.ReadFrom(r)
-	return buf.Bytes(), err
-}
-
-// ReadAll reads from r until an error or EOF and returns the data it read.
-// A successful call returns err == nil, not err == EOF. Because ReadAll is
-// defined to read from src until EOF, it does not treat an EOF from Read
-// as an error to be reported.
-func ReadAll(r io.Reader) ([]byte, error) {
-	return readAll(r, bytes.MinRead)
-}
-
-// WriteFile writes data to a file named by filename.
-// If the file does not exist, WriteFile creates it with permissions perm;
-// otherwise WriteFile truncates it before writing.
-func (a Afero) WriteFile(filename string, data []byte, perm os.FileMode) error {
-	return WriteFile(a.Fs, filename, data, perm)
-}
-
-func WriteFile(fs Fs, filename string, data []byte, perm os.FileMode) error {
-	f, err := fs.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm)
-	if err != nil {
-		return err
-	}
-	n, err := f.Write(data)
-	if err == nil && n < len(data) {
-		err = io.ErrShortWrite
-	}
-	if err1 := f.Close(); err == nil {
-		err = err1
-	}
-	return err
-}
-
-// Random number state.
-// We generate random temporary file names so that there's a good
-// chance the file doesn't exist yet - keeps the number of tries in
-// TempFile to a minimum.
-var rand uint32
-var randmu sync.Mutex
-
-func reseed() uint32 {
-	return uint32(time.Now().UnixNano() + int64(os.Getpid()))
-}
-
-func nextSuffix() string {
-	randmu.Lock()
-	r := rand
-	if r == 0 {
-		r = reseed()
-	}
-	r = r*1664525 + 1013904223 // constants from Numerical Recipes
-	rand = r
-	randmu.Unlock()
-	return strconv.Itoa(int(1e9 + r%1e9))[1:]
-}
-
-// TempFile creates a new temporary file in the directory dir
-// with a name beginning with prefix, opens the file for reading
-// and writing, and returns the resulting *File.
-// If dir is the empty string, TempFile uses the default directory
-// for temporary files (see os.TempDir).
-// Multiple programs calling TempFile simultaneously
-// will not choose the same file.  The caller can use f.Name()
-// to find the pathname of the file.  It is the caller's responsibility
-// to remove the file when no longer needed.
-func (a Afero) TempFile(dir, prefix string) (f File, err error) {
-	return TempFile(a.Fs, dir, prefix)
-}
-
-func TempFile(fs Fs, dir, prefix string) (f File, err error) {
-	if dir == "" {
-		dir = os.TempDir()
-	}
-
-	nconflict := 0
-	for i := 0; i < 10000; i++ {
-		name := filepath.Join(dir, prefix+nextSuffix())
-		f, err = fs.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600)
-		if os.IsExist(err) {
-			if nconflict++; nconflict > 10 {
-				randmu.Lock()
-				rand = reseed()
-				randmu.Unlock()
-			}
-			continue
-		}
-		break
-	}
-	return
-}
-
-// TempDir creates a new temporary directory in the directory dir
-// with a name beginning with prefix and returns the path of the
-// new directory.  If dir is the empty string, TempDir uses the
-// default directory for temporary files (see os.TempDir).
-// Multiple programs calling TempDir simultaneously
-// will not choose the same directory.  It is the caller's responsibility
-// to remove the directory when no longer needed.
-func (a Afero) TempDir(dir, prefix string) (name string, err error) {
-	return TempDir(a.Fs, dir, prefix)
-}
-func TempDir(fs Fs, dir, prefix string) (name string, err error) {
-	if dir == "" {
-		dir = os.TempDir()
-	}
-
-	nconflict := 0
-	for i := 0; i < 10000; i++ {
-		try := filepath.Join(dir, prefix+nextSuffix())
-		err = fs.Mkdir(try, 0700)
-		if os.IsExist(err) {
-			if nconflict++; nconflict > 10 {
-				randmu.Lock()
-				rand = reseed()
-				randmu.Unlock()
-			}
-			continue
-		}
-		if err == nil {
-			name = try
-		}
-		break
-	}
-	return
-}

vendor/github.com/spf13/afero/ioutil_test.go

@@ -1,112 +0,0 @@
-// ©2015 The Go Authors
-// Copyright ©2015 Steve Francia <spf@spf13.com>
-//
-// 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 afero
-
-import "testing"
-
-func checkSizePath(t *testing.T, path string, size int64) {
-	dir, err := testFS.Stat(path)
-	if err != nil {
-		t.Fatalf("Stat %q (looking for size %d): %s", path, size, err)
-	}
-	if dir.Size() != size {
-		t.Errorf("Stat %q: size %d want %d", path, dir.Size(), size)
-	}
-}
-
-func TestReadFile(t *testing.T) {
-	testFS = &MemMapFs{}
-	fsutil := &Afero{Fs: testFS}
-
-	testFS.Create("this_exists.go")
-	filename := "rumpelstilzchen"
-	contents, err := fsutil.ReadFile(filename)
-	if err == nil {
-		t.Fatalf("ReadFile %s: error expected, none found", filename)
-	}
-
-	filename = "this_exists.go"
-	contents, err = fsutil.ReadFile(filename)
-	if err != nil {
-		t.Fatalf("ReadFile %s: %v", filename, err)
-	}
-
-	checkSizePath(t, filename, int64(len(contents)))
-}
-
-func TestWriteFile(t *testing.T) {
-	testFS = &MemMapFs{}
-	fsutil := &Afero{Fs: testFS}
-	f, err := fsutil.TempFile("", "ioutil-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	filename := f.Name()
-	data := "Programming today is a race between software engineers striving to " +
-		"build bigger and better idiot-proof programs, and the Universe trying " +
-		"to produce bigger and better idiots. So far, the Universe is winning."
-
-	if err := fsutil.WriteFile(filename, []byte(data), 0644); err != nil {
-		t.Fatalf("WriteFile %s: %v", filename, err)
-	}
-
-	contents, err := fsutil.ReadFile(filename)
-	if err != nil {
-		t.Fatalf("ReadFile %s: %v", filename, err)
-	}
-
-	if string(contents) != data {
-		t.Fatalf("contents = %q\nexpected = %q", string(contents), data)
-	}
-
-	// cleanup
-	f.Close()
-	testFS.Remove(filename) // ignore error
-}
-
-func TestReadDir(t *testing.T) {
-	testFS = &MemMapFs{}
-	testFS.Mkdir("/i-am-a-dir", 0777)
-	testFS.Create("/this_exists.go")
-	dirname := "rumpelstilzchen"
-	_, err := ReadDir(testFS, dirname)
-	if err == nil {
-		t.Fatalf("ReadDir %s: error expected, none found", dirname)
-	}
-
-	dirname = ".."
-	list, err := ReadDir(testFS, dirname)
-	if err != nil {
-		t.Fatalf("ReadDir %s: %v", dirname, err)
-	}
-
-	foundFile := false
-	foundSubDir := false
-	for _, dir := range list {
-		switch {
-		case !dir.IsDir() && dir.Name() == "this_exists.go":
-			foundFile = true
-		case dir.IsDir() && dir.Name() == "i-am-a-dir":
-			foundSubDir = true
-		}
-	}
-	if !foundFile {
-		t.Fatalf("ReadDir %s: this_exists.go file not found", dirname)
-	}
-	if !foundSubDir {
-		t.Fatalf("ReadDir %s: i-am-a-dir directory not found", dirname)
-	}
-}

vendor/github.com/spf13/afero/match.go

@@ -1,110 +0,0 @@
-// Copyright © 2014 Steve Francia <spf@spf13.com>.
-// Copyright 2009 The Go Authors. All rights reserved.
-
-// 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 afero
-
-import (
-	"path/filepath"
-	"sort"
-	"strings"
-)
-
-// Glob returns the names of all files matching pattern or nil
-// if there is no matching file. The syntax of patterns is the same
-// as in Match. The pattern may describe hierarchical names such as
-// /usr/*/bin/ed (assuming the Separator is '/').
-//
-// Glob ignores file system errors such as I/O errors reading directories.
-// The only possible returned error is ErrBadPattern, when pattern
-// is malformed.
-//
-// This was adapted from (http://golang.org/pkg/path/filepath) and uses several
-// built-ins from that package.
-func Glob(fs Fs, pattern string) (matches []string, err error) {
-	if !hasMeta(pattern) {
-		// afero does not support Lstat directly.
-		if _, err = lstatIfOs(fs, pattern); err != nil {
-			return nil, nil
-		}
-		return []string{pattern}, nil
-	}
-
-	dir, file := filepath.Split(pattern)
-	switch dir {
-	case "":
-		dir = "."
-	case string(filepath.Separator):
-	// nothing
-	default:
-		dir = dir[0 : len(dir)-1] // chop off trailing separator
-	}
-
-	if !hasMeta(dir) {
-		return glob(fs, dir, file, nil)
-	}
-
-	var m []string
-	m, err = Glob(fs, dir)
-	if err != nil {
-		return
-	}
-	for _, d := range m {
-		matches, err = glob(fs, d, file, matches)
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-// glob searches for files matching pattern in the directory dir
-// and appends them to matches. If the directory cannot be
-// opened, it returns the existing matches. New matches are
-// added in lexicographical order.
-func glob(fs Fs, dir, pattern string, matches []string) (m []string, e error) {
-	m = matches
-	fi, err := fs.Stat(dir)
-	if err != nil {
-		return
-	}
-	if !fi.IsDir() {
-		return
-	}
-	d, err := fs.Open(dir)
-	if err != nil {
-		return
-	}
-	defer d.Close()
-
-	names, _ := d.Readdirnames(-1)
-	sort.Strings(names)
-
-	for _, n := range names {
-		matched, err := filepath.Match(pattern, n)
-		if err != nil {
-			return m, err
-		}
-		if matched {
-			m = append(m, filepath.Join(dir, n))
-		}
-	}
-	return
-}
-
-// hasMeta reports whether path contains any of the magic characters
-// recognized by Match.
-func hasMeta(path string) bool {
-	// TODO(niemeyer): Should other magic characters be added here?
-	return strings.IndexAny(path, "*?[") >= 0
-}

vendor/github.com/spf13/afero/match_test.go

@@ -1,183 +0,0 @@
-// Copyright © 2014 Steve Francia <spf@spf13.com>.
-// Copyright 2009 The Go Authors. All rights reserved.
-//
-// 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 afero
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-)
-
-// contains returns true if vector contains the string s.
-func contains(vector []string, s string) bool {
-	for _, elem := range vector {
-		if elem == s {
-			return true
-		}
-	}
-	return false
-}
-
-func setupGlobDirRoot(t *testing.T, fs Fs) string {
-	path := testDir(fs)
-	setupGlobFiles(t, fs, path)
-	return path
-}
-
-func setupGlobDirReusePath(t *testing.T, fs Fs, path string) string {
-	testRegistry[fs] = append(testRegistry[fs], path)
-	return setupGlobFiles(t, fs, path)
-}
-
-func setupGlobFiles(t *testing.T, fs Fs, path string) string {
-	testSubDir := filepath.Join(path, "globs", "bobs")
-	err := fs.MkdirAll(testSubDir, 0700)
-	if err != nil && !os.IsExist(err) {
-		t.Fatal(err)
-	}
-
-	f, err := fs.Create(filepath.Join(testSubDir, "/matcher"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	f.WriteString("Testfile 1 content")
-	f.Close()
-
-	f, err = fs.Create(filepath.Join(testSubDir, "/../submatcher"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	f.WriteString("Testfile 2 content")
-	f.Close()
-
-	f, err = fs.Create(filepath.Join(testSubDir, "/../../match"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	f.WriteString("Testfile 3 content")
-	f.Close()
-
-	return testSubDir
-}
-
-func TestGlob(t *testing.T) {
-	defer removeAllTestFiles(t)
-	var testDir string
-	for i, fs := range Fss {
-		if i == 0 {
-			testDir = setupGlobDirRoot(t, fs)
-		} else {
-			setupGlobDirReusePath(t, fs, testDir)
-		}
-	}
-
-	var globTests = []struct {
-		pattern, result string
-	}{
-		{testDir + "/globs/bobs/matcher", testDir + "/globs/bobs/matcher"},
-		{testDir + "/globs/*/mat?her", testDir + "/globs/bobs/matcher"},
-		{testDir + "/globs/bobs/../*", testDir + "/globs/submatcher"},
-		{testDir + "/match", testDir + "/match"},
-	}
-
-	for _, fs := range Fss {
-
-		for _, tt := range globTests {
-			pattern := tt.pattern
-			result := tt.result
-			if runtime.GOOS == "windows" {
-				pattern = filepath.Clean(pattern)
-				result = filepath.Clean(result)
-			}
-			matches, err := Glob(fs, pattern)
-			if err != nil {
-				t.Errorf("Glob error for %q: %s", pattern, err)
-				continue
-			}
-			if !contains(matches, result) {
-				t.Errorf("Glob(%#q) = %#v want %v", pattern, matches, result)
-			}
-		}
-		for _, pattern := range []string{"no_match", "../*/no_match"} {
-			matches, err := Glob(fs, pattern)
-			if err != nil {
-				t.Errorf("Glob error for %q: %s", pattern, err)
-				continue
-			}
-			if len(matches) != 0 {
-				t.Errorf("Glob(%#q) = %#v want []", pattern, matches)
-			}
-		}
-
-	}
-}
-
-func TestGlobSymlink(t *testing.T) {
-	defer removeAllTestFiles(t)
-
-	fs := &OsFs{}
-	testDir := setupGlobDirRoot(t, fs)
-
-	err := os.Symlink("target", filepath.Join(testDir, "symlink"))
-	if err != nil {
-		t.Skipf("skipping on %s", runtime.GOOS)
-	}
-
-	var globSymlinkTests = []struct {
-		path, dest string
-		brokenLink bool
-	}{
-		{"test1", "link1", false},
-		{"test2", "link2", true},
-	}
-
-	for _, tt := range globSymlinkTests {
-		path := filepath.Join(testDir, tt.path)
-		dest := filepath.Join(testDir, tt.dest)
-		f, err := fs.Create(path)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if err := f.Close(); err != nil {
-			t.Fatal(err)
-		}
-		err = os.Symlink(path, dest)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if tt.brokenLink {
-			// Break the symlink.
-			fs.Remove(path)
-		}
-		matches, err := Glob(fs, dest)
-		if err != nil {
-			t.Errorf("GlobSymlink error for %q: %s", dest, err)
-		}
-		if !contains(matches, dest) {
-			t.Errorf("Glob(%#q) = %#v want %v", dest, matches, dest)
-		}
-	}
-}
-
-
-func TestGlobError(t *testing.T) {
-	for _, fs := range Fss {
-		_, err := Glob(fs, "[7]")
-		if err != nil {
-			t.Error("expected error for bad pattern; got none")
-		}
-	}
-}

vendor/github.com/spf13/afero/mem/dir.go

@@ -1,37 +0,0 @@
-// Copyright © 2014 Steve Francia <spf@spf13.com>.
-//
-// 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 mem
-
-type Dir interface {
-	Len() int
-	Names() []string
-	Files() []*FileData
-	Add(*FileData)
-	Remove(*FileData)
-}
-
-func RemoveFromMemDir(dir *FileData, f *FileData) {
-	dir.memDir.Remove(f)
-}
-
-func AddToMemDir(dir *FileData, f *FileData) {
-	dir.memDir.Add(f)
-}
-
-func InitializeDir(d *FileData) {
-	if d.memDir == nil {
-		d.dir = true
-		d.memDir = &DirMap{}
-	}
-}

vendor/github.com/spf13/afero/mem/dirmap.go

@@ -1,43 +0,0 @@
-// Copyright © 2015 Steve Francia <spf@spf13.com>.
-//
-// 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 mem
-
-import "sort"
-
-type DirMap map[string]*FileData
-
-func (m DirMap) Len() int           { return len(m) }
-func (m DirMap) Add(f *FileData)    { m[f.name] = f }
-func (m DirMap) Remove(f *FileData) { delete(m, f.name) }
-func (m DirMap) Files() (files []*FileData) {
-	for _, f := range m {
-		files = append(files, f)
-	}
-	sort.Sort(filesSorter(files))
-	return files
-}
-
-// implement sort.Interface for []*FileData
-type filesSorter []*FileData
-
-func (s filesSorter) Len() int           { return len(s) }
-func (s filesSorter) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-func (s filesSorter) Less(i, j int) bool { return s[i].name < s[j].name }
-
-func (m DirMap) Names() (names []string) {
-	for x := range m {
-		names = append(names, x)
-	}
-	return names
-}

vendor/github.com/spf13/afero/mem/file.go

@@ -1,285 +0,0 @@
-// Copyright © 2015 Steve Francia <spf@spf13.com>.
-// Copyright 2013 tsuru authors. All rights reserved.
-//
-// 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 mem
-
-import (
-	"bytes"
-	"errors"
-	"io"
-	"os"
-	"path/filepath"
-	"sync"
-	"sync/atomic"
-)
-
-import "time"
-
-const FilePathSeparator = string(filepath.Separator)
-
-type File struct {
-	// atomic requires 64-bit alignment for struct field access
-	at           int64
-	readDirCount int64
-	closed       bool
-	readOnly     bool
-	fileData     *FileData
-}
-
-func NewFileHandle(data *FileData) *File {
-	return &File{fileData: data}
-}
-
-func NewReadOnlyFileHandle(data *FileData) *File {
-	return &File{fileData: data, readOnly: true}
-}
-
-func (f File) Data() *FileData {
-	return f.fileData
-}
-
-type FileData struct {
-	sync.Mutex
-	name    string
-	data    []byte
-	memDir  Dir
-	dir     bool
-	mode    os.FileMode
-	modtime time.Time
-}
-
-func (d *FileData) Name() string {
-	d.Lock()
-	defer d.Unlock()
-	return d.name
-}
-
-func CreateFile(name string) *FileData {
-	return &FileData{name: name, mode: os.ModeTemporary, modtime: time.Now()}
-}
-
-func CreateDir(name string) *FileData {
-	return &FileData{name: name, memDir: &DirMap{}, dir: true}
-}
-
-func ChangeFileName(f *FileData, newname string) {
-	f.name = newname
-}
-
-func SetMode(f *FileData, mode os.FileMode) {
-	f.mode = mode
-}
-
-func SetModTime(f *FileData, mtime time.Time) {
-	f.modtime = mtime
-}
-
-func GetFileInfo(f *FileData) *FileInfo {
-	return &FileInfo{f}
-}
-
-func (f *File) Open() error {
-	atomic.StoreInt64(&f.at, 0)
-	atomic.StoreInt64(&f.readDirCount, 0)
-	f.fileData.Lock()
-	f.closed = false
-	f.fileData.Unlock()
-	return nil
-}
-
-func (f *File) Close() error {
-	f.fileData.Lock()
-	f.closed = true
-	if !f.readOnly {
-		SetModTime(f.fileData, time.Now())
-	}
-	f.fileData.Unlock()
-	return nil
-}
-
-func (f *File) Name() string {
-	return f.fileData.Name()
-}
-
-func (f *File) Stat() (os.FileInfo, error) {
-	return &FileInfo{f.fileData}, nil
-}
-
-func (f *File) Sync() error {
-	return nil
-}
-
-func (f *File) Readdir(count int) (res []os.FileInfo, err error) {
-	var outLength int64
-
-	f.fileData.Lock()
-	files := f.fileData.memDir.Files()[f.readDirCount:]
-	if count > 0 {
-		if len(files) < count {
-			outLength = int64(len(files))
-		} else {
-			outLength = int64(count)
-		}
-		if len(files) == 0 {
-			err = io.EOF
-		}
-	} else {
-		outLength = int64(len(files))
-	}
-	f.readDirCount += outLength
-	f.fileData.Unlock()
-
-	res = make([]os.FileInfo, outLength)
-	for i := range res {
-		res[i] = &FileInfo{files[i]}
-	}
-
-	return res, err
-}
-
-func (f *File) Readdirnames(n int) (names []string, err error) {
-	fi, err := f.Readdir(n)
-	names = make([]string, len(fi))
-	for i, f := range fi {
-		_, names[i] = filepath.Split(f.Name())
-	}
-	return names, err
-}
-
-func (f *File) Read(b []byte) (n int, err error) {
-	f.fileData.Lock()
-	defer f.fileData.Unlock()
-	if f.closed == true {
-		return 0, ErrFileClosed
-	}
-	if len(b) > 0 && int(f.at) == len(f.fileData.data) {
-		return 0, io.EOF
-	}
-	if len(f.fileData.data)-int(f.at) >= len(b) {
-		n = len(b)
-	} else {
-		n = len(f.fileData.data) - int(f.at)
-	}
-	copy(b, f.fileData.data[f.at:f.at+int64(n)])
-	atomic.AddInt64(&f.at, int64(n))
-	return
-}
-
-func (f *File) ReadAt(b []byte, off int64) (n int, err error) {
-	atomic.StoreInt64(&f.at, off)
-	return f.Read(b)
-}
-
-func (f *File) Truncate(size int64) error {
-	if f.closed == true {
-		return ErrFileClosed
-	}
-	if f.readOnly {
-		return &os.PathError{Op: "truncate", Path: f.fileData.name, Err: errors.New("file handle is read only")}
-	}
-	if size < 0 {
-		return ErrOutOfRange
-	}
-	if size > int64(len(f.fileData.data)) {
-		diff := size - int64(len(f.fileData.data))
-		f.fileData.data = append(f.fileData.data, bytes.Repeat([]byte{00}, int(diff))...)
-	} else {
-		f.fileData.data = f.fileData.data[0:size]
-	}
-	SetModTime(f.fileData, time.Now())
-	return nil
-}
-
-func (f *File) Seek(offset int64, whence int) (int64, error) {
-	if f.closed == true {
-		return 0, ErrFileClosed
-	}
-	switch whence {
-	case 0:
-		atomic.StoreInt64(&f.at, offset)
-	case 1:
-		atomic.AddInt64(&f.at, int64(offset))
-	case 2:
-		atomic.StoreInt64(&f.at, int64(len(f.fileData.data))+offset)
-	}
-	return f.at, nil
-}
-
-func (f *File) Write(b []byte) (n int, err error) {
-	if f.readOnly {
-		return 0, &os.PathError{Op: "write", Path: f.fileData.name, Err: errors.New("file handle is read only")}
-	}
-	n = len(b)
-	cur := atomic.LoadInt64(&f.at)
-	f.fileData.Lock()
-	defer f.fileData.Unlock()
-	diff := cur - int64(len(f.fileData.data))
-	var tail []byte
-	if n+int(cur) < len(f.fileData.data) {
-		tail = f.fileData.data[n+int(cur):]
-	}
-	if diff > 0 {
-		f.fileData.data = append(bytes.Repeat([]byte{00}, int(diff)), b...)
-		f.fileData.data = append(f.fileData.data, tail...)
-	} else {
-		f.fileData.data = append(f.fileData.data[:cur], b...)
-		f.fileData.data = append(f.fileData.data, tail...)
-	}
-	SetModTime(f.fileData, time.Now())
-
-	atomic.StoreInt64(&f.at, int64(len(f.fileData.data)))
-	return
-}
-
-func (f *File) WriteAt(b []byte, off int64) (n int, err error) {
-	atomic.StoreInt64(&f.at, off)
-	return f.Write(b)
-}
-
-func (f *File) WriteString(s string) (ret int, err error) {
-	return f.Write([]byte(s))
-}
-
-func (f *File) Info() *FileInfo {
-	return &FileInfo{f.fileData}
-}
-
-type FileInfo struct {
-	*FileData
-}
-
-// Implements os.FileInfo
-func (s *FileInfo) Name() string {
-	_, name := filepath.Split(s.name)
-	return name
-}
-func (s *FileInfo) Mode() os.FileMode  { return s.mode }
-func (s *FileInfo) ModTime() time.Time { return s.modtime }
-func (s *FileInfo) IsDir() bool        { return s.dir }
-func (s *FileInfo) Sys() interface{}   { return nil }
-func (s *FileInfo) Size() int64 {
-	if s.IsDir() {
-		return int64(42)
-	}
-	return int64(len(s.data))
-}
-
-var (
-	ErrFileClosed        = errors.New("File is closed")
-	ErrOutOfRange        = errors.New("Out of range")
-	ErrTooLarge          = errors.New("Too large")
-	ErrFileNotFound      = os.ErrNotExist
-	ErrFileExists        = os.ErrExist
-	ErrDestinationExists = os.ErrExist
-)

vendor/github.com/spf13/afero/memmap.go

@@ -1,366 +0,0 @@
-// Copyright © 2014 Steve Francia <spf@spf13.com>.
-//
-// 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 afero
-
-import (
-	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/spf13/afero/mem"
-)
-
-type MemMapFs struct {
-	mu   sync.RWMutex
-	data map[string]*mem.FileData
-	init sync.Once
-}
-
-func NewMemMapFs() Fs {
-	return &MemMapFs{}
-}
-
-func (m *MemMapFs) getData() map[string]*mem.FileData {
-	m.init.Do(func() {
-		m.data = make(map[string]*mem.FileData)
-		// Root should always exist, right?
-		// TODO: what about windows?
-		m.data[FilePathSeparator] = mem.CreateDir(FilePathSeparator)
-	})
-	return m.data
-}
-
-func (*MemMapFs) Name() string { return "MemMapFS" }
-
-func (m *MemMapFs) Create(name string) (File, error) {
-	name = normalizePath(name)
-	m.mu.Lock()
-	file := mem.CreateFile(name)
-	m.getData()[name] = file
-	m.registerWithParent(file)
-	m.mu.Unlock()
-	return mem.NewFileHandle(file), nil
-}
-
-func (m *MemMapFs) unRegisterWithParent(fileName string) error {
-	f, err := m.lockfreeOpen(fileName)
-	if err != nil {
-		return err
-	}
-	parent := m.findParent(f)
-	if parent == nil {
-		log.Panic("parent of ", f.Name(), " is nil")
-	}
-
-	parent.Lock()
-	mem.RemoveFromMemDir(parent, f)
-	parent.Unlock()
-	return nil
-}
-
-func (m *MemMapFs) findParent(f *mem.FileData) *mem.FileData {
-	pdir, _ := filepath.Split(f.Name())
-	pdir = filepath.Clean(pdir)
-	pfile, err := m.lockfreeOpen(pdir)
-	if err != nil {
-		return nil
-	}
-	return pfile
-}
-
-func (m *MemMapFs) registerWithParent(f *mem.FileData) {
-	if f == nil {
-		return
-	}
-	parent := m.findParent(f)
-	if parent == nil {
-		pdir := filepath.Dir(filepath.Clean(f.Name()))
-		err := m.lockfreeMkdir(pdir, 0777)
-		if err != nil {
-			//log.Println("Mkdir error:", err)
-			return
-		}
-		parent, err = m.lockfreeOpen(pdir)
-		if err != nil {
-			//log.Println("Open after Mkdir error:", err)
-			return
-		}
-	}
-
-	parent.Lock()
-	mem.InitializeDir(parent)
-	mem.AddToMemDir(parent, f)
-	parent.Unlock()
-}
-
-func (m *MemMapFs) lockfreeMkdir(name string, perm os.FileMode) error {
-	name = normalizePath(name)
-	x, ok := m.getData()[name]
-	if ok {
-		// Only return ErrFileExists if it's a file, not a directory.
-		i := mem.FileInfo{FileData: x}
-		if !i.IsDir() {
-			return ErrFileExists
-		}
-	} else {
-		item := mem.CreateDir(name)
-		m.getData()[name] = item
-		m.registerWithParent(item)
-	}
-	return nil
-}
-
-func (m *MemMapFs) Mkdir(name string, perm os.FileMode) error {
-	name = normalizePath(name)
-
-	m.mu.RLock()
-	_, ok := m.getData()[name]
-	m.mu.RUnlock()
-	if ok {
-		return &os.PathError{Op: "mkdir", Path: name, Err: ErrFileExists}
-	}
-
-	m.mu.Lock()
-	item := mem.CreateDir(name)
-	m.getData()[name] = item
-	m.registerWithParent(item)
-	m.mu.Unlock()
-
-	m.Chmod(name, perm)
-
-	return nil
-}
-
-func (m *MemMapFs) MkdirAll(path string, perm os.FileMode) error {
-	err := m.Mkdir(path, perm)
-	if err != nil {
-		if err.(*os.PathError).Err == ErrFileExists {
-			return nil
-		} else {
-			return err
-		}
-	}
-	return nil
-}
-
-// Handle some relative paths
-func normalizePath(path string) string {
-	path = filepath.Clean(path)
-
-	switch path {
-	case ".":
-		return FilePathSeparator
-	case "..":
-		return FilePathSeparator
-	default:
-		return path
-	}
-}
-
-func (m *MemMapFs) Open(name string) (File, error) {
-	f, err := m.open(name)
-	if f != nil {
-		return mem.NewReadOnlyFileHandle(f), err
-	}
-	return nil, err
-}
-
-func (m *MemMapFs) openWrite(name string) (File, error) {
-	f, err := m.open(name)
-	if f != nil {
-		return mem.NewFileHandle(f), err
-	}
-	return nil, err
-}
-
-func (m *MemMapFs) open(name string) (*mem.FileData, error) {
-	name = normalizePath(name)
-
-	m.mu.RLock()
-	f, ok := m.getData()[name]
-	m.mu.RUnlock()
-	if !ok {
-		return nil, &os.PathError{Op: "open", Path: name, Err: ErrFileNotFound}
-	}
-	return f, nil
-}
-
-func (m *MemMapFs) lockfreeOpen(name string) (*mem.FileData, error) {
-	name = normalizePath(name)
-	f, ok := m.getData()[name]
-	if ok {
-		return f, nil
-	} else {
-		return nil, ErrFileNotFound
-	}
-}
-
-func (m *MemMapFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
-	chmod := false
-	file, err := m.openWrite(name)
-	if os.IsNotExist(err) && (flag&os.O_CREATE > 0) {
-		file, err = m.Create(name)
-		chmod = true
-	}
-	if err != nil {
-		return nil, err
-	}
-	if flag == os.O_RDONLY {
-		file = mem.NewReadOnlyFileHandle(file.(*mem.File).Data())
-	}
-	if flag&os.O_APPEND > 0 {
-		_, err = file.Seek(0, os.SEEK_END)
-		if err != nil {
-			file.Close()
-			return nil, err
-		}
-	}
-	if flag&os.O_TRUNC > 0 && flag&(os.O_RDWR|os.O_WRONLY) > 0 {
-		err = file.Truncate(0)
-		if err != nil {
-			file.Close()
-			return nil, err
-		}
-	}
-	if chmod {
-		m.Chmod(name, perm)
-	}
-	return file, nil
-}
-
-func (m *MemMapFs) Remove(name string) error {
-	name = normalizePath(name)
-
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	if _, ok := m.getData()[name]; ok {
-		err := m.unRegisterWithParent(name)
-		if err != nil {
-			return &os.PathError{Op: "remove", Path: name, Err: err}
-		}
-		delete(m.getData(), name)
-	} else {
-		return &os.PathError{Op: "remove", Path: name, Err: os.ErrNotExist}
-	}
-	return nil
-}
-
-func (m *MemMapFs) RemoveAll(path string) error {
-	path = normalizePath(path)
-	m.mu.Lock()
-	m.unRegisterWithParent(path)
-	m.mu.Unlock()
-
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	for p, _ := range m.getData() {
-		if strings.HasPrefix(p, path) {
-			m.mu.RUnlock()
-			m.mu.Lock()
-			delete(m.getData(), p)
-			m.mu.Unlock()
-			m.mu.RLock()
-		}
-	}
-	return nil
-}
-
-func (m *MemMapFs) Rename(oldname, newname string) error {
-	oldname = normalizePath(oldname)
-	newname = normalizePath(newname)
-
-	if oldname == newname {
-		return nil
-	}
-
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	if _, ok := m.getData()[oldname]; ok {
-		m.mu.RUnlock()
-		m.mu.Lock()
-		m.unRegisterWithParent(oldname)
-		fileData := m.getData()[oldname]
-		delete(m.getData(), oldname)
-		mem.ChangeFileName(fileData, newname)
-		m.getData()[newname] = fileData
-		m.registerWithParent(fileData)
-		m.mu.Unlock()
-		m.mu.RLock()
-	} else {
-		return &os.PathError{Op: "rename", Path: oldname, Err: ErrFileNotFound}
-	}
-	return nil
-}
-
-func (m *MemMapFs) Stat(name string) (os.FileInfo, error) {
-	f, err := m.Open(name)
-	if err != nil {
-		return nil, err
-	}
-	fi := mem.GetFileInfo(f.(*mem.File).Data())
-	return fi, nil
-}
-
-func (m *MemMapFs) Chmod(name string, mode os.FileMode) error {
-	name = normalizePath(name)
-
-	m.mu.RLock()
-	f, ok := m.getData()[name]
-	m.mu.RUnlock()
-	if !ok {
-		return &os.PathError{Op: "chmod", Path: name, Err: ErrFileNotFound}
-	}
-
-	m.mu.Lock()
-	mem.SetMode(f, mode)
-	m.mu.Unlock()
-
-	return nil
-}
-
-func (m *MemMapFs) Chtimes(name string, atime time.Time, mtime time.Time) error {
-	name = normalizePath(name)
-
-	m.mu.RLock()
-	f, ok := m.getData()[name]
-	m.mu.RUnlock()
-	if !ok {
-		return &os.PathError{Op: "chtimes", Path: name, Err: ErrFileNotFound}
-	}
-
-	m.mu.Lock()
-	mem.SetModTime(f, mtime)
-	m.mu.Unlock()
-
-	return nil
-}
-
-func (m *MemMapFs) List() {
-	for _, x := range m.data {
-		y := mem.FileInfo{FileData: x}
-		fmt.Println(x.Name(), y.Size())
-	}
-}
-
-// func debugMemMapList(fs Fs) {
-// 	if x, ok := fs.(*MemMapFs); ok {
-// 		x.List()
-// 	}
-// }

vendor/github.com/spf13/afero/memmap_test.go

@@ -1,386 +0,0 @@
-package afero
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-	"time"
-)
-
-func TestNormalizePath(t *testing.T) {
-	type test struct {
-		input    string
-		expected string
-	}
-
-	data := []test{
-		{".", FilePathSeparator},
-		{"./", FilePathSeparator},
-		{"..", FilePathSeparator},
-		{"../", FilePathSeparator},
-		{"./..", FilePathSeparator},
-		{"./../", FilePathSeparator},
-	}
-
-	for i, d := range data {
-		cpath := normalizePath(d.input)
-		if d.expected != cpath {
-			t.Errorf("Test %d failed. Expected %q got %q", i, d.expected, cpath)
-		}
-	}
-}
-
-func TestPathErrors(t *testing.T) {
-	path := filepath.Join(".", "some", "path")
-	path2 := filepath.Join(".", "different", "path")
-	fs := NewMemMapFs()
-	perm := os.FileMode(0755)
-
-	// relevant functions:
-	// func (m *MemMapFs) Chmod(name string, mode os.FileMode) error
-	// func (m *MemMapFs) Chtimes(name string, atime time.Time, mtime time.Time) error
-	// func (m *MemMapFs) Create(name string) (File, error)
-	// func (m *MemMapFs) Mkdir(name string, perm os.FileMode) error
-	// func (m *MemMapFs) MkdirAll(path string, perm os.FileMode) error
-	// func (m *MemMapFs) Open(name string) (File, error)
-	// func (m *MemMapFs) OpenFile(name string, flag int, perm os.FileMode) (File, error)
-	// func (m *MemMapFs) Remove(name string) error
-	// func (m *MemMapFs) Rename(oldname, newname string) error
-	// func (m *MemMapFs) Stat(name string) (os.FileInfo, error)
-
-	err := fs.Chmod(path, perm)
-	checkPathError(t, err, "Chmod")
-
-	err = fs.Chtimes(path, time.Now(), time.Now())
-	checkPathError(t, err, "Chtimes")
-
-	// fs.Create doesn't return an error
-
-	err = fs.Mkdir(path2, perm)
-	if err != nil {
-		t.Error(err)
-	}
-	err = fs.Mkdir(path2, perm)
-	checkPathError(t, err, "Mkdir")
-
-	err = fs.MkdirAll(path2, perm)
-	if err != nil {
-		t.Error("MkdirAll:", err)
-	}
-
-	_, err = fs.Open(path)
-	checkPathError(t, err, "Open")
-
-	_, err = fs.OpenFile(path, os.O_RDWR, perm)
-	checkPathError(t, err, "OpenFile")
-
-	err = fs.Remove(path)
-	checkPathError(t, err, "Remove")
-
-	err = fs.RemoveAll(path)
-	if err != nil {
-		t.Error("RemoveAll:", err)
-	}
-
-	err = fs.Rename(path, path2)
-	checkPathError(t, err, "Rename")
-
-	_, err = fs.Stat(path)
-	checkPathError(t, err, "Stat")
-}
-
-func checkPathError(t *testing.T, err error, op string) {
-	pathErr, ok := err.(*os.PathError)
-	if !ok {
-		t.Error(op+":", err, "is not a os.PathError")
-		return
-	}
-	_, ok = pathErr.Err.(*os.PathError)
-	if ok {
-		t.Error(op+":", err, "contains another os.PathError")
-	}
-}
-
-// Ensure Permissions are set on OpenFile/Mkdir/MkdirAll
-func TestPermSet(t *testing.T) {
-	const fileName = "/myFileTest"
-	const dirPath = "/myDirTest"
-	const dirPathAll = "/my/path/to/dir"
-
-	const fileMode = os.FileMode(0765)
-
-	fs := NewMemMapFs()
-
-	// Test Openfile
-	f, err := fs.OpenFile(fileName, os.O_CREATE, fileMode)
-	if err != nil {
-		t.Errorf("OpenFile Create failed: %s", err)
-		return
-	}
-	f.Close()
-
-	s, err := fs.Stat(fileName)
-	if err != nil {
-		t.Errorf("Stat failed: %s", err)
-		return
-	}
-	if s.Mode().String() != fileMode.String() {
-		t.Errorf("Permissions Incorrect: %s != %s", s.Mode().String(), fileMode.String())
-		return
-	}
-
-	// Test Mkdir
-	err = fs.Mkdir(dirPath, fileMode)
-	if err != nil {
-		t.Errorf("MkDir Create failed: %s", err)
-		return
-	}
-	s, err = fs.Stat(dirPath)
-	if err != nil {
-		t.Errorf("Stat failed: %s", err)
-		return
-	}
-	if s.Mode().String() != fileMode.String() {
-		t.Errorf("Permissions Incorrect: %s != %s", s.Mode().String(), fileMode.String())
-		return
-	}
-
-	// Test MkdirAll
-	err = fs.MkdirAll(dirPathAll, fileMode)
-	if err != nil {
-		t.Errorf("MkDir Create failed: %s", err)
-		return
-	}
-	s, err = fs.Stat(dirPathAll)
-	if err != nil {
-		t.Errorf("Stat failed: %s", err)
-		return
-	}
-	if s.Mode().String() != fileMode.String() {
-		t.Errorf("Permissions Incorrect: %s != %s", s.Mode().String(), fileMode.String())
-		return
-	}
-}
-
-// Fails if multiple file objects use the same file.at counter in MemMapFs
-func TestMultipleOpenFiles(t *testing.T) {
-	defer removeAllTestFiles(t)
-	const fileName = "afero-demo2.txt"
-
-	var data = make([][]byte, len(Fss))
-
-	for i, fs := range Fss {
-		dir := testDir(fs)
-		path := filepath.Join(dir, fileName)
-		fh1, err := fs.Create(path)
-		if err != nil {
-			t.Error("fs.Create failed: " + err.Error())
-		}
-		_, err = fh1.Write([]byte("test"))
-		if err != nil {
-			t.Error("fh.Write failed: " + err.Error())
-		}
-		_, err = fh1.Seek(0, os.SEEK_SET)
-		if err != nil {
-			t.Error(err)
-		}
-
-		fh2, err := fs.OpenFile(path, os.O_RDWR, 0777)
-		if err != nil {
-			t.Error("fs.OpenFile failed: " + err.Error())
-		}
-		_, err = fh2.Seek(0, os.SEEK_END)
-		if err != nil {
-			t.Error(err)
-		}
-		_, err = fh2.Write([]byte("data"))
-		if err != nil {
-			t.Error(err)
-		}
-		err = fh2.Close()
-		if err != nil {
-			t.Error(err)
-		}
-
-		_, err = fh1.Write([]byte("data"))
-		if err != nil {
-			t.Error(err)
-		}
-		err = fh1.Close()
-		if err != nil {
-			t.Error(err)
-		}
-		// the file now should contain "datadata"
-		data[i], err = ReadFile(fs, path)
-		if err != nil {
-			t.Error(err)
-		}
-	}
-
-	for i, fs := range Fss {
-		if i == 0 {
-			continue
-		}
-		if string(data[0]) != string(data[i]) {
-			t.Errorf("%s and %s don't behave the same\n"+
-				"%s: \"%s\"\n%s: \"%s\"\n",
-				Fss[0].Name(), fs.Name(), Fss[0].Name(), data[0], fs.Name(), data[i])
-		}
-	}
-}
-
-// Test if file.Write() fails when opened as read only
-func TestReadOnly(t *testing.T) {
-	defer removeAllTestFiles(t)
-	const fileName = "afero-demo.txt"
-
-	for _, fs := range Fss {
-		dir := testDir(fs)
-		path := filepath.Join(dir, fileName)
-
-		f, err := fs.Create(path)
-		if err != nil {
-			t.Error(fs.Name()+":", "fs.Create failed: "+err.Error())
-		}
-		_, err = f.Write([]byte("test"))
-		if err != nil {
-			t.Error(fs.Name()+":", "Write failed: "+err.Error())
-		}
-		f.Close()
-
-		f, err = fs.Open(path)
-		if err != nil {
-			t.Error("fs.Open failed: " + err.Error())
-		}
-		_, err = f.Write([]byte("data"))
-		if err == nil {
-			t.Error(fs.Name()+":", "No write error")
-		}
-		f.Close()
-
-		f, err = fs.OpenFile(path, os.O_RDONLY, 0644)
-		if err != nil {
-			t.Error("fs.Open failed: " + err.Error())
-		}
-		_, err = f.Write([]byte("data"))
-		if err == nil {
-			t.Error(fs.Name()+":", "No write error")
-		}
-		f.Close()
-	}
-}
-
-func TestWriteCloseTime(t *testing.T) {
-	defer removeAllTestFiles(t)
-	const fileName = "afero-demo.txt"
-
-	for _, fs := range Fss {
-		dir := testDir(fs)
-		path := filepath.Join(dir, fileName)
-
-		f, err := fs.Create(path)
-		if err != nil {
-			t.Error(fs.Name()+":", "fs.Create failed: "+err.Error())
-		}
-		f.Close()
-
-		f, err = fs.Create(path)
-		if err != nil {
-			t.Error(fs.Name()+":", "fs.Create failed: "+err.Error())
-		}
-		fi, err := f.Stat()
-		if err != nil {
-			t.Error(fs.Name()+":", "Stat failed: "+err.Error())
-		}
-		timeBefore := fi.ModTime()
-
-		// sorry for the delay, but we have to make sure time advances,
-		// also on non Un*x systems...
-		switch runtime.GOOS {
-		case "windows":
-			time.Sleep(2 * time.Second)
-		case "darwin":
-			time.Sleep(1 * time.Second)
-		default: // depending on the FS, this may work with < 1 second, on my old ext3 it does not
-			time.Sleep(1 * time.Second)
-		}
-
-		_, err = f.Write([]byte("test"))
-		if err != nil {
-			t.Error(fs.Name()+":", "Write failed: "+err.Error())
-		}
-		f.Close()
-		fi, err = fs.Stat(path)
-		if err != nil {
-			t.Error(fs.Name()+":", "fs.Stat failed: "+err.Error())
-		}
-		if fi.ModTime().Equal(timeBefore) {
-			t.Error(fs.Name()+":", "ModTime was not set on Close()")
-		}
-	}
-}
-
-// This test should be run with the race detector on:
-// go test -race -v -timeout 10s -run TestRacingDeleteAndClose
-func TestRacingDeleteAndClose(t *testing.T) {
-	fs := NewMemMapFs()
-	pathname := "testfile"
-	f, err := fs.Create(pathname)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	in := make(chan bool)
-
-	go func() {
-		<-in
-		f.Close()
-	}()
-	go func() {
-		<-in
-		fs.Remove(pathname)
-	}()
-	close(in)
-}
-
-// This test should be run with the race detector on:
-// go test -run TestMemFsDataRace -race
-func TestMemFsDataRace(t *testing.T) {
-	const dir = "test_dir"
-	fs := NewMemMapFs()
-
-	if err := fs.MkdirAll(dir, 0777); err != nil {
-		t.Fatal(err)
-	}
-
-	const n = 1000
-	done := make(chan struct{})
-
-	go func() {
-		defer close(done)
-		for i := 0; i < n; i++ {
-			fname := filepath.Join(dir, fmt.Sprintf("%d.txt", i))
-			if err := WriteFile(fs, fname, []byte(""), 0777); err != nil {
-				panic(err)
-			}
-			if err := fs.Remove(fname); err != nil {
-				panic(err)
-			}
-		}
-	}()
-
-loop:
-	for {
-		select {
-		case <-done:
-			break loop
-		default:
-			_, err := ReadDir(fs, dir)
-			if err != nil {
-				t.Fatal(err)
-			}
-		}
-	}
-}

vendor/github.com/spf13/afero/memradix.go

@@ -1,14 +0,0 @@
-// Copyright © 2014 Steve Francia <spf@spf13.com>.
-//
-// 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 afero

vendor/github.com/spf13/afero/os.go

@@ -1,94 +0,0 @@
-// Copyright © 2014 Steve Francia <spf@spf13.com>.
-// Copyright 2013 tsuru authors. All rights reserved.
-//
-// 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 afero
-
-import (
-	"os"
-	"time"
-)
-
-// OsFs is a Fs implementation that uses functions provided by the os package.
-//
-// For details in any method, check the documentation of the os package
-// (http://golang.org/pkg/os/).
-type OsFs struct{}
-
-func NewOsFs() Fs {
-	return &OsFs{}
-}
-
-func (OsFs) Name() string { return "OsFs" }
-
-func (OsFs) Create(name string) (File, error) {
-	f, e := os.Create(name)
-	if f == nil {
-		// while this looks strange, we need to return a bare nil (of type nil) not
-		// a nil value of type *os.File or nil won't be nil
-		return nil, e
-	}
-	return f, e
-}
-
-func (OsFs) Mkdir(name string, perm os.FileMode) error {
-	return os.Mkdir(name, perm)
-}
-
-func (OsFs) MkdirAll(path string, perm os.FileMode) error {
-	return os.MkdirAll(path, perm)
-}
-
-func (OsFs) Open(name string) (File, error) {
-	f, e := os.Open(name)
-	if f == nil {
-		// while this looks strange, we need to return a bare nil (of type nil) not
-		// a nil value of type *os.File or nil won't be nil
-		return nil, e
-	}
-	return f, e
-}
-
-func (OsFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
-	f, e := os.OpenFile(name, flag, perm)
-	if f == nil {
-		// while this looks strange, we need to return a bare nil (of type nil) not
-		// a nil value of type *os.File or nil won't be nil
-		return nil, e
-	}
-	return f, e
-}
-
-func (OsFs) Remove(name string) error {
-	return os.Remove(name)
-}
-
-func (OsFs) RemoveAll(path string) error {
-	return os.RemoveAll(path)
-}
-
-func (OsFs) Rename(oldname, newname string) error {
-	return os.Rename(oldname, newname)
-}
-
-func (OsFs) Stat(name string) (os.FileInfo, error) {
-	return os.Stat(name)
-}
-
-func (OsFs) Chmod(name string, mode os.FileMode) error {
-	return os.Chmod(name, mode)
-}
-
-func (OsFs) Chtimes(name string, atime time.Time, mtime time.Time) error {
-	return os.Chtimes(name, atime, mtime)
-}

vendor/github.com/spf13/afero/path.go

@@ -1,108 +0,0 @@
-// Copyright ©2015 The Go Authors
-// Copyright ©2015 Steve Francia <spf@spf13.com>
-//
-// 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 afero
-
-import (
-	"os"
-	"path/filepath"
-	"sort"
-)
-
-// readDirNames reads the directory named by dirname and returns
-// a sorted list of directory entries.
-// adapted from https://golang.org/src/path/filepath/path.go
-func readDirNames(fs Fs, dirname string) ([]string, error) {
-	f, err := fs.Open(dirname)
-	if err != nil {
-		return nil, err
-	}
-	names, err := f.Readdirnames(-1)
-	f.Close()
-	if err != nil {
-		return nil, err
-	}
-	sort.Strings(names)
-	return names, nil
-}
-
-// walk recursively descends path, calling walkFn
-// adapted from https://golang.org/src/path/filepath/path.go
-func walk(fs Fs, path string, info os.FileInfo, walkFn filepath.WalkFunc) error {
-	err := walkFn(path, info, nil)
-	if err != nil {
-		if info.IsDir() && err == filepath.SkipDir {
-			return nil
-		}
-		return err
-	}
-
-	if !info.IsDir() {
-		return nil
-	}
-
-	names, err := readDirNames(fs, path)
-	if err != nil {
-		return walkFn(path, info, err)
-	}
-
-	for _, name := range names {
-		filename := filepath.Join(path, name)
-		fileInfo, err := lstatIfOs(fs, filename)
-		if err != nil {
-			if err := walkFn(filename, fileInfo, err); err != nil && err != filepath.SkipDir {
-				return err
-			}
-		} else {
-			err = walk(fs, filename, fileInfo, walkFn)
-			if err != nil {
-				if !fileInfo.IsDir() || err != filepath.SkipDir {
-					return err
-				}
-			}
-		}
-	}
-	return nil
-}
-
-// if the filesystem is OsFs use Lstat, else use fs.Stat
-func lstatIfOs(fs Fs, path string) (info os.FileInfo, err error) {
-	_, ok := fs.(*OsFs)
-	if ok {
-		info, err = os.Lstat(path)
-	} else {
-		info, err = fs.Stat(path)
-	}
-	return
-}
-
-// Walk walks the file tree rooted at root, calling walkFn for each file or
-// directory in the tree, including root. All errors that arise visiting files
-// and directories are filtered by walkFn. The files are walked in lexical
-// order, which makes the output deterministic but means that for very
-// large directories Walk can be inefficient.
-// Walk does not follow symbolic links.
-
-func (a Afero) Walk(root string, walkFn filepath.WalkFunc) error {
-	return Walk(a.Fs, root, walkFn)
-}
-
-func Walk(fs Fs, root string, walkFn filepath.WalkFunc) error {
-	info, err := lstatIfOs(fs, root)
-	if err != nil {
-		return walkFn(root, nil, err)
-	}
-	return walk(fs, root, info, walkFn)
-}

vendor/github.com/spf13/afero/path_test.go

@@ -1,69 +0,0 @@
-// Copyright © 2014 Steve Francia <spf@spf13.com>.
-// Copyright 2009 The Go Authors. All rights reserved.
-//
-// 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 afero
-
-import (
-	"fmt"
-	"os"
-	"testing"
-)
-
-func TestWalk(t *testing.T) {
-	defer removeAllTestFiles(t)
-	var testDir string
-	for i, fs := range Fss {
-		if i == 0 {
-			testDir = setupTestDirRoot(t, fs)
-		} else {
-			setupTestDirReusePath(t, fs, testDir)
-		}
-	}
-
-	outputs := make([]string, len(Fss))
-	for i, fs := range Fss {
-		walkFn := func(path string, info os.FileInfo, err error) error {
-			if err != nil {
-				t.Error("walkFn err:", err)
-			}
-			var size int64
-			if !info.IsDir() {
-				size = info.Size()
-			}
-			outputs[i] += fmt.Sprintln(path, info.Name(), size, info.IsDir(), err)
-			return nil
-		}
-		err := Walk(fs, testDir, walkFn)
-		if err != nil {
-			t.Error(err)
-		}
-	}
-	fail := false
-	for i, o := range outputs {
-		if i == 0 {
-			continue
-		}
-		if o != outputs[i-1] {
-			fail = true
-			break
-		}
-	}
-	if fail {
-		t.Log("Walk outputs not equal!")
-		for i, o := range outputs {
-			t.Log(Fss[i].Name() + "\n" + o)
-		}
-		t.Fail()
-	}
-}

vendor/github.com/spf13/afero/readonlyfs.go

@@ -1,70 +0,0 @@
-package afero
-
-import (
-	"os"
-	"syscall"
-	"time"
-)
-
-type ReadOnlyFs struct {
-	source Fs
-}
-
-func NewReadOnlyFs(source Fs) Fs {
-	return &ReadOnlyFs{source: source}
-}
-
-func (r *ReadOnlyFs) ReadDir(name string) ([]os.FileInfo, error) {
-	return ReadDir(r.source, name)
-}
-
-func (r *ReadOnlyFs) Chtimes(n string, a, m time.Time) error {
-	return syscall.EPERM
-}
-
-func (r *ReadOnlyFs) Chmod(n string, m os.FileMode) error {
-	return syscall.EPERM
-}
-
-func (r *ReadOnlyFs) Name() string {
-	return "ReadOnlyFilter"
-}
-
-func (r *ReadOnlyFs) Stat(name string) (os.FileInfo, error) {
-	return r.source.Stat(name)
-}
-
-func (r *ReadOnlyFs) Rename(o, n string) error {
-	return syscall.EPERM
-}
-
-func (r *ReadOnlyFs) RemoveAll(p string) error {
-	return syscall.EPERM
-}
-
-func (r *ReadOnlyFs) Remove(n string) error {
-	return syscall.EPERM
-}
-
-func (r *ReadOnlyFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
-	if flag&(os.O_WRONLY|syscall.O_RDWR|os.O_APPEND|os.O_CREATE|os.O_TRUNC) != 0 {
-		return nil, syscall.EPERM
-	}
-	return r.source.OpenFile(name, flag, perm)
-}
-
-func (r *ReadOnlyFs) Open(n string) (File, error) {
-	return r.source.Open(n)
-}
-
-func (r *ReadOnlyFs) Mkdir(n string, p os.FileMode) error {
-	return syscall.EPERM
-}
-
-func (r *ReadOnlyFs) MkdirAll(n string, p os.FileMode) error {
-	return syscall.EPERM
-}
-
-func (r *ReadOnlyFs) Create(n string) (File, error) {
-	return nil, syscall.EPERM
-}

vendor/github.com/spf13/afero/regexpfs.go

@@ -1,214 +0,0 @@
-package afero
-
-import (
-	"os"
-	"regexp"
-	"syscall"
-	"time"
-)
-
-// The RegexpFs filters files (not directories) by regular expression. Only
-// files matching the given regexp will be allowed, all others get a ENOENT error (
-// "No such file or directory").
-//
-type RegexpFs struct {
-	re     *regexp.Regexp
-	source Fs
-}
-
-func NewRegexpFs(source Fs, re *regexp.Regexp) Fs {
-	return &RegexpFs{source: source, re: re}
-}
-
-type RegexpFile struct {
-	f  File
-	re *regexp.Regexp
-}
-
-func (r *RegexpFs) matchesName(name string) error {
-	if r.re == nil {
-		return nil
-	}
-	if r.re.MatchString(name) {
-		return nil
-	}
-	return syscall.ENOENT
-}
-
-func (r *RegexpFs) dirOrMatches(name string) error {
-	dir, err := IsDir(r.source, name)
-	if err != nil {
-		return err
-	}
-	if dir {
-		return nil
-	}
-	return r.matchesName(name)
-}
-
-func (r *RegexpFs) Chtimes(name string, a, m time.Time) error {
-	if err := r.dirOrMatches(name); err != nil {
-		return err
-	}
-	return r.source.Chtimes(name, a, m)
-}
-
-func (r *RegexpFs) Chmod(name string, mode os.FileMode) error {
-	if err := r.dirOrMatches(name); err != nil {
-		return err
-	}
-	return r.source.Chmod(name, mode)
-}
-
-func (r *RegexpFs) Name() string {
-	return "RegexpFs"
-}
-
-func (r *RegexpFs) Stat(name string) (os.FileInfo, error) {
-	if err := r.dirOrMatches(name); err != nil {
-		return nil, err
-	}
-	return r.source.Stat(name)
-}
-
-func (r *RegexpFs) Rename(oldname, newname string) error {
-	dir, err := IsDir(r.source, oldname)
-	if err != nil {
-		return err
-	}
-	if dir {
-		return nil
-	}
-	if err := r.matchesName(oldname); err != nil {
-		return err
-	}
-	if err := r.matchesName(newname); err != nil {
-		return err
-	}
-	return r.source.Rename(oldname, newname)
-}
-
-func (r *RegexpFs) RemoveAll(p string) error {
-	dir, err := IsDir(r.source, p)
-	if err != nil {
-		return err
-	}
-	if !dir {
-		if err := r.matchesName(p); err != nil {
-			return err
-		}
-	}
-	return r.source.RemoveAll(p)
-}
-
-func (r *RegexpFs) Remove(name string) error {
-	if err := r.dirOrMatches(name); err != nil {
-		return err
-	}
-	return r.source.Remove(name)
-}
-
-func (r *RegexpFs) OpenFile(name string, flag int, perm os.FileMode) (File, error) {
-	if err := r.dirOrMatches(name); err != nil {
-		return nil, err
-	}
-	return r.source.OpenFile(name, flag, perm)
-}
-
-func (r *RegexpFs) Open(name string) (File, error) {
-	dir, err := IsDir(r.source, name)
-	if err != nil {
-		return nil, err
-	}
-	if !dir {
-		if err := r.matchesName(name); err != nil {
-			return nil, err
-		}
-	}
-	f, err := r.source.Open(name)
-	return &RegexpFile{f: f, re: r.re}, nil
-}
-
-func (r *RegexpFs) Mkdir(n string, p os.FileMode) error {
-	return r.source.Mkdir(n, p)
-}
-
-func (r *RegexpFs) MkdirAll(n string, p os.FileMode) error {
-	return r.source.MkdirAll(n, p)
-}
-
-func (r *RegexpFs) Create(name string) (File, error) {
-	if err := r.matchesName(name); err != nil {
-		return nil, err
-	}
-	return r.source.Create(name)
-}
-
-func (f *RegexpFile) Close() error {
-	return f.f.Close()
-}
-
-func (f *RegexpFile) Read(s []byte) (int, error) {
-	return f.f.Read(s)
-}
-
-func (f *RegexpFile) ReadAt(s []byte, o int64) (int, error) {
-	return f.f.ReadAt(s, o)
-}
-
-func (f *RegexpFile) Seek(o int64, w int) (int64, error) {
-	return f.f.Seek(o, w)
-}
-
-func (f *RegexpFile) Write(s []byte) (int, error) {
-	return f.f.Write(s)
-}
-
-func (f *RegexpFile) WriteAt(s []byte, o int64) (int, error) {
-	return f.f.WriteAt(s, o)
-}
-
-func (f *RegexpFile) Name() string {
-	return f.f.Name()
-}
-
-func (f *RegexpFile) Readdir(c int) (fi []os.FileInfo, err error) {
-	var rfi []os.FileInfo
-	rfi, err = f.f.Readdir(c)
-	if err != nil {
-		return nil, err
-	}
-	for _, i := range rfi {
-		if i.IsDir() || f.re.MatchString(i.Name()) {
-			fi = append(fi, i)
-		}
-	}
-	return fi, nil
-}
-
-func (f *RegexpFile) Readdirnames(c int) (n []string, err error) {
-	fi, err := f.Readdir(c)
-	if err != nil {
-		return nil, err
-	}
-	for _, s := range fi {
-		n = append(n, s.Name())
-	}
-	return n, nil
-}
-
-func (f *RegexpFile) Stat() (os.FileInfo, error) {
-	return f.f.Stat()
-}
-
-func (f *RegexpFile) Sync() error {
-	return f.f.Sync()
-}
-
-func (f *RegexpFile) Truncate(s int64) error {
-	return f.f.Truncate(s)
-}
-
-func (f *RegexpFile) WriteString(s string) (int, error) {
-	return f.f.WriteString(s)
-}

vendor/github.com/spf13/afero/ro_regexp_test.go

@@ -1,96 +0,0 @@
-package afero
-
-import (
-	"regexp"
-	"testing"
-)
-
-func TestFilterReadOnly(t *testing.T) {
-	fs := &ReadOnlyFs{source: &MemMapFs{}}
-	_, err := fs.Create("/file.txt")
-	if err == nil {
-		t.Errorf("Did not fail to create file")
-	}
-	// t.Logf("ERR=%s", err)
-}
-
-func TestFilterReadonlyRemoveAndRead(t *testing.T) {
-	mfs := &MemMapFs{}
-	fh, err := mfs.Create("/file.txt")
-	fh.Write([]byte("content here"))
-	fh.Close()
-
-	fs := NewReadOnlyFs(mfs)
-	err = fs.Remove("/file.txt")
-	if err == nil {
-		t.Errorf("Did not fail to remove file")
-	}
-
-	fh, err = fs.Open("/file.txt")
-	if err != nil {
-		t.Errorf("Failed to open file: %s", err)
-	}
-
-	buf := make([]byte, len("content here"))
-	_, err = fh.Read(buf)
-	fh.Close()
-	if string(buf) != "content here" {
-		t.Errorf("Failed to read file: %s", err)
-	}
-
-	err = mfs.Remove("/file.txt")
-	if err != nil {
-		t.Errorf("Failed to remove file")
-	}
-
-	fh, err = fs.Open("/file.txt")
-	if err == nil {
-		fh.Close()
-		t.Errorf("File still present")
-	}
-}
-
-func TestFilterRegexp(t *testing.T) {
-	fs := NewRegexpFs(&MemMapFs{}, regexp.MustCompile(`\.txt$`))
-	_, err := fs.Create("/file.html")
-	if err == nil {
-
-		t.Errorf("Did not fail to create file")
-	}
-	// t.Logf("ERR=%s", err)
-}
-
-func TestFilterRORegexpChain(t *testing.T) {
-	rofs := &ReadOnlyFs{source: &MemMapFs{}}
-	fs := &RegexpFs{re: regexp.MustCompile(`\.txt$`), source: rofs}
-	_, err := fs.Create("/file.txt")
-	if err == nil {
-		t.Errorf("Did not fail to create file")
-	}
-	// t.Logf("ERR=%s", err)
-}
-
-func TestFilterRegexReadDir(t *testing.T) {
-	mfs := &MemMapFs{}
-	fs1 := &RegexpFs{re: regexp.MustCompile(`\.txt$`), source: mfs}
-	fs := &RegexpFs{re: regexp.MustCompile(`^a`), source: fs1}
-
-	mfs.MkdirAll("/dir/sub", 0777)
-	for _, name := range []string{"afile.txt", "afile.html", "bfile.txt"} {
-		for _, dir := range []string{"/dir/", "/dir/sub/"} {
-			fh, _ := mfs.Create(dir + name)
-			fh.Close()
-		}
-	}
-
-	files, _ := ReadDir(fs, "/dir")
-	if len(files) != 2 { // afile.txt, sub
-		t.Errorf("Got wrong number of files: %#v", files)
-	}
-
-	f, _ := fs.Open("/dir/sub")
-	names, _ := f.Readdirnames(-1)
-	if len(names) != 1 {
-		t.Errorf("Got wrong number of names: %v", names)
-	}
-}

vendor/github.com/spf13/afero/sftpfs/file.go

@@ -1,95 +0,0 @@
-// Copyright © 2015 Jerry Jacobs <jerry.jacobs@xor-gate.org>.
-//
-// 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 sftpfs
-
-import (
-	"github.com/pkg/sftp"
-	"os"
-)
-
-type File struct {
-	fd *sftp.File
-}
-
-func FileOpen(s *sftp.Client, name string) (*File, error) {
-	fd, err := s.Open(name)
-	if err != nil {
-		return &File{}, err
-	}
-	return &File{fd: fd}, nil
-}
-
-func FileCreate(s *sftp.Client, name string) (*File, error) {
-	fd, err := s.Create(name)
-	if err != nil {
-		return &File{}, err
-	}
-	return &File{fd: fd}, nil
-}
-
-func (f *File) Close() error {
-	return f.fd.Close()
-}
-
-func (f *File) Name() string {
-	return f.fd.Name()
-}
-
-func (f *File) Stat() (os.FileInfo, error) {
-	return f.fd.Stat()
-}
-
-func (f *File) Sync() error {
-	return nil
-}
-
-func (f *File) Truncate(size int64) error {
-	return f.fd.Truncate(size)
-}
-
-func (f *File) Read(b []byte) (n int, err error) {
-	return f.fd.Read(b)
-}
-
-// TODO
-func (f *File) ReadAt(b []byte, off int64) (n int, err error) {
-	return 0, nil
-}
-
-// TODO
-func (f *File) Readdir(count int) (res []os.FileInfo, err error) {
-	return nil, nil
-}
-
-// TODO
-func (f *File) Readdirnames(n int) (names []string, err error) {
-	return nil, nil
-}
-
-func (f *File) Seek(offset int64, whence int) (int64, error) {
-	return f.fd.Seek(offset, whence)
-}
-
-func (f *File) Write(b []byte) (n int, err error) {
-	return f.fd.Write(b)
-}
-
-// TODO
-func (f *File) WriteAt(b []byte, off int64) (n int, err error) {
-	return 0, nil
-}
-
-func (f *File) WriteString(s string) (ret int, err error) {
-	return f.fd.Write([]byte(s))
-}

vendor/github.com/spf13/afero/sftpfs/sftp.go

@@ -1,129 +0,0 @@
-// Copyright © 2015 Jerry Jacobs <jerry.jacobs@xor-gate.org>.
-//
-// 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 sftpfs
-
-import (
-	"os"
-	"time"
-
-	"github.com/pkg/sftp"
-	"github.com/spf13/afero"
-)
-
-// Fs is a afero.Fs implementation that uses functions provided by the sftp package.
-//
-// For details in any method, check the documentation of the sftp package
-// (github.com/pkg/sftp).
-type Fs struct {
-	client *sftp.Client
-}
-
-func New(client *sftp.Client) afero.Fs {
-	return &Fs{client: client}
-}
-
-func (s Fs) Name() string { return "sftpfs" }
-
-func (s Fs) Create(name string) (afero.File, error) {
-	return FileCreate(s.client, name)
-}
-
-func (s Fs) Mkdir(name string, perm os.FileMode) error {
-	err := s.client.Mkdir(name)
-	if err != nil {
-		return err
-	}
-	return s.client.Chmod(name, perm)
-}
-
-func (s Fs) MkdirAll(path string, perm os.FileMode) error {
-	// Fast path: if we can tell whether path is a directory or file, stop with success or error.
-	dir, err := s.Stat(path)
-	if err == nil {
-		if dir.IsDir() {
-			return nil
-		}
-		return err
-	}
-
-	// Slow path: make sure parent exists and then call Mkdir for path.
-	i := len(path)
-	for i > 0 && os.IsPathSeparator(path[i-1]) { // Skip trailing path separator.
-		i--
-	}
-
-	j := i
-	for j > 0 && !os.IsPathSeparator(path[j-1]) { // Scan backward over element.
-		j--
-	}
-
-	if j > 1 {
-		// Create parent
-		err = s.MkdirAll(path[0:j-1], perm)
-		if err != nil {
-			return err
-		}
-	}
-
-	// Parent now exists; invoke Mkdir and use its result.
-	err = s.Mkdir(path, perm)
-	if err != nil {
-		// Handle arguments like "foo/." by
-		// double-checking that directory doesn't exist.
-		dir, err1 := s.Lstat(path)
-		if err1 == nil && dir.IsDir() {
-			return nil
-		}
-		return err
-	}
-	return nil
-}
-
-func (s Fs) Open(name string) (afero.File, error) {
-	return FileOpen(s.client, name)
-}
-
-func (s Fs) OpenFile(name string, flag int, perm os.FileMode) (afero.File, error) {
-	return nil, nil
-}
-
-func (s Fs) Remove(name string) error {
-	return s.client.Remove(name)
-}
-
-func (s Fs) RemoveAll(path string) error {
-	// TODO have a look at os.RemoveAll
-	// https://github.com/golang/go/blob/master/src/os/path.go#L66
-	return nil
-}
-
-func (s Fs) Rename(oldname, newname string) error {
-	return s.client.Rename(oldname, newname)
-}
-
-func (s Fs) Stat(name string) (os.FileInfo, error) {
-	return s.client.Stat(name)
-}
-
-func (s Fs) Lstat(p string) (os.FileInfo, error) {
-	return s.client.Lstat(p)
-}
-
-func (s Fs) Chmod(name string, mode os.FileMode) error {
-	return s.client.Chmod(name, mode)
-}
-
-func (s Fs) Chtimes(name string, atime time.Time, mtime time.Time) error {
-	return s.client.Chtimes(name, atime, mtime)
-}

vendor/github.com/spf13/afero/sftpfs/sftp_test_go

@@ -1,286 +0,0 @@
-// Copyright © 2015 Jerry Jacobs <jerry.jacobs@xor-gate.org>.
-//
-// 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 afero
-
-import (
-	"testing"
-	"os"
-	"log"
-	"fmt"
-	"net"
-	"flag"
-	"time"
-	"io/ioutil"
-	"crypto/rsa"
-	_rand "crypto/rand"
-	"encoding/pem"
-	"crypto/x509"
-
-	"golang.org/x/crypto/ssh"
-	"github.com/pkg/sftp"
-)
-
-type SftpFsContext struct {
-	sshc   *ssh.Client
-	sshcfg *ssh.ClientConfig
-	sftpc  *sftp.Client
-}
-
-// TODO we only connect with hardcoded user+pass for now
-// it should be possible to use $HOME/.ssh/id_rsa to login into the stub sftp server
-func SftpConnect(user, password, host string) (*SftpFsContext, error) {
-/*
-	pemBytes, err := ioutil.ReadFile(os.Getenv("HOME") + "/.ssh/id_rsa")
-	if err != nil {
-		return nil,err
-	}
-
-	signer, err := ssh.ParsePrivateKey(pemBytes)
-	if err != nil {
-		return nil,err
-	}
-
-	sshcfg := &ssh.ClientConfig{
-		User: user,
-		Auth: []ssh.AuthMethod{
-			ssh.Password(password),
-			ssh.PublicKeys(signer),
-		},
-	}
-*/
-
-	sshcfg := &ssh.ClientConfig{
-		User: user,
-		Auth: []ssh.AuthMethod{
-			ssh.Password(password),
-		},
-	}
-
-	sshc, err := ssh.Dial("tcp", host, sshcfg)
-	if err != nil {
-		return nil,err
-	}
-
-	sftpc, err := sftp.NewClient(sshc)
-	if err != nil {
-		return nil,err
-	}
-
-	ctx := &SftpFsContext{
-		sshc: sshc,
-		sshcfg: sshcfg,
-		sftpc: sftpc,
-	}
-
-	return ctx,nil
-}
-
-func (ctx *SftpFsContext) Disconnect() error {
-	ctx.sftpc.Close()
-	ctx.sshc.Close()
-	return nil
-}
-
-// TODO for such a weird reason rootpath is "." when writing "file1" with afero sftp backend
-func RunSftpServer(rootpath string) {
-	var (
-		readOnly      bool
-		debugLevelStr string
-		debugLevel    int
-		debugStderr   bool
-		rootDir       string
-	)
-
-	flag.BoolVar(&readOnly, "R", false, "read-only server")
-	flag.BoolVar(&debugStderr, "e", true, "debug to stderr")
-	flag.StringVar(&debugLevelStr, "l", "none", "debug level")
-	flag.StringVar(&rootDir, "root", rootpath, "root directory")
-	flag.Parse()
-
-	debugStream := ioutil.Discard
-	if debugStderr {
-		debugStream = os.Stderr
-		debugLevel = 1
-	}
-
-	// An SSH server is represented by a ServerConfig, which holds
-	// certificate details and handles authentication of ServerConns.
-	config := &ssh.ServerConfig{
-		PasswordCallback: func(c ssh.ConnMetadata, pass []byte) (*ssh.Permissions, error) {
-			// Should use constant-time compare (or better, salt+hash) in
-			// a production setting.
-			fmt.Fprintf(debugStream, "Login: %s\n", c.User())
-			if c.User() == "test" && string(pass) == "test" {
-				return nil, nil
-			}
-			return nil, fmt.Errorf("password rejected for %q", c.User())
-		},
-	}
-
-	privateBytes, err := ioutil.ReadFile("./test/id_rsa")
-	if err != nil {
-		log.Fatal("Failed to load private key", err)
-	}
-
-	private, err := ssh.ParsePrivateKey(privateBytes)
-	if err != nil {
-		log.Fatal("Failed to parse private key", err)
-	}
-
-	config.AddHostKey(private)
-
-	// Once a ServerConfig has been configured, connections can be
-	// accepted.
-	listener, err := net.Listen("tcp", "0.0.0.0:2022")
-	if err != nil {
-		log.Fatal("failed to listen for connection", err)
-	}
-	fmt.Printf("Listening on %v\n", listener.Addr())
-
-	nConn, err := listener.Accept()
-	if err != nil {
-		log.Fatal("failed to accept incoming connection", err)
-	}
-
-	// Before use, a handshake must be performed on the incoming
-	// net.Conn.
-	_, chans, reqs, err := ssh.NewServerConn(nConn, config)
-	if err != nil {
-		log.Fatal("failed to handshake", err)
-	}
-	fmt.Fprintf(debugStream, "SSH server established\n")
-
-	// The incoming Request channel must be serviced.
-	go ssh.DiscardRequests(reqs)
-
-	// Service the incoming Channel channel.
-	for newChannel := range chans {
-		// Channels have a type, depending on the application level
-		// protocol intended. In the case of an SFTP session, this is "subsystem"
-		// with a payload string of "<length=4>sftp"
-		fmt.Fprintf(debugStream, "Incoming channel: %s\n", newChannel.ChannelType())
-		if newChannel.ChannelType() != "session" {
-			newChannel.Reject(ssh.UnknownChannelType, "unknown channel type")
-			fmt.Fprintf(debugStream, "Unknown channel type: %s\n", newChannel.ChannelType())
-			continue
-		}
-		channel, requests, err := newChannel.Accept()
-		if err != nil {
-			log.Fatal("could not accept channel.", err)
-		}
-		fmt.Fprintf(debugStream, "Channel accepted\n")
-
-		// Sessions have out-of-band requests such as "shell",
-		// "pty-req" and "env".  Here we handle only the
-		// "subsystem" request.
-		go func(in <-chan *ssh.Request) {
-			for req := range in {
-				fmt.Fprintf(debugStream, "Request: %v\n", req.Type)
-				ok := false
-				switch req.Type {
-				case "subsystem":
-					fmt.Fprintf(debugStream, "Subsystem: %s\n", req.Payload[4:])
-					if string(req.Payload[4:]) == "sftp" {
-						ok = true
-					}
-				}
-				fmt.Fprintf(debugStream, " - accepted: %v\n", ok)
-				req.Reply(ok, nil)
-			}
-		}(requests)
-
-		server, err := sftp.NewServer(channel, channel, debugStream, debugLevel, readOnly, rootpath)
-		if err != nil {
-			log.Fatal(err)
-		}
-		if err := server.Serve(); err != nil {
-			log.Fatal("sftp server completed with error:", err)
-		}
-	}
-}
-
-// MakeSSHKeyPair make a pair of public and private keys for SSH access.
-// Public key is encoded in the format for inclusion in an OpenSSH authorized_keys file.
-// Private Key generated is PEM encoded
-func MakeSSHKeyPair(bits int, pubKeyPath, privateKeyPath string) error {
-	privateKey, err := rsa.GenerateKey(_rand.Reader, bits)
-	if err != nil {
-		return err
-	}
-
-	// generate and write private key as PEM
-	privateKeyFile, err := os.Create(privateKeyPath)
-	defer privateKeyFile.Close()
-	if err != nil {
-		return err
-	}
-
-	privateKeyPEM := &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(privateKey)}
-	if err := pem.Encode(privateKeyFile, privateKeyPEM); err != nil {
-		return err
-	}
-
-	// generate and write public key
-	pub, err := ssh.NewPublicKey(&privateKey.PublicKey)
-	if err != nil {
-		return err
-	}
-
-	return ioutil.WriteFile(pubKeyPath, ssh.MarshalAuthorizedKey(pub), 0655)
-}
-
-func TestSftpCreate(t *testing.T) {
-	os.Mkdir("./test", 0777)
-	MakeSSHKeyPair(1024, "./test/id_rsa.pub", "./test/id_rsa")
-
-	go RunSftpServer("./test/")
-	time.Sleep(5 * time.Second)
-
-	ctx, err := SftpConnect("test", "test", "localhost:2022")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer ctx.Disconnect()
-
-	var AppFs Fs = SftpFs{
-		SftpClient: ctx.sftpc,
-	}
-
-	AppFs.MkdirAll("test/dir1/dir2/dir3", os.FileMode(0777))
-	AppFs.Mkdir("test/foo", os.FileMode(0000))
-	AppFs.Chmod("test/foo", os.FileMode(0700))
-	AppFs.Mkdir("test/bar", os.FileMode(0777))
-
-	file, err := AppFs.Create("file1")
-	if err != nil {
-		t.Error(err)
-	}
-	defer file.Close()
-
-	file.Write([]byte("hello\t"))
-	file.WriteString("world!\n")
-
-	f1, err := AppFs.Open("file1")
-	if err != nil {
-		log.Fatalf("open: %v", err)
-	}
-	defer f1.Close()
-
-	b := make([]byte, 100)
-
-	_, err = f1.Read(b)
-	fmt.Println(string(b))
-
-	// TODO check here if "hello\tworld\n" is in buffer b
-}

vendor/github.com/spf13/afero/unionFile.go

@@ -1,274 +0,0 @@
-package afero
-
-import (
-	"io"
-	"os"
-	"path/filepath"
-	"syscall"
-)
-
-// The UnionFile implements the afero.File interface and will be returned
-// when reading a directory present at least in the overlay or opening a file
-// for writing.
-//
-// The calls to
-// Readdir() and Readdirnames() merge the file os.FileInfo / names from the
-// base and the overlay - for files present in both layers, only those
-// from the overlay will be used.
-//
-// When opening files for writing (Create() / OpenFile() with the right flags)
-// the operations will be done in both layers, starting with the overlay. A
-// successful read in the overlay will move the cursor position in the base layer
-// by the number of bytes read.
-type UnionFile struct {
-	base  File
-	layer File
-	off   int
-	files []os.FileInfo
-}
-
-func (f *UnionFile) Close() error {
-	// first close base, so we have a newer timestamp in the overlay. If we'd close
-	// the overlay first, we'd get a cacheStale the next time we access this file
-	// -> cache would be useless ;-)
-	if f.base != nil {
-		f.base.Close()
-	}
-	if f.layer != nil {
-		return f.layer.Close()
-	}
-	return BADFD
-}
-
-func (f *UnionFile) Read(s []byte) (int, error) {
-	if f.layer != nil {
-		n, err := f.layer.Read(s)
-		if (err == nil || err == io.EOF) && f.base != nil {
-			// advance the file position also in the base file, the next
-			// call may be a write at this position (or a seek with SEEK_CUR)
-			if _, seekErr := f.base.Seek(int64(n), os.SEEK_CUR); seekErr != nil {
-				// only overwrite err in case the seek fails: we need to
-				// report an eventual io.EOF to the caller
-				err = seekErr
-			}
-		}
-		return n, err
-	}
-	if f.base != nil {
-		return f.base.Read(s)
-	}
-	return 0, BADFD
-}
-
-func (f *UnionFile) ReadAt(s []byte, o int64) (int, error) {
-	if f.layer != nil {
-		n, err := f.layer.ReadAt(s, o)
-		if (err == nil || err == io.EOF) && f.base != nil {
-			_, err = f.base.Seek(o+int64(n), os.SEEK_SET)
-		}
-		return n, err
-	}
-	if f.base != nil {
-		return f.base.ReadAt(s, o)
-	}
-	return 0, BADFD
-}
-
-func (f *UnionFile) Seek(o int64, w int) (pos int64, err error) {
-	if f.layer != nil {
-		pos, err = f.layer.Seek(o, w)
-		if (err == nil || err == io.EOF) && f.base != nil {
-			_, err = f.base.Seek(o, w)
-		}
-		return pos, err
-	}
-	if f.base != nil {
-		return f.base.Seek(o, w)
-	}
-	return 0, BADFD
-}
-
-func (f *UnionFile) Write(s []byte) (n int, err error) {
-	if f.layer != nil {
-		n, err = f.layer.Write(s)
-		if err == nil && f.base != nil { // hmm, do we have fixed size files where a write may hit the EOF mark?
-			_, err = f.base.Write(s)
-		}
-		return n, err
-	}
-	if f.base != nil {
-		return f.base.Write(s)
-	}
-	return 0, BADFD
-}
-
-func (f *UnionFile) WriteAt(s []byte, o int64) (n int, err error) {
-	if f.layer != nil {
-		n, err = f.layer.WriteAt(s, o)
-		if err == nil && f.base != nil {
-			_, err = f.base.WriteAt(s, o)
-		}
-		return n, err
-	}
-	if f.base != nil {
-		return f.base.WriteAt(s, o)
-	}
-	return 0, BADFD
-}
-
-func (f *UnionFile) Name() string {
-	if f.layer != nil {
-		return f.layer.Name()
-	}
-	return f.base.Name()
-}
-
-// Readdir will weave the two directories together and
-// return a single view of the overlayed directories
-func (f *UnionFile) Readdir(c int) (ofi []os.FileInfo, err error) {
-	if f.off == 0 {
-		var files = make(map[string]os.FileInfo)
-		var rfi []os.FileInfo
-		if f.layer != nil {
-			rfi, err = f.layer.Readdir(-1)
-			if err != nil {
-				return nil, err
-			}
-			for _, fi := range rfi {
-				files[fi.Name()] = fi
-			}
-		}
-
-		if f.base != nil {
-			rfi, err = f.base.Readdir(-1)
-			if err != nil {
-				return nil, err
-			}
-			for _, fi := range rfi {
-				if _, exists := files[fi.Name()]; !exists {
-					files[fi.Name()] = fi
-				}
-			}
-		}
-		for _, fi := range files {
-			f.files = append(f.files, fi)
-		}
-	}
-	if c == -1 {
-		return f.files[f.off:], nil
-	}
-	defer func() { f.off += c }()
-	return f.files[f.off:c], nil
-}
-
-func (f *UnionFile) Readdirnames(c int) ([]string, error) {
-	rfi, err := f.Readdir(c)
-	if err != nil {
-		return nil, err
-	}
-	var names []string
-	for _, fi := range rfi {
-		names = append(names, fi.Name())
-	}
-	return names, nil
-}
-
-func (f *UnionFile) Stat() (os.FileInfo, error) {
-	if f.layer != nil {
-		return f.layer.Stat()
-	}
-	if f.base != nil {
-		return f.base.Stat()
-	}
-	return nil, BADFD
-}
-
-func (f *UnionFile) Sync() (err error) {
-	if f.layer != nil {
-		err = f.layer.Sync()
-		if err == nil && f.base != nil {
-			err = f.base.Sync()
-		}
-		return err
-	}
-	if f.base != nil {
-		return f.base.Sync()
-	}
-	return BADFD
-}
-
-func (f *UnionFile) Truncate(s int64) (err error) {
-	if f.layer != nil {
-		err = f.layer.Truncate(s)
-		if err == nil && f.base != nil {
-			err = f.base.Truncate(s)
-		}
-		return err
-	}
-	if f.base != nil {
-		return f.base.Truncate(s)
-	}
-	return BADFD
-}
-
-func (f *UnionFile) WriteString(s string) (n int, err error) {
-	if f.layer != nil {
-		n, err = f.layer.WriteString(s)
-		if err == nil && f.base != nil {
-			_, err = f.base.WriteString(s)
-		}
-		return n, err
-	}
-	if f.base != nil {
-		return f.base.WriteString(s)
-	}
-	return 0, BADFD
-}
-
-func copyToLayer(base Fs, layer Fs, name string) error {
-	bfh, err := base.Open(name)
-	if err != nil {
-		return err
-	}
-	defer bfh.Close()
-
-	// First make sure the directory exists
-	exists, err := Exists(layer, filepath.Dir(name))
-	if err != nil {
-		return err
-	}
-	if !exists {
-		err = layer.MkdirAll(filepath.Dir(name), 0777) // FIXME?
-		if err != nil {
-			return err
-		}
-	}
-
-	// Create the file on the overlay
-	lfh, err := layer.Create(name)
-	if err != nil {
-		return err
-	}
-	n, err := io.Copy(lfh, bfh)
-	if err != nil {
-		// If anything fails, clean up the file
-		layer.Remove(name)
-		lfh.Close()
-		return err
-	}
-
-	bfi, err := bfh.Stat()
-	if err != nil || bfi.Size() != n {
-		layer.Remove(name)
-		lfh.Close()
-		return syscall.EIO
-	}
-
-	err = lfh.Close()
-	if err != nil {
-		layer.Remove(name)
-		lfh.Close()
-		return err
-	}
-	return layer.Chtimes(name, bfi.ModTime(), bfi.ModTime())
-}

vendor/github.com/spf13/afero/util.go

@@ -1,331 +0,0 @@
-// Copyright ©2015 Steve Francia <spf@spf13.com>
-// Portions Copyright ©2015 The Hugo Authors
-// Portions Copyright 2016-present Bjørn Erik Pedersen <bjorn.erik.pedersen@gmail.com>
-//
-// 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 afero
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-	"unicode"
-
-	"golang.org/x/text/transform"
-	"golang.org/x/text/unicode/norm"
-)
-
-// Filepath separator defined by os.Separator.
-const FilePathSeparator = string(filepath.Separator)
-
-// Takes a reader and a path and writes the content
-func (a Afero) WriteReader(path string, r io.Reader) (err error) {
-	return WriteReader(a.Fs, path, r)
-}
-
-func WriteReader(fs Fs, path string, r io.Reader) (err error) {
-	dir, _ := filepath.Split(path)
-	ospath := filepath.FromSlash(dir)
-
-	if ospath != "" {
-		err = fs.MkdirAll(ospath, 0777) // rwx, rw, r
-		if err != nil {
-			if err != os.ErrExist {
-				log.Panicln(err)
-			}
-		}
-	}
-
-	file, err := fs.Create(path)
-	if err != nil {
-		return
-	}
-	defer file.Close()
-
-	_, err = io.Copy(file, r)
-	return
-}
-
-// Same as WriteReader but checks to see if file/directory already exists.
-func (a Afero) SafeWriteReader(path string, r io.Reader) (err error) {
-	return SafeWriteReader(a.Fs, path, r)
-}
-
-func SafeWriteReader(fs Fs, path string, r io.Reader) (err error) {
-	dir, _ := filepath.Split(path)
-	ospath := filepath.FromSlash(dir)
-
-	if ospath != "" {
-		err = fs.MkdirAll(ospath, 0777) // rwx, rw, r
-		if err != nil {
-			return
-		}
-	}
-
-	exists, err := Exists(fs, path)
-	if err != nil {
-		return
-	}
-	if exists {
-		return fmt.Errorf("%v already exists", path)
-	}
-
-	file, err := fs.Create(path)
-	if err != nil {
-		return
-	}
-	defer file.Close()
-
-	_, err = io.Copy(file, r)
-	return
-}
-
-func (a Afero) GetTempDir(subPath string) string {
-	return GetTempDir(a.Fs, subPath)
-}
-
-// GetTempDir returns the default temp directory with trailing slash
-// if subPath is not empty then it will be created recursively with mode 777 rwx rwx rwx
-func GetTempDir(fs Fs, subPath string) string {
-	addSlash := func(p string) string {
-		if FilePathSeparator != p[len(p)-1:] {
-			p = p + FilePathSeparator
-		}
-		return p
-	}
-	dir := addSlash(os.TempDir())
-
-	if subPath != "" {
-		// preserve windows backslash :-(
-		if FilePathSeparator == "\\" {
-			subPath = strings.Replace(subPath, "\\", "____", -1)
-		}
-		dir = dir + UnicodeSanitize((subPath))
-		if FilePathSeparator == "\\" {
-			dir = strings.Replace(dir, "____", "\\", -1)
-		}
-
-		if exists, _ := Exists(fs, dir); exists {
-			return addSlash(dir)
-		}
-
-		err := fs.MkdirAll(dir, 0777)
-		if err != nil {
-			panic(err)
-		}
-		dir = addSlash(dir)
-	}
-	return dir
-}
-
-// Rewrite string to remove non-standard path characters
-func UnicodeSanitize(s string) string {
-	source := []rune(s)
-	target := make([]rune, 0, len(source))
-
-	for _, r := range source {
-		if unicode.IsLetter(r) ||
-			unicode.IsDigit(r) ||
-			unicode.IsMark(r) ||
-			r == '.' ||
-			r == '/' ||
-			r == '\\' ||
-			r == '_' ||
-			r == '-' ||
-			r == '%' ||
-			r == ' ' ||
-			r == '#' {
-			target = append(target, r)
-		}
-	}
-
-	return string(target)
-}
-
-// Transform characters with accents into plan forms
-func NeuterAccents(s string) string {
-	t := transform.Chain(norm.NFD, transform.RemoveFunc(isMn), norm.NFC)
-	result, _, _ := transform.String(t, string(s))
-
-	return result
-}
-
-func isMn(r rune) bool {
-	return unicode.Is(unicode.Mn, r) // Mn: nonspacing marks
-}
-
-func (a Afero) FileContainsBytes(filename string, subslice []byte) (bool, error) {
-	return FileContainsBytes(a.Fs, filename, subslice)
-}
-
-// Check if a file contains a specified byte slice.
-func FileContainsBytes(fs Fs, filename string, subslice []byte) (bool, error) {
-	f, err := fs.Open(filename)
-	if err != nil {
-		return false, err
-	}
-	defer f.Close()
-
-	return readerContainsAny(f, subslice), nil
-}
-
-func (a Afero) FileContainsAnyBytes(filename string, subslices [][]byte) (bool, error) {
-	return FileContainsAnyBytes(a.Fs, filename, subslices)
-}
-
-// Check if a file contains any of the specified byte slices.
-func FileContainsAnyBytes(fs Fs, filename string, subslices [][]byte) (bool, error) {
-	f, err := fs.Open(filename)
-	if err != nil {
-		return false, err
-	}
-	defer f.Close()
-
-	return readerContainsAny(f, subslices...), nil
-}
-
-// readerContains reports whether any of the subslices is within r.
-func readerContainsAny(r io.Reader, subslices ...[]byte) bool {
-
-	if r == nil || len(subslices) == 0 {
-		return false
-	}
-
-	largestSlice := 0
-
-	for _, sl := range subslices {
-		if len(sl) > largestSlice {
-			largestSlice = len(sl)
-		}
-	}
-
-	if largestSlice == 0 {
-		return false
-	}
-
-	bufflen := largestSlice * 4
-	halflen := bufflen / 2
-	buff := make([]byte, bufflen)
-	var err error
-	var n, i int
-
-	for {
-		i++
-		if i == 1 {
-			n, err = io.ReadAtLeast(r, buff[:halflen], halflen)
-		} else {
-			if i != 2 {
-				// shift left to catch overlapping matches
-				copy(buff[:], buff[halflen:])
-			}
-			n, err = io.ReadAtLeast(r, buff[halflen:], halflen)
-		}
-
-		if n > 0 {
-			for _, sl := range subslices {
-				if bytes.Contains(buff, sl) {
-					return true
-				}
-			}
-		}
-
-		if err != nil {
-			break
-		}
-	}
-	return false
-}
-
-func (a Afero) DirExists(path string) (bool, error) {
-	return DirExists(a.Fs, path)
-}
-
-// DirExists checks if a path exists and is a directory.
-func DirExists(fs Fs, path string) (bool, error) {
-	fi, err := fs.Stat(path)
-	if err == nil && fi.IsDir() {
-		return true, nil
-	}
-	if os.IsNotExist(err) {
-		return false, nil
-	}
-	return false, err
-}
-
-func (a Afero) IsDir(path string) (bool, error) {
-	return IsDir(a.Fs, path)
-}
-
-// IsDir checks if a given path is a directory.
-func IsDir(fs Fs, path string) (bool, error) {
-	fi, err := fs.Stat(path)
-	if err != nil {
-		return false, err
-	}
-	return fi.IsDir(), nil
-}
-
-func (a Afero) IsEmpty(path string) (bool, error) {
-	return IsEmpty(a.Fs, path)
-}
-
-// IsEmpty checks if a given file or directory is empty.
-func IsEmpty(fs Fs, path string) (bool, error) {
-	if b, _ := Exists(fs, path); !b {
-		return false, fmt.Errorf("%q path does not exist", path)
-	}
-	fi, err := fs.Stat(path)
-	if err != nil {
-		return false, err
-	}
-	if fi.IsDir() {
-		f, err := fs.Open(path)
-		if err != nil {
-			return false, err
-		}
-		defer f.Close()
-		list, err := f.Readdir(-1)
-		return len(list) == 0, nil
-	}
-	return fi.Size() == 0, nil
-}
-
-func (a Afero) Exists(path string) (bool, error) {
-	return Exists(a.Fs, path)
-}
-
-// Check if a file or directory exists.
-func Exists(fs Fs, path string) (bool, error) {
-	_, err := fs.Stat(path)
-	if err == nil {
-		return true, nil
-	}
-	if os.IsNotExist(err) {
-		return false, nil
-	}
-	return false, err
-}
-
-func FullBaseFsPath(basePathFs *BasePathFs, relativePath string) string {
-	combinedPath := filepath.Join(basePathFs.path, relativePath)
-	if parent, ok := basePathFs.source.(*BasePathFs); ok {
-		return FullBaseFsPath(parent, combinedPath)
-	}
-
-	return combinedPath
-}

vendor/github.com/spf13/afero/util_test.go

@@ -1,450 +0,0 @@
-// Copyright ©2015 Steve Francia <spf@spf13.com>
-// Portions Copyright ©2015 The Hugo Authors
-//
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-package afero
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"testing"
-	"time"
-)
-
-var testFS = new(MemMapFs)
-
-func TestDirExists(t *testing.T) {
-	type test struct {
-		input    string
-		expected bool
-	}
-
-	// First create a couple directories so there is something in the filesystem
-	//testFS := new(MemMapFs)
-	testFS.MkdirAll("/foo/bar", 0777)
-
-	data := []test{
-		{".", true},
-		{"./", true},
-		{"..", true},
-		{"../", true},
-		{"./..", true},
-		{"./../", true},
-		{"/foo/", true},
-		{"/foo", true},
-		{"/foo/bar", true},
-		{"/foo/bar/", true},
-		{"/", true},
-		{"/some-really-random-directory-name", false},
-		{"/some/really/random/directory/name", false},
-		{"./some-really-random-local-directory-name", false},
-		{"./some/really/random/local/directory/name", false},
-	}
-
-	for i, d := range data {
-		exists, _ := DirExists(testFS, filepath.FromSlash(d.input))
-		if d.expected != exists {
-			t.Errorf("Test %d %q failed. Expected %t got %t", i, d.input, d.expected, exists)
-		}
-	}
-}
-
-func TestIsDir(t *testing.T) {
-	testFS = new(MemMapFs)
-
-	type test struct {
-		input    string
-		expected bool
-	}
-	data := []test{
-		{"./", true},
-		{"/", true},
-		{"./this-directory-does-not-existi", false},
-		{"/this-absolute-directory/does-not-exist", false},
-	}
-
-	for i, d := range data {
-
-		exists, _ := IsDir(testFS, d.input)
-		if d.expected != exists {
-			t.Errorf("Test %d failed. Expected %t got %t", i, d.expected, exists)
-		}
-	}
-}
-
-func TestIsEmpty(t *testing.T) {
-	testFS = new(MemMapFs)
-
-	zeroSizedFile, _ := createZeroSizedFileInTempDir()
-	defer deleteFileInTempDir(zeroSizedFile)
-	nonZeroSizedFile, _ := createNonZeroSizedFileInTempDir()
-	defer deleteFileInTempDir(nonZeroSizedFile)
-	emptyDirectory, _ := createEmptyTempDir()
-	defer deleteTempDir(emptyDirectory)
-	nonEmptyZeroLengthFilesDirectory, _ := createTempDirWithZeroLengthFiles()
-	defer deleteTempDir(nonEmptyZeroLengthFilesDirectory)
-	nonEmptyNonZeroLengthFilesDirectory, _ := createTempDirWithNonZeroLengthFiles()
-	defer deleteTempDir(nonEmptyNonZeroLengthFilesDirectory)
-	nonExistentFile := os.TempDir() + "/this-file-does-not-exist.txt"
-	nonExistentDir := os.TempDir() + "/this/direcotry/does/not/exist/"
-
-	fileDoesNotExist := fmt.Errorf("%q path does not exist", nonExistentFile)
-	dirDoesNotExist := fmt.Errorf("%q path does not exist", nonExistentDir)
-
-	type test struct {
-		input          string
-		expectedResult bool
-		expectedErr    error
-	}
-
-	data := []test{
-		{zeroSizedFile.Name(), true, nil},
-		{nonZeroSizedFile.Name(), false, nil},
-		{emptyDirectory, true, nil},
-		{nonEmptyZeroLengthFilesDirectory, false, nil},
-		{nonEmptyNonZeroLengthFilesDirectory, false, nil},
-		{nonExistentFile, false, fileDoesNotExist},
-		{nonExistentDir, false, dirDoesNotExist},
-	}
-	for i, d := range data {
-		exists, err := IsEmpty(testFS, d.input)
-		if d.expectedResult != exists {
-			t.Errorf("Test %d %q failed exists. Expected result %t got %t", i, d.input, d.expectedResult, exists)
-		}
-		if d.expectedErr != nil {
-			if d.expectedErr.Error() != err.Error() {
-				t.Errorf("Test %d failed with err. Expected %q(%#v) got %q(%#v)", i, d.expectedErr, d.expectedErr, err, err)
-			}
-		} else {
-			if d.expectedErr != err {
-				t.Errorf("Test %d failed. Expected error %q(%#v) got %q(%#v)", i, d.expectedErr, d.expectedErr, err, err)
-			}
-		}
-	}
-}
-
-func TestReaderContains(t *testing.T) {
-	for i, this := range []struct {
-		v1     string
-		v2     [][]byte
-		expect bool
-	}{
-		{"abc", [][]byte{[]byte("a")}, true},
-		{"abc", [][]byte{[]byte("b")}, true},
-		{"abcdefg", [][]byte{[]byte("efg")}, true},
-		{"abc", [][]byte{[]byte("d")}, false},
-		{"abc", [][]byte{[]byte("d"), []byte("e")}, false},
-		{"abc", [][]byte{[]byte("d"), []byte("a")}, true},
-		{"abc", [][]byte{[]byte("b"), []byte("e")}, true},
-		{"", nil, false},
-		{"", [][]byte{[]byte("a")}, false},
-		{"a", [][]byte{[]byte("")}, false},
-		{"", [][]byte{[]byte("")}, false}} {
-		result := readerContainsAny(strings.NewReader(this.v1), this.v2...)
-		if result != this.expect {
-			t.Errorf("[%d] readerContains: got %t but expected %t", i, result, this.expect)
-		}
-	}
-
-	if readerContainsAny(nil, []byte("a")) {
-		t.Error("readerContains with nil reader")
-	}
-
-	if readerContainsAny(nil, nil) {
-		t.Error("readerContains with nil arguments")
-	}
-}
-
-func createZeroSizedFileInTempDir() (File, error) {
-	filePrefix := "_path_test_"
-	f, e := TempFile(testFS, "", filePrefix) // dir is os.TempDir()
-	if e != nil {
-		// if there was an error no file was created.
-		// => no requirement to delete the file
-		return nil, e
-	}
-	return f, nil
-}
-
-func createNonZeroSizedFileInTempDir() (File, error) {
-	f, err := createZeroSizedFileInTempDir()
-	if err != nil {
-		// no file ??
-	}
-	byteString := []byte("byteString")
-	err = WriteFile(testFS, f.Name(), byteString, 0644)
-	if err != nil {
-		// delete the file
-		deleteFileInTempDir(f)
-		return nil, err
-	}
-	return f, nil
-}
-
-func deleteFileInTempDir(f File) {
-	err := testFS.Remove(f.Name())
-	if err != nil {
-		// now what?
-	}
-}
-
-func createEmptyTempDir() (string, error) {
-	dirPrefix := "_dir_prefix_"
-	d, e := TempDir(testFS, "", dirPrefix) // will be in os.TempDir()
-	if e != nil {
-		// no directory to delete - it was never created
-		return "", e
-	}
-	return d, nil
-}
-
-func createTempDirWithZeroLengthFiles() (string, error) {
-	d, dirErr := createEmptyTempDir()
-	if dirErr != nil {
-		//now what?
-	}
-	filePrefix := "_path_test_"
-	_, fileErr := TempFile(testFS, d, filePrefix) // dir is os.TempDir()
-	if fileErr != nil {
-		// if there was an error no file was created.
-		// but we need to remove the directory to clean-up
-		deleteTempDir(d)
-		return "", fileErr
-	}
-	// the dir now has one, zero length file in it
-	return d, nil
-
-}
-
-func createTempDirWithNonZeroLengthFiles() (string, error) {
-	d, dirErr := createEmptyTempDir()
-	if dirErr != nil {
-		//now what?
-	}
-	filePrefix := "_path_test_"
-	f, fileErr := TempFile(testFS, d, filePrefix) // dir is os.TempDir()
-	if fileErr != nil {
-		// if there was an error no file was created.
-		// but we need to remove the directory to clean-up
-		deleteTempDir(d)
-		return "", fileErr
-	}
-	byteString := []byte("byteString")
-	fileErr = WriteFile(testFS, f.Name(), byteString, 0644)
-	if fileErr != nil {
-		// delete the file
-		deleteFileInTempDir(f)
-		// also delete the directory
-		deleteTempDir(d)
-		return "", fileErr
-	}
-
-	// the dir now has one, zero length file in it
-	return d, nil
-
-}
-
-func TestExists(t *testing.T) {
-	zeroSizedFile, _ := createZeroSizedFileInTempDir()
-	defer deleteFileInTempDir(zeroSizedFile)
-	nonZeroSizedFile, _ := createNonZeroSizedFileInTempDir()
-	defer deleteFileInTempDir(nonZeroSizedFile)
-	emptyDirectory, _ := createEmptyTempDir()
-	defer deleteTempDir(emptyDirectory)
-	nonExistentFile := os.TempDir() + "/this-file-does-not-exist.txt"
-	nonExistentDir := os.TempDir() + "/this/direcotry/does/not/exist/"
-
-	type test struct {
-		input          string
-		expectedResult bool
-		expectedErr    error
-	}
-
-	data := []test{
-		{zeroSizedFile.Name(), true, nil},
-		{nonZeroSizedFile.Name(), true, nil},
-		{emptyDirectory, true, nil},
-		{nonExistentFile, false, nil},
-		{nonExistentDir, false, nil},
-	}
-	for i, d := range data {
-		exists, err := Exists(testFS, d.input)
-		if d.expectedResult != exists {
-			t.Errorf("Test %d failed. Expected result %t got %t", i, d.expectedResult, exists)
-		}
-		if d.expectedErr != err {
-			t.Errorf("Test %d failed. Expected %q got %q", i, d.expectedErr, err)
-		}
-	}
-
-}
-
-func TestSafeWriteToDisk(t *testing.T) {
-	emptyFile, _ := createZeroSizedFileInTempDir()
-	defer deleteFileInTempDir(emptyFile)
-	tmpDir, _ := createEmptyTempDir()
-	defer deleteTempDir(tmpDir)
-
-	randomString := "This is a random string!"
-	reader := strings.NewReader(randomString)
-
-	fileExists := fmt.Errorf("%v already exists", emptyFile.Name())
-
-	type test struct {
-		filename    string
-		expectedErr error
-	}
-
-	now := time.Now().Unix()
-	nowStr := strconv.FormatInt(now, 10)
-	data := []test{
-		{emptyFile.Name(), fileExists},
-		{tmpDir + "/" + nowStr, nil},
-	}
-
-	for i, d := range data {
-		e := SafeWriteReader(testFS, d.filename, reader)
-		if d.expectedErr != nil {
-			if d.expectedErr.Error() != e.Error() {
-				t.Errorf("Test %d failed. Expected error %q but got %q", i, d.expectedErr.Error(), e.Error())
-			}
-		} else {
-			if d.expectedErr != e {
-				t.Errorf("Test %d failed. Expected %q but got %q", i, d.expectedErr, e)
-			}
-			contents, _ := ReadFile(testFS, d.filename)
-			if randomString != string(contents) {
-				t.Errorf("Test %d failed. Expected contents %q but got %q", i, randomString, string(contents))
-			}
-		}
-		reader.Seek(0, 0)
-	}
-}
-
-func TestWriteToDisk(t *testing.T) {
-	emptyFile, _ := createZeroSizedFileInTempDir()
-	defer deleteFileInTempDir(emptyFile)
-	tmpDir, _ := createEmptyTempDir()
-	defer deleteTempDir(tmpDir)
-
-	randomString := "This is a random string!"
-	reader := strings.NewReader(randomString)
-
-	type test struct {
-		filename    string
-		expectedErr error
-	}
-
-	now := time.Now().Unix()
-	nowStr := strconv.FormatInt(now, 10)
-	data := []test{
-		{emptyFile.Name(), nil},
-		{tmpDir + "/" + nowStr, nil},
-	}
-
-	for i, d := range data {
-		e := WriteReader(testFS, d.filename, reader)
-		if d.expectedErr != e {
-			t.Errorf("Test %d failed. WriteToDisk Error Expected %q but got %q", i, d.expectedErr, e)
-		}
-		contents, e := ReadFile(testFS, d.filename)
-		if e != nil {
-			t.Errorf("Test %d failed. Could not read file %s. Reason: %s\n", i, d.filename, e)
-		}
-		if randomString != string(contents) {
-			t.Errorf("Test %d failed. Expected contents %q but got %q", i, randomString, string(contents))
-		}
-		reader.Seek(0, 0)
-	}
-}
-
-func TestGetTempDir(t *testing.T) {
-	dir := os.TempDir()
-	if FilePathSeparator != dir[len(dir)-1:] {
-		dir = dir + FilePathSeparator
-	}
-	testDir := "hugoTestFolder" + FilePathSeparator
-	tests := []struct {
-		input    string
-		expected string
-	}{
-		{"", dir},
-		{testDir + "  Foo bar  ", dir + testDir + "  Foo bar  " + FilePathSeparator},
-		{testDir + "Foo.Bar/foo_Bar-Foo", dir + testDir + "Foo.Bar/foo_Bar-Foo" + FilePathSeparator},
-		{testDir + "fOO,bar:foo%bAR", dir + testDir + "fOObarfoo%bAR" + FilePathSeparator},
-		{testDir + "FOo/BaR.html", dir + testDir + "FOo/BaR.html" + FilePathSeparator},
-		{testDir + "трям/трям", dir + testDir + "трям/трям" + FilePathSeparator},
-		{testDir + "은행", dir + testDir + "은행" + FilePathSeparator},
-		{testDir + "Банковский кассир", dir + testDir + "Банковский кассир" + FilePathSeparator},
-	}
-
-	for _, test := range tests {
-		output := GetTempDir(new(MemMapFs), test.input)
-		if output != test.expected {
-			t.Errorf("Expected %#v, got %#v\n", test.expected, output)
-		}
-	}
-}
-
-// This function is very dangerous. Don't use it.
-func deleteTempDir(d string) {
-	err := os.RemoveAll(d)
-	if err != nil {
-		// now what?
-	}
-}
-
-func TestFullBaseFsPath(t *testing.T) {
-	type dirSpec struct {
-		Dir1, Dir2, Dir3 string
-	}
-	dirSpecs := []dirSpec{
-		dirSpec{Dir1: "/", Dir2: "/", Dir3: "/"},
-		dirSpec{Dir1: "/", Dir2: "/path2", Dir3: "/"},
-		dirSpec{Dir1: "/path1/dir", Dir2: "/path2/dir/", Dir3: "/path3/dir"},
-		dirSpec{Dir1: "C:/path1", Dir2: "path2/dir", Dir3: "/path3/dir/"},
-	}
-
-	for _, ds := range dirSpecs {
-		memFs := NewMemMapFs()
-		level1Fs := NewBasePathFs(memFs, ds.Dir1)
-		level2Fs := NewBasePathFs(level1Fs, ds.Dir2)
-		level3Fs := NewBasePathFs(level2Fs, ds.Dir3)
-
-		type spec struct {
-			BaseFs       Fs
-			FileName     string
-			ExpectedPath string
-		}
-		specs := []spec{
-			spec{BaseFs: level3Fs, FileName: "f.txt", ExpectedPath: filepath.Join(ds.Dir1, ds.Dir2, ds.Dir3, "f.txt")},
-			spec{BaseFs: level3Fs, FileName: "", ExpectedPath: filepath.Join(ds.Dir1, ds.Dir2, ds.Dir3, "")},
-			spec{BaseFs: level2Fs, FileName: "f.txt", ExpectedPath: filepath.Join(ds.Dir1, ds.Dir2, "f.txt")},
-			spec{BaseFs: level2Fs, FileName: "", ExpectedPath: filepath.Join(ds.Dir1, ds.Dir2, "")},
-			spec{BaseFs: level1Fs, FileName: "f.txt", ExpectedPath: filepath.Join(ds.Dir1, "f.txt")},
-			spec{BaseFs: level1Fs, FileName: "", ExpectedPath: filepath.Join(ds.Dir1, "")},
-		}
-
-		for _, s := range specs {
-			if actualPath := FullBaseFsPath(s.BaseFs.(*BasePathFs), s.FileName); actualPath != s.ExpectedPath {
-				t.Errorf("Expected \n%s got \n%s", s.ExpectedPath, actualPath)
-			}
-		}
-	}
-}

vendor/github.com/spf13/cast/.gitignore

@@ -1,25 +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
-*.test
-
-*.bench

vendor/github.com/spf13/cast/.travis.yml

@@ -1,14 +0,0 @@
-language: go
-sudo: required
-go:
-  - 1.7.5
-  - 1.8
-  - tip
-os:
-  - linux
-matrix:
-  allow_failures:
-    - go: tip
-  fast_finish: true
-script:
-  - make check

vendor/github.com/spf13/cast/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Steve Francia
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

vendor/github.com/spf13/cast/Makefile

@@ -1,38 +0,0 @@
-# A Self-Documenting Makefile: http://marmelab.com/blog/2016/02/29/auto-documented-makefile.html
-
-.PHONY: check fmt lint test test-race vet test-cover-html help
-.DEFAULT_GOAL := help
-
-check: test-race fmt vet lint ## Run tests and linters
-
-test: ## Run tests
-	go test ./...
-
-test-race: ## Run tests with race detector
-	go test -race ./...
-
-fmt: ## Run gofmt linter
-	@for d in `go list` ; do \
-		if [ "`gofmt -l -s $$GOPATH/src/$$d | tee /dev/stderr`" ]; then \
-			echo "^ improperly formatted go files" && echo && exit 1; \
-		fi \
-	done
-
-lint: ## Run golint linter
-	@for d in `go list` ; do \
-		if [ "`golint $$d | tee /dev/stderr`" ]; then \
-			echo "^ golint errors!" && echo && exit 1; \
-		fi \
-	done
-
-vet: ## Run go vet linter
-	@if [ "`go vet | tee /dev/stderr`" ]; then \
-		echo "^ go vet errors!" && echo && exit 1; \
-	fi
-
-test-cover-html: ## Generate test coverage report
-	go test -coverprofile=coverage.out -covermode=count
-	go tool cover -func=coverage.out
-
-help:
-	@grep -E '^[a-zA-Z0-9_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'

vendor/github.com/spf13/cast/README.md

@@ -1,75 +0,0 @@
-cast
-====
-[![GoDoc](https://godoc.org/github.com/spf13/cast?status.svg)](https://godoc.org/github.com/spf13/cast)
-[![Build Status](https://api.travis-ci.org/spf13/cast.svg?branch=master)](https://travis-ci.org/spf13/cast)
-[![Go Report Card](https://goreportcard.com/badge/github.com/spf13/cast)](https://goreportcard.com/report/github.com/spf13/cast)
-
-Easy and safe casting from one type to another in Go
-
-Don’t Panic! ... Cast
-
-## What is Cast?
-
-Cast is a library to convert between different go types in a consistent and easy way.
-
-Cast provides simple functions to easily convert a number to a string, an
-interface into a bool, etc. Cast does this intelligently when an obvious
-conversion is possible. It doesn’t make any attempts to guess what you meant,
-for example you can only convert a string to an int when it is a string
-representation of an int such as “8”. Cast was developed for use in
-[Hugo](http://hugo.spf13.com), a website engine which uses YAML, TOML or JSON
-for meta data.
-
-## Why use Cast?
-
-When working with dynamic data in Go you often need to cast or convert the data
-from one type into another. Cast goes beyond just using type assertion (though
-it uses that when possible) to provide a very straightforward and convenient
-library.
-
-If you are working with interfaces to handle things like dynamic content
-you’ll need an easy way to convert an interface into a given type. This
-is the library for you.
-
-If you are taking in data from YAML, TOML or JSON or other formats which lack
-full types, then Cast is the library for you.
-
-## Usage
-
-Cast provides a handful of To_____ methods. These methods will always return
-the desired type. **If input is provided that will not convert to that type, the
-0 or nil value for that type will be returned**.
-
-Cast also provides identical methods To_____E. These return the same result as
-the To_____ methods, plus an additional error which tells you if it successfully
-converted. Using these methods you can tell the difference between when the
-input matched the zero value or when the conversion failed and the zero value
-was returned.
-
-The following examples are merely a sample of what is available. Please review
-the code for a complete set.
-
-### Example ‘ToString’:
-
-    cast.ToString("mayonegg")         // "mayonegg"
-    cast.ToString(8)                  // "8"
-    cast.ToString(8.31)               // "8.31"
-    cast.ToString([]byte("one time")) // "one time"
-    cast.ToString(nil)                // ""
-
-	var foo interface{} = "one more time"
-    cast.ToString(foo)                // "one more time"
-
-
-### Example ‘ToInt’:
-
-    cast.ToInt(8)                  // 8
-    cast.ToInt(8.31)               // 8
-    cast.ToInt("8")                // 8
-    cast.ToInt(true)               // 1
-    cast.ToInt(false)              // 0
-
-	var eight interface{} = 8
-    cast.ToInt(eight)              // 8
-    cast.ToInt(nil)                // 0
-

vendor/github.com/spf13/cast/cast.go

@@ -1,159 +0,0 @@
-// Copyright © 2014 Steve Francia <spf@spf13.com>.
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-
-// Package cast provides easy and safe casting in Go.
-package cast
-
-import "time"
-
-// ToBool casts an interface to a bool type.
-func ToBool(i interface{}) bool {
-	v, _ := ToBoolE(i)
-	return v
-}
-
-// ToTime casts an interface to a time.Time type.
-func ToTime(i interface{}) time.Time {
-	v, _ := ToTimeE(i)
-	return v
-}
-
-// ToDuration casts an interface to a time.Duration type.
-func ToDuration(i interface{}) time.Duration {
-	v, _ := ToDurationE(i)
-	return v
-}
-
-// ToFloat64 casts an interface to a float64 type.
-func ToFloat64(i interface{}) float64 {
-	v, _ := ToFloat64E(i)
-	return v
-}
-
-// ToFloat32 casts an interface to a float32 type.
-func ToFloat32(i interface{}) float32 {
-	v, _ := ToFloat32E(i)
-	return v
-}
-
-// ToInt64 casts an interface to an int64 type.
-func ToInt64(i interface{}) int64 {
-	v, _ := ToInt64E(i)
-	return v
-}
-
-// ToInt32 casts an interface to an int32 type.
-func ToInt32(i interface{}) int32 {
-	v, _ := ToInt32E(i)
-	return v
-}
-
-// ToInt16 casts an interface to an int16 type.
-func ToInt16(i interface{}) int16 {
-	v, _ := ToInt16E(i)
-	return v
-}
-
-// ToInt8 casts an interface to an int8 type.
-func ToInt8(i interface{}) int8 {
-	v, _ := ToInt8E(i)
-	return v
-}
-
-// ToInt casts an interface to an int type.
-func ToInt(i interface{}) int {
-	v, _ := ToIntE(i)
-	return v
-}
-
-// ToUint casts an interface to a uint type.
-func ToUint(i interface{}) uint {
-	v, _ := ToUintE(i)
-	return v
-}
-
-// ToUint64 casts an interface to a uint64 type.
-func ToUint64(i interface{}) uint64 {
-	v, _ := ToUint64E(i)
-	return v
-}
-
-// ToUint32 casts an interface to a uint32 type.
-func ToUint32(i interface{}) uint32 {
-	v, _ := ToUint32E(i)
-	return v
-}
-
-// ToUint16 casts an interface to a uint16 type.
-func ToUint16(i interface{}) uint16 {
-	v, _ := ToUint16E(i)
-	return v
-}
-
-// ToUint8 casts an interface to a uint8 type.
-func ToUint8(i interface{}) uint8 {
-	v, _ := ToUint8E(i)
-	return v
-}
-
-// ToString casts an interface to a string type.
-func ToString(i interface{}) string {
-	v, _ := ToStringE(i)
-	return v
-}
-
-// ToStringMapString casts an interface to a map[string]string type.
-func ToStringMapString(i interface{}) map[string]string {
-	v, _ := ToStringMapStringE(i)
-	return v
-}
-
-// ToStringMapStringSlice casts an interface to a map[string][]string type.
-func ToStringMapStringSlice(i interface{}) map[string][]string {
-	v, _ := ToStringMapStringSliceE(i)
-	return v
-}
-
-// ToStringMapBool casts an interface to a map[string]bool type.
-func ToStringMapBool(i interface{}) map[string]bool {
-	v, _ := ToStringMapBoolE(i)
-	return v
-}
-
-// ToStringMap casts an interface to a map[string]interface{} type.
-func ToStringMap(i interface{}) map[string]interface{} {
-	v, _ := ToStringMapE(i)
-	return v
-}
-
-// ToSlice casts an interface to a []interface{} type.
-func ToSlice(i interface{}) []interface{} {
-	v, _ := ToSliceE(i)
-	return v
-}
-
-// ToBoolSlice casts an interface to a []bool type.
-func ToBoolSlice(i interface{}) []bool {
-	v, _ := ToBoolSliceE(i)
-	return v
-}
-
-// ToStringSlice casts an interface to a []string type.
-func ToStringSlice(i interface{}) []string {
-	v, _ := ToStringSliceE(i)
-	return v
-}
-
-// ToIntSlice casts an interface to a []int type.
-func ToIntSlice(i interface{}) []int {
-	v, _ := ToIntSliceE(i)
-	return v
-}
-
-// ToDurationSlice casts an interface to a []time.Duration type.
-func ToDurationSlice(i interface{}) []time.Duration {
-	v, _ := ToDurationSliceE(i)
-	return v
-}

vendor/github.com/spf13/jwalterweatherman/.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

vendor/github.com/spf13/jwalterweatherman/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Steve Francia
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

vendor/github.com/spf13/jwalterweatherman/README.md

@@ -1,148 +0,0 @@
-jWalterWeatherman
-=================
-
-Seamless printing to the terminal (stdout) and logging to a io.Writer
-(file) that’s as easy to use as fmt.Println.
-
-![and_that__s_why_you_always_leave_a_note_by_jonnyetc-d57q7um](https://cloud.githubusercontent.com/assets/173412/11002937/ccd01654-847d-11e5-828e-12ebaf582eaf.jpg)
-Graphic by [JonnyEtc](http://jonnyetc.deviantart.com/art/And-That-s-Why-You-Always-Leave-a-Note-315311422)
-
-JWW is primarily a wrapper around the excellent standard log library. It
-provides a few advantages over using the standard log library alone.
-
-1. Ready to go out of the box. 
-2. One library for both printing to the terminal and logging (to files).
-3. Really easy to log to either a temp file or a file you specify.
-
-
-I really wanted a very straightforward library that could seamlessly do
-the following things.
-
-1. Replace all the println, printf, etc statements thought my code with
-   something more useful
-2. Allow the user to easily control what levels are printed to stdout
-3. Allow the user to easily control what levels are logged
-4. Provide an easy mechanism (like fmt.Println) to print info to the user
-   which can be easily logged as well 
-5. Due to 2 & 3 provide easy verbose mode for output and logs
-6. Not have any unnecessary initialization cruft. Just use it.
-
-# Usage
-
-## Step 1. Use it
-Put calls throughout your source based on type of feedback.
-No initialization or setup needs to happen. Just start calling things.
-
-Available Loggers are:
-
- * TRACE
- * DEBUG
- * INFO
- * WARN
- * ERROR
- * CRITICAL
- * FATAL
-
-These each are loggers based on the log standard library and follow the
-standard usage. Eg.
-
-```go
-    import (
-        jww "github.com/spf13/jwalterweatherman"
-    )
-
-    ...
-
-    if err != nil {
-
-        // This is a pretty serious error and the user should know about
-        // it. It will be printed to the terminal as well as logged under the
-        // default thresholds.
-
-        jww.ERROR.Println(err)
-    }
-
-    if err2 != nil {
-        // This error isn’t going to materially change the behavior of the
-        // application, but it’s something that may not be what the user
-        // expects. Under the default thresholds, Warn will be logged, but
-        // not printed to the terminal. 
-
-        jww.WARN.Println(err2)
-    }
-
-    // Information that’s relevant to what’s happening, but not very
-    // important for the user. Under the default thresholds this will be
-    // discarded.
-
-    jww.INFO.Printf("information %q", response)
-
-```
-
-NOTE: You can also use the library in a non-global setting by creating an instance of a Notebook:
-
-```go
-notepad = jww.NewNotepad(jww.LevelInfo, jww.LevelTrace, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
-notepad.WARN.Println("Some warning"")
-```
-
-_Why 7 levels?_
-
-Maybe you think that 7 levels are too much for any application... and you
-are probably correct. Just because there are seven levels doesn’t mean
-that you should be using all 7 levels. Pick the right set for your needs.
-Remember they only have to mean something to your project.
-
-## Step 2. Optionally configure JWW
-
-Under the default thresholds :
-
- * Debug, Trace & Info goto /dev/null
- * Warn and above is logged (when a log file/io.Writer is provided)
- * Error and above is printed to the terminal (stdout)
-
-### Changing the thresholds
-
-The threshold can be changed at any time, but will only affect calls that
-execute after the change was made.
-
-This is very useful if your application has a verbose mode. Of course you
-can decide what verbose means to you or even have multiple levels of
-verbosity.
-
-
-```go
-    import (
-        jww "github.com/spf13/jwalterweatherman"
-    )
-
-    if Verbose {
-        jww.SetLogThreshold(jww.LevelTrace)
-        jww.SetStdoutThreshold(jww.LevelInfo)
-    }
-```
-
-Note that JWW's own internal output uses log levels as well, so set the log
-level before making any other calls if you want to see what it's up to.
-
-
-### Setting a log file
-
-JWW can log to any `io.Writer`:
-
-
-```go
-
-    jww.SetLogOutput(customWriter) 
-
-```
-
-
-# More information
-
-This is an early release. I’ve been using it for a while and this is the
-third interface I’ve tried. I like this one pretty well, but no guarantees
-that it won’t change a bit.
-
-I wrote this for use in [hugo](http://hugo.spf13.com). If you are looking
-for a static website engine that’s super fast please checkout Hugo.

vendor/github.com/spf13/jwalterweatherman/default_notepad.go

@@ -1,113 +0,0 @@
-// Copyright © 2016 Steve Francia <spf@spf13.com>.
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-
-package jwalterweatherman
-
-import (
-	"io"
-	"io/ioutil"
-	"log"
-	"os"
-)
-
-var (
-	TRACE    *log.Logger
-	DEBUG    *log.Logger
-	INFO     *log.Logger
-	WARN     *log.Logger
-	ERROR    *log.Logger
-	CRITICAL *log.Logger
-	FATAL    *log.Logger
-
-	LOG      *log.Logger
-	FEEDBACK *Feedback
-
-	defaultNotepad *Notepad
-)
-
-func reloadDefaultNotepad() {
-	TRACE = defaultNotepad.TRACE
-	DEBUG = defaultNotepad.DEBUG
-	INFO = defaultNotepad.INFO
-	WARN = defaultNotepad.WARN
-	ERROR = defaultNotepad.ERROR
-	CRITICAL = defaultNotepad.CRITICAL
-	FATAL = defaultNotepad.FATAL
-
-	LOG = defaultNotepad.LOG
-	FEEDBACK = defaultNotepad.FEEDBACK
-}
-
-func init() {
-	defaultNotepad = NewNotepad(LevelError, LevelWarn, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
-	reloadDefaultNotepad()
-}
-
-// SetLogThreshold set the log threshold for the default notepad. Trace by default.
-func SetLogThreshold(threshold Threshold) {
-	defaultNotepad.SetLogThreshold(threshold)
-	reloadDefaultNotepad()
-}
-
-// SetLogOutput set the log output for the default notepad. Discarded by default.
-func SetLogOutput(handle io.Writer) {
-	defaultNotepad.SetLogOutput(handle)
-	reloadDefaultNotepad()
-}
-
-// SetStdoutThreshold set the standard output threshold for the default notepad.
-// Info by default.
-func SetStdoutThreshold(threshold Threshold) {
-	defaultNotepad.SetStdoutThreshold(threshold)
-	reloadDefaultNotepad()
-}
-
-// SetPrefix set the prefix for the default logger. Empty by default.
-func SetPrefix(prefix string) {
-	defaultNotepad.SetPrefix(prefix)
-	reloadDefaultNotepad()
-}
-
-// SetFlags set the flags for the default logger. "log.Ldate | log.Ltime" by default.
-func SetFlags(flags int) {
-	defaultNotepad.SetFlags(flags)
-	reloadDefaultNotepad()
-}
-
-// Level returns the current global log threshold.
-func LogThreshold() Threshold {
-	return defaultNotepad.logThreshold
-}
-
-// Level returns the current global output threshold.
-func StdoutThreshold() Threshold {
-	return defaultNotepad.stdoutThreshold
-}
-
-// GetStdoutThreshold returns the defined Treshold for the log logger.
-func GetLogThreshold() Threshold {
-	return defaultNotepad.GetLogThreshold()
-}
-
-// GetStdoutThreshold returns the Treshold for the stdout logger.
-func GetStdoutThreshold() Threshold {
-	return defaultNotepad.GetStdoutThreshold()
-}
-
-// LogCountForLevel returns the number of log invocations for a given threshold.
-func LogCountForLevel(l Threshold) uint64 {
-	return defaultNotepad.LogCountForLevel(l)
-}
-
-// LogCountForLevelsGreaterThanorEqualTo returns the number of log invocations
-// greater than or equal to a given threshold.
-func LogCountForLevelsGreaterThanorEqualTo(threshold Threshold) uint64 {
-	return defaultNotepad.LogCountForLevelsGreaterThanorEqualTo(threshold)
-}
-
-// ResetLogCounters resets the invocation counters for all levels.
-func ResetLogCounters() {
-	defaultNotepad.ResetLogCounters()
-}

vendor/github.com/spf13/jwalterweatherman/default_notepad_test.go

@@ -1,102 +0,0 @@
-// Copyright © 2016 Steve Francia <spf@spf13.com>.
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-
-package jwalterweatherman
-
-import (
-	"bytes"
-	"io/ioutil"
-	"sync"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestThresholds(t *testing.T) {
-	SetStdoutThreshold(LevelError)
-	require.Equal(t, StdoutThreshold(), LevelError)
-	SetLogThreshold(LevelCritical)
-	require.Equal(t, LogThreshold(), LevelCritical)
-	require.NotEqual(t, StdoutThreshold(), LevelCritical)
-	SetStdoutThreshold(LevelWarn)
-	require.Equal(t, StdoutThreshold(), LevelWarn)
-}
-
-func TestDefaultLogging(t *testing.T) {
-	var outputBuf, logBuf bytes.Buffer
-
-	defaultNotepad.logHandle = &logBuf
-	defaultNotepad.outHandle = &outputBuf
-
-	SetLogThreshold(LevelWarn)
-	SetStdoutThreshold(LevelError)
-
-	FATAL.Println("fatal err")
-	CRITICAL.Println("critical err")
-	ERROR.Println("an error")
-	WARN.Println("a warning")
-	INFO.Println("information")
-	DEBUG.Println("debugging info")
-	TRACE.Println("trace")
-
-	require.Contains(t, logBuf.String(), "fatal err")
-	require.Contains(t, logBuf.String(), "critical err")
-	require.Contains(t, logBuf.String(), "an error")
-	require.Contains(t, logBuf.String(), "a warning")
-	require.NotContains(t, logBuf.String(), "information")
-	require.NotContains(t, logBuf.String(), "debugging info")
-	require.NotContains(t, logBuf.String(), "trace")
-
-	require.Contains(t, outputBuf.String(), "fatal err")
-	require.Contains(t, outputBuf.String(), "critical err")
-	require.Contains(t, outputBuf.String(), "an error")
-	require.NotContains(t, outputBuf.String(), "a warning")
-	require.NotContains(t, outputBuf.String(), "information")
-	require.NotContains(t, outputBuf.String(), "debugging info")
-	require.NotContains(t, outputBuf.String(), "trace")
-}
-
-func TestLogCounter(t *testing.T) {
-	defaultNotepad.logHandle = ioutil.Discard
-	defaultNotepad.outHandle = ioutil.Discard
-
-	SetLogThreshold(LevelTrace)
-	SetStdoutThreshold(LevelTrace)
-
-	FATAL.Println("fatal err")
-	CRITICAL.Println("critical err")
-	WARN.Println("a warning")
-	WARN.Println("another warning")
-	INFO.Println("information")
-	DEBUG.Println("debugging info")
-	TRACE.Println("trace")
-
-	wg := &sync.WaitGroup{}
-
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			for j := 0; j < 10; j++ {
-				ERROR.Println("error", j)
-				// check for data races
-				require.True(t, LogCountForLevel(LevelError) > uint64(j))
-				require.True(t, LogCountForLevelsGreaterThanorEqualTo(LevelError) > uint64(j))
-			}
-		}()
-
-	}
-
-	wg.Wait()
-
-	require.Equal(t, uint64(1), LogCountForLevel(LevelFatal))
-	require.Equal(t, uint64(1), LogCountForLevel(LevelCritical))
-	require.Equal(t, uint64(2), LogCountForLevel(LevelWarn))
-	require.Equal(t, uint64(1), LogCountForLevel(LevelInfo))
-	require.Equal(t, uint64(1), LogCountForLevel(LevelDebug))
-	require.Equal(t, uint64(1), LogCountForLevel(LevelTrace))
-	require.Equal(t, uint64(100), LogCountForLevel(LevelError))
-	require.Equal(t, uint64(102), LogCountForLevelsGreaterThanorEqualTo(LevelError))
-}

vendor/github.com/spf13/jwalterweatherman/log_counter.go

@@ -1,55 +0,0 @@
-// Copyright © 2016 Steve Francia <spf@spf13.com>.
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-
-package jwalterweatherman
-
-import (
-	"sync/atomic"
-)
-
-type logCounter struct {
-	counter uint64
-}
-
-func (c *logCounter) incr() {
-	atomic.AddUint64(&c.counter, 1)
-}
-
-func (c *logCounter) resetCounter() {
-	atomic.StoreUint64(&c.counter, 0)
-}
-
-func (c *logCounter) getCount() uint64 {
-	return atomic.LoadUint64(&c.counter)
-}
-
-func (c *logCounter) Write(p []byte) (n int, err error) {
-	c.incr()
-	return len(p), nil
-}
-
-// LogCountForLevel returns the number of log invocations for a given threshold.
-func (n *Notepad) LogCountForLevel(l Threshold) uint64 {
-	return n.logCounters[l].getCount()
-}
-
-// LogCountForLevelsGreaterThanorEqualTo returns the number of log invocations
-// greater than or equal to a given threshold.
-func (n *Notepad) LogCountForLevelsGreaterThanorEqualTo(threshold Threshold) uint64 {
-	var cnt uint64
-
-	for i := int(threshold); i < len(n.logCounters); i++ {
-		cnt += n.LogCountForLevel(Threshold(i))
-	}
-
-	return cnt
-}
-
-// ResetLogCounters resets the invocation counters for all levels.
-func (n *Notepad) ResetLogCounters() {
-	for _, np := range n.logCounters {
-		np.resetCounter()
-	}
-}

vendor/github.com/spf13/jwalterweatherman/notepad.go

@@ -1,194 +0,0 @@
-// Copyright © 2016 Steve Francia <spf@spf13.com>.
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-
-package jwalterweatherman
-
-import (
-	"fmt"
-	"io"
-	"log"
-)
-
-type Threshold int
-
-func (t Threshold) String() string {
-	return prefixes[t]
-}
-
-const (
-	LevelTrace Threshold = iota
-	LevelDebug
-	LevelInfo
-	LevelWarn
-	LevelError
-	LevelCritical
-	LevelFatal
-)
-
-var prefixes map[Threshold]string = map[Threshold]string{
-	LevelTrace:    "TRACE",
-	LevelDebug:    "DEBUG",
-	LevelInfo:     "INFO",
-	LevelWarn:     "WARN",
-	LevelError:    "ERROR",
-	LevelCritical: "CRITICAL",
-	LevelFatal:    "FATAL",
-}
-
-// Notepad is where you leave a note!
-type Notepad struct {
-	TRACE    *log.Logger
-	DEBUG    *log.Logger
-	INFO     *log.Logger
-	WARN     *log.Logger
-	ERROR    *log.Logger
-	CRITICAL *log.Logger
-	FATAL    *log.Logger
-
-	LOG      *log.Logger
-	FEEDBACK *Feedback
-
-	loggers         [7]**log.Logger
-	logHandle       io.Writer
-	outHandle       io.Writer
-	logThreshold    Threshold
-	stdoutThreshold Threshold
-	prefix          string
-	flags           int
-
-	// One per Threshold
-	logCounters [7]*logCounter
-}
-
-// NewNotepad create a new notepad.
-func NewNotepad(outThreshold Threshold, logThreshold Threshold, outHandle, logHandle io.Writer, prefix string, flags int) *Notepad {
-	n := &Notepad{}
-
-	n.loggers = [7]**log.Logger{&n.TRACE, &n.DEBUG, &n.INFO, &n.WARN, &n.ERROR, &n.CRITICAL, &n.FATAL}
-	n.outHandle = outHandle
-	n.logHandle = logHandle
-	n.stdoutThreshold = outThreshold
-	n.logThreshold = logThreshold
-
-	if len(prefix) != 0 {
-		n.prefix = "[" + prefix + "] "
-	} else {
-		n.prefix = ""
-	}
-
-	n.flags = flags
-
-	n.LOG = log.New(n.logHandle,
-		"LOG:   ",
-		n.flags)
-	n.FEEDBACK = &Feedback{out: log.New(outHandle, "", 0), log: n.LOG}
-
-	n.init()
-	return n
-}
-
-// init creates the loggers for each level depending on the notepad thresholds.
-func (n *Notepad) init() {
-	logAndOut := io.MultiWriter(n.outHandle, n.logHandle)
-
-	for t, logger := range n.loggers {
-		threshold := Threshold(t)
-		counter := &logCounter{}
-		n.logCounters[t] = counter
-		prefix := n.prefix + threshold.String() + " "
-
-		switch {
-		case threshold >= n.logThreshold && threshold >= n.stdoutThreshold:
-			*logger = log.New(io.MultiWriter(counter, logAndOut), prefix, n.flags)
-
-		case threshold >= n.logThreshold:
-			*logger = log.New(io.MultiWriter(counter, n.logHandle), prefix, n.flags)
-
-		case threshold >= n.stdoutThreshold:
-			*logger = log.New(io.MultiWriter(counter, n.outHandle), prefix, n.flags)
-
-		default:
-			// counter doesn't care about prefix and flags, so don't use them
-			// for performance.
-			*logger = log.New(counter, "", 0)
-		}
-	}
-}
-
-// SetLogThreshold changes the threshold above which messages are written to the
-// log file.
-func (n *Notepad) SetLogThreshold(threshold Threshold) {
-	n.logThreshold = threshold
-	n.init()
-}
-
-// SetLogOutput changes the file where log messages are written.
-func (n *Notepad) SetLogOutput(handle io.Writer) {
-	n.logHandle = handle
-	n.init()
-}
-
-// GetStdoutThreshold returns the defined Treshold for the log logger.
-func (n *Notepad) GetLogThreshold() Threshold {
-	return n.logThreshold
-}
-
-// SetStdoutThreshold changes the threshold above which messages are written to the
-// standard output.
-func (n *Notepad) SetStdoutThreshold(threshold Threshold) {
-	n.stdoutThreshold = threshold
-	n.init()
-}
-
-// GetStdoutThreshold returns the Treshold for the stdout logger.
-func (n *Notepad) GetStdoutThreshold() Threshold {
-	return n.stdoutThreshold
-}
-
-// SetPrefix changes the prefix used by the notepad. Prefixes are displayed between
-// brackets at the beginning of the line. An empty prefix won't be displayed at all.
-func (n *Notepad) SetPrefix(prefix string) {
-	if len(prefix) != 0 {
-		n.prefix = "[" + prefix + "] "
-	} else {
-		n.prefix = ""
-	}
-	n.init()
-}
-
-// SetFlags choose which flags the logger will display (after prefix and message
-// level). See the package log for more informations on this.
-func (n *Notepad) SetFlags(flags int) {
-	n.flags = flags
-	n.init()
-}
-
-// Feedback writes plainly to the outHandle while
-// logging with the standard extra information (date, file, etc).
-type Feedback struct {
-	out *log.Logger
-	log *log.Logger
-}
-
-func (fb *Feedback) Println(v ...interface{}) {
-	fb.output(fmt.Sprintln(v...))
-}
-
-func (fb *Feedback) Printf(format string, v ...interface{}) {
-	fb.output(fmt.Sprintf(format, v...))
-}
-
-func (fb *Feedback) Print(v ...interface{}) {
-	fb.output(fmt.Sprint(v...))
-}
-
-func (fb *Feedback) output(s string) {
-	if fb.out != nil {
-		fb.out.Output(2, s)
-	}
-	if fb.log != nil {
-		fb.log.Output(2, s)
-	}
-}

vendor/github.com/spf13/jwalterweatherman/notepad_test.go

@@ -1,50 +0,0 @@
-// Copyright © 2016 Steve Francia <spf@spf13.com>.
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-
-package jwalterweatherman
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestNotepad(t *testing.T) {
-	var logHandle, outHandle bytes.Buffer
-
-	n := NewNotepad(LevelCritical, LevelError, &outHandle, &logHandle, "TestNotePad", 0)
-
-	require.Equal(t, LevelCritical, n.GetStdoutThreshold())
-	require.Equal(t, LevelError, n.GetLogThreshold())
-
-	n.DEBUG.Println("Some debug")
-	n.ERROR.Println("Some error")
-	n.CRITICAL.Println("Some critical error")
-
-	require.Contains(t, logHandle.String(), "[TestNotePad] ERROR Some error")
-	require.NotContains(t, logHandle.String(), "Some debug")
-	require.NotContains(t, outHandle.String(), "Some error")
-	require.Contains(t, outHandle.String(), "Some critical error")
-
-	require.Equal(t, n.LogCountForLevel(LevelError), uint64(1))
-	require.Equal(t, n.LogCountForLevel(LevelDebug), uint64(1))
-	require.Equal(t, n.LogCountForLevel(LevelTrace), uint64(0))
-}
-
-func TestThresholdString(t *testing.T) {
-	require.Equal(t, LevelError.String(), "ERROR")
-	require.Equal(t, LevelTrace.String(), "TRACE")
-}
-
-func BenchmarkLogPrintOnlyToCounter(b *testing.B) {
-	var logHandle, outHandle bytes.Buffer
-	n := NewNotepad(LevelCritical, LevelCritical, &outHandle, &logHandle, "TestNotePad", 0)
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		n.INFO.Print("Test")
-	}
-}

vendor/github.com/spf13/pflag/.gitignore

@@ -1,2 +0,0 @@
-.idea/*
-

vendor/github.com/spf13/pflag/.travis.yml

@@ -1,21 +0,0 @@
-sudo: false
-
-language: go
-
-go:
-  - 1.7.3
-  - 1.8.1
-  - tip
-
-matrix:
-  allow_failures:
-    - go: tip
-
-install:
-  - go get github.com/golang/lint/golint
-  - export PATH=$GOPATH/bin:$PATH
-  - go install ./...
-
-script:
-  - verify/all.sh -v
-  - go test ./...

vendor/github.com/spf13/pflag/LICENSE

@@ -1,28 +0,0 @@
-Copyright (c) 2012 Alex Ogier. All rights reserved.
-Copyright (c) 2012 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/spf13/pflag/README.md

@@ -1,296 +0,0 @@
-[![Build Status](https://travis-ci.org/spf13/pflag.svg?branch=master)](https://travis-ci.org/spf13/pflag)
-[![Go Report Card](https://goreportcard.com/badge/github.com/spf13/pflag)](https://goreportcard.com/report/github.com/spf13/pflag)
-[![GoDoc](https://godoc.org/github.com/spf13/pflag?status.svg)](https://godoc.org/github.com/spf13/pflag)
-
-## Description
-
-pflag is a drop-in replacement for Go's flag package, implementing
-POSIX/GNU-style --flags.
-
-pflag is compatible with the [GNU extensions to the POSIX recommendations
-for command-line options][1]. For a more precise description, see the
-"Command-line flag syntax" section below.
-
-[1]: http://www.gnu.org/software/libc/manual/html_node/Argument-Syntax.html
-
-pflag is available under the same style of BSD license as the Go language,
-which can be found in the LICENSE file.
-
-## Installation
-
-pflag is available using the standard `go get` command.
-
-Install by running:
-
-    go get github.com/spf13/pflag
-
-Run tests by running:
-
-    go test github.com/spf13/pflag
-
-## Usage
-
-pflag is a drop-in replacement of Go's native flag package. If you import
-pflag under the name "flag" then all code should continue to function
-with no changes.
-
-``` go
-import flag "github.com/spf13/pflag"
-```
-
-There is one exception to this: if you directly instantiate the Flag struct
-there is one more field "Shorthand" that you will need to set.
-Most code never instantiates this struct directly, and instead uses
-functions such as String(), BoolVar(), and Var(), and is therefore
-unaffected.
-
-Define flags using flag.String(), Bool(), Int(), etc.
-
-This declares an integer flag, -flagname, stored in the pointer ip, with type *int.
-
-``` go
-var ip *int = flag.Int("flagname", 1234, "help message for flagname")
-```
-
-If you like, you can bind the flag to a variable using the Var() functions.
-
-``` go
-var flagvar int
-func init() {
-    flag.IntVar(&flagvar, "flagname", 1234, "help message for flagname")
-}
-```
-
-Or you can create custom flags that satisfy the Value interface (with
-pointer receivers) and couple them to flag parsing by
-
-``` go
-flag.Var(&flagVal, "name", "help message for flagname")
-```
-
-For such flags, the default value is just the initial value of the variable.
-
-After all flags are defined, call
-
-``` go
-flag.Parse()
-```
-
-to parse the command line into the defined flags.
-
-Flags may then be used directly. If you're using the flags themselves,
-they are all pointers; if you bind to variables, they're values.
-
-``` go
-fmt.Println("ip has value ", *ip)
-fmt.Println("flagvar has value ", flagvar)
-```
-
-There are helpers function to get values later if you have the FlagSet but
-it was difficult to keep up with all of the flag pointers in your code.
-If you have a pflag.FlagSet with a flag called 'flagname' of type int you
-can use GetInt() to get the int value. But notice that 'flagname' must exist
-and it must be an int. GetString("flagname") will fail.
-
-``` go
-i, err := flagset.GetInt("flagname")
-```
-
-After parsing, the arguments after the flag are available as the
-slice flag.Args() or individually as flag.Arg(i).
-The arguments are indexed from 0 through flag.NArg()-1.
-
-The pflag package also defines some new functions that are not in flag,
-that give one-letter shorthands for flags. You can use these by appending
-'P' to the name of any function that defines a flag.
-
-``` go
-var ip = flag.IntP("flagname", "f", 1234, "help message")
-var flagvar bool
-func init() {
-	flag.BoolVarP(&flagvar, "boolname", "b", true, "help message")
-}
-flag.VarP(&flagVal, "varname", "v", "help message")
-```
-
-Shorthand letters can be used with single dashes on the command line.
-Boolean shorthand flags can be combined with other shorthand flags.
-
-The default set of command-line flags is controlled by
-top-level functions.  The FlagSet type allows one to define
-independent sets of flags, such as to implement subcommands
-in a command-line interface. The methods of FlagSet are
-analogous to the top-level functions for the command-line
-flag set.
-
-## Setting no option default values for flags
-
-After you create a flag it is possible to set the pflag.NoOptDefVal for
-the given flag. Doing this changes the meaning of the flag slightly. If
-a flag has a NoOptDefVal and the flag is set on the command line without
-an option the flag will be set to the NoOptDefVal. For example given:
-
-``` go
-var ip = flag.IntP("flagname", "f", 1234, "help message")
-flag.Lookup("flagname").NoOptDefVal = "4321"
-```
-
-Would result in something like
-
-| Parsed Arguments | Resulting Value |
-| -------------    | -------------   |
-| --flagname=1357  | ip=1357         |
-| --flagname       | ip=4321         |
-| [nothing]        | ip=1234         |
-
-## Command line flag syntax
-
-```
---flag    // boolean flags, or flags with no option default values
---flag x  // only on flags without a default value
---flag=x
-```
-
-Unlike the flag package, a single dash before an option means something
-different than a double dash. Single dashes signify a series of shorthand
-letters for flags. All but the last shorthand letter must be boolean flags
-or a flag with a default value
-
-```
-// boolean or flags where the 'no option default value' is set
--f
--f=true
--abc
-but
--b true is INVALID
-
-// non-boolean and flags without a 'no option default value'
--n 1234
--n=1234
--n1234
-
-// mixed
--abcs "hello"
--absd="hello"
--abcs1234
-```
-
-Flag parsing stops after the terminator "--". Unlike the flag package,
-flags can be interspersed with arguments anywhere on the command line
-before this terminator.
-
-Integer flags accept 1234, 0664, 0x1234 and may be negative.
-Boolean flags (in their long form) accept 1, 0, t, f, true, false,
-TRUE, FALSE, True, False.
-Duration flags accept any input valid for time.ParseDuration.
-
-## Mutating or "Normalizing" Flag names
-
-It is possible to set a custom flag name 'normalization function.' It allows flag names to be mutated both when created in the code and when used on the command line to some 'normalized' form. The 'normalized' form is used for comparison. Two examples of using the custom normalization func follow.
-
-**Example #1**: You want -, _, and . in flags to compare the same. aka --my-flag == --my_flag == --my.flag
-
-``` go
-func wordSepNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName {
-	from := []string{"-", "_"}
-	to := "."
-	for _, sep := range from {
-		name = strings.Replace(name, sep, to, -1)
-	}
-	return pflag.NormalizedName(name)
-}
-
-myFlagSet.SetNormalizeFunc(wordSepNormalizeFunc)
-```
-
-**Example #2**: You want to alias two flags. aka --old-flag-name == --new-flag-name
-
-``` go
-func aliasNormalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName {
-	switch name {
-	case "old-flag-name":
-		name = "new-flag-name"
-		break
-	}
-	return pflag.NormalizedName(name)
-}
-
-myFlagSet.SetNormalizeFunc(aliasNormalizeFunc)
-```
-
-## Deprecating a flag or its shorthand
-It is possible to deprecate a flag, or just its shorthand. Deprecating a flag/shorthand hides it from help text and prints a usage message when the deprecated flag/shorthand is used.
-
-**Example #1**: You want to deprecate a flag named "badflag" as well as inform the users what flag they should use instead.
-```go
-// deprecate a flag by specifying its name and a usage message
-flags.MarkDeprecated("badflag", "please use --good-flag instead")
-```
-This hides "badflag" from help text, and prints `Flag --badflag has been deprecated, please use --good-flag instead` when "badflag" is used.
-
-**Example #2**: You want to keep a flag name "noshorthandflag" but deprecate its shortname "n".
-```go
-// deprecate a flag shorthand by specifying its flag name and a usage message
-flags.MarkShorthandDeprecated("noshorthandflag", "please use --noshorthandflag only")
-```
-This hides the shortname "n" from help text, and prints `Flag shorthand -n has been deprecated, please use --noshorthandflag only` when the shorthand "n" is used.
-
-Note that usage message is essential here, and it should not be empty.
-
-## Hidden flags
-It is possible to mark a flag as hidden, meaning it will still function as normal, however will not show up in usage/help text.
-
-**Example**: You have a flag named "secretFlag" that you need for internal use only and don't want it showing up in help text, or for its usage text to be available.
-```go
-// hide a flag by specifying its name
-flags.MarkHidden("secretFlag")
-```
-
-## Disable sorting of flags
-`pflag` allows you to disable sorting of flags for help and usage message.
-
-**Example**:
-```go
-flags.BoolP("verbose", "v", false, "verbose output")
-flags.String("coolflag", "yeaah", "it's really cool flag")
-flags.Int("usefulflag", 777, "sometimes it's very useful")
-flags.SortFlags = false
-flags.PrintDefaults()
-```
-**Output**:
-```
-  -v, --verbose           verbose output
-      --coolflag string   it's really cool flag (default "yeaah")
-      --usefulflag int    sometimes it's very useful (default 777)
-```
-
-
-## Supporting Go flags when using pflag
-In order to support flags defined using Go's `flag` package, they must be added to the `pflag` flagset. This is usually necessary
-to support flags defined by third-party dependencies (e.g. `golang/glog`).
-
-**Example**: You want to add the Go flags to the `CommandLine` flagset
-```go
-import (
-	goflag "flag"
-	flag "github.com/spf13/pflag"
-)
-
-var ip *int = flag.Int("flagname", 1234, "help message for flagname")
-
-func main() {
-	flag.CommandLine.AddGoFlagSet(goflag.CommandLine)
-	flag.Parse()
-}
-```
-
-## More info
-
-You can see the full reference documentation of the pflag package
-[at godoc.org][3], or through go's standard documentation system by
-running `godoc -http=:6060` and browsing to
-[http://localhost:6060/pkg/github.com/spf13/pflag][2] after
-installation.
-
-[2]: http://localhost:6060/pkg/github.com/spf13/pflag
-[3]: http://godoc.org/github.com/spf13/pflag

vendor/github.com/spf13/pflag/bool.go

@@ -1,94 +0,0 @@
-package pflag
-
-import "strconv"
-
-// optional interface to indicate boolean flags that can be
-// supplied without "=value" text
-type boolFlag interface {
-	Value
-	IsBoolFlag() bool
-}
-
-// -- bool Value
-type boolValue bool
-
-func newBoolValue(val bool, p *bool) *boolValue {
-	*p = val
-	return (*boolValue)(p)
-}
-
-func (b *boolValue) Set(s string) error {
-	v, err := strconv.ParseBool(s)
-	*b = boolValue(v)
-	return err
-}
-
-func (b *boolValue) Type() string {
-	return "bool"
-}
-
-func (b *boolValue) String() string { return strconv.FormatBool(bool(*b)) }
-
-func (b *boolValue) IsBoolFlag() bool { return true }
-
-func boolConv(sval string) (interface{}, error) {
-	return strconv.ParseBool(sval)
-}
-
-// GetBool return the bool value of a flag with the given name
-func (f *FlagSet) GetBool(name string) (bool, error) {
-	val, err := f.getFlagType(name, "bool", boolConv)
-	if err != nil {
-		return false, err
-	}
-	return val.(bool), nil
-}
-
-// BoolVar defines a bool flag with specified name, default value, and usage string.
-// The argument p points to a bool variable in which to store the value of the flag.
-func (f *FlagSet) BoolVar(p *bool, name string, value bool, usage string) {
-	f.BoolVarP(p, name, "", value, usage)
-}
-
-// BoolVarP is like BoolVar, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) BoolVarP(p *bool, name, shorthand string, value bool, usage string) {
-	flag := f.VarPF(newBoolValue(value, p), name, shorthand, usage)
-	flag.NoOptDefVal = "true"
-}
-
-// BoolVar defines a bool flag with specified name, default value, and usage string.
-// The argument p points to a bool variable in which to store the value of the flag.
-func BoolVar(p *bool, name string, value bool, usage string) {
-	BoolVarP(p, name, "", value, usage)
-}
-
-// BoolVarP is like BoolVar, but accepts a shorthand letter that can be used after a single dash.
-func BoolVarP(p *bool, name, shorthand string, value bool, usage string) {
-	flag := CommandLine.VarPF(newBoolValue(value, p), name, shorthand, usage)
-	flag.NoOptDefVal = "true"
-}
-
-// Bool defines a bool flag with specified name, default value, and usage string.
-// The return value is the address of a bool variable that stores the value of the flag.
-func (f *FlagSet) Bool(name string, value bool, usage string) *bool {
-	return f.BoolP(name, "", value, usage)
-}
-
-// BoolP is like Bool, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) BoolP(name, shorthand string, value bool, usage string) *bool {
-	p := new(bool)
-	f.BoolVarP(p, name, shorthand, value, usage)
-	return p
-}
-
-// Bool defines a bool flag with specified name, default value, and usage string.
-// The return value is the address of a bool variable that stores the value of the flag.
-func Bool(name string, value bool, usage string) *bool {
-	return BoolP(name, "", value, usage)
-}
-
-// BoolP is like Bool, but accepts a shorthand letter that can be used after a single dash.
-func BoolP(name, shorthand string, value bool, usage string) *bool {
-	b := CommandLine.BoolP(name, shorthand, value, usage)
-	return b
-}

vendor/github.com/spf13/pflag/bool_slice.go

@@ -1,147 +0,0 @@
-package pflag
-
-import (
-	"io"
-	"strconv"
-	"strings"
-)
-
-// -- boolSlice Value
-type boolSliceValue struct {
-	value   *[]bool
-	changed bool
-}
-
-func newBoolSliceValue(val []bool, p *[]bool) *boolSliceValue {
-	bsv := new(boolSliceValue)
-	bsv.value = p
-	*bsv.value = val
-	return bsv
-}
-
-// Set converts, and assigns, the comma-separated boolean argument string representation as the []bool value of this flag.
-// If Set is called on a flag that already has a []bool assigned, the newly converted values will be appended.
-func (s *boolSliceValue) Set(val string) error {
-
-	// remove all quote characters
-	rmQuote := strings.NewReplacer(`"`, "", `'`, "", "`", "")
-
-	// read flag arguments with CSV parser
-	boolStrSlice, err := readAsCSV(rmQuote.Replace(val))
-	if err != nil && err != io.EOF {
-		return err
-	}
-
-	// parse boolean values into slice
-	out := make([]bool, 0, len(boolStrSlice))
-	for _, boolStr := range boolStrSlice {
-		b, err := strconv.ParseBool(strings.TrimSpace(boolStr))
-		if err != nil {
-			return err
-		}
-		out = append(out, b)
-	}
-
-	if !s.changed {
-		*s.value = out
-	} else {
-		*s.value = append(*s.value, out...)
-	}
-
-	s.changed = true
-
-	return nil
-}
-
-// Type returns a string that uniquely represents this flag's type.
-func (s *boolSliceValue) Type() string {
-	return "boolSlice"
-}
-
-// String defines a "native" format for this boolean slice flag value.
-func (s *boolSliceValue) String() string {
-
-	boolStrSlice := make([]string, len(*s.value))
-	for i, b := range *s.value {
-		boolStrSlice[i] = strconv.FormatBool(b)
-	}
-
-	out, _ := writeAsCSV(boolStrSlice)
-
-	return "[" + out + "]"
-}
-
-func boolSliceConv(val string) (interface{}, error) {
-	val = strings.Trim(val, "[]")
-	// Empty string would cause a slice with one (empty) entry
-	if len(val) == 0 {
-		return []bool{}, nil
-	}
-	ss := strings.Split(val, ",")
-	out := make([]bool, len(ss))
-	for i, t := range ss {
-		var err error
-		out[i], err = strconv.ParseBool(t)
-		if err != nil {
-			return nil, err
-		}
-	}
-	return out, nil
-}
-
-// GetBoolSlice returns the []bool value of a flag with the given name.
-func (f *FlagSet) GetBoolSlice(name string) ([]bool, error) {
-	val, err := f.getFlagType(name, "boolSlice", boolSliceConv)
-	if err != nil {
-		return []bool{}, err
-	}
-	return val.([]bool), nil
-}
-
-// BoolSliceVar defines a boolSlice flag with specified name, default value, and usage string.
-// The argument p points to a []bool variable in which to store the value of the flag.
-func (f *FlagSet) BoolSliceVar(p *[]bool, name string, value []bool, usage string) {
-	f.VarP(newBoolSliceValue(value, p), name, "", usage)
-}
-
-// BoolSliceVarP is like BoolSliceVar, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) BoolSliceVarP(p *[]bool, name, shorthand string, value []bool, usage string) {
-	f.VarP(newBoolSliceValue(value, p), name, shorthand, usage)
-}
-
-// BoolSliceVar defines a []bool flag with specified name, default value, and usage string.
-// The argument p points to a []bool variable in which to store the value of the flag.
-func BoolSliceVar(p *[]bool, name string, value []bool, usage string) {
-	CommandLine.VarP(newBoolSliceValue(value, p), name, "", usage)
-}
-
-// BoolSliceVarP is like BoolSliceVar, but accepts a shorthand letter that can be used after a single dash.
-func BoolSliceVarP(p *[]bool, name, shorthand string, value []bool, usage string) {
-	CommandLine.VarP(newBoolSliceValue(value, p), name, shorthand, usage)
-}
-
-// BoolSlice defines a []bool flag with specified name, default value, and usage string.
-// The return value is the address of a []bool variable that stores the value of the flag.
-func (f *FlagSet) BoolSlice(name string, value []bool, usage string) *[]bool {
-	p := []bool{}
-	f.BoolSliceVarP(&p, name, "", value, usage)
-	return &p
-}
-
-// BoolSliceP is like BoolSlice, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) BoolSliceP(name, shorthand string, value []bool, usage string) *[]bool {
-	p := []bool{}
-	f.BoolSliceVarP(&p, name, shorthand, value, usage)
-	return &p
-}
-
-// BoolSlice defines a []bool flag with specified name, default value, and usage string.
-// The return value is the address of a []bool variable that stores the value of the flag.
-func BoolSlice(name string, value []bool, usage string) *[]bool {
-	return CommandLine.BoolSliceP(name, "", value, usage)
-}
-
-// BoolSliceP is like BoolSlice, but accepts a shorthand letter that can be used after a single dash.
-func BoolSliceP(name, shorthand string, value []bool, usage string) *[]bool {
-	return CommandLine.BoolSliceP(name, shorthand, value, usage)
-}

vendor/github.com/spf13/pflag/bool_slice_test.go

@@ -1,215 +0,0 @@
-package pflag
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"testing"
-)
-
-func setUpBSFlagSet(bsp *[]bool) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.BoolSliceVar(bsp, "bs", []bool{}, "Command separated list!")
-	return f
-}
-
-func setUpBSFlagSetWithDefault(bsp *[]bool) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.BoolSliceVar(bsp, "bs", []bool{false, true}, "Command separated list!")
-	return f
-}
-
-func TestEmptyBS(t *testing.T) {
-	var bs []bool
-	f := setUpBSFlagSet(&bs)
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	getBS, err := f.GetBoolSlice("bs")
-	if err != nil {
-		t.Fatal("got an error from GetBoolSlice():", err)
-	}
-	if len(getBS) != 0 {
-		t.Fatalf("got bs %v with len=%d but expected length=0", getBS, len(getBS))
-	}
-}
-
-func TestBS(t *testing.T) {
-	var bs []bool
-	f := setUpBSFlagSet(&bs)
-
-	vals := []string{"1", "F", "TRUE", "0"}
-	arg := fmt.Sprintf("--bs=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range bs {
-		b, err := strconv.ParseBool(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if b != v {
-			t.Fatalf("expected is[%d] to be %s but got: %t", i, vals[i], v)
-		}
-	}
-	getBS, err := f.GetBoolSlice("bs")
-	if err != nil {
-		t.Fatalf("got error: %v", err)
-	}
-	for i, v := range getBS {
-		b, err := strconv.ParseBool(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if b != v {
-			t.Fatalf("expected bs[%d] to be %s but got: %t from GetBoolSlice", i, vals[i], v)
-		}
-	}
-}
-
-func TestBSDefault(t *testing.T) {
-	var bs []bool
-	f := setUpBSFlagSetWithDefault(&bs)
-
-	vals := []string{"false", "T"}
-
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range bs {
-		b, err := strconv.ParseBool(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if b != v {
-			t.Fatalf("expected bs[%d] to be %t from GetBoolSlice but got: %t", i, b, v)
-		}
-	}
-
-	getBS, err := f.GetBoolSlice("bs")
-	if err != nil {
-		t.Fatal("got an error from GetBoolSlice():", err)
-	}
-	for i, v := range getBS {
-		b, err := strconv.ParseBool(vals[i])
-		if err != nil {
-			t.Fatal("got an error from GetBoolSlice():", err)
-		}
-		if b != v {
-			t.Fatalf("expected bs[%d] to be %t from GetBoolSlice but got: %t", i, b, v)
-		}
-	}
-}
-
-func TestBSWithDefault(t *testing.T) {
-	var bs []bool
-	f := setUpBSFlagSetWithDefault(&bs)
-
-	vals := []string{"FALSE", "1"}
-	arg := fmt.Sprintf("--bs=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range bs {
-		b, err := strconv.ParseBool(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if b != v {
-			t.Fatalf("expected bs[%d] to be %t but got: %t", i, b, v)
-		}
-	}
-
-	getBS, err := f.GetBoolSlice("bs")
-	if err != nil {
-		t.Fatal("got an error from GetBoolSlice():", err)
-	}
-	for i, v := range getBS {
-		b, err := strconv.ParseBool(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if b != v {
-			t.Fatalf("expected bs[%d] to be %t from GetBoolSlice but got: %t", i, b, v)
-		}
-	}
-}
-
-func TestBSCalledTwice(t *testing.T) {
-	var bs []bool
-	f := setUpBSFlagSet(&bs)
-
-	in := []string{"T,F", "T"}
-	expected := []bool{true, false, true}
-	argfmt := "--bs=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	err := f.Parse([]string{arg1, arg2})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range bs {
-		if expected[i] != v {
-			t.Fatalf("expected bs[%d] to be %t but got %t", i, expected[i], v)
-		}
-	}
-}
-
-func TestBSBadQuoting(t *testing.T) {
-
-	tests := []struct {
-		Want    []bool
-		FlagArg []string
-	}{
-		{
-			Want:    []bool{true, false, true},
-			FlagArg: []string{"1", "0", "true"},
-		},
-		{
-			Want:    []bool{true, false},
-			FlagArg: []string{"True", "F"},
-		},
-		{
-			Want:    []bool{true, false},
-			FlagArg: []string{"T", "0"},
-		},
-		{
-			Want:    []bool{true, false},
-			FlagArg: []string{"1", "0"},
-		},
-		{
-			Want:    []bool{true, false, false},
-			FlagArg: []string{"true,false", "false"},
-		},
-		{
-			Want:    []bool{true, false, false, true, false, true, false},
-			FlagArg: []string{`"true,false,false,1,0,     T"`, " false "},
-		},
-		{
-			Want:    []bool{false, false, true, false, true, false, true},
-			FlagArg: []string{`"0, False,  T,false  , true,F"`, "true"},
-		},
-	}
-
-	for i, test := range tests {
-
-		var bs []bool
-		f := setUpBSFlagSet(&bs)
-
-		if err := f.Parse([]string{fmt.Sprintf("--bs=%s", strings.Join(test.FlagArg, ","))}); err != nil {
-			t.Fatalf("flag parsing failed with error: %s\nparsing:\t%#v\nwant:\t\t%#v",
-				err, test.FlagArg, test.Want[i])
-		}
-
-		for j, b := range bs {
-			if b != test.Want[j] {
-				t.Fatalf("bad value parsed for test %d on bool %d:\nwant:\t%t\ngot:\t%t", i, j, test.Want[j], b)
-			}
-		}
-	}
-}

vendor/github.com/spf13/pflag/bool_test.go

@@ -1,179 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pflag
-
-import (
-	"bytes"
-	"strconv"
-	"testing"
-)
-
-// This value can be a boolean ("true", "false") or "maybe"
-type triStateValue int
-
-const (
-	triStateFalse triStateValue = 0
-	triStateTrue  triStateValue = 1
-	triStateMaybe triStateValue = 2
-)
-
-const strTriStateMaybe = "maybe"
-
-func (v *triStateValue) IsBoolFlag() bool {
-	return true
-}
-
-func (v *triStateValue) Get() interface{} {
-	return triStateValue(*v)
-}
-
-func (v *triStateValue) Set(s string) error {
-	if s == strTriStateMaybe {
-		*v = triStateMaybe
-		return nil
-	}
-	boolVal, err := strconv.ParseBool(s)
-	if boolVal {
-		*v = triStateTrue
-	} else {
-		*v = triStateFalse
-	}
-	return err
-}
-
-func (v *triStateValue) String() string {
-	if *v == triStateMaybe {
-		return strTriStateMaybe
-	}
-	return strconv.FormatBool(*v == triStateTrue)
-}
-
-// The type of the flag as required by the pflag.Value interface
-func (v *triStateValue) Type() string {
-	return "version"
-}
-
-func setUpFlagSet(tristate *triStateValue) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	*tristate = triStateFalse
-	flag := f.VarPF(tristate, "tristate", "t", "tristate value (true, maybe or false)")
-	flag.NoOptDefVal = "true"
-	return f
-}
-
-func TestExplicitTrue(t *testing.T) {
-	var tristate triStateValue
-	f := setUpFlagSet(&tristate)
-	err := f.Parse([]string{"--tristate=true"})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	if tristate != triStateTrue {
-		t.Fatal("expected", triStateTrue, "(triStateTrue) but got", tristate, "instead")
-	}
-}
-
-func TestImplicitTrue(t *testing.T) {
-	var tristate triStateValue
-	f := setUpFlagSet(&tristate)
-	err := f.Parse([]string{"--tristate"})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	if tristate != triStateTrue {
-		t.Fatal("expected", triStateTrue, "(triStateTrue) but got", tristate, "instead")
-	}
-}
-
-func TestShortFlag(t *testing.T) {
-	var tristate triStateValue
-	f := setUpFlagSet(&tristate)
-	err := f.Parse([]string{"-t"})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	if tristate != triStateTrue {
-		t.Fatal("expected", triStateTrue, "(triStateTrue) but got", tristate, "instead")
-	}
-}
-
-func TestShortFlagExtraArgument(t *testing.T) {
-	var tristate triStateValue
-	f := setUpFlagSet(&tristate)
-	// The"maybe"turns into an arg, since short boolean options will only do true/false
-	err := f.Parse([]string{"-t", "maybe"})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	if tristate != triStateTrue {
-		t.Fatal("expected", triStateTrue, "(triStateTrue) but got", tristate, "instead")
-	}
-	args := f.Args()
-	if len(args) != 1 || args[0] != "maybe" {
-		t.Fatal("expected an extra 'maybe' argument to stick around")
-	}
-}
-
-func TestExplicitMaybe(t *testing.T) {
-	var tristate triStateValue
-	f := setUpFlagSet(&tristate)
-	err := f.Parse([]string{"--tristate=maybe"})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	if tristate != triStateMaybe {
-		t.Fatal("expected", triStateMaybe, "(triStateMaybe) but got", tristate, "instead")
-	}
-}
-
-func TestExplicitFalse(t *testing.T) {
-	var tristate triStateValue
-	f := setUpFlagSet(&tristate)
-	err := f.Parse([]string{"--tristate=false"})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	if tristate != triStateFalse {
-		t.Fatal("expected", triStateFalse, "(triStateFalse) but got", tristate, "instead")
-	}
-}
-
-func TestImplicitFalse(t *testing.T) {
-	var tristate triStateValue
-	f := setUpFlagSet(&tristate)
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	if tristate != triStateFalse {
-		t.Fatal("expected", triStateFalse, "(triStateFalse) but got", tristate, "instead")
-	}
-}
-
-func TestInvalidValue(t *testing.T) {
-	var tristate triStateValue
-	f := setUpFlagSet(&tristate)
-	var buf bytes.Buffer
-	f.SetOutput(&buf)
-	err := f.Parse([]string{"--tristate=invalid"})
-	if err == nil {
-		t.Fatal("expected an error but did not get any, tristate has value", tristate)
-	}
-}
-
-func TestBoolP(t *testing.T) {
-	b := BoolP("bool", "b", false, "bool value in CommandLine")
-	c := BoolP("c", "c", false, "other bool value")
-	args := []string{"--bool"}
-	if err := CommandLine.Parse(args); err != nil {
-		t.Error("expected no error, got ", err)
-	}
-	if *b != true {
-		t.Errorf("expected b=true got b=%v", *b)
-	}
-	if *c != false {
-		t.Errorf("expect c=false got c=%v", *c)
-	}
-}

vendor/github.com/spf13/pflag/count.go

@@ -1,96 +0,0 @@
-package pflag
-
-import "strconv"
-
-// -- count Value
-type countValue int
-
-func newCountValue(val int, p *int) *countValue {
-	*p = val
-	return (*countValue)(p)
-}
-
-func (i *countValue) Set(s string) error {
-	v, err := strconv.ParseInt(s, 0, 64)
-	// -1 means that no specific value was passed, so increment
-	if v == -1 {
-		*i = countValue(*i + 1)
-	} else {
-		*i = countValue(v)
-	}
-	return err
-}
-
-func (i *countValue) Type() string {
-	return "count"
-}
-
-func (i *countValue) String() string { return strconv.Itoa(int(*i)) }
-
-func countConv(sval string) (interface{}, error) {
-	i, err := strconv.Atoi(sval)
-	if err != nil {
-		return nil, err
-	}
-	return i, nil
-}
-
-// GetCount return the int value of a flag with the given name
-func (f *FlagSet) GetCount(name string) (int, error) {
-	val, err := f.getFlagType(name, "count", countConv)
-	if err != nil {
-		return 0, err
-	}
-	return val.(int), nil
-}
-
-// CountVar defines a count flag with specified name, default value, and usage string.
-// The argument p points to an int variable in which to store the value of the flag.
-// A count flag will add 1 to its value evey time it is found on the command line
-func (f *FlagSet) CountVar(p *int, name string, usage string) {
-	f.CountVarP(p, name, "", usage)
-}
-
-// CountVarP is like CountVar only take a shorthand for the flag name.
-func (f *FlagSet) CountVarP(p *int, name, shorthand string, usage string) {
-	flag := f.VarPF(newCountValue(0, p), name, shorthand, usage)
-	flag.NoOptDefVal = "-1"
-}
-
-// CountVar like CountVar only the flag is placed on the CommandLine instead of a given flag set
-func CountVar(p *int, name string, usage string) {
-	CommandLine.CountVar(p, name, usage)
-}
-
-// CountVarP is like CountVar only take a shorthand for the flag name.
-func CountVarP(p *int, name, shorthand string, usage string) {
-	CommandLine.CountVarP(p, name, shorthand, usage)
-}
-
-// Count defines a count flag with specified name, default value, and usage string.
-// The return value is the address of an int variable that stores the value of the flag.
-// A count flag will add 1 to its value evey time it is found on the command line
-func (f *FlagSet) Count(name string, usage string) *int {
-	p := new(int)
-	f.CountVarP(p, name, "", usage)
-	return p
-}
-
-// CountP is like Count only takes a shorthand for the flag name.
-func (f *FlagSet) CountP(name, shorthand string, usage string) *int {
-	p := new(int)
-	f.CountVarP(p, name, shorthand, usage)
-	return p
-}
-
-// Count defines a count flag with specified name, default value, and usage string.
-// The return value is the address of an int variable that stores the value of the flag.
-// A count flag will add 1 to its value evey time it is found on the command line
-func Count(name string, usage string) *int {
-	return CommandLine.CountP(name, "", usage)
-}
-
-// CountP is like Count only takes a shorthand for the flag name.
-func CountP(name, shorthand string, usage string) *int {
-	return CommandLine.CountP(name, shorthand, usage)
-}

vendor/github.com/spf13/pflag/count_test.go

@@ -1,52 +0,0 @@
-package pflag
-
-import (
-	"os"
-	"testing"
-)
-
-func setUpCount(c *int) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.CountVarP(c, "verbose", "v", "a counter")
-	return f
-}
-
-func TestCount(t *testing.T) {
-	testCases := []struct {
-		input    []string
-		success  bool
-		expected int
-	}{
-		{[]string{"-vvv"}, true, 3},
-		{[]string{"-v", "-v", "-v"}, true, 3},
-		{[]string{"-v", "--verbose", "-v"}, true, 3},
-		{[]string{"-v=3", "-v"}, true, 4},
-		{[]string{"-v=a"}, false, 0},
-	}
-
-	devnull, _ := os.Open(os.DevNull)
-	os.Stderr = devnull
-	for i := range testCases {
-		var count int
-		f := setUpCount(&count)
-
-		tc := &testCases[i]
-
-		err := f.Parse(tc.input)
-		if err != nil && tc.success == true {
-			t.Errorf("expected success, got %q", err)
-			continue
-		} else if err == nil && tc.success == false {
-			t.Errorf("expected failure, got success")
-			continue
-		} else if tc.success {
-			c, err := f.GetCount("verbose")
-			if err != nil {
-				t.Errorf("Got error trying to fetch the counter flag")
-			}
-			if c != tc.expected {
-				t.Errorf("expected %q, got %q", tc.expected, c)
-			}
-		}
-	}
-}

vendor/github.com/spf13/pflag/duration.go

@@ -1,86 +0,0 @@
-package pflag
-
-import (
-	"time"
-)
-
-// -- time.Duration Value
-type durationValue time.Duration
-
-func newDurationValue(val time.Duration, p *time.Duration) *durationValue {
-	*p = val
-	return (*durationValue)(p)
-}
-
-func (d *durationValue) Set(s string) error {
-	v, err := time.ParseDuration(s)
-	*d = durationValue(v)
-	return err
-}
-
-func (d *durationValue) Type() string {
-	return "duration"
-}
-
-func (d *durationValue) String() string { return (*time.Duration)(d).String() }
-
-func durationConv(sval string) (interface{}, error) {
-	return time.ParseDuration(sval)
-}
-
-// GetDuration return the duration value of a flag with the given name
-func (f *FlagSet) GetDuration(name string) (time.Duration, error) {
-	val, err := f.getFlagType(name, "duration", durationConv)
-	if err != nil {
-		return 0, err
-	}
-	return val.(time.Duration), nil
-}
-
-// DurationVar defines a time.Duration flag with specified name, default value, and usage string.
-// The argument p points to a time.Duration variable in which to store the value of the flag.
-func (f *FlagSet) DurationVar(p *time.Duration, name string, value time.Duration, usage string) {
-	f.VarP(newDurationValue(value, p), name, "", usage)
-}
-
-// DurationVarP is like DurationVar, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) DurationVarP(p *time.Duration, name, shorthand string, value time.Duration, usage string) {
-	f.VarP(newDurationValue(value, p), name, shorthand, usage)
-}
-
-// DurationVar defines a time.Duration flag with specified name, default value, and usage string.
-// The argument p points to a time.Duration variable in which to store the value of the flag.
-func DurationVar(p *time.Duration, name string, value time.Duration, usage string) {
-	CommandLine.VarP(newDurationValue(value, p), name, "", usage)
-}
-
-// DurationVarP is like DurationVar, but accepts a shorthand letter that can be used after a single dash.
-func DurationVarP(p *time.Duration, name, shorthand string, value time.Duration, usage string) {
-	CommandLine.VarP(newDurationValue(value, p), name, shorthand, usage)
-}
-
-// Duration defines a time.Duration flag with specified name, default value, and usage string.
-// The return value is the address of a time.Duration variable that stores the value of the flag.
-func (f *FlagSet) Duration(name string, value time.Duration, usage string) *time.Duration {
-	p := new(time.Duration)
-	f.DurationVarP(p, name, "", value, usage)
-	return p
-}
-
-// DurationP is like Duration, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) DurationP(name, shorthand string, value time.Duration, usage string) *time.Duration {
-	p := new(time.Duration)
-	f.DurationVarP(p, name, shorthand, value, usage)
-	return p
-}
-
-// Duration defines a time.Duration flag with specified name, default value, and usage string.
-// The return value is the address of a time.Duration variable that stores the value of the flag.
-func Duration(name string, value time.Duration, usage string) *time.Duration {
-	return CommandLine.DurationP(name, "", value, usage)
-}
-
-// DurationP is like Duration, but accepts a shorthand letter that can be used after a single dash.
-func DurationP(name, shorthand string, value time.Duration, usage string) *time.Duration {
-	return CommandLine.DurationP(name, shorthand, value, usage)
-}

vendor/github.com/spf13/pflag/example_test.go

@@ -1,36 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pflag_test
-
-import (
-	"fmt"
-
-	"github.com/spf13/pflag"
-)
-
-func ExampleShorthandLookup() {
-	name := "verbose"
-	short := name[:1]
-
-	pflag.BoolP(name, short, false, "verbose output")
-
-	// len(short) must be == 1
-	flag := pflag.ShorthandLookup(short)
-
-	fmt.Println(flag.Name)
-}
-
-func ExampleFlagSet_ShorthandLookup() {
-	name := "verbose"
-	short := name[:1]
-
-	fs := pflag.NewFlagSet("Example", pflag.ContinueOnError)
-	fs.BoolP(name, short, false, "verbose output")
-
-	// len(short) must be == 1
-	flag := fs.ShorthandLookup(short)
-
-	fmt.Println(flag.Name)
-}

vendor/github.com/spf13/pflag/export_test.go

@@ -1,29 +0,0 @@
-// Copyright 2010 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pflag
-
-import (
-	"io/ioutil"
-	"os"
-)
-
-// Additional routines compiled into the package only during testing.
-
-// ResetForTesting clears all flag state and sets the usage function as directed.
-// After calling ResetForTesting, parse errors in flag handling will not
-// exit the program.
-func ResetForTesting(usage func()) {
-	CommandLine = &FlagSet{
-		name:          os.Args[0],
-		errorHandling: ContinueOnError,
-		output:        ioutil.Discard,
-	}
-	Usage = usage
-}
-
-// GetCommandLine returns the default FlagSet.
-func GetCommandLine() *FlagSet {
-	return CommandLine
-}

vendor/github.com/spf13/pflag/float32.go

@@ -1,88 +0,0 @@
-package pflag
-
-import "strconv"
-
-// -- float32 Value
-type float32Value float32
-
-func newFloat32Value(val float32, p *float32) *float32Value {
-	*p = val
-	return (*float32Value)(p)
-}
-
-func (f *float32Value) Set(s string) error {
-	v, err := strconv.ParseFloat(s, 32)
-	*f = float32Value(v)
-	return err
-}
-
-func (f *float32Value) Type() string {
-	return "float32"
-}
-
-func (f *float32Value) String() string { return strconv.FormatFloat(float64(*f), 'g', -1, 32) }
-
-func float32Conv(sval string) (interface{}, error) {
-	v, err := strconv.ParseFloat(sval, 32)
-	if err != nil {
-		return 0, err
-	}
-	return float32(v), nil
-}
-
-// GetFloat32 return the float32 value of a flag with the given name
-func (f *FlagSet) GetFloat32(name string) (float32, error) {
-	val, err := f.getFlagType(name, "float32", float32Conv)
-	if err != nil {
-		return 0, err
-	}
-	return val.(float32), nil
-}
-
-// Float32Var defines a float32 flag with specified name, default value, and usage string.
-// The argument p points to a float32 variable in which to store the value of the flag.
-func (f *FlagSet) Float32Var(p *float32, name string, value float32, usage string) {
-	f.VarP(newFloat32Value(value, p), name, "", usage)
-}
-
-// Float32VarP is like Float32Var, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) Float32VarP(p *float32, name, shorthand string, value float32, usage string) {
-	f.VarP(newFloat32Value(value, p), name, shorthand, usage)
-}
-
-// Float32Var defines a float32 flag with specified name, default value, and usage string.
-// The argument p points to a float32 variable in which to store the value of the flag.
-func Float32Var(p *float32, name string, value float32, usage string) {
-	CommandLine.VarP(newFloat32Value(value, p), name, "", usage)
-}
-
-// Float32VarP is like Float32Var, but accepts a shorthand letter that can be used after a single dash.
-func Float32VarP(p *float32, name, shorthand string, value float32, usage string) {
-	CommandLine.VarP(newFloat32Value(value, p), name, shorthand, usage)
-}
-
-// Float32 defines a float32 flag with specified name, default value, and usage string.
-// The return value is the address of a float32 variable that stores the value of the flag.
-func (f *FlagSet) Float32(name string, value float32, usage string) *float32 {
-	p := new(float32)
-	f.Float32VarP(p, name, "", value, usage)
-	return p
-}
-
-// Float32P is like Float32, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) Float32P(name, shorthand string, value float32, usage string) *float32 {
-	p := new(float32)
-	f.Float32VarP(p, name, shorthand, value, usage)
-	return p
-}
-
-// Float32 defines a float32 flag with specified name, default value, and usage string.
-// The return value is the address of a float32 variable that stores the value of the flag.
-func Float32(name string, value float32, usage string) *float32 {
-	return CommandLine.Float32P(name, "", value, usage)
-}
-
-// Float32P is like Float32, but accepts a shorthand letter that can be used after a single dash.
-func Float32P(name, shorthand string, value float32, usage string) *float32 {
-	return CommandLine.Float32P(name, shorthand, value, usage)
-}

vendor/github.com/spf13/pflag/float64.go

@@ -1,84 +0,0 @@
-package pflag
-
-import "strconv"
-
-// -- float64 Value
-type float64Value float64
-
-func newFloat64Value(val float64, p *float64) *float64Value {
-	*p = val
-	return (*float64Value)(p)
-}
-
-func (f *float64Value) Set(s string) error {
-	v, err := strconv.ParseFloat(s, 64)
-	*f = float64Value(v)
-	return err
-}
-
-func (f *float64Value) Type() string {
-	return "float64"
-}
-
-func (f *float64Value) String() string { return strconv.FormatFloat(float64(*f), 'g', -1, 64) }
-
-func float64Conv(sval string) (interface{}, error) {
-	return strconv.ParseFloat(sval, 64)
-}
-
-// GetFloat64 return the float64 value of a flag with the given name
-func (f *FlagSet) GetFloat64(name string) (float64, error) {
-	val, err := f.getFlagType(name, "float64", float64Conv)
-	if err != nil {
-		return 0, err
-	}
-	return val.(float64), nil
-}
-
-// Float64Var defines a float64 flag with specified name, default value, and usage string.
-// The argument p points to a float64 variable in which to store the value of the flag.
-func (f *FlagSet) Float64Var(p *float64, name string, value float64, usage string) {
-	f.VarP(newFloat64Value(value, p), name, "", usage)
-}
-
-// Float64VarP is like Float64Var, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) Float64VarP(p *float64, name, shorthand string, value float64, usage string) {
-	f.VarP(newFloat64Value(value, p), name, shorthand, usage)
-}
-
-// Float64Var defines a float64 flag with specified name, default value, and usage string.
-// The argument p points to a float64 variable in which to store the value of the flag.
-func Float64Var(p *float64, name string, value float64, usage string) {
-	CommandLine.VarP(newFloat64Value(value, p), name, "", usage)
-}
-
-// Float64VarP is like Float64Var, but accepts a shorthand letter that can be used after a single dash.
-func Float64VarP(p *float64, name, shorthand string, value float64, usage string) {
-	CommandLine.VarP(newFloat64Value(value, p), name, shorthand, usage)
-}
-
-// Float64 defines a float64 flag with specified name, default value, and usage string.
-// The return value is the address of a float64 variable that stores the value of the flag.
-func (f *FlagSet) Float64(name string, value float64, usage string) *float64 {
-	p := new(float64)
-	f.Float64VarP(p, name, "", value, usage)
-	return p
-}
-
-// Float64P is like Float64, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) Float64P(name, shorthand string, value float64, usage string) *float64 {
-	p := new(float64)
-	f.Float64VarP(p, name, shorthand, value, usage)
-	return p
-}
-
-// Float64 defines a float64 flag with specified name, default value, and usage string.
-// The return value is the address of a float64 variable that stores the value of the flag.
-func Float64(name string, value float64, usage string) *float64 {
-	return CommandLine.Float64P(name, "", value, usage)
-}
-
-// Float64P is like Float64, but accepts a shorthand letter that can be used after a single dash.
-func Float64P(name, shorthand string, value float64, usage string) *float64 {
-	return CommandLine.Float64P(name, shorthand, value, usage)
-}

vendor/github.com/spf13/pflag/golangflag.go

@@ -1,101 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pflag
-
-import (
-	goflag "flag"
-	"reflect"
-	"strings"
-)
-
-// flagValueWrapper implements pflag.Value around a flag.Value.  The main
-// difference here is the addition of the Type method that returns a string
-// name of the type.  As this is generally unknown, we approximate that with
-// reflection.
-type flagValueWrapper struct {
-	inner    goflag.Value
-	flagType string
-}
-
-// We are just copying the boolFlag interface out of goflag as that is what
-// they use to decide if a flag should get "true" when no arg is given.
-type goBoolFlag interface {
-	goflag.Value
-	IsBoolFlag() bool
-}
-
-func wrapFlagValue(v goflag.Value) Value {
-	// If the flag.Value happens to also be a pflag.Value, just use it directly.
-	if pv, ok := v.(Value); ok {
-		return pv
-	}
-
-	pv := &flagValueWrapper{
-		inner: v,
-	}
-
-	t := reflect.TypeOf(v)
-	if t.Kind() == reflect.Interface || t.Kind() == reflect.Ptr {
-		t = t.Elem()
-	}
-
-	pv.flagType = strings.TrimSuffix(t.Name(), "Value")
-	return pv
-}
-
-func (v *flagValueWrapper) String() string {
-	return v.inner.String()
-}
-
-func (v *flagValueWrapper) Set(s string) error {
-	return v.inner.Set(s)
-}
-
-func (v *flagValueWrapper) Type() string {
-	return v.flagType
-}
-
-// PFlagFromGoFlag will return a *pflag.Flag given a *flag.Flag
-// If the *flag.Flag.Name was a single character (ex: `v`) it will be accessiblei
-// with both `-v` and `--v` in flags. If the golang flag was more than a single
-// character (ex: `verbose`) it will only be accessible via `--verbose`
-func PFlagFromGoFlag(goflag *goflag.Flag) *Flag {
-	// Remember the default value as a string; it won't change.
-	flag := &Flag{
-		Name:  goflag.Name,
-		Usage: goflag.Usage,
-		Value: wrapFlagValue(goflag.Value),
-		// Looks like golang flags don't set DefValue correctly  :-(
-		//DefValue: goflag.DefValue,
-		DefValue: goflag.Value.String(),
-	}
-	// Ex: if the golang flag was -v, allow both -v and --v to work
-	if len(flag.Name) == 1 {
-		flag.Shorthand = flag.Name
-	}
-	if fv, ok := goflag.Value.(goBoolFlag); ok && fv.IsBoolFlag() {
-		flag.NoOptDefVal = "true"
-	}
-	return flag
-}
-
-// AddGoFlag will add the given *flag.Flag to the pflag.FlagSet
-func (f *FlagSet) AddGoFlag(goflag *goflag.Flag) {
-	if f.Lookup(goflag.Name) != nil {
-		return
-	}
-	newflag := PFlagFromGoFlag(goflag)
-	f.AddFlag(newflag)
-}
-
-// AddGoFlagSet will add the given *flag.FlagSet to the pflag.FlagSet
-func (f *FlagSet) AddGoFlagSet(newSet *goflag.FlagSet) {
-	if newSet == nil {
-		return
-	}
-	newSet.VisitAll(func(goflag *goflag.Flag) {
-		f.AddGoFlag(goflag)
-	})
-}

vendor/github.com/spf13/pflag/golangflag_test.go

@@ -1,39 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pflag
-
-import (
-	goflag "flag"
-	"testing"
-)
-
-func TestGoflags(t *testing.T) {
-	goflag.String("stringFlag", "stringFlag", "stringFlag")
-	goflag.Bool("boolFlag", false, "boolFlag")
-
-	f := NewFlagSet("test", ContinueOnError)
-
-	f.AddGoFlagSet(goflag.CommandLine)
-	err := f.Parse([]string{"--stringFlag=bob", "--boolFlag"})
-	if err != nil {
-		t.Fatal("expected no error; get", err)
-	}
-
-	getString, err := f.GetString("stringFlag")
-	if err != nil {
-		t.Fatal("expected no error; get", err)
-	}
-	if getString != "bob" {
-		t.Fatalf("expected getString=bob but got getString=%s", getString)
-	}
-
-	getBool, err := f.GetBool("boolFlag")
-	if err != nil {
-		t.Fatal("expected no error; get", err)
-	}
-	if getBool != true {
-		t.Fatalf("expected getBool=true but got getBool=%v", getBool)
-	}
-}

vendor/github.com/spf13/pflag/int.go

@@ -1,84 +0,0 @@
-package pflag
-
-import "strconv"
-
-// -- int Value
-type intValue int
-
-func newIntValue(val int, p *int) *intValue {
-	*p = val
-	return (*intValue)(p)
-}
-
-func (i *intValue) Set(s string) error {
-	v, err := strconv.ParseInt(s, 0, 64)
-	*i = intValue(v)
-	return err
-}
-
-func (i *intValue) Type() string {
-	return "int"
-}
-
-func (i *intValue) String() string { return strconv.Itoa(int(*i)) }
-
-func intConv(sval string) (interface{}, error) {
-	return strconv.Atoi(sval)
-}
-
-// GetInt return the int value of a flag with the given name
-func (f *FlagSet) GetInt(name string) (int, error) {
-	val, err := f.getFlagType(name, "int", intConv)
-	if err != nil {
-		return 0, err
-	}
-	return val.(int), nil
-}
-
-// IntVar defines an int flag with specified name, default value, and usage string.
-// The argument p points to an int variable in which to store the value of the flag.
-func (f *FlagSet) IntVar(p *int, name string, value int, usage string) {
-	f.VarP(newIntValue(value, p), name, "", usage)
-}
-
-// IntVarP is like IntVar, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) IntVarP(p *int, name, shorthand string, value int, usage string) {
-	f.VarP(newIntValue(value, p), name, shorthand, usage)
-}
-
-// IntVar defines an int flag with specified name, default value, and usage string.
-// The argument p points to an int variable in which to store the value of the flag.
-func IntVar(p *int, name string, value int, usage string) {
-	CommandLine.VarP(newIntValue(value, p), name, "", usage)
-}
-
-// IntVarP is like IntVar, but accepts a shorthand letter that can be used after a single dash.
-func IntVarP(p *int, name, shorthand string, value int, usage string) {
-	CommandLine.VarP(newIntValue(value, p), name, shorthand, usage)
-}
-
-// Int defines an int flag with specified name, default value, and usage string.
-// The return value is the address of an int variable that stores the value of the flag.
-func (f *FlagSet) Int(name string, value int, usage string) *int {
-	p := new(int)
-	f.IntVarP(p, name, "", value, usage)
-	return p
-}
-
-// IntP is like Int, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) IntP(name, shorthand string, value int, usage string) *int {
-	p := new(int)
-	f.IntVarP(p, name, shorthand, value, usage)
-	return p
-}
-
-// Int defines an int flag with specified name, default value, and usage string.
-// The return value is the address of an int variable that stores the value of the flag.
-func Int(name string, value int, usage string) *int {
-	return CommandLine.IntP(name, "", value, usage)
-}
-
-// IntP is like Int, but accepts a shorthand letter that can be used after a single dash.
-func IntP(name, shorthand string, value int, usage string) *int {
-	return CommandLine.IntP(name, shorthand, value, usage)
-}

vendor/github.com/spf13/pflag/int32.go

@@ -1,88 +0,0 @@
-package pflag
-
-import "strconv"
-
-// -- int32 Value
-type int32Value int32
-
-func newInt32Value(val int32, p *int32) *int32Value {
-	*p = val
-	return (*int32Value)(p)
-}
-
-func (i *int32Value) Set(s string) error {
-	v, err := strconv.ParseInt(s, 0, 32)
-	*i = int32Value(v)
-	return err
-}
-
-func (i *int32Value) Type() string {
-	return "int32"
-}
-
-func (i *int32Value) String() string { return strconv.FormatInt(int64(*i), 10) }
-
-func int32Conv(sval string) (interface{}, error) {
-	v, err := strconv.ParseInt(sval, 0, 32)
-	if err != nil {
-		return 0, err
-	}
-	return int32(v), nil
-}
-
-// GetInt32 return the int32 value of a flag with the given name
-func (f *FlagSet) GetInt32(name string) (int32, error) {
-	val, err := f.getFlagType(name, "int32", int32Conv)
-	if err != nil {
-		return 0, err
-	}
-	return val.(int32), nil
-}
-
-// Int32Var defines an int32 flag with specified name, default value, and usage string.
-// The argument p points to an int32 variable in which to store the value of the flag.
-func (f *FlagSet) Int32Var(p *int32, name string, value int32, usage string) {
-	f.VarP(newInt32Value(value, p), name, "", usage)
-}
-
-// Int32VarP is like Int32Var, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) Int32VarP(p *int32, name, shorthand string, value int32, usage string) {
-	f.VarP(newInt32Value(value, p), name, shorthand, usage)
-}
-
-// Int32Var defines an int32 flag with specified name, default value, and usage string.
-// The argument p points to an int32 variable in which to store the value of the flag.
-func Int32Var(p *int32, name string, value int32, usage string) {
-	CommandLine.VarP(newInt32Value(value, p), name, "", usage)
-}
-
-// Int32VarP is like Int32Var, but accepts a shorthand letter that can be used after a single dash.
-func Int32VarP(p *int32, name, shorthand string, value int32, usage string) {
-	CommandLine.VarP(newInt32Value(value, p), name, shorthand, usage)
-}
-
-// Int32 defines an int32 flag with specified name, default value, and usage string.
-// The return value is the address of an int32 variable that stores the value of the flag.
-func (f *FlagSet) Int32(name string, value int32, usage string) *int32 {
-	p := new(int32)
-	f.Int32VarP(p, name, "", value, usage)
-	return p
-}
-
-// Int32P is like Int32, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) Int32P(name, shorthand string, value int32, usage string) *int32 {
-	p := new(int32)
-	f.Int32VarP(p, name, shorthand, value, usage)
-	return p
-}
-
-// Int32 defines an int32 flag with specified name, default value, and usage string.
-// The return value is the address of an int32 variable that stores the value of the flag.
-func Int32(name string, value int32, usage string) *int32 {
-	return CommandLine.Int32P(name, "", value, usage)
-}
-
-// Int32P is like Int32, but accepts a shorthand letter that can be used after a single dash.
-func Int32P(name, shorthand string, value int32, usage string) *int32 {
-	return CommandLine.Int32P(name, shorthand, value, usage)
-}

vendor/github.com/spf13/pflag/int64.go

@@ -1,84 +0,0 @@
-package pflag
-
-import "strconv"
-
-// -- int64 Value
-type int64Value int64
-
-func newInt64Value(val int64, p *int64) *int64Value {
-	*p = val
-	return (*int64Value)(p)
-}
-
-func (i *int64Value) Set(s string) error {
-	v, err := strconv.ParseInt(s, 0, 64)
-	*i = int64Value(v)
-	return err
-}
-
-func (i *int64Value) Type() string {
-	return "int64"
-}
-
-func (i *int64Value) String() string { return strconv.FormatInt(int64(*i), 10) }
-
-func int64Conv(sval string) (interface{}, error) {
-	return strconv.ParseInt(sval, 0, 64)
-}
-
-// GetInt64 return the int64 value of a flag with the given name
-func (f *FlagSet) GetInt64(name string) (int64, error) {
-	val, err := f.getFlagType(name, "int64", int64Conv)
-	if err != nil {
-		return 0, err
-	}
-	return val.(int64), nil
-}
-
-// Int64Var defines an int64 flag with specified name, default value, and usage string.
-// The argument p points to an int64 variable in which to store the value of the flag.
-func (f *FlagSet) Int64Var(p *int64, name string, value int64, usage string) {
-	f.VarP(newInt64Value(value, p), name, "", usage)
-}
-
-// Int64VarP is like Int64Var, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) Int64VarP(p *int64, name, shorthand string, value int64, usage string) {
-	f.VarP(newInt64Value(value, p), name, shorthand, usage)
-}
-
-// Int64Var defines an int64 flag with specified name, default value, and usage string.
-// The argument p points to an int64 variable in which to store the value of the flag.
-func Int64Var(p *int64, name string, value int64, usage string) {
-	CommandLine.VarP(newInt64Value(value, p), name, "", usage)
-}
-
-// Int64VarP is like Int64Var, but accepts a shorthand letter that can be used after a single dash.
-func Int64VarP(p *int64, name, shorthand string, value int64, usage string) {
-	CommandLine.VarP(newInt64Value(value, p), name, shorthand, usage)
-}
-
-// Int64 defines an int64 flag with specified name, default value, and usage string.
-// The return value is the address of an int64 variable that stores the value of the flag.
-func (f *FlagSet) Int64(name string, value int64, usage string) *int64 {
-	p := new(int64)
-	f.Int64VarP(p, name, "", value, usage)
-	return p
-}
-
-// Int64P is like Int64, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) Int64P(name, shorthand string, value int64, usage string) *int64 {
-	p := new(int64)
-	f.Int64VarP(p, name, shorthand, value, usage)
-	return p
-}
-
-// Int64 defines an int64 flag with specified name, default value, and usage string.
-// The return value is the address of an int64 variable that stores the value of the flag.
-func Int64(name string, value int64, usage string) *int64 {
-	return CommandLine.Int64P(name, "", value, usage)
-}
-
-// Int64P is like Int64, but accepts a shorthand letter that can be used after a single dash.
-func Int64P(name, shorthand string, value int64, usage string) *int64 {
-	return CommandLine.Int64P(name, shorthand, value, usage)
-}

vendor/github.com/spf13/pflag/int8.go

@@ -1,88 +0,0 @@
-package pflag
-
-import "strconv"
-
-// -- int8 Value
-type int8Value int8
-
-func newInt8Value(val int8, p *int8) *int8Value {
-	*p = val
-	return (*int8Value)(p)
-}
-
-func (i *int8Value) Set(s string) error {
-	v, err := strconv.ParseInt(s, 0, 8)
-	*i = int8Value(v)
-	return err
-}
-
-func (i *int8Value) Type() string {
-	return "int8"
-}
-
-func (i *int8Value) String() string { return strconv.FormatInt(int64(*i), 10) }
-
-func int8Conv(sval string) (interface{}, error) {
-	v, err := strconv.ParseInt(sval, 0, 8)
-	if err != nil {
-		return 0, err
-	}
-	return int8(v), nil
-}
-
-// GetInt8 return the int8 value of a flag with the given name
-func (f *FlagSet) GetInt8(name string) (int8, error) {
-	val, err := f.getFlagType(name, "int8", int8Conv)
-	if err != nil {
-		return 0, err
-	}
-	return val.(int8), nil
-}
-
-// Int8Var defines an int8 flag with specified name, default value, and usage string.
-// The argument p points to an int8 variable in which to store the value of the flag.
-func (f *FlagSet) Int8Var(p *int8, name string, value int8, usage string) {
-	f.VarP(newInt8Value(value, p), name, "", usage)
-}
-
-// Int8VarP is like Int8Var, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) Int8VarP(p *int8, name, shorthand string, value int8, usage string) {
-	f.VarP(newInt8Value(value, p), name, shorthand, usage)
-}
-
-// Int8Var defines an int8 flag with specified name, default value, and usage string.
-// The argument p points to an int8 variable in which to store the value of the flag.
-func Int8Var(p *int8, name string, value int8, usage string) {
-	CommandLine.VarP(newInt8Value(value, p), name, "", usage)
-}
-
-// Int8VarP is like Int8Var, but accepts a shorthand letter that can be used after a single dash.
-func Int8VarP(p *int8, name, shorthand string, value int8, usage string) {
-	CommandLine.VarP(newInt8Value(value, p), name, shorthand, usage)
-}
-
-// Int8 defines an int8 flag with specified name, default value, and usage string.
-// The return value is the address of an int8 variable that stores the value of the flag.
-func (f *FlagSet) Int8(name string, value int8, usage string) *int8 {
-	p := new(int8)
-	f.Int8VarP(p, name, "", value, usage)
-	return p
-}
-
-// Int8P is like Int8, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) Int8P(name, shorthand string, value int8, usage string) *int8 {
-	p := new(int8)
-	f.Int8VarP(p, name, shorthand, value, usage)
-	return p
-}
-
-// Int8 defines an int8 flag with specified name, default value, and usage string.
-// The return value is the address of an int8 variable that stores the value of the flag.
-func Int8(name string, value int8, usage string) *int8 {
-	return CommandLine.Int8P(name, "", value, usage)
-}
-
-// Int8P is like Int8, but accepts a shorthand letter that can be used after a single dash.
-func Int8P(name, shorthand string, value int8, usage string) *int8 {
-	return CommandLine.Int8P(name, shorthand, value, usage)
-}

vendor/github.com/spf13/pflag/int_slice.go

@@ -1,128 +0,0 @@
-package pflag
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-)
-
-// -- intSlice Value
-type intSliceValue struct {
-	value   *[]int
-	changed bool
-}
-
-func newIntSliceValue(val []int, p *[]int) *intSliceValue {
-	isv := new(intSliceValue)
-	isv.value = p
-	*isv.value = val
-	return isv
-}
-
-func (s *intSliceValue) Set(val string) error {
-	ss := strings.Split(val, ",")
-	out := make([]int, len(ss))
-	for i, d := range ss {
-		var err error
-		out[i], err = strconv.Atoi(d)
-		if err != nil {
-			return err
-		}
-
-	}
-	if !s.changed {
-		*s.value = out
-	} else {
-		*s.value = append(*s.value, out...)
-	}
-	s.changed = true
-	return nil
-}
-
-func (s *intSliceValue) Type() string {
-	return "intSlice"
-}
-
-func (s *intSliceValue) String() string {
-	out := make([]string, len(*s.value))
-	for i, d := range *s.value {
-		out[i] = fmt.Sprintf("%d", d)
-	}
-	return "[" + strings.Join(out, ",") + "]"
-}
-
-func intSliceConv(val string) (interface{}, error) {
-	val = strings.Trim(val, "[]")
-	// Empty string would cause a slice with one (empty) entry
-	if len(val) == 0 {
-		return []int{}, nil
-	}
-	ss := strings.Split(val, ",")
-	out := make([]int, len(ss))
-	for i, d := range ss {
-		var err error
-		out[i], err = strconv.Atoi(d)
-		if err != nil {
-			return nil, err
-		}
-
-	}
-	return out, nil
-}
-
-// GetIntSlice return the []int value of a flag with the given name
-func (f *FlagSet) GetIntSlice(name string) ([]int, error) {
-	val, err := f.getFlagType(name, "intSlice", intSliceConv)
-	if err != nil {
-		return []int{}, err
-	}
-	return val.([]int), nil
-}
-
-// IntSliceVar defines a intSlice flag with specified name, default value, and usage string.
-// The argument p points to a []int variable in which to store the value of the flag.
-func (f *FlagSet) IntSliceVar(p *[]int, name string, value []int, usage string) {
-	f.VarP(newIntSliceValue(value, p), name, "", usage)
-}
-
-// IntSliceVarP is like IntSliceVar, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) IntSliceVarP(p *[]int, name, shorthand string, value []int, usage string) {
-	f.VarP(newIntSliceValue(value, p), name, shorthand, usage)
-}
-
-// IntSliceVar defines a int[] flag with specified name, default value, and usage string.
-// The argument p points to a int[] variable in which to store the value of the flag.
-func IntSliceVar(p *[]int, name string, value []int, usage string) {
-	CommandLine.VarP(newIntSliceValue(value, p), name, "", usage)
-}
-
-// IntSliceVarP is like IntSliceVar, but accepts a shorthand letter that can be used after a single dash.
-func IntSliceVarP(p *[]int, name, shorthand string, value []int, usage string) {
-	CommandLine.VarP(newIntSliceValue(value, p), name, shorthand, usage)
-}
-
-// IntSlice defines a []int flag with specified name, default value, and usage string.
-// The return value is the address of a []int variable that stores the value of the flag.
-func (f *FlagSet) IntSlice(name string, value []int, usage string) *[]int {
-	p := []int{}
-	f.IntSliceVarP(&p, name, "", value, usage)
-	return &p
-}
-
-// IntSliceP is like IntSlice, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) IntSliceP(name, shorthand string, value []int, usage string) *[]int {
-	p := []int{}
-	f.IntSliceVarP(&p, name, shorthand, value, usage)
-	return &p
-}
-
-// IntSlice defines a []int flag with specified name, default value, and usage string.
-// The return value is the address of a []int variable that stores the value of the flag.
-func IntSlice(name string, value []int, usage string) *[]int {
-	return CommandLine.IntSliceP(name, "", value, usage)
-}
-
-// IntSliceP is like IntSlice, but accepts a shorthand letter that can be used after a single dash.
-func IntSliceP(name, shorthand string, value []int, usage string) *[]int {
-	return CommandLine.IntSliceP(name, shorthand, value, usage)
-}

vendor/github.com/spf13/pflag/int_slice_test.go

@@ -1,165 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pflag
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"testing"
-)
-
-func setUpISFlagSet(isp *[]int) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.IntSliceVar(isp, "is", []int{}, "Command separated list!")
-	return f
-}
-
-func setUpISFlagSetWithDefault(isp *[]int) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.IntSliceVar(isp, "is", []int{0, 1}, "Command separated list!")
-	return f
-}
-
-func TestEmptyIS(t *testing.T) {
-	var is []int
-	f := setUpISFlagSet(&is)
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	getIS, err := f.GetIntSlice("is")
-	if err != nil {
-		t.Fatal("got an error from GetIntSlice():", err)
-	}
-	if len(getIS) != 0 {
-		t.Fatalf("got is %v with len=%d but expected length=0", getIS, len(getIS))
-	}
-}
-
-func TestIS(t *testing.T) {
-	var is []int
-	f := setUpISFlagSet(&is)
-
-	vals := []string{"1", "2", "4", "3"}
-	arg := fmt.Sprintf("--is=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range is {
-		d, err := strconv.Atoi(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if d != v {
-			t.Fatalf("expected is[%d] to be %s but got: %d", i, vals[i], v)
-		}
-	}
-	getIS, err := f.GetIntSlice("is")
-	if err != nil {
-		t.Fatalf("got error: %v", err)
-	}
-	for i, v := range getIS {
-		d, err := strconv.Atoi(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if d != v {
-			t.Fatalf("expected is[%d] to be %s but got: %d from GetIntSlice", i, vals[i], v)
-		}
-	}
-}
-
-func TestISDefault(t *testing.T) {
-	var is []int
-	f := setUpISFlagSetWithDefault(&is)
-
-	vals := []string{"0", "1"}
-
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range is {
-		d, err := strconv.Atoi(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if d != v {
-			t.Fatalf("expected is[%d] to be %d but got: %d", i, d, v)
-		}
-	}
-
-	getIS, err := f.GetIntSlice("is")
-	if err != nil {
-		t.Fatal("got an error from GetIntSlice():", err)
-	}
-	for i, v := range getIS {
-		d, err := strconv.Atoi(vals[i])
-		if err != nil {
-			t.Fatal("got an error from GetIntSlice():", err)
-		}
-		if d != v {
-			t.Fatalf("expected is[%d] to be %d from GetIntSlice but got: %d", i, d, v)
-		}
-	}
-}
-
-func TestISWithDefault(t *testing.T) {
-	var is []int
-	f := setUpISFlagSetWithDefault(&is)
-
-	vals := []string{"1", "2"}
-	arg := fmt.Sprintf("--is=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range is {
-		d, err := strconv.Atoi(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if d != v {
-			t.Fatalf("expected is[%d] to be %d but got: %d", i, d, v)
-		}
-	}
-
-	getIS, err := f.GetIntSlice("is")
-	if err != nil {
-		t.Fatal("got an error from GetIntSlice():", err)
-	}
-	for i, v := range getIS {
-		d, err := strconv.Atoi(vals[i])
-		if err != nil {
-			t.Fatalf("got error: %v", err)
-		}
-		if d != v {
-			t.Fatalf("expected is[%d] to be %d from GetIntSlice but got: %d", i, d, v)
-		}
-	}
-}
-
-func TestISCalledTwice(t *testing.T) {
-	var is []int
-	f := setUpISFlagSet(&is)
-
-	in := []string{"1,2", "3"}
-	expected := []int{1, 2, 3}
-	argfmt := "--is=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	err := f.Parse([]string{arg1, arg2})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range is {
-		if expected[i] != v {
-			t.Fatalf("expected is[%d] to be %d but got: %d", i, expected[i], v)
-		}
-	}
-}

vendor/github.com/spf13/pflag/ip.go

@@ -1,94 +0,0 @@
-package pflag
-
-import (
-	"fmt"
-	"net"
-	"strings"
-)
-
-// -- net.IP value
-type ipValue net.IP
-
-func newIPValue(val net.IP, p *net.IP) *ipValue {
-	*p = val
-	return (*ipValue)(p)
-}
-
-func (i *ipValue) String() string { return net.IP(*i).String() }
-func (i *ipValue) Set(s string) error {
-	ip := net.ParseIP(strings.TrimSpace(s))
-	if ip == nil {
-		return fmt.Errorf("failed to parse IP: %q", s)
-	}
-	*i = ipValue(ip)
-	return nil
-}
-
-func (i *ipValue) Type() string {
-	return "ip"
-}
-
-func ipConv(sval string) (interface{}, error) {
-	ip := net.ParseIP(sval)
-	if ip != nil {
-		return ip, nil
-	}
-	return nil, fmt.Errorf("invalid string being converted to IP address: %s", sval)
-}
-
-// GetIP return the net.IP value of a flag with the given name
-func (f *FlagSet) GetIP(name string) (net.IP, error) {
-	val, err := f.getFlagType(name, "ip", ipConv)
-	if err != nil {
-		return nil, err
-	}
-	return val.(net.IP), nil
-}
-
-// IPVar defines an net.IP flag with specified name, default value, and usage string.
-// The argument p points to an net.IP variable in which to store the value of the flag.
-func (f *FlagSet) IPVar(p *net.IP, name string, value net.IP, usage string) {
-	f.VarP(newIPValue(value, p), name, "", usage)
-}
-
-// IPVarP is like IPVar, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) IPVarP(p *net.IP, name, shorthand string, value net.IP, usage string) {
-	f.VarP(newIPValue(value, p), name, shorthand, usage)
-}
-
-// IPVar defines an net.IP flag with specified name, default value, and usage string.
-// The argument p points to an net.IP variable in which to store the value of the flag.
-func IPVar(p *net.IP, name string, value net.IP, usage string) {
-	CommandLine.VarP(newIPValue(value, p), name, "", usage)
-}
-
-// IPVarP is like IPVar, but accepts a shorthand letter that can be used after a single dash.
-func IPVarP(p *net.IP, name, shorthand string, value net.IP, usage string) {
-	CommandLine.VarP(newIPValue(value, p), name, shorthand, usage)
-}
-
-// IP defines an net.IP flag with specified name, default value, and usage string.
-// The return value is the address of an net.IP variable that stores the value of the flag.
-func (f *FlagSet) IP(name string, value net.IP, usage string) *net.IP {
-	p := new(net.IP)
-	f.IPVarP(p, name, "", value, usage)
-	return p
-}
-
-// IPP is like IP, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) IPP(name, shorthand string, value net.IP, usage string) *net.IP {
-	p := new(net.IP)
-	f.IPVarP(p, name, shorthand, value, usage)
-	return p
-}
-
-// IP defines an net.IP flag with specified name, default value, and usage string.
-// The return value is the address of an net.IP variable that stores the value of the flag.
-func IP(name string, value net.IP, usage string) *net.IP {
-	return CommandLine.IPP(name, "", value, usage)
-}
-
-// IPP is like IP, but accepts a shorthand letter that can be used after a single dash.
-func IPP(name, shorthand string, value net.IP, usage string) *net.IP {
-	return CommandLine.IPP(name, shorthand, value, usage)
-}

vendor/github.com/spf13/pflag/ip_slice.go

@@ -1,148 +0,0 @@
-package pflag
-
-import (
-	"fmt"
-	"io"
-	"net"
-	"strings"
-)
-
-// -- ipSlice Value
-type ipSliceValue struct {
-	value   *[]net.IP
-	changed bool
-}
-
-func newIPSliceValue(val []net.IP, p *[]net.IP) *ipSliceValue {
-	ipsv := new(ipSliceValue)
-	ipsv.value = p
-	*ipsv.value = val
-	return ipsv
-}
-
-// Set converts, and assigns, the comma-separated IP argument string representation as the []net.IP value of this flag.
-// If Set is called on a flag that already has a []net.IP assigned, the newly converted values will be appended.
-func (s *ipSliceValue) Set(val string) error {
-
-	// remove all quote characters
-	rmQuote := strings.NewReplacer(`"`, "", `'`, "", "`", "")
-
-	// read flag arguments with CSV parser
-	ipStrSlice, err := readAsCSV(rmQuote.Replace(val))
-	if err != nil && err != io.EOF {
-		return err
-	}
-
-	// parse ip values into slice
-	out := make([]net.IP, 0, len(ipStrSlice))
-	for _, ipStr := range ipStrSlice {
-		ip := net.ParseIP(strings.TrimSpace(ipStr))
-		if ip == nil {
-			return fmt.Errorf("invalid string being converted to IP address: %s", ipStr)
-		}
-		out = append(out, ip)
-	}
-
-	if !s.changed {
-		*s.value = out
-	} else {
-		*s.value = append(*s.value, out...)
-	}
-
-	s.changed = true
-
-	return nil
-}
-
-// Type returns a string that uniquely represents this flag's type.
-func (s *ipSliceValue) Type() string {
-	return "ipSlice"
-}
-
-// String defines a "native" format for this net.IP slice flag value.
-func (s *ipSliceValue) String() string {
-
-	ipStrSlice := make([]string, len(*s.value))
-	for i, ip := range *s.value {
-		ipStrSlice[i] = ip.String()
-	}
-
-	out, _ := writeAsCSV(ipStrSlice)
-
-	return "[" + out + "]"
-}
-
-func ipSliceConv(val string) (interface{}, error) {
-	val = strings.Trim(val, "[]")
-	// Emtpy string would cause a slice with one (empty) entry
-	if len(val) == 0 {
-		return []net.IP{}, nil
-	}
-	ss := strings.Split(val, ",")
-	out := make([]net.IP, len(ss))
-	for i, sval := range ss {
-		ip := net.ParseIP(strings.TrimSpace(sval))
-		if ip == nil {
-			return nil, fmt.Errorf("invalid string being converted to IP address: %s", sval)
-		}
-		out[i] = ip
-	}
-	return out, nil
-}
-
-// GetIPSlice returns the []net.IP value of a flag with the given name
-func (f *FlagSet) GetIPSlice(name string) ([]net.IP, error) {
-	val, err := f.getFlagType(name, "ipSlice", ipSliceConv)
-	if err != nil {
-		return []net.IP{}, err
-	}
-	return val.([]net.IP), nil
-}
-
-// IPSliceVar defines a ipSlice flag with specified name, default value, and usage string.
-// The argument p points to a []net.IP variable in which to store the value of the flag.
-func (f *FlagSet) IPSliceVar(p *[]net.IP, name string, value []net.IP, usage string) {
-	f.VarP(newIPSliceValue(value, p), name, "", usage)
-}
-
-// IPSliceVarP is like IPSliceVar, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) IPSliceVarP(p *[]net.IP, name, shorthand string, value []net.IP, usage string) {
-	f.VarP(newIPSliceValue(value, p), name, shorthand, usage)
-}
-
-// IPSliceVar defines a []net.IP flag with specified name, default value, and usage string.
-// The argument p points to a []net.IP variable in which to store the value of the flag.
-func IPSliceVar(p *[]net.IP, name string, value []net.IP, usage string) {
-	CommandLine.VarP(newIPSliceValue(value, p), name, "", usage)
-}
-
-// IPSliceVarP is like IPSliceVar, but accepts a shorthand letter that can be used after a single dash.
-func IPSliceVarP(p *[]net.IP, name, shorthand string, value []net.IP, usage string) {
-	CommandLine.VarP(newIPSliceValue(value, p), name, shorthand, usage)
-}
-
-// IPSlice defines a []net.IP flag with specified name, default value, and usage string.
-// The return value is the address of a []net.IP variable that stores the value of that flag.
-func (f *FlagSet) IPSlice(name string, value []net.IP, usage string) *[]net.IP {
-	p := []net.IP{}
-	f.IPSliceVarP(&p, name, "", value, usage)
-	return &p
-}
-
-// IPSliceP is like IPSlice, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) IPSliceP(name, shorthand string, value []net.IP, usage string) *[]net.IP {
-	p := []net.IP{}
-	f.IPSliceVarP(&p, name, shorthand, value, usage)
-	return &p
-}
-
-// IPSlice defines a []net.IP flag with specified name, default value, and usage string.
-// The return value is the address of a []net.IP variable that stores the value of the flag.
-func IPSlice(name string, value []net.IP, usage string) *[]net.IP {
-	return CommandLine.IPSliceP(name, "", value, usage)
-}
-
-// IPSliceP is like IPSlice, but accepts a shorthand letter that can be used after a single dash.
-func IPSliceP(name, shorthand string, value []net.IP, usage string) *[]net.IP {
-	return CommandLine.IPSliceP(name, shorthand, value, usage)
-}

vendor/github.com/spf13/pflag/ip_slice_test.go

@@ -1,222 +0,0 @@
-package pflag
-
-import (
-	"fmt"
-	"net"
-	"strings"
-	"testing"
-)
-
-func setUpIPSFlagSet(ipsp *[]net.IP) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.IPSliceVar(ipsp, "ips", []net.IP{}, "Command separated list!")
-	return f
-}
-
-func setUpIPSFlagSetWithDefault(ipsp *[]net.IP) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.IPSliceVar(ipsp, "ips",
-		[]net.IP{
-			net.ParseIP("192.168.1.1"),
-			net.ParseIP("0:0:0:0:0:0:0:1"),
-		},
-		"Command separated list!")
-	return f
-}
-
-func TestEmptyIP(t *testing.T) {
-	var ips []net.IP
-	f := setUpIPSFlagSet(&ips)
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	getIPS, err := f.GetIPSlice("ips")
-	if err != nil {
-		t.Fatal("got an error from GetIPSlice():", err)
-	}
-	if len(getIPS) != 0 {
-		t.Fatalf("got ips %v with len=%d but expected length=0", getIPS, len(getIPS))
-	}
-}
-
-func TestIPS(t *testing.T) {
-	var ips []net.IP
-	f := setUpIPSFlagSet(&ips)
-
-	vals := []string{"192.168.1.1", "10.0.0.1", "0:0:0:0:0:0:0:2"}
-	arg := fmt.Sprintf("--ips=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ips {
-		if ip := net.ParseIP(vals[i]); ip == nil {
-			t.Fatalf("invalid string being converted to IP address: %s", vals[i])
-		} else if !ip.Equal(v) {
-			t.Fatalf("expected ips[%d] to be %s but got: %s from GetIPSlice", i, vals[i], v)
-		}
-	}
-}
-
-func TestIPSDefault(t *testing.T) {
-	var ips []net.IP
-	f := setUpIPSFlagSetWithDefault(&ips)
-
-	vals := []string{"192.168.1.1", "0:0:0:0:0:0:0:1"}
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ips {
-		if ip := net.ParseIP(vals[i]); ip == nil {
-			t.Fatalf("invalid string being converted to IP address: %s", vals[i])
-		} else if !ip.Equal(v) {
-			t.Fatalf("expected ips[%d] to be %s but got: %s", i, vals[i], v)
-		}
-	}
-
-	getIPS, err := f.GetIPSlice("ips")
-	if err != nil {
-		t.Fatal("got an error from GetIPSlice")
-	}
-	for i, v := range getIPS {
-		if ip := net.ParseIP(vals[i]); ip == nil {
-			t.Fatalf("invalid string being converted to IP address: %s", vals[i])
-		} else if !ip.Equal(v) {
-			t.Fatalf("expected ips[%d] to be %s but got: %s", i, vals[i], v)
-		}
-	}
-}
-
-func TestIPSWithDefault(t *testing.T) {
-	var ips []net.IP
-	f := setUpIPSFlagSetWithDefault(&ips)
-
-	vals := []string{"192.168.1.1", "0:0:0:0:0:0:0:1"}
-	arg := fmt.Sprintf("--ips=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ips {
-		if ip := net.ParseIP(vals[i]); ip == nil {
-			t.Fatalf("invalid string being converted to IP address: %s", vals[i])
-		} else if !ip.Equal(v) {
-			t.Fatalf("expected ips[%d] to be %s but got: %s", i, vals[i], v)
-		}
-	}
-
-	getIPS, err := f.GetIPSlice("ips")
-	if err != nil {
-		t.Fatal("got an error from GetIPSlice")
-	}
-	for i, v := range getIPS {
-		if ip := net.ParseIP(vals[i]); ip == nil {
-			t.Fatalf("invalid string being converted to IP address: %s", vals[i])
-		} else if !ip.Equal(v) {
-			t.Fatalf("expected ips[%d] to be %s but got: %s", i, vals[i], v)
-		}
-	}
-}
-
-func TestIPSCalledTwice(t *testing.T) {
-	var ips []net.IP
-	f := setUpIPSFlagSet(&ips)
-
-	in := []string{"192.168.1.2,0:0:0:0:0:0:0:1", "10.0.0.1"}
-	expected := []net.IP{net.ParseIP("192.168.1.2"), net.ParseIP("0:0:0:0:0:0:0:1"), net.ParseIP("10.0.0.1")}
-	argfmt := "ips=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	err := f.Parse([]string{arg1, arg2})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ips {
-		if !expected[i].Equal(v) {
-			t.Fatalf("expected ips[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-}
-
-func TestIPSBadQuoting(t *testing.T) {
-
-	tests := []struct {
-		Want    []net.IP
-		FlagArg []string
-	}{
-		{
-			Want: []net.IP{
-				net.ParseIP("a4ab:61d:f03e:5d7d:fad7:d4c2:a1a5:568"),
-				net.ParseIP("203.107.49.208"),
-				net.ParseIP("14.57.204.90"),
-			},
-			FlagArg: []string{
-				"a4ab:61d:f03e:5d7d:fad7:d4c2:a1a5:568",
-				"203.107.49.208",
-				"14.57.204.90",
-			},
-		},
-		{
-			Want: []net.IP{
-				net.ParseIP("204.228.73.195"),
-				net.ParseIP("86.141.15.94"),
-			},
-			FlagArg: []string{
-				"204.228.73.195",
-				"86.141.15.94",
-			},
-		},
-		{
-			Want: []net.IP{
-				net.ParseIP("c70c:db36:3001:890f:c6ea:3f9b:7a39:cc3f"),
-				net.ParseIP("4d17:1d6e:e699:bd7a:88c5:5e7e:ac6a:4472"),
-			},
-			FlagArg: []string{
-				"c70c:db36:3001:890f:c6ea:3f9b:7a39:cc3f",
-				"4d17:1d6e:e699:bd7a:88c5:5e7e:ac6a:4472",
-			},
-		},
-		{
-			Want: []net.IP{
-				net.ParseIP("5170:f971:cfac:7be3:512a:af37:952c:bc33"),
-				net.ParseIP("93.21.145.140"),
-				net.ParseIP("2cac:61d3:c5ff:6caf:73e0:1b1a:c336:c1ca"),
-			},
-			FlagArg: []string{
-				" 5170:f971:cfac:7be3:512a:af37:952c:bc33  , 93.21.145.140     ",
-				"2cac:61d3:c5ff:6caf:73e0:1b1a:c336:c1ca",
-			},
-		},
-		{
-			Want: []net.IP{
-				net.ParseIP("2e5e:66b2:6441:848:5b74:76ea:574c:3a7b"),
-				net.ParseIP("2e5e:66b2:6441:848:5b74:76ea:574c:3a7b"),
-				net.ParseIP("2e5e:66b2:6441:848:5b74:76ea:574c:3a7b"),
-				net.ParseIP("2e5e:66b2:6441:848:5b74:76ea:574c:3a7b"),
-			},
-			FlagArg: []string{
-				`"2e5e:66b2:6441:848:5b74:76ea:574c:3a7b,        2e5e:66b2:6441:848:5b74:76ea:574c:3a7b,2e5e:66b2:6441:848:5b74:76ea:574c:3a7b     "`,
-				" 2e5e:66b2:6441:848:5b74:76ea:574c:3a7b"},
-		},
-	}
-
-	for i, test := range tests {
-
-		var ips []net.IP
-		f := setUpIPSFlagSet(&ips)
-
-		if err := f.Parse([]string{fmt.Sprintf("--ips=%s", strings.Join(test.FlagArg, ","))}); err != nil {
-			t.Fatalf("flag parsing failed with error: %s\nparsing:\t%#v\nwant:\t\t%s",
-				err, test.FlagArg, test.Want[i])
-		}
-
-		for j, b := range ips {
-			if !b.Equal(test.Want[j]) {
-				t.Fatalf("bad value parsed for test %d on net.IP %d:\nwant:\t%s\ngot:\t%s", i, j, test.Want[j], b)
-			}
-		}
-	}
-}

vendor/github.com/spf13/pflag/ip_test.go

@@ -1,63 +0,0 @@
-package pflag
-
-import (
-	"fmt"
-	"net"
-	"os"
-	"testing"
-)
-
-func setUpIP(ip *net.IP) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.IPVar(ip, "address", net.ParseIP("0.0.0.0"), "IP Address")
-	return f
-}
-
-func TestIP(t *testing.T) {
-	testCases := []struct {
-		input    string
-		success  bool
-		expected string
-	}{
-		{"0.0.0.0", true, "0.0.0.0"},
-		{" 0.0.0.0 ", true, "0.0.0.0"},
-		{"1.2.3.4", true, "1.2.3.4"},
-		{"127.0.0.1", true, "127.0.0.1"},
-		{"255.255.255.255", true, "255.255.255.255"},
-		{"", false, ""},
-		{"0", false, ""},
-		{"localhost", false, ""},
-		{"0.0.0", false, ""},
-		{"0.0.0.", false, ""},
-		{"0.0.0.0.", false, ""},
-		{"0.0.0.256", false, ""},
-		{"0 . 0 . 0 . 0", false, ""},
-	}
-
-	devnull, _ := os.Open(os.DevNull)
-	os.Stderr = devnull
-	for i := range testCases {
-		var addr net.IP
-		f := setUpIP(&addr)
-
-		tc := &testCases[i]
-
-		arg := fmt.Sprintf("--address=%s", tc.input)
-		err := f.Parse([]string{arg})
-		if err != nil && tc.success == true {
-			t.Errorf("expected success, got %q", err)
-			continue
-		} else if err == nil && tc.success == false {
-			t.Errorf("expected failure")
-			continue
-		} else if tc.success {
-			ip, err := f.GetIP("address")
-			if err != nil {
-				t.Errorf("Got error trying to fetch the IP flag: %v", err)
-			}
-			if ip.String() != tc.expected {
-				t.Errorf("expected %q, got %q", tc.expected, ip.String())
-			}
-		}
-	}
-}

vendor/github.com/spf13/pflag/ipmask.go

@@ -1,122 +0,0 @@
-package pflag
-
-import (
-	"fmt"
-	"net"
-	"strconv"
-)
-
-// -- net.IPMask value
-type ipMaskValue net.IPMask
-
-func newIPMaskValue(val net.IPMask, p *net.IPMask) *ipMaskValue {
-	*p = val
-	return (*ipMaskValue)(p)
-}
-
-func (i *ipMaskValue) String() string { return net.IPMask(*i).String() }
-func (i *ipMaskValue) Set(s string) error {
-	ip := ParseIPv4Mask(s)
-	if ip == nil {
-		return fmt.Errorf("failed to parse IP mask: %q", s)
-	}
-	*i = ipMaskValue(ip)
-	return nil
-}
-
-func (i *ipMaskValue) Type() string {
-	return "ipMask"
-}
-
-// ParseIPv4Mask written in IP form (e.g. 255.255.255.0).
-// This function should really belong to the net package.
-func ParseIPv4Mask(s string) net.IPMask {
-	mask := net.ParseIP(s)
-	if mask == nil {
-		if len(s) != 8 {
-			return nil
-		}
-		// net.IPMask.String() actually outputs things like ffffff00
-		// so write a horrible parser for that as well  :-(
-		m := []int{}
-		for i := 0; i < 4; i++ {
-			b := "0x" + s[2*i:2*i+2]
-			d, err := strconv.ParseInt(b, 0, 0)
-			if err != nil {
-				return nil
-			}
-			m = append(m, int(d))
-		}
-		s := fmt.Sprintf("%d.%d.%d.%d", m[0], m[1], m[2], m[3])
-		mask = net.ParseIP(s)
-		if mask == nil {
-			return nil
-		}
-	}
-	return net.IPv4Mask(mask[12], mask[13], mask[14], mask[15])
-}
-
-func parseIPv4Mask(sval string) (interface{}, error) {
-	mask := ParseIPv4Mask(sval)
-	if mask == nil {
-		return nil, fmt.Errorf("unable to parse %s as net.IPMask", sval)
-	}
-	return mask, nil
-}
-
-// GetIPv4Mask return the net.IPv4Mask value of a flag with the given name
-func (f *FlagSet) GetIPv4Mask(name string) (net.IPMask, error) {
-	val, err := f.getFlagType(name, "ipMask", parseIPv4Mask)
-	if err != nil {
-		return nil, err
-	}
-	return val.(net.IPMask), nil
-}
-
-// IPMaskVar defines an net.IPMask flag with specified name, default value, and usage string.
-// The argument p points to an net.IPMask variable in which to store the value of the flag.
-func (f *FlagSet) IPMaskVar(p *net.IPMask, name string, value net.IPMask, usage string) {
-	f.VarP(newIPMaskValue(value, p), name, "", usage)
-}
-
-// IPMaskVarP is like IPMaskVar, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) IPMaskVarP(p *net.IPMask, name, shorthand string, value net.IPMask, usage string) {
-	f.VarP(newIPMaskValue(value, p), name, shorthand, usage)
-}
-
-// IPMaskVar defines an net.IPMask flag with specified name, default value, and usage string.
-// The argument p points to an net.IPMask variable in which to store the value of the flag.
-func IPMaskVar(p *net.IPMask, name string, value net.IPMask, usage string) {
-	CommandLine.VarP(newIPMaskValue(value, p), name, "", usage)
-}
-
-// IPMaskVarP is like IPMaskVar, but accepts a shorthand letter that can be used after a single dash.
-func IPMaskVarP(p *net.IPMask, name, shorthand string, value net.IPMask, usage string) {
-	CommandLine.VarP(newIPMaskValue(value, p), name, shorthand, usage)
-}
-
-// IPMask defines an net.IPMask flag with specified name, default value, and usage string.
-// The return value is the address of an net.IPMask variable that stores the value of the flag.
-func (f *FlagSet) IPMask(name string, value net.IPMask, usage string) *net.IPMask {
-	p := new(net.IPMask)
-	f.IPMaskVarP(p, name, "", value, usage)
-	return p
-}
-
-// IPMaskP is like IPMask, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) IPMaskP(name, shorthand string, value net.IPMask, usage string) *net.IPMask {
-	p := new(net.IPMask)
-	f.IPMaskVarP(p, name, shorthand, value, usage)
-	return p
-}
-
-// IPMask defines an net.IPMask flag with specified name, default value, and usage string.
-// The return value is the address of an net.IPMask variable that stores the value of the flag.
-func IPMask(name string, value net.IPMask, usage string) *net.IPMask {
-	return CommandLine.IPMaskP(name, "", value, usage)
-}
-
-// IPMaskP is like IP, but accepts a shorthand letter that can be used after a single dash.
-func IPMaskP(name, shorthand string, value net.IPMask, usage string) *net.IPMask {
-	return CommandLine.IPMaskP(name, shorthand, value, usage)
-}

vendor/github.com/spf13/pflag/ipnet.go

@@ -1,98 +0,0 @@
-package pflag
-
-import (
-	"fmt"
-	"net"
-	"strings"
-)
-
-// IPNet adapts net.IPNet for use as a flag.
-type ipNetValue net.IPNet
-
-func (ipnet ipNetValue) String() string {
-	n := net.IPNet(ipnet)
-	return n.String()
-}
-
-func (ipnet *ipNetValue) Set(value string) error {
-	_, n, err := net.ParseCIDR(strings.TrimSpace(value))
-	if err != nil {
-		return err
-	}
-	*ipnet = ipNetValue(*n)
-	return nil
-}
-
-func (*ipNetValue) Type() string {
-	return "ipNet"
-}
-
-func newIPNetValue(val net.IPNet, p *net.IPNet) *ipNetValue {
-	*p = val
-	return (*ipNetValue)(p)
-}
-
-func ipNetConv(sval string) (interface{}, error) {
-	_, n, err := net.ParseCIDR(strings.TrimSpace(sval))
-	if err == nil {
-		return *n, nil
-	}
-	return nil, fmt.Errorf("invalid string being converted to IPNet: %s", sval)
-}
-
-// GetIPNet return the net.IPNet value of a flag with the given name
-func (f *FlagSet) GetIPNet(name string) (net.IPNet, error) {
-	val, err := f.getFlagType(name, "ipNet", ipNetConv)
-	if err != nil {
-		return net.IPNet{}, err
-	}
-	return val.(net.IPNet), nil
-}
-
-// IPNetVar defines an net.IPNet flag with specified name, default value, and usage string.
-// The argument p points to an net.IPNet variable in which to store the value of the flag.
-func (f *FlagSet) IPNetVar(p *net.IPNet, name string, value net.IPNet, usage string) {
-	f.VarP(newIPNetValue(value, p), name, "", usage)
-}
-
-// IPNetVarP is like IPNetVar, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) IPNetVarP(p *net.IPNet, name, shorthand string, value net.IPNet, usage string) {
-	f.VarP(newIPNetValue(value, p), name, shorthand, usage)
-}
-
-// IPNetVar defines an net.IPNet flag with specified name, default value, and usage string.
-// The argument p points to an net.IPNet variable in which to store the value of the flag.
-func IPNetVar(p *net.IPNet, name string, value net.IPNet, usage string) {
-	CommandLine.VarP(newIPNetValue(value, p), name, "", usage)
-}
-
-// IPNetVarP is like IPNetVar, but accepts a shorthand letter that can be used after a single dash.
-func IPNetVarP(p *net.IPNet, name, shorthand string, value net.IPNet, usage string) {
-	CommandLine.VarP(newIPNetValue(value, p), name, shorthand, usage)
-}
-
-// IPNet defines an net.IPNet flag with specified name, default value, and usage string.
-// The return value is the address of an net.IPNet variable that stores the value of the flag.
-func (f *FlagSet) IPNet(name string, value net.IPNet, usage string) *net.IPNet {
-	p := new(net.IPNet)
-	f.IPNetVarP(p, name, "", value, usage)
-	return p
-}
-
-// IPNetP is like IPNet, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) IPNetP(name, shorthand string, value net.IPNet, usage string) *net.IPNet {
-	p := new(net.IPNet)
-	f.IPNetVarP(p, name, shorthand, value, usage)
-	return p
-}
-
-// IPNet defines an net.IPNet flag with specified name, default value, and usage string.
-// The return value is the address of an net.IPNet variable that stores the value of the flag.
-func IPNet(name string, value net.IPNet, usage string) *net.IPNet {
-	return CommandLine.IPNetP(name, "", value, usage)
-}
-
-// IPNetP is like IPNet, but accepts a shorthand letter that can be used after a single dash.
-func IPNetP(name, shorthand string, value net.IPNet, usage string) *net.IPNet {
-	return CommandLine.IPNetP(name, shorthand, value, usage)
-}

vendor/github.com/spf13/pflag/ipnet_test.go

@@ -1,70 +0,0 @@
-package pflag
-
-import (
-	"fmt"
-	"net"
-	"os"
-	"testing"
-)
-
-func setUpIPNet(ip *net.IPNet) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	_, def, _ := net.ParseCIDR("0.0.0.0/0")
-	f.IPNetVar(ip, "address", *def, "IP Address")
-	return f
-}
-
-func TestIPNet(t *testing.T) {
-	testCases := []struct {
-		input    string
-		success  bool
-		expected string
-	}{
-		{"0.0.0.0/0", true, "0.0.0.0/0"},
-		{" 0.0.0.0/0 ", true, "0.0.0.0/0"},
-		{"1.2.3.4/8", true, "1.0.0.0/8"},
-		{"127.0.0.1/16", true, "127.0.0.0/16"},
-		{"255.255.255.255/19", true, "255.255.224.0/19"},
-		{"255.255.255.255/32", true, "255.255.255.255/32"},
-		{"", false, ""},
-		{"/0", false, ""},
-		{"0", false, ""},
-		{"0/0", false, ""},
-		{"localhost/0", false, ""},
-		{"0.0.0/4", false, ""},
-		{"0.0.0./8", false, ""},
-		{"0.0.0.0./12", false, ""},
-		{"0.0.0.256/16", false, ""},
-		{"0.0.0.0 /20", false, ""},
-		{"0.0.0.0/ 24", false, ""},
-		{"0 . 0 . 0 . 0 / 28", false, ""},
-		{"0.0.0.0/33", false, ""},
-	}
-
-	devnull, _ := os.Open(os.DevNull)
-	os.Stderr = devnull
-	for i := range testCases {
-		var addr net.IPNet
-		f := setUpIPNet(&addr)
-
-		tc := &testCases[i]
-
-		arg := fmt.Sprintf("--address=%s", tc.input)
-		err := f.Parse([]string{arg})
-		if err != nil && tc.success == true {
-			t.Errorf("expected success, got %q", err)
-			continue
-		} else if err == nil && tc.success == false {
-			t.Errorf("expected failure")
-			continue
-		} else if tc.success {
-			ip, err := f.GetIPNet("address")
-			if err != nil {
-				t.Errorf("Got error trying to fetch the IP flag: %v", err)
-			}
-			if ip.String() != tc.expected {
-				t.Errorf("expected %q, got %q", tc.expected, ip.String())
-			}
-		}
-	}
-}

vendor/github.com/spf13/pflag/string.go

@@ -1,80 +0,0 @@
-package pflag
-
-// -- string Value
-type stringValue string
-
-func newStringValue(val string, p *string) *stringValue {
-	*p = val
-	return (*stringValue)(p)
-}
-
-func (s *stringValue) Set(val string) error {
-	*s = stringValue(val)
-	return nil
-}
-func (s *stringValue) Type() string {
-	return "string"
-}
-
-func (s *stringValue) String() string { return string(*s) }
-
-func stringConv(sval string) (interface{}, error) {
-	return sval, nil
-}
-
-// GetString return the string value of a flag with the given name
-func (f *FlagSet) GetString(name string) (string, error) {
-	val, err := f.getFlagType(name, "string", stringConv)
-	if err != nil {
-		return "", err
-	}
-	return val.(string), nil
-}
-
-// StringVar defines a string flag with specified name, default value, and usage string.
-// The argument p points to a string variable in which to store the value of the flag.
-func (f *FlagSet) StringVar(p *string, name string, value string, usage string) {
-	f.VarP(newStringValue(value, p), name, "", usage)
-}
-
-// StringVarP is like StringVar, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) StringVarP(p *string, name, shorthand string, value string, usage string) {
-	f.VarP(newStringValue(value, p), name, shorthand, usage)
-}
-
-// StringVar defines a string flag with specified name, default value, and usage string.
-// The argument p points to a string variable in which to store the value of the flag.
-func StringVar(p *string, name string, value string, usage string) {
-	CommandLine.VarP(newStringValue(value, p), name, "", usage)
-}
-
-// StringVarP is like StringVar, but accepts a shorthand letter that can be used after a single dash.
-func StringVarP(p *string, name, shorthand string, value string, usage string) {
-	CommandLine.VarP(newStringValue(value, p), name, shorthand, usage)
-}
-
-// String defines a string flag with specified name, default value, and usage string.
-// The return value is the address of a string variable that stores the value of the flag.
-func (f *FlagSet) String(name string, value string, usage string) *string {
-	p := new(string)
-	f.StringVarP(p, name, "", value, usage)
-	return p
-}
-
-// StringP is like String, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) StringP(name, shorthand string, value string, usage string) *string {
-	p := new(string)
-	f.StringVarP(p, name, shorthand, value, usage)
-	return p
-}
-
-// String defines a string flag with specified name, default value, and usage string.
-// The return value is the address of a string variable that stores the value of the flag.
-func String(name string, value string, usage string) *string {
-	return CommandLine.StringP(name, "", value, usage)
-}
-
-// StringP is like String, but accepts a shorthand letter that can be used after a single dash.
-func StringP(name, shorthand string, value string, usage string) *string {
-	return CommandLine.StringP(name, shorthand, value, usage)
-}

vendor/github.com/spf13/pflag/string_array.go

@@ -1,103 +0,0 @@
-package pflag
-
-// -- stringArray Value
-type stringArrayValue struct {
-	value   *[]string
-	changed bool
-}
-
-func newStringArrayValue(val []string, p *[]string) *stringArrayValue {
-	ssv := new(stringArrayValue)
-	ssv.value = p
-	*ssv.value = val
-	return ssv
-}
-
-func (s *stringArrayValue) Set(val string) error {
-	if !s.changed {
-		*s.value = []string{val}
-		s.changed = true
-	} else {
-		*s.value = append(*s.value, val)
-	}
-	return nil
-}
-
-func (s *stringArrayValue) Type() string {
-	return "stringArray"
-}
-
-func (s *stringArrayValue) String() string {
-	str, _ := writeAsCSV(*s.value)
-	return "[" + str + "]"
-}
-
-func stringArrayConv(sval string) (interface{}, error) {
-	sval = sval[1 : len(sval)-1]
-	// An empty string would cause a array with one (empty) string
-	if len(sval) == 0 {
-		return []string{}, nil
-	}
-	return readAsCSV(sval)
-}
-
-// GetStringArray return the []string value of a flag with the given name
-func (f *FlagSet) GetStringArray(name string) ([]string, error) {
-	val, err := f.getFlagType(name, "stringArray", stringArrayConv)
-	if err != nil {
-		return []string{}, err
-	}
-	return val.([]string), nil
-}
-
-// StringArrayVar defines a string flag with specified name, default value, and usage string.
-// The argument p points to a []string variable in which to store the values of the multiple flags.
-// The value of each argument will not try to be separated by comma
-func (f *FlagSet) StringArrayVar(p *[]string, name string, value []string, usage string) {
-	f.VarP(newStringArrayValue(value, p), name, "", usage)
-}
-
-// StringArrayVarP is like StringArrayVar, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) StringArrayVarP(p *[]string, name, shorthand string, value []string, usage string) {
-	f.VarP(newStringArrayValue(value, p), name, shorthand, usage)
-}
-
-// StringArrayVar defines a string flag with specified name, default value, and usage string.
-// The argument p points to a []string variable in which to store the value of the flag.
-// The value of each argument will not try to be separated by comma
-func StringArrayVar(p *[]string, name string, value []string, usage string) {
-	CommandLine.VarP(newStringArrayValue(value, p), name, "", usage)
-}
-
-// StringArrayVarP is like StringArrayVar, but accepts a shorthand letter that can be used after a single dash.
-func StringArrayVarP(p *[]string, name, shorthand string, value []string, usage string) {
-	CommandLine.VarP(newStringArrayValue(value, p), name, shorthand, usage)
-}
-
-// StringArray defines a string flag with specified name, default value, and usage string.
-// The return value is the address of a []string variable that stores the value of the flag.
-// The value of each argument will not try to be separated by comma
-func (f *FlagSet) StringArray(name string, value []string, usage string) *[]string {
-	p := []string{}
-	f.StringArrayVarP(&p, name, "", value, usage)
-	return &p
-}
-
-// StringArrayP is like StringArray, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) StringArrayP(name, shorthand string, value []string, usage string) *[]string {
-	p := []string{}
-	f.StringArrayVarP(&p, name, shorthand, value, usage)
-	return &p
-}
-
-// StringArray defines a string flag with specified name, default value, and usage string.
-// The return value is the address of a []string variable that stores the value of the flag.
-// The value of each argument will not try to be separated by comma
-func StringArray(name string, value []string, usage string) *[]string {
-	return CommandLine.StringArrayP(name, "", value, usage)
-}
-
-// StringArrayP is like StringArray, but accepts a shorthand letter that can be used after a single dash.
-func StringArrayP(name, shorthand string, value []string, usage string) *[]string {
-	return CommandLine.StringArrayP(name, shorthand, value, usage)
-}

vendor/github.com/spf13/pflag/string_array_test.go

@@ -1,233 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pflag
-
-import (
-	"fmt"
-	"testing"
-)
-
-func setUpSAFlagSet(sap *[]string) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.StringArrayVar(sap, "sa", []string{}, "Command separated list!")
-	return f
-}
-
-func setUpSAFlagSetWithDefault(sap *[]string) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.StringArrayVar(sap, "sa", []string{"default", "values"}, "Command separated list!")
-	return f
-}
-
-func TestEmptySA(t *testing.T) {
-	var sa []string
-	f := setUpSAFlagSet(&sa)
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	getSA, err := f.GetStringArray("sa")
-	if err != nil {
-		t.Fatal("got an error from GetStringArray():", err)
-	}
-	if len(getSA) != 0 {
-		t.Fatalf("got sa %v with len=%d but expected length=0", getSA, len(getSA))
-	}
-}
-
-func TestEmptySAValue(t *testing.T) {
-	var sa []string
-	f := setUpSAFlagSet(&sa)
-	err := f.Parse([]string{"--sa="})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	getSA, err := f.GetStringArray("sa")
-	if err != nil {
-		t.Fatal("got an error from GetStringArray():", err)
-	}
-	if len(getSA) != 0 {
-		t.Fatalf("got sa %v with len=%d but expected length=0", getSA, len(getSA))
-	}
-}
-
-func TestSADefault(t *testing.T) {
-	var sa []string
-	f := setUpSAFlagSetWithDefault(&sa)
-
-	vals := []string{"default", "values"}
-
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range sa {
-		if vals[i] != v {
-			t.Fatalf("expected sa[%d] to be %s but got: %s", i, vals[i], v)
-		}
-	}
-
-	getSA, err := f.GetStringArray("sa")
-	if err != nil {
-		t.Fatal("got an error from GetStringArray():", err)
-	}
-	for i, v := range getSA {
-		if vals[i] != v {
-			t.Fatalf("expected sa[%d] to be %s from GetStringArray but got: %s", i, vals[i], v)
-		}
-	}
-}
-
-func TestSAWithDefault(t *testing.T) {
-	var sa []string
-	f := setUpSAFlagSetWithDefault(&sa)
-
-	val := "one"
-	arg := fmt.Sprintf("--sa=%s", val)
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(sa) != 1 {
-		t.Fatalf("expected number of values to be %d but %d", 1, len(sa))
-	}
-
-	if sa[0] != val {
-		t.Fatalf("expected value to be %s but got: %s", sa[0], val)
-	}
-
-	getSA, err := f.GetStringArray("sa")
-	if err != nil {
-		t.Fatal("got an error from GetStringArray():", err)
-	}
-
-	if len(getSA) != 1 {
-		t.Fatalf("expected number of values to be %d but %d", 1, len(getSA))
-	}
-
-	if getSA[0] != val {
-		t.Fatalf("expected value to be %s but got: %s", getSA[0], val)
-	}
-}
-
-func TestSACalledTwice(t *testing.T) {
-	var sa []string
-	f := setUpSAFlagSet(&sa)
-
-	in := []string{"one", "two"}
-	expected := []string{"one", "two"}
-	argfmt := "--sa=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	err := f.Parse([]string{arg1, arg2})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(sa) {
-		t.Fatalf("expected number of sa to be %d but got: %d", len(expected), len(sa))
-	}
-	for i, v := range sa {
-		if expected[i] != v {
-			t.Fatalf("expected sa[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-
-	values, err := f.GetStringArray("sa")
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(values) {
-		t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(sa))
-	}
-	for i, v := range values {
-		if expected[i] != v {
-			t.Fatalf("expected got sa[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-}
-
-func TestSAWithSpecialChar(t *testing.T) {
-	var sa []string
-	f := setUpSAFlagSet(&sa)
-
-	in := []string{"one,two", `"three"`, `"four,five",six`, "seven eight"}
-	expected := []string{"one,two", `"three"`, `"four,five",six`, "seven eight"}
-	argfmt := "--sa=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	arg3 := fmt.Sprintf(argfmt, in[2])
-	arg4 := fmt.Sprintf(argfmt, in[3])
-	err := f.Parse([]string{arg1, arg2, arg3, arg4})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(sa) {
-		t.Fatalf("expected number of sa to be %d but got: %d", len(expected), len(sa))
-	}
-	for i, v := range sa {
-		if expected[i] != v {
-			t.Fatalf("expected sa[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-
-	values, err := f.GetStringArray("sa")
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(values) {
-		t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
-	}
-	for i, v := range values {
-		if expected[i] != v {
-			t.Fatalf("expected got sa[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-}
-
-func TestSAWithSquareBrackets(t *testing.T) {
-	var sa []string
-	f := setUpSAFlagSet(&sa)
-
-	in := []string{"][]-[", "[a-z]", "[a-z]+"}
-	expected := []string{"][]-[", "[a-z]", "[a-z]+"}
-	argfmt := "--sa=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	arg3 := fmt.Sprintf(argfmt, in[2])
-	err := f.Parse([]string{arg1, arg2, arg3})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(sa) {
-		t.Fatalf("expected number of sa to be %d but got: %d", len(expected), len(sa))
-	}
-	for i, v := range sa {
-		if expected[i] != v {
-			t.Fatalf("expected sa[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-
-	values, err := f.GetStringArray("sa")
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(values) {
-		t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
-	}
-	for i, v := range values {
-		if expected[i] != v {
-			t.Fatalf("expected got sa[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-}

vendor/github.com/spf13/pflag/string_slice.go

@@ -1,129 +0,0 @@
-package pflag
-
-import (
-	"bytes"
-	"encoding/csv"
-	"strings"
-)
-
-// -- stringSlice Value
-type stringSliceValue struct {
-	value   *[]string
-	changed bool
-}
-
-func newStringSliceValue(val []string, p *[]string) *stringSliceValue {
-	ssv := new(stringSliceValue)
-	ssv.value = p
-	*ssv.value = val
-	return ssv
-}
-
-func readAsCSV(val string) ([]string, error) {
-	if val == "" {
-		return []string{}, nil
-	}
-	stringReader := strings.NewReader(val)
-	csvReader := csv.NewReader(stringReader)
-	return csvReader.Read()
-}
-
-func writeAsCSV(vals []string) (string, error) {
-	b := &bytes.Buffer{}
-	w := csv.NewWriter(b)
-	err := w.Write(vals)
-	if err != nil {
-		return "", err
-	}
-	w.Flush()
-	return strings.TrimSuffix(b.String(), "\n"), nil
-}
-
-func (s *stringSliceValue) Set(val string) error {
-	v, err := readAsCSV(val)
-	if err != nil {
-		return err
-	}
-	if !s.changed {
-		*s.value = v
-	} else {
-		*s.value = append(*s.value, v...)
-	}
-	s.changed = true
-	return nil
-}
-
-func (s *stringSliceValue) Type() string {
-	return "stringSlice"
-}
-
-func (s *stringSliceValue) String() string {
-	str, _ := writeAsCSV(*s.value)
-	return "[" + str + "]"
-}
-
-func stringSliceConv(sval string) (interface{}, error) {
-	sval = sval[1 : len(sval)-1]
-	// An empty string would cause a slice with one (empty) string
-	if len(sval) == 0 {
-		return []string{}, nil
-	}
-	return readAsCSV(sval)
-}
-
-// GetStringSlice return the []string value of a flag with the given name
-func (f *FlagSet) GetStringSlice(name string) ([]string, error) {
-	val, err := f.getFlagType(name, "stringSlice", stringSliceConv)
-	if err != nil {
-		return []string{}, err
-	}
-	return val.([]string), nil
-}
-
-// StringSliceVar defines a string flag with specified name, default value, and usage string.
-// The argument p points to a []string variable in which to store the value of the flag.
-func (f *FlagSet) StringSliceVar(p *[]string, name string, value []string, usage string) {
-	f.VarP(newStringSliceValue(value, p), name, "", usage)
-}
-
-// StringSliceVarP is like StringSliceVar, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) StringSliceVarP(p *[]string, name, shorthand string, value []string, usage string) {
-	f.VarP(newStringSliceValue(value, p), name, shorthand, usage)
-}
-
-// StringSliceVar defines a string flag with specified name, default value, and usage string.
-// The argument p points to a []string variable in which to store the value of the flag.
-func StringSliceVar(p *[]string, name string, value []string, usage string) {
-	CommandLine.VarP(newStringSliceValue(value, p), name, "", usage)
-}
-
-// StringSliceVarP is like StringSliceVar, but accepts a shorthand letter that can be used after a single dash.
-func StringSliceVarP(p *[]string, name, shorthand string, value []string, usage string) {
-	CommandLine.VarP(newStringSliceValue(value, p), name, shorthand, usage)
-}
-
-// StringSlice defines a string flag with specified name, default value, and usage string.
-// The return value is the address of a []string variable that stores the value of the flag.
-func (f *FlagSet) StringSlice(name string, value []string, usage string) *[]string {
-	p := []string{}
-	f.StringSliceVarP(&p, name, "", value, usage)
-	return &p
-}
-
-// StringSliceP is like StringSlice, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) StringSliceP(name, shorthand string, value []string, usage string) *[]string {
-	p := []string{}
-	f.StringSliceVarP(&p, name, shorthand, value, usage)
-	return &p
-}
-
-// StringSlice defines a string flag with specified name, default value, and usage string.
-// The return value is the address of a []string variable that stores the value of the flag.
-func StringSlice(name string, value []string, usage string) *[]string {
-	return CommandLine.StringSliceP(name, "", value, usage)
-}
-
-// StringSliceP is like StringSlice, but accepts a shorthand letter that can be used after a single dash.
-func StringSliceP(name, shorthand string, value []string, usage string) *[]string {
-	return CommandLine.StringSliceP(name, shorthand, value, usage)
-}

vendor/github.com/spf13/pflag/string_slice_test.go

@@ -1,253 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package pflag
-
-import (
-	"fmt"
-	"strings"
-	"testing"
-)
-
-func setUpSSFlagSet(ssp *[]string) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.StringSliceVar(ssp, "ss", []string{}, "Command separated list!")
-	return f
-}
-
-func setUpSSFlagSetWithDefault(ssp *[]string) *FlagSet {
-	f := NewFlagSet("test", ContinueOnError)
-	f.StringSliceVar(ssp, "ss", []string{"default", "values"}, "Command separated list!")
-	return f
-}
-
-func TestEmptySS(t *testing.T) {
-	var ss []string
-	f := setUpSSFlagSet(&ss)
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	getSS, err := f.GetStringSlice("ss")
-	if err != nil {
-		t.Fatal("got an error from GetStringSlice():", err)
-	}
-	if len(getSS) != 0 {
-		t.Fatalf("got ss %v with len=%d but expected length=0", getSS, len(getSS))
-	}
-}
-
-func TestEmptySSValue(t *testing.T) {
-	var ss []string
-	f := setUpSSFlagSet(&ss)
-	err := f.Parse([]string{"--ss="})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	getSS, err := f.GetStringSlice("ss")
-	if err != nil {
-		t.Fatal("got an error from GetStringSlice():", err)
-	}
-	if len(getSS) != 0 {
-		t.Fatalf("got ss %v with len=%d but expected length=0", getSS, len(getSS))
-	}
-}
-
-func TestSS(t *testing.T) {
-	var ss []string
-	f := setUpSSFlagSet(&ss)
-
-	vals := []string{"one", "two", "4", "3"}
-	arg := fmt.Sprintf("--ss=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ss {
-		if vals[i] != v {
-			t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v)
-		}
-	}
-
-	getSS, err := f.GetStringSlice("ss")
-	if err != nil {
-		t.Fatal("got an error from GetStringSlice():", err)
-	}
-	for i, v := range getSS {
-		if vals[i] != v {
-			t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v)
-		}
-	}
-}
-
-func TestSSDefault(t *testing.T) {
-	var ss []string
-	f := setUpSSFlagSetWithDefault(&ss)
-
-	vals := []string{"default", "values"}
-
-	err := f.Parse([]string{})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ss {
-		if vals[i] != v {
-			t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v)
-		}
-	}
-
-	getSS, err := f.GetStringSlice("ss")
-	if err != nil {
-		t.Fatal("got an error from GetStringSlice():", err)
-	}
-	for i, v := range getSS {
-		if vals[i] != v {
-			t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v)
-		}
-	}
-}
-
-func TestSSWithDefault(t *testing.T) {
-	var ss []string
-	f := setUpSSFlagSetWithDefault(&ss)
-
-	vals := []string{"one", "two", "4", "3"}
-	arg := fmt.Sprintf("--ss=%s", strings.Join(vals, ","))
-	err := f.Parse([]string{arg})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-	for i, v := range ss {
-		if vals[i] != v {
-			t.Fatalf("expected ss[%d] to be %s but got: %s", i, vals[i], v)
-		}
-	}
-
-	getSS, err := f.GetStringSlice("ss")
-	if err != nil {
-		t.Fatal("got an error from GetStringSlice():", err)
-	}
-	for i, v := range getSS {
-		if vals[i] != v {
-			t.Fatalf("expected ss[%d] to be %s from GetStringSlice but got: %s", i, vals[i], v)
-		}
-	}
-}
-
-func TestSSCalledTwice(t *testing.T) {
-	var ss []string
-	f := setUpSSFlagSet(&ss)
-
-	in := []string{"one,two", "three"}
-	expected := []string{"one", "two", "three"}
-	argfmt := "--ss=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	err := f.Parse([]string{arg1, arg2})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(ss) {
-		t.Fatalf("expected number of ss to be %d but got: %d", len(expected), len(ss))
-	}
-	for i, v := range ss {
-		if expected[i] != v {
-			t.Fatalf("expected ss[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-
-	values, err := f.GetStringSlice("ss")
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(values) {
-		t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(ss))
-	}
-	for i, v := range values {
-		if expected[i] != v {
-			t.Fatalf("expected got ss[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-}
-
-func TestSSWithComma(t *testing.T) {
-	var ss []string
-	f := setUpSSFlagSet(&ss)
-
-	in := []string{`"one,two"`, `"three"`, `"four,five",six`}
-	expected := []string{"one,two", "three", "four,five", "six"}
-	argfmt := "--ss=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	arg3 := fmt.Sprintf(argfmt, in[2])
-	err := f.Parse([]string{arg1, arg2, arg3})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(ss) {
-		t.Fatalf("expected number of ss to be %d but got: %d", len(expected), len(ss))
-	}
-	for i, v := range ss {
-		if expected[i] != v {
-			t.Fatalf("expected ss[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-
-	values, err := f.GetStringSlice("ss")
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(values) {
-		t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
-	}
-	for i, v := range values {
-		if expected[i] != v {
-			t.Fatalf("expected got ss[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-}
-
-func TestSSWithSquareBrackets(t *testing.T) {
-	var ss []string
-	f := setUpSSFlagSet(&ss)
-
-	in := []string{`"[a-z]"`, `"[a-z]+"`}
-	expected := []string{"[a-z]", "[a-z]+"}
-	argfmt := "--ss=%s"
-	arg1 := fmt.Sprintf(argfmt, in[0])
-	arg2 := fmt.Sprintf(argfmt, in[1])
-	err := f.Parse([]string{arg1, arg2})
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(ss) {
-		t.Fatalf("expected number of ss to be %d but got: %d", len(expected), len(ss))
-	}
-	for i, v := range ss {
-		if expected[i] != v {
-			t.Fatalf("expected ss[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-
-	values, err := f.GetStringSlice("ss")
-	if err != nil {
-		t.Fatal("expected no error; got", err)
-	}
-
-	if len(expected) != len(values) {
-		t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
-	}
-	for i, v := range values {
-		if expected[i] != v {
-			t.Fatalf("expected got ss[%d] to be %s but got: %s", i, expected[i], v)
-		}
-	}
-}

vendor/github.com/spf13/pflag/uint.go

@@ -1,88 +0,0 @@
-package pflag
-
-import "strconv"
-
-// -- uint Value
-type uintValue uint
-
-func newUintValue(val uint, p *uint) *uintValue {
-	*p = val
-	return (*uintValue)(p)
-}
-
-func (i *uintValue) Set(s string) error {
-	v, err := strconv.ParseUint(s, 0, 64)
-	*i = uintValue(v)
-	return err
-}
-
-func (i *uintValue) Type() string {
-	return "uint"
-}
-
-func (i *uintValue) String() string { return strconv.FormatUint(uint64(*i), 10) }
-
-func uintConv(sval string) (interface{}, error) {
-	v, err := strconv.ParseUint(sval, 0, 0)
-	if err != nil {
-		return 0, err
-	}
-	return uint(v), nil
-}
-
-// GetUint return the uint value of a flag with the given name
-func (f *FlagSet) GetUint(name string) (uint, error) {
-	val, err := f.getFlagType(name, "uint", uintConv)
-	if err != nil {
-		return 0, err
-	}
-	return val.(uint), nil
-}
-
-// UintVar defines a uint flag with specified name, default value, and usage string.
-// The argument p points to a uint variable in which to store the value of the flag.
-func (f *FlagSet) UintVar(p *uint, name string, value uint, usage string) {
-	f.VarP(newUintValue(value, p), name, "", usage)
-}
-
-// UintVarP is like UintVar, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) UintVarP(p *uint, name, shorthand string, value uint, usage string) {
-	f.VarP(newUintValue(value, p), name, shorthand, usage)
-}
-
-// UintVar defines a uint flag with specified name, default value, and usage string.
-// The argument p points to a uint  variable in which to store the value of the flag.
-func UintVar(p *uint, name string, value uint, usage string) {
-	CommandLine.VarP(newUintValue(value, p), name, "", usage)
-}
-
-// UintVarP is like UintVar, but accepts a shorthand letter that can be used after a single dash.
-func UintVarP(p *uint, name, shorthand string, value uint, usage string) {
-	CommandLine.VarP(newUintValue(value, p), name, shorthand, usage)
-}
-
-// Uint defines a uint flag with specified name, default value, and usage string.
-// The return value is the address of a uint  variable that stores the value of the flag.
-func (f *FlagSet) Uint(name string, value uint, usage string) *uint {
-	p := new(uint)
-	f.UintVarP(p, name, "", value, usage)
-	return p
-}
-
-// UintP is like Uint, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) UintP(name, shorthand string, value uint, usage string) *uint {
-	p := new(uint)
-	f.UintVarP(p, name, shorthand, value, usage)
-	return p
-}
-
-// Uint defines a uint flag with specified name, default value, and usage string.
-// The return value is the address of a uint  variable that stores the value of the flag.
-func Uint(name string, value uint, usage string) *uint {
-	return CommandLine.UintP(name, "", value, usage)
-}
-
-// UintP is like Uint, but accepts a shorthand letter that can be used after a single dash.
-func UintP(name, shorthand string, value uint, usage string) *uint {
-	return CommandLine.UintP(name, shorthand, value, usage)
-}

vendor/github.com/spf13/pflag/uint16.go

@@ -1,88 +0,0 @@
-package pflag
-
-import "strconv"
-
-// -- uint16 value
-type uint16Value uint16
-
-func newUint16Value(val uint16, p *uint16) *uint16Value {
-	*p = val
-	return (*uint16Value)(p)
-}
-
-func (i *uint16Value) Set(s string) error {
-	v, err := strconv.ParseUint(s, 0, 16)
-	*i = uint16Value(v)
-	return err
-}
-
-func (i *uint16Value) Type() string {
-	return "uint16"
-}
-
-func (i *uint16Value) String() string { return strconv.FormatUint(uint64(*i), 10) }
-
-func uint16Conv(sval string) (interface{}, error) {
-	v, err := strconv.ParseUint(sval, 0, 16)
-	if err != nil {
-		return 0, err
-	}
-	return uint16(v), nil
-}
-
-// GetUint16 return the uint16 value of a flag with the given name
-func (f *FlagSet) GetUint16(name string) (uint16, error) {
-	val, err := f.getFlagType(name, "uint16", uint16Conv)
-	if err != nil {
-		return 0, err
-	}
-	return val.(uint16), nil
-}
-
-// Uint16Var defines a uint flag with specified name, default value, and usage string.
-// The argument p points to a uint variable in which to store the value of the flag.
-func (f *FlagSet) Uint16Var(p *uint16, name string, value uint16, usage string) {
-	f.VarP(newUint16Value(value, p), name, "", usage)
-}
-
-// Uint16VarP is like Uint16Var, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) Uint16VarP(p *uint16, name, shorthand string, value uint16, usage string) {
-	f.VarP(newUint16Value(value, p), name, shorthand, usage)
-}
-
-// Uint16Var defines a uint flag with specified name, default value, and usage string.
-// The argument p points to a uint  variable in which to store the value of the flag.
-func Uint16Var(p *uint16, name string, value uint16, usage string) {
-	CommandLine.VarP(newUint16Value(value, p), name, "", usage)
-}
-
-// Uint16VarP is like Uint16Var, but accepts a shorthand letter that can be used after a single dash.
-func Uint16VarP(p *uint16, name, shorthand string, value uint16, usage string) {
-	CommandLine.VarP(newUint16Value(value, p), name, shorthand, usage)
-}
-
-// Uint16 defines a uint flag with specified name, default value, and usage string.
-// The return value is the address of a uint  variable that stores the value of the flag.
-func (f *FlagSet) Uint16(name string, value uint16, usage string) *uint16 {
-	p := new(uint16)
-	f.Uint16VarP(p, name, "", value, usage)
-	return p
-}
-
-// Uint16P is like Uint16, but accepts a shorthand letter that can be used after a single dash.
-func (f *FlagSet) Uint16P(name, shorthand string, value uint16, usage string) *uint16 {
-	p := new(uint16)
-	f.Uint16VarP(p, name, shorthand, value, usage)
-	return p
-}
-
-// Uint16 defines a uint flag with specified name, default value, and usage string.
-// The return value is the address of a uint  variable that stores the value of the flag.
-func Uint16(name string, value uint16, usage string) *uint16 {
-	return CommandLine.Uint16P(name, "", value, usage)
-}
-
-// Uint16P is like Uint16, but accepts a shorthand letter that can be used after a single dash.
-func Uint16P(name, shorthand string, value uint16, usage string) *uint16 {
-	return CommandLine.Uint16P(name, shorthand, value, usage)
-}