Browse Source

Added libs

tags/v0.2
konrad 1 year ago
parent
commit
adf7700a8a
Signed by: kolaente <konrad@kola-entertainments.de> GPG Key ID: F40E70337AB24C9B
53 changed files with 17012 additions and 0 deletions
  1. 15
    0
      vendor/github.com/davecgh/go-spew/LICENSE
  2. 152
    0
      vendor/github.com/davecgh/go-spew/spew/bypass.go
  3. 38
    0
      vendor/github.com/davecgh/go-spew/spew/bypasssafe.go
  4. 341
    0
      vendor/github.com/davecgh/go-spew/spew/common.go
  5. 306
    0
      vendor/github.com/davecgh/go-spew/spew/config.go
  6. 211
    0
      vendor/github.com/davecgh/go-spew/spew/doc.go
  7. 509
    0
      vendor/github.com/davecgh/go-spew/spew/dump.go
  8. 419
    0
      vendor/github.com/davecgh/go-spew/spew/format.go
  9. 148
    0
      vendor/github.com/davecgh/go-spew/spew/spew.go
  10. 27
    0
      vendor/github.com/pmezard/go-difflib/LICENSE
  11. 772
    0
      vendor/github.com/pmezard/go-difflib/difflib/difflib.go
  12. 22
    0
      vendor/github.com/stretchr/testify/LICENSE
  13. 349
    0
      vendor/github.com/stretchr/testify/assert/assertion_format.go
  14. 4
    0
      vendor/github.com/stretchr/testify/assert/assertion_format.go.tmpl
  15. 686
    0
      vendor/github.com/stretchr/testify/assert/assertion_forward.go
  16. 4
    0
      vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl
  17. 1256
    0
      vendor/github.com/stretchr/testify/assert/assertions.go
  18. 45
    0
      vendor/github.com/stretchr/testify/assert/doc.go
  19. 10
    0
      vendor/github.com/stretchr/testify/assert/errors.go
  20. 16
    0
      vendor/github.com/stretchr/testify/assert/forward_assertions.go
  21. 127
    0
      vendor/github.com/stretchr/testify/assert/http_assertions.go
  22. 21
    0
      vendor/gopkg.in/testfixtures.v2/LICENSE
  23. 368
    0
      vendor/gopkg.in/testfixtures.v2/README.md
  24. 62
    0
      vendor/gopkg.in/testfixtures.v2/Taskfile.yml
  25. 75
    0
      vendor/gopkg.in/testfixtures.v2/deprecated.go
  26. 41
    0
      vendor/gopkg.in/testfixtures.v2/errors.go
  27. 110
    0
      vendor/gopkg.in/testfixtures.v2/generate.go
  28. 63
    0
      vendor/gopkg.in/testfixtures.v2/helper.go
  29. 44
    0
      vendor/gopkg.in/testfixtures.v2/json.go
  30. 133
    0
      vendor/gopkg.in/testfixtures.v2/mysql.go
  31. 19
    0
      vendor/gopkg.in/testfixtures.v2/options.go
  32. 171
    0
      vendor/gopkg.in/testfixtures.v2/oracle.go
  33. 291
    0
      vendor/gopkg.in/testfixtures.v2/postgresql.go
  34. 76
    0
      vendor/gopkg.in/testfixtures.v2/sqlite.go
  35. 122
    0
      vendor/gopkg.in/testfixtures.v2/sqlserver.go
  36. 294
    0
      vendor/gopkg.in/testfixtures.v2/testfixtures.go
  37. 34
    0
      vendor/gopkg.in/testfixtures.v2/time.go
  38. 201
    0
      vendor/gopkg.in/yaml.v2/LICENSE
  39. 31
    0
      vendor/gopkg.in/yaml.v2/LICENSE.libyaml
  40. 135
    0
      vendor/gopkg.in/yaml.v2/README.md
  41. 742
    0
      vendor/gopkg.in/yaml.v2/apic.go
  42. 685
    0
      vendor/gopkg.in/yaml.v2/decode.go
  43. 1684
    0
      vendor/gopkg.in/yaml.v2/emitterc.go
  44. 306
    0
      vendor/gopkg.in/yaml.v2/encode.go
  45. 1095
    0
      vendor/gopkg.in/yaml.v2/parserc.go
  46. 394
    0
      vendor/gopkg.in/yaml.v2/readerc.go
  47. 208
    0
      vendor/gopkg.in/yaml.v2/resolve.go
  48. 2711
    0
      vendor/gopkg.in/yaml.v2/scannerc.go
  49. 104
    0
      vendor/gopkg.in/yaml.v2/sorter.go
  50. 89
    0
      vendor/gopkg.in/yaml.v2/writerc.go
  51. 357
    0
      vendor/gopkg.in/yaml.v2/yaml.go
  52. 716
    0
      vendor/gopkg.in/yaml.v2/yamlh.go
  53. 173
    0
      vendor/gopkg.in/yaml.v2/yamlprivateh.go

+ 15
- 0
vendor/github.com/davecgh/go-spew/LICENSE View File

@@ -0,0 +1,15 @@
1
+ISC License
2
+
3
+Copyright (c) 2012-2016 Dave Collins <dave@davec.name>
4
+
5
+Permission to use, copy, modify, and/or distribute this software for any
6
+purpose with or without fee is hereby granted, provided that the above
7
+copyright notice and this permission notice appear in all copies.
8
+
9
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

+ 152
- 0
vendor/github.com/davecgh/go-spew/spew/bypass.go View File

@@ -0,0 +1,152 @@
1
+// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
2
+//
3
+// Permission to use, copy, modify, and distribute this software for any
4
+// purpose with or without fee is hereby granted, provided that the above
5
+// copyright notice and this permission notice appear in all copies.
6
+//
7
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
8
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
9
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
10
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
11
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
12
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
13
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
14
+
15
+// NOTE: Due to the following build constraints, this file will only be compiled
16
+// when the code is not running on Google App Engine, compiled by GopherJS, and
17
+// "-tags safe" is not added to the go build command line.  The "disableunsafe"
18
+// tag is deprecated and thus should not be used.
19
+// +build !js,!appengine,!safe,!disableunsafe
20
+
21
+package spew
22
+
23
+import (
24
+	"reflect"
25
+	"unsafe"
26
+)
27
+
28
+const (
29
+	// UnsafeDisabled is a build-time constant which specifies whether or
30
+	// not access to the unsafe package is available.
31
+	UnsafeDisabled = false
32
+
33
+	// ptrSize is the size of a pointer on the current arch.
34
+	ptrSize = unsafe.Sizeof((*byte)(nil))
35
+)
36
+
37
+var (
38
+	// offsetPtr, offsetScalar, and offsetFlag are the offsets for the
39
+	// internal reflect.Value fields.  These values are valid before golang
40
+	// commit ecccf07e7f9d which changed the format.  The are also valid
41
+	// after commit 82f48826c6c7 which changed the format again to mirror
42
+	// the original format.  Code in the init function updates these offsets
43
+	// as necessary.
44
+	offsetPtr    = ptrSize
45
+	offsetScalar = uintptr(0)
46
+	offsetFlag   = ptrSize * 2
47
+
48
+	// flagKindWidth and flagKindShift indicate various bits that the
49
+	// reflect package uses internally to track kind information.
50
+	//
51
+	// flagRO indicates whether or not the value field of a reflect.Value is
52
+	// read-only.
53
+	//
54
+	// flagIndir indicates whether the value field of a reflect.Value is
55
+	// the actual data or a pointer to the data.
56
+	//
57
+	// These values are valid before golang commit 90a7c3c86944 which
58
+	// changed their positions.  Code in the init function updates these
59
+	// flags as necessary.
60
+	flagKindWidth = uintptr(5)
61
+	flagKindShift = flagKindWidth - 1
62
+	flagRO        = uintptr(1 << 0)
63
+	flagIndir     = uintptr(1 << 1)
64
+)
65
+
66
+func init() {
67
+	// Older versions of reflect.Value stored small integers directly in the
68
+	// ptr field (which is named val in the older versions).  Versions
69
+	// between commits ecccf07e7f9d and 82f48826c6c7 added a new field named
70
+	// scalar for this purpose which unfortunately came before the flag
71
+	// field, so the offset of the flag field is different for those
72
+	// versions.
73
+	//
74
+	// This code constructs a new reflect.Value from a known small integer
75
+	// and checks if the size of the reflect.Value struct indicates it has
76
+	// the scalar field. When it does, the offsets are updated accordingly.
77
+	vv := reflect.ValueOf(0xf00)
78
+	if unsafe.Sizeof(vv) == (ptrSize * 4) {
79
+		offsetScalar = ptrSize * 2
80
+		offsetFlag = ptrSize * 3
81
+	}
82
+
83
+	// Commit 90a7c3c86944 changed the flag positions such that the low
84
+	// order bits are the kind.  This code extracts the kind from the flags
85
+	// field and ensures it's the correct type.  When it's not, the flag
86
+	// order has been changed to the newer format, so the flags are updated
87
+	// accordingly.
88
+	upf := unsafe.Pointer(uintptr(unsafe.Pointer(&vv)) + offsetFlag)
89
+	upfv := *(*uintptr)(upf)
90
+	flagKindMask := uintptr((1<<flagKindWidth - 1) << flagKindShift)
91
+	if (upfv&flagKindMask)>>flagKindShift != uintptr(reflect.Int) {
92
+		flagKindShift = 0
93
+		flagRO = 1 << 5
94
+		flagIndir = 1 << 6
95
+
96
+		// Commit adf9b30e5594 modified the flags to separate the
97
+		// flagRO flag into two bits which specifies whether or not the
98
+		// field is embedded.  This causes flagIndir to move over a bit
99
+		// and means that flagRO is the combination of either of the
100
+		// original flagRO bit and the new bit.
101
+		//
102
+		// This code detects the change by extracting what used to be
103
+		// the indirect bit to ensure it's set.  When it's not, the flag
104
+		// order has been changed to the newer format, so the flags are
105
+		// updated accordingly.
106
+		if upfv&flagIndir == 0 {
107
+			flagRO = 3 << 5
108
+			flagIndir = 1 << 7
109
+		}
110
+	}
111
+}
112
+
113
+// unsafeReflectValue converts the passed reflect.Value into a one that bypasses
114
+// the typical safety restrictions preventing access to unaddressable and
115
+// unexported data.  It works by digging the raw pointer to the underlying
116
+// value out of the protected value and generating a new unprotected (unsafe)
117
+// reflect.Value to it.
118
+//
119
+// This allows us to check for implementations of the Stringer and error
120
+// interfaces to be used for pretty printing ordinarily unaddressable and
121
+// inaccessible values such as unexported struct fields.
122
+func unsafeReflectValue(v reflect.Value) (rv reflect.Value) {
123
+	indirects := 1
124
+	vt := v.Type()
125
+	upv := unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetPtr)
126
+	rvf := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetFlag))
127
+	if rvf&flagIndir != 0 {
128
+		vt = reflect.PtrTo(v.Type())
129
+		indirects++
130
+	} else if offsetScalar != 0 {
131
+		// The value is in the scalar field when it's not one of the
132
+		// reference types.
133
+		switch vt.Kind() {
134
+		case reflect.Uintptr:
135
+		case reflect.Chan:
136
+		case reflect.Func:
137
+		case reflect.Map:
138
+		case reflect.Ptr:
139
+		case reflect.UnsafePointer:
140
+		default:
141
+			upv = unsafe.Pointer(uintptr(unsafe.Pointer(&v)) +
142
+				offsetScalar)
143
+		}
144
+	}
145
+
146
+	pv := reflect.NewAt(vt, upv)
147
+	rv = pv
148
+	for i := 0; i < indirects; i++ {
149
+		rv = rv.Elem()
150
+	}
151
+	return rv
152
+}

+ 38
- 0
vendor/github.com/davecgh/go-spew/spew/bypasssafe.go View File

@@ -0,0 +1,38 @@
1
+// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
2
+//
3
+// Permission to use, copy, modify, and distribute this software for any
4
+// purpose with or without fee is hereby granted, provided that the above
5
+// copyright notice and this permission notice appear in all copies.
6
+//
7
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
8
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
9
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
10
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
11
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
12
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
13
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
14
+
15
+// NOTE: Due to the following build constraints, this file will only be compiled
16
+// when the code is running on Google App Engine, compiled by GopherJS, or
17
+// "-tags safe" is added to the go build command line.  The "disableunsafe"
18
+// tag is deprecated and thus should not be used.
19
+// +build js appengine safe disableunsafe
20
+
21
+package spew
22
+
23
+import "reflect"
24
+
25
+const (
26
+	// UnsafeDisabled is a build-time constant which specifies whether or
27
+	// not access to the unsafe package is available.
28
+	UnsafeDisabled = true
29
+)
30
+
31
+// unsafeReflectValue typically converts the passed reflect.Value into a one
32
+// that bypasses the typical safety restrictions preventing access to
33
+// unaddressable and unexported data.  However, doing this relies on access to
34
+// the unsafe package.  This is a stub version which simply returns the passed
35
+// reflect.Value when the unsafe package is not available.
36
+func unsafeReflectValue(v reflect.Value) reflect.Value {
37
+	return v
38
+}

+ 341
- 0
vendor/github.com/davecgh/go-spew/spew/common.go View File

@@ -0,0 +1,341 @@
1
+/*
2
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
3
+ *
4
+ * Permission to use, copy, modify, and distribute this software for any
5
+ * purpose with or without fee is hereby granted, provided that the above
6
+ * copyright notice and this permission notice appear in all copies.
7
+ *
8
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15
+ */
16
+
17
+package spew
18
+
19
+import (
20
+	"bytes"
21
+	"fmt"
22
+	"io"
23
+	"reflect"
24
+	"sort"
25
+	"strconv"
26
+)
27
+
28
+// Some constants in the form of bytes to avoid string overhead.  This mirrors
29
+// the technique used in the fmt package.
30
+var (
31
+	panicBytes            = []byte("(PANIC=")
32
+	plusBytes             = []byte("+")
33
+	iBytes                = []byte("i")
34
+	trueBytes             = []byte("true")
35
+	falseBytes            = []byte("false")
36
+	interfaceBytes        = []byte("(interface {})")
37
+	commaNewlineBytes     = []byte(",\n")
38
+	newlineBytes          = []byte("\n")
39
+	openBraceBytes        = []byte("{")
40
+	openBraceNewlineBytes = []byte("{\n")
41
+	closeBraceBytes       = []byte("}")
42
+	asteriskBytes         = []byte("*")
43
+	colonBytes            = []byte(":")
44
+	colonSpaceBytes       = []byte(": ")
45
+	openParenBytes        = []byte("(")
46
+	closeParenBytes       = []byte(")")
47
+	spaceBytes            = []byte(" ")
48
+	pointerChainBytes     = []byte("->")
49
+	nilAngleBytes         = []byte("<nil>")
50
+	maxNewlineBytes       = []byte("<max depth reached>\n")
51
+	maxShortBytes         = []byte("<max>")
52
+	circularBytes         = []byte("<already shown>")
53
+	circularShortBytes    = []byte("<shown>")
54
+	invalidAngleBytes     = []byte("<invalid>")
55
+	openBracketBytes      = []byte("[")
56
+	closeBracketBytes     = []byte("]")
57
+	percentBytes          = []byte("%")
58
+	precisionBytes        = []byte(".")
59
+	openAngleBytes        = []byte("<")
60
+	closeAngleBytes       = []byte(">")
61
+	openMapBytes          = []byte("map[")
62
+	closeMapBytes         = []byte("]")
63
+	lenEqualsBytes        = []byte("len=")
64
+	capEqualsBytes        = []byte("cap=")
65
+)
66
+
67
+// hexDigits is used to map a decimal value to a hex digit.
68
+var hexDigits = "0123456789abcdef"
69
+
70
+// catchPanic handles any panics that might occur during the handleMethods
71
+// calls.
72
+func catchPanic(w io.Writer, v reflect.Value) {
73
+	if err := recover(); err != nil {
74
+		w.Write(panicBytes)
75
+		fmt.Fprintf(w, "%v", err)
76
+		w.Write(closeParenBytes)
77
+	}
78
+}
79
+
80
+// handleMethods attempts to call the Error and String methods on the underlying
81
+// type the passed reflect.Value represents and outputes the result to Writer w.
82
+//
83
+// It handles panics in any called methods by catching and displaying the error
84
+// as the formatted value.
85
+func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {
86
+	// We need an interface to check if the type implements the error or
87
+	// Stringer interface.  However, the reflect package won't give us an
88
+	// interface on certain things like unexported struct fields in order
89
+	// to enforce visibility rules.  We use unsafe, when it's available,
90
+	// to bypass these restrictions since this package does not mutate the
91
+	// values.
92
+	if !v.CanInterface() {
93
+		if UnsafeDisabled {
94
+			return false
95
+		}
96
+
97
+		v = unsafeReflectValue(v)
98
+	}
99
+
100
+	// Choose whether or not to do error and Stringer interface lookups against
101
+	// the base type or a pointer to the base type depending on settings.
102
+	// Technically calling one of these methods with a pointer receiver can
103
+	// mutate the value, however, types which choose to satisify an error or
104
+	// Stringer interface with a pointer receiver should not be mutating their
105
+	// state inside these interface methods.
106
+	if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {
107
+		v = unsafeReflectValue(v)
108
+	}
109
+	if v.CanAddr() {
110
+		v = v.Addr()
111
+	}
112
+
113
+	// Is it an error or Stringer?
114
+	switch iface := v.Interface().(type) {
115
+	case error:
116
+		defer catchPanic(w, v)
117
+		if cs.ContinueOnMethod {
118
+			w.Write(openParenBytes)
119
+			w.Write([]byte(iface.Error()))
120
+			w.Write(closeParenBytes)
121
+			w.Write(spaceBytes)
122
+			return false
123
+		}
124
+
125
+		w.Write([]byte(iface.Error()))
126
+		return true
127
+
128
+	case fmt.Stringer:
129
+		defer catchPanic(w, v)
130
+		if cs.ContinueOnMethod {
131
+			w.Write(openParenBytes)
132
+			w.Write([]byte(iface.String()))
133
+			w.Write(closeParenBytes)
134
+			w.Write(spaceBytes)
135
+			return false
136
+		}
137
+		w.Write([]byte(iface.String()))
138
+		return true
139
+	}
140
+	return false
141
+}
142
+
143
+// printBool outputs a boolean value as true or false to Writer w.
144
+func printBool(w io.Writer, val bool) {
145
+	if val {
146
+		w.Write(trueBytes)
147
+	} else {
148
+		w.Write(falseBytes)
149
+	}
150
+}
151
+
152
+// printInt outputs a signed integer value to Writer w.
153
+func printInt(w io.Writer, val int64, base int) {
154
+	w.Write([]byte(strconv.FormatInt(val, base)))
155
+}
156
+
157
+// printUint outputs an unsigned integer value to Writer w.
158
+func printUint(w io.Writer, val uint64, base int) {
159
+	w.Write([]byte(strconv.FormatUint(val, base)))
160
+}
161
+
162
+// printFloat outputs a floating point value using the specified precision,
163
+// which is expected to be 32 or 64bit, to Writer w.
164
+func printFloat(w io.Writer, val float64, precision int) {
165
+	w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
166
+}
167
+
168
+// printComplex outputs a complex value using the specified float precision
169
+// for the real and imaginary parts to Writer w.
170
+func printComplex(w io.Writer, c complex128, floatPrecision int) {
171
+	r := real(c)
172
+	w.Write(openParenBytes)
173
+	w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
174
+	i := imag(c)
175
+	if i >= 0 {
176
+		w.Write(plusBytes)
177
+	}
178
+	w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
179
+	w.Write(iBytes)
180
+	w.Write(closeParenBytes)
181
+}
182
+
183
+// printHexPtr outputs a uintptr formatted as hexadecimal with a leading '0x'
184
+// prefix to Writer w.
185
+func printHexPtr(w io.Writer, p uintptr) {
186
+	// Null pointer.
187
+	num := uint64(p)
188
+	if num == 0 {
189
+		w.Write(nilAngleBytes)
190
+		return
191
+	}
192
+
193
+	// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
194
+	buf := make([]byte, 18)
195
+
196
+	// It's simpler to construct the hex string right to left.
197
+	base := uint64(16)
198
+	i := len(buf) - 1
199
+	for num >= base {
200
+		buf[i] = hexDigits[num%base]
201
+		num /= base
202
+		i--
203
+	}
204
+	buf[i] = hexDigits[num]
205
+
206
+	// Add '0x' prefix.
207
+	i--
208
+	buf[i] = 'x'
209
+	i--
210
+	buf[i] = '0'
211
+
212
+	// Strip unused leading bytes.
213
+	buf = buf[i:]
214
+	w.Write(buf)
215
+}
216
+
217
+// valuesSorter implements sort.Interface to allow a slice of reflect.Value
218
+// elements to be sorted.
219
+type valuesSorter struct {
220
+	values  []reflect.Value
221
+	strings []string // either nil or same len and values
222
+	cs      *ConfigState
223
+}
224
+
225
+// newValuesSorter initializes a valuesSorter instance, which holds a set of
226
+// surrogate keys on which the data should be sorted.  It uses flags in
227
+// ConfigState to decide if and how to populate those surrogate keys.
228
+func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface {
229
+	vs := &valuesSorter{values: values, cs: cs}
230
+	if canSortSimply(vs.values[0].Kind()) {
231
+		return vs
232
+	}
233
+	if !cs.DisableMethods {
234
+		vs.strings = make([]string, len(values))
235
+		for i := range vs.values {
236
+			b := bytes.Buffer{}
237
+			if !handleMethods(cs, &b, vs.values[i]) {
238
+				vs.strings = nil
239
+				break
240
+			}
241
+			vs.strings[i] = b.String()
242
+		}
243
+	}
244
+	if vs.strings == nil && cs.SpewKeys {
245
+		vs.strings = make([]string, len(values))
246
+		for i := range vs.values {
247
+			vs.strings[i] = Sprintf("%#v", vs.values[i].Interface())
248
+		}
249
+	}
250
+	return vs
251
+}
252
+
253
+// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted
254
+// directly, or whether it should be considered for sorting by surrogate keys
255
+// (if the ConfigState allows it).
256
+func canSortSimply(kind reflect.Kind) bool {
257
+	// This switch parallels valueSortLess, except for the default case.
258
+	switch kind {
259
+	case reflect.Bool:
260
+		return true
261
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
262
+		return true
263
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
264
+		return true
265
+	case reflect.Float32, reflect.Float64:
266
+		return true
267
+	case reflect.String:
268
+		return true
269
+	case reflect.Uintptr:
270
+		return true
271
+	case reflect.Array:
272
+		return true
273
+	}
274
+	return false
275
+}
276
+
277
+// Len returns the number of values in the slice.  It is part of the
278
+// sort.Interface implementation.
279
+func (s *valuesSorter) Len() int {
280
+	return len(s.values)
281
+}
282
+
283
+// Swap swaps the values at the passed indices.  It is part of the
284
+// sort.Interface implementation.
285
+func (s *valuesSorter) Swap(i, j int) {
286
+	s.values[i], s.values[j] = s.values[j], s.values[i]
287
+	if s.strings != nil {
288
+		s.strings[i], s.strings[j] = s.strings[j], s.strings[i]
289
+	}
290
+}
291
+
292
+// valueSortLess returns whether the first value should sort before the second
293
+// value.  It is used by valueSorter.Less as part of the sort.Interface
294
+// implementation.
295
+func valueSortLess(a, b reflect.Value) bool {
296
+	switch a.Kind() {
297
+	case reflect.Bool:
298
+		return !a.Bool() && b.Bool()
299
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
300
+		return a.Int() < b.Int()
301
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
302
+		return a.Uint() < b.Uint()
303
+	case reflect.Float32, reflect.Float64:
304
+		return a.Float() < b.Float()
305
+	case reflect.String:
306
+		return a.String() < b.String()
307
+	case reflect.Uintptr:
308
+		return a.Uint() < b.Uint()
309
+	case reflect.Array:
310
+		// Compare the contents of both arrays.
311
+		l := a.Len()
312
+		for i := 0; i < l; i++ {
313
+			av := a.Index(i)
314
+			bv := b.Index(i)
315
+			if av.Interface() == bv.Interface() {
316
+				continue
317
+			}
318
+			return valueSortLess(av, bv)
319
+		}
320
+	}
321
+	return a.String() < b.String()
322
+}
323
+
324
+// Less returns whether the value at index i should sort before the
325
+// value at index j.  It is part of the sort.Interface implementation.
326
+func (s *valuesSorter) Less(i, j int) bool {
327
+	if s.strings == nil {
328
+		return valueSortLess(s.values[i], s.values[j])
329
+	}
330
+	return s.strings[i] < s.strings[j]
331
+}
332
+
333
+// sortValues is a sort function that handles both native types and any type that
334
+// can be converted to error or Stringer.  Other inputs are sorted according to
335
+// their Value.String() value to ensure display stability.
336
+func sortValues(values []reflect.Value, cs *ConfigState) {
337
+	if len(values) == 0 {
338
+		return
339
+	}
340
+	sort.Sort(newValuesSorter(values, cs))
341
+}

+ 306
- 0
vendor/github.com/davecgh/go-spew/spew/config.go View File

@@ -0,0 +1,306 @@
1
+/*
2
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
3
+ *
4
+ * Permission to use, copy, modify, and distribute this software for any
5
+ * purpose with or without fee is hereby granted, provided that the above
6
+ * copyright notice and this permission notice appear in all copies.
7
+ *
8
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15
+ */
16
+
17
+package spew
18
+
19
+import (
20
+	"bytes"
21
+	"fmt"
22
+	"io"
23
+	"os"
24
+)
25
+
26
+// ConfigState houses the configuration options used by spew to format and
27
+// display values.  There is a global instance, Config, that is used to control
28
+// all top-level Formatter and Dump functionality.  Each ConfigState instance
29
+// provides methods equivalent to the top-level functions.
30
+//
31
+// The zero value for ConfigState provides no indentation.  You would typically
32
+// want to set it to a space or a tab.
33
+//
34
+// Alternatively, you can use NewDefaultConfig to get a ConfigState instance
35
+// with default settings.  See the documentation of NewDefaultConfig for default
36
+// values.
37
+type ConfigState struct {
38
+	// Indent specifies the string to use for each indentation level.  The
39
+	// global config instance that all top-level functions use set this to a
40
+	// single space by default.  If you would like more indentation, you might
41
+	// set this to a tab with "\t" or perhaps two spaces with "  ".
42
+	Indent string
43
+
44
+	// MaxDepth controls the maximum number of levels to descend into nested
45
+	// data structures.  The default, 0, means there is no limit.
46
+	//
47
+	// NOTE: Circular data structures are properly detected, so it is not
48
+	// necessary to set this value unless you specifically want to limit deeply
49
+	// nested data structures.
50
+	MaxDepth int
51
+
52
+	// DisableMethods specifies whether or not error and Stringer interfaces are
53
+	// invoked for types that implement them.
54
+	DisableMethods bool
55
+
56
+	// DisablePointerMethods specifies whether or not to check for and invoke
57
+	// error and Stringer interfaces on types which only accept a pointer
58
+	// receiver when the current type is not a pointer.
59
+	//
60
+	// NOTE: This might be an unsafe action since calling one of these methods
61
+	// with a pointer receiver could technically mutate the value, however,
62
+	// in practice, types which choose to satisify an error or Stringer
63
+	// interface with a pointer receiver should not be mutating their state
64
+	// inside these interface methods.  As a result, this option relies on
65
+	// access to the unsafe package, so it will not have any effect when
66
+	// running in environments without access to the unsafe package such as
67
+	// Google App Engine or with the "safe" build tag specified.
68
+	DisablePointerMethods bool
69
+
70
+	// DisablePointerAddresses specifies whether to disable the printing of
71
+	// pointer addresses. This is useful when diffing data structures in tests.
72
+	DisablePointerAddresses bool
73
+
74
+	// DisableCapacities specifies whether to disable the printing of capacities
75
+	// for arrays, slices, maps and channels. This is useful when diffing
76
+	// data structures in tests.
77
+	DisableCapacities bool
78
+
79
+	// ContinueOnMethod specifies whether or not recursion should continue once
80
+	// a custom error or Stringer interface is invoked.  The default, false,
81
+	// means it will print the results of invoking the custom error or Stringer
82
+	// interface and return immediately instead of continuing to recurse into
83
+	// the internals of the data type.
84
+	//
85
+	// NOTE: This flag does not have any effect if method invocation is disabled
86
+	// via the DisableMethods or DisablePointerMethods options.
87
+	ContinueOnMethod bool
88
+
89
+	// SortKeys specifies map keys should be sorted before being printed. Use
90
+	// this to have a more deterministic, diffable output.  Note that only
91
+	// native types (bool, int, uint, floats, uintptr and string) and types
92
+	// that support the error or Stringer interfaces (if methods are
93
+	// enabled) are supported, with other types sorted according to the
94
+	// reflect.Value.String() output which guarantees display stability.
95
+	SortKeys bool
96
+
97
+	// SpewKeys specifies that, as a last resort attempt, map keys should
98
+	// be spewed to strings and sorted by those strings.  This is only
99
+	// considered if SortKeys is true.
100
+	SpewKeys bool
101
+}
102
+
103
+// Config is the active configuration of the top-level functions.
104
+// The configuration can be changed by modifying the contents of spew.Config.
105
+var Config = ConfigState{Indent: " "}
106
+
107
+// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
108
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
109
+// the formatted string as a value that satisfies error.  See NewFormatter
110
+// for formatting details.
111
+//
112
+// This function is shorthand for the following syntax:
113
+//
114
+//	fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b))
115
+func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) {
116
+	return fmt.Errorf(format, c.convertArgs(a)...)
117
+}
118
+
119
+// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
120
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
121
+// the number of bytes written and any write error encountered.  See
122
+// NewFormatter for formatting details.
123
+//
124
+// This function is shorthand for the following syntax:
125
+//
126
+//	fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b))
127
+func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
128
+	return fmt.Fprint(w, c.convertArgs(a)...)
129
+}
130
+
131
+// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
132
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
133
+// the number of bytes written and any write error encountered.  See
134
+// NewFormatter for formatting details.
135
+//
136
+// This function is shorthand for the following syntax:
137
+//
138
+//	fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b))
139
+func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
140
+	return fmt.Fprintf(w, format, c.convertArgs(a)...)
141
+}
142
+
143
+// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
144
+// passed with a Formatter interface returned by c.NewFormatter.  See
145
+// NewFormatter for formatting details.
146
+//
147
+// This function is shorthand for the following syntax:
148
+//
149
+//	fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b))
150
+func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
151
+	return fmt.Fprintln(w, c.convertArgs(a)...)
152
+}
153
+
154
+// Print is a wrapper for fmt.Print that treats each argument as if it were
155
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
156
+// the number of bytes written and any write error encountered.  See
157
+// NewFormatter for formatting details.
158
+//
159
+// This function is shorthand for the following syntax:
160
+//
161
+//	fmt.Print(c.NewFormatter(a), c.NewFormatter(b))
162
+func (c *ConfigState) Print(a ...interface{}) (n int, err error) {
163
+	return fmt.Print(c.convertArgs(a)...)
164
+}
165
+
166
+// Printf is a wrapper for fmt.Printf that treats each argument as if it were
167
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
168
+// the number of bytes written and any write error encountered.  See
169
+// NewFormatter for formatting details.
170
+//
171
+// This function is shorthand for the following syntax:
172
+//
173
+//	fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b))
174
+func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) {
175
+	return fmt.Printf(format, c.convertArgs(a)...)
176
+}
177
+
178
+// Println is a wrapper for fmt.Println that treats each argument as if it were
179
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
180
+// the number of bytes written and any write error encountered.  See
181
+// NewFormatter for formatting details.
182
+//
183
+// This function is shorthand for the following syntax:
184
+//
185
+//	fmt.Println(c.NewFormatter(a), c.NewFormatter(b))
186
+func (c *ConfigState) Println(a ...interface{}) (n int, err error) {
187
+	return fmt.Println(c.convertArgs(a)...)
188
+}
189
+
190
+// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
191
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
192
+// the resulting string.  See NewFormatter for formatting details.
193
+//
194
+// This function is shorthand for the following syntax:
195
+//
196
+//	fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b))
197
+func (c *ConfigState) Sprint(a ...interface{}) string {
198
+	return fmt.Sprint(c.convertArgs(a)...)
199
+}
200
+
201
+// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
202
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
203
+// the resulting string.  See NewFormatter for formatting details.
204
+//
205
+// This function is shorthand for the following syntax:
206
+//
207
+//	fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b))
208
+func (c *ConfigState) Sprintf(format string, a ...interface{}) string {
209
+	return fmt.Sprintf(format, c.convertArgs(a)...)
210
+}
211
+
212
+// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
213
+// were passed with a Formatter interface returned by c.NewFormatter.  It
214
+// returns the resulting string.  See NewFormatter for formatting details.
215
+//
216
+// This function is shorthand for the following syntax:
217
+//
218
+//	fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b))
219
+func (c *ConfigState) Sprintln(a ...interface{}) string {
220
+	return fmt.Sprintln(c.convertArgs(a)...)
221
+}
222
+
223
+/*
224
+NewFormatter returns a custom formatter that satisfies the fmt.Formatter
225
+interface.  As a result, it integrates cleanly with standard fmt package
226
+printing functions.  The formatter is useful for inline printing of smaller data
227
+types similar to the standard %v format specifier.
228
+
229
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
230
+addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb
231
+combinations.  Any other verbs such as %x and %q will be sent to the the
232
+standard fmt package for formatting.  In addition, the custom formatter ignores
233
+the width and precision arguments (however they will still work on the format
234
+specifiers not handled by the custom formatter).
235
+
236
+Typically this function shouldn't be called directly.  It is much easier to make
237
+use of the custom formatter by calling one of the convenience functions such as
238
+c.Printf, c.Println, or c.Printf.
239
+*/
240
+func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter {
241
+	return newFormatter(c, v)
242
+}
243
+
244
+// Fdump formats and displays the passed arguments to io.Writer w.  It formats
245
+// exactly the same as Dump.
246
+func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) {
247
+	fdump(c, w, a...)
248
+}
249
+
250
+/*
251
+Dump displays the passed parameters to standard out with newlines, customizable
252
+indentation, and additional debug information such as complete types and all
253
+pointer addresses used to indirect to the final value.  It provides the
254
+following features over the built-in printing facilities provided by the fmt
255
+package:
256
+
257
+	* Pointers are dereferenced and followed
258
+	* Circular data structures are detected and handled properly
259
+	* Custom Stringer/error interfaces are optionally invoked, including
260
+	  on unexported types
261
+	* Custom types which only implement the Stringer/error interfaces via
262
+	  a pointer receiver are optionally invoked when passing non-pointer
263
+	  variables
264
+	* Byte arrays and slices are dumped like the hexdump -C command which
265
+	  includes offsets, byte values in hex, and ASCII output
266
+
267
+The configuration options are controlled by modifying the public members
268
+of c.  See ConfigState for options documentation.
269
+
270
+See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
271
+get the formatted result as a string.
272
+*/
273
+func (c *ConfigState) Dump(a ...interface{}) {
274
+	fdump(c, os.Stdout, a...)
275
+}
276
+
277
+// Sdump returns a string with the passed arguments formatted exactly the same
278
+// as Dump.
279
+func (c *ConfigState) Sdump(a ...interface{}) string {
280
+	var buf bytes.Buffer
281
+	fdump(c, &buf, a...)
282
+	return buf.String()
283
+}
284
+
285
+// convertArgs accepts a slice of arguments and returns a slice of the same
286
+// length with each argument converted to a spew Formatter interface using
287
+// the ConfigState associated with s.
288
+func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) {
289
+	formatters = make([]interface{}, len(args))
290
+	for index, arg := range args {
291
+		formatters[index] = newFormatter(c, arg)
292
+	}
293
+	return formatters
294
+}
295
+
296
+// NewDefaultConfig returns a ConfigState with the following default settings.
297
+//
298
+// 	Indent: " "
299
+// 	MaxDepth: 0
300
+// 	DisableMethods: false
301
+// 	DisablePointerMethods: false
302
+// 	ContinueOnMethod: false
303
+// 	SortKeys: false
304
+func NewDefaultConfig() *ConfigState {
305
+	return &ConfigState{Indent: " "}
306
+}

+ 211
- 0
vendor/github.com/davecgh/go-spew/spew/doc.go View File

@@ -0,0 +1,211 @@
1
+/*
2
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
3
+ *
4
+ * Permission to use, copy, modify, and distribute this software for any
5
+ * purpose with or without fee is hereby granted, provided that the above
6
+ * copyright notice and this permission notice appear in all copies.
7
+ *
8
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15
+ */
16
+
17
+/*
18
+Package spew implements a deep pretty printer for Go data structures to aid in
19
+debugging.
20
+
21
+A quick overview of the additional features spew provides over the built-in
22
+printing facilities for Go data types are as follows:
23
+
24
+	* Pointers are dereferenced and followed
25
+	* Circular data structures are detected and handled properly
26
+	* Custom Stringer/error interfaces are optionally invoked, including
27
+	  on unexported types
28
+	* Custom types which only implement the Stringer/error interfaces via
29
+	  a pointer receiver are optionally invoked when passing non-pointer
30
+	  variables
31
+	* Byte arrays and slices are dumped like the hexdump -C command which
32
+	  includes offsets, byte values in hex, and ASCII output (only when using
33
+	  Dump style)
34
+
35
+There are two different approaches spew allows for dumping Go data structures:
36
+
37
+	* Dump style which prints with newlines, customizable indentation,
38
+	  and additional debug information such as types and all pointer addresses
39
+	  used to indirect to the final value
40
+	* A custom Formatter interface that integrates cleanly with the standard fmt
41
+	  package and replaces %v, %+v, %#v, and %#+v to provide inline printing
42
+	  similar to the default %v while providing the additional functionality
43
+	  outlined above and passing unsupported format verbs such as %x and %q
44
+	  along to fmt
45
+
46
+Quick Start
47
+
48
+This section demonstrates how to quickly get started with spew.  See the
49
+sections below for further details on formatting and configuration options.
50
+
51
+To dump a variable with full newlines, indentation, type, and pointer
52
+information use Dump, Fdump, or Sdump:
53
+	spew.Dump(myVar1, myVar2, ...)
54
+	spew.Fdump(someWriter, myVar1, myVar2, ...)
55
+	str := spew.Sdump(myVar1, myVar2, ...)
56
+
57
+Alternatively, if you would prefer to use format strings with a compacted inline
58
+printing style, use the convenience wrappers Printf, Fprintf, etc with
59
+%v (most compact), %+v (adds pointer addresses), %#v (adds types), or
60
+%#+v (adds types and pointer addresses):
61
+	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
62
+	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
63
+	spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
64
+	spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
65
+
66
+Configuration Options
67
+
68
+Configuration of spew is handled by fields in the ConfigState type.  For
69
+convenience, all of the top-level functions use a global state available
70
+via the spew.Config global.
71
+
72
+It is also possible to create a ConfigState instance that provides methods
73
+equivalent to the top-level functions.  This allows concurrent configuration
74
+options.  See the ConfigState documentation for more details.
75
+
76
+The following configuration options are available:
77
+	* Indent
78
+		String to use for each indentation level for Dump functions.
79
+		It is a single space by default.  A popular alternative is "\t".
80
+
81
+	* MaxDepth
82
+		Maximum number of levels to descend into nested data structures.
83
+		There is no limit by default.
84
+
85
+	* DisableMethods
86
+		Disables invocation of error and Stringer interface methods.
87
+		Method invocation is enabled by default.
88
+
89
+	* DisablePointerMethods
90
+		Disables invocation of error and Stringer interface methods on types
91
+		which only accept pointer receivers from non-pointer variables.
92
+		Pointer method invocation is enabled by default.
93
+
94
+	* DisablePointerAddresses
95
+		DisablePointerAddresses specifies whether to disable the printing of
96
+		pointer addresses. This is useful when diffing data structures in tests.
97
+
98
+	* DisableCapacities
99
+		DisableCapacities specifies whether to disable the printing of
100
+		capacities for arrays, slices, maps and channels. This is useful when
101
+		diffing data structures in tests.
102
+
103
+	* ContinueOnMethod
104
+		Enables recursion into types after invoking error and Stringer interface
105
+		methods. Recursion after method invocation is disabled by default.
106
+
107
+	* SortKeys
108
+		Specifies map keys should be sorted before being printed. Use
109
+		this to have a more deterministic, diffable output.  Note that
110
+		only native types (bool, int, uint, floats, uintptr and string)
111
+		and types which implement error or Stringer interfaces are
112
+		supported with other types sorted according to the
113
+		reflect.Value.String() output which guarantees display
114
+		stability.  Natural map order is used by default.
115
+
116
+	* SpewKeys
117
+		Specifies that, as a last resort attempt, map keys should be
118
+		spewed to strings and sorted by those strings.  This is only
119
+		considered if SortKeys is true.
120
+
121
+Dump Usage
122
+
123
+Simply call spew.Dump with a list of variables you want to dump:
124
+
125
+	spew.Dump(myVar1, myVar2, ...)
126
+
127
+You may also call spew.Fdump if you would prefer to output to an arbitrary
128
+io.Writer.  For example, to dump to standard error:
129
+
130
+	spew.Fdump(os.Stderr, myVar1, myVar2, ...)
131
+
132
+A third option is to call spew.Sdump to get the formatted output as a string:
133
+
134
+	str := spew.Sdump(myVar1, myVar2, ...)
135
+
136
+Sample Dump Output
137
+
138
+See the Dump example for details on the setup of the types and variables being
139
+shown here.
140
+
141
+	(main.Foo) {
142
+	 unexportedField: (*main.Bar)(0xf84002e210)({
143
+	  flag: (main.Flag) flagTwo,
144
+	  data: (uintptr) <nil>
145
+	 }),
146
+	 ExportedField: (map[interface {}]interface {}) (len=1) {
147
+	  (string) (len=3) "one": (bool) true
148
+	 }
149
+	}
150
+
151
+Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C
152
+command as shown.
153
+	([]uint8) (len=32 cap=32) {
154
+	 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |
155
+	 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|
156
+	 00000020  31 32                                             |12|
157
+	}
158
+
159
+Custom Formatter
160
+
161
+Spew provides a custom formatter that implements the fmt.Formatter interface
162
+so that it integrates cleanly with standard fmt package printing functions. The
163
+formatter is useful for inline printing of smaller data types similar to the
164
+standard %v format specifier.
165
+
166
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
167
+addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
168
+combinations.  Any other verbs such as %x and %q will be sent to the the
169
+standard fmt package for formatting.  In addition, the custom formatter ignores
170
+the width and precision arguments (however they will still work on the format
171
+specifiers not handled by the custom formatter).
172
+
173
+Custom Formatter Usage
174
+
175
+The simplest way to make use of the spew custom formatter is to call one of the
176
+convenience functions such as spew.Printf, spew.Println, or spew.Printf.  The
177
+functions have syntax you are most likely already familiar with:
178
+
179
+	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
180
+	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
181
+	spew.Println(myVar, myVar2)
182
+	spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
183
+	spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
184
+
185
+See the Index for the full list convenience functions.
186
+
187
+Sample Formatter Output
188
+
189
+Double pointer to a uint8:
190
+	  %v: <**>5
191
+	 %+v: <**>(0xf8400420d0->0xf8400420c8)5
192
+	 %#v: (**uint8)5
193
+	%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
194
+
195
+Pointer to circular struct with a uint8 field and a pointer to itself:
196
+	  %v: <*>{1 <*><shown>}
197
+	 %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
198
+	 %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
199
+	%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
200
+
201
+See the Printf example for details on the setup of variables being shown
202
+here.
203
+
204
+Errors
205
+
206
+Since it is possible for custom Stringer/error interfaces to panic, spew
207
+detects them and handles them internally by printing the panic information
208
+inline with the output.  Since spew is intended to provide deep pretty printing
209
+capabilities on structures, it intentionally does not return any errors.
210
+*/
211
+package spew

+ 509
- 0
vendor/github.com/davecgh/go-spew/spew/dump.go View File

@@ -0,0 +1,509 @@
1
+/*
2
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
3
+ *
4
+ * Permission to use, copy, modify, and distribute this software for any
5
+ * purpose with or without fee is hereby granted, provided that the above
6
+ * copyright notice and this permission notice appear in all copies.
7
+ *
8
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15
+ */
16
+
17
+package spew
18
+
19
+import (
20
+	"bytes"
21
+	"encoding/hex"
22
+	"fmt"
23
+	"io"
24
+	"os"
25
+	"reflect"
26
+	"regexp"
27
+	"strconv"
28
+	"strings"
29
+)
30
+
31
+var (
32
+	// uint8Type is a reflect.Type representing a uint8.  It is used to
33
+	// convert cgo types to uint8 slices for hexdumping.
34
+	uint8Type = reflect.TypeOf(uint8(0))
35
+
36
+	// cCharRE is a regular expression that matches a cgo char.
37
+	// It is used to detect character arrays to hexdump them.
38
+	cCharRE = regexp.MustCompile(`^.*\._Ctype_char$`)
39
+
40
+	// cUnsignedCharRE is a regular expression that matches a cgo unsigned
41
+	// char.  It is used to detect unsigned character arrays to hexdump
42
+	// them.
43
+	cUnsignedCharRE = regexp.MustCompile(`^.*\._Ctype_unsignedchar$`)
44
+
45
+	// cUint8tCharRE is a regular expression that matches a cgo uint8_t.
46
+	// It is used to detect uint8_t arrays to hexdump them.
47
+	cUint8tCharRE = regexp.MustCompile(`^.*\._Ctype_uint8_t$`)
48
+)
49
+
50
+// dumpState contains information about the state of a dump operation.
51
+type dumpState struct {
52
+	w                io.Writer
53
+	depth            int
54
+	pointers         map[uintptr]int
55
+	ignoreNextType   bool
56
+	ignoreNextIndent bool
57
+	cs               *ConfigState
58
+}
59
+
60
+// indent performs indentation according to the depth level and cs.Indent
61
+// option.
62
+func (d *dumpState) indent() {
63
+	if d.ignoreNextIndent {
64
+		d.ignoreNextIndent = false
65
+		return
66
+	}
67
+	d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth))
68
+}
69
+
70
+// unpackValue returns values inside of non-nil interfaces when possible.
71
+// This is useful for data types like structs, arrays, slices, and maps which
72
+// can contain varying types packed inside an interface.
73
+func (d *dumpState) unpackValue(v reflect.Value) reflect.Value {
74
+	if v.Kind() == reflect.Interface && !v.IsNil() {
75
+		v = v.Elem()
76
+	}
77
+	return v
78
+}
79
+
80
+// dumpPtr handles formatting of pointers by indirecting them as necessary.
81
+func (d *dumpState) dumpPtr(v reflect.Value) {
82
+	// Remove pointers at or below the current depth from map used to detect
83
+	// circular refs.
84
+	for k, depth := range d.pointers {
85
+		if depth >= d.depth {
86
+			delete(d.pointers, k)
87
+		}
88
+	}
89
+
90
+	// Keep list of all dereferenced pointers to show later.
91
+	pointerChain := make([]uintptr, 0)
92
+
93
+	// Figure out how many levels of indirection there are by dereferencing
94
+	// pointers and unpacking interfaces down the chain while detecting circular
95
+	// references.
96
+	nilFound := false
97
+	cycleFound := false
98
+	indirects := 0
99
+	ve := v
100
+	for ve.Kind() == reflect.Ptr {
101
+		if ve.IsNil() {
102
+			nilFound = true
103
+			break
104
+		}
105
+		indirects++
106
+		addr := ve.Pointer()
107
+		pointerChain = append(pointerChain, addr)
108
+		if pd, ok := d.pointers[addr]; ok && pd < d.depth {
109
+			cycleFound = true
110
+			indirects--
111
+			break
112
+		}
113
+		d.pointers[addr] = d.depth
114
+
115
+		ve = ve.Elem()
116
+		if ve.Kind() == reflect.Interface {
117
+			if ve.IsNil() {
118
+				nilFound = true
119
+				break
120
+			}
121
+			ve = ve.Elem()
122
+		}
123
+	}
124
+
125
+	// Display type information.
126
+	d.w.Write(openParenBytes)
127
+	d.w.Write(bytes.Repeat(asteriskBytes, indirects))
128
+	d.w.Write([]byte(ve.Type().String()))
129
+	d.w.Write(closeParenBytes)
130
+
131
+	// Display pointer information.
132
+	if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 {
133
+		d.w.Write(openParenBytes)
134
+		for i, addr := range pointerChain {
135
+			if i > 0 {
136
+				d.w.Write(pointerChainBytes)
137
+			}
138
+			printHexPtr(d.w, addr)
139
+		}
140
+		d.w.Write(closeParenBytes)
141
+	}
142
+
143
+	// Display dereferenced value.
144
+	d.w.Write(openParenBytes)
145
+	switch {
146
+	case nilFound:
147
+		d.w.Write(nilAngleBytes)
148
+
149
+	case cycleFound:
150
+		d.w.Write(circularBytes)
151
+
152
+	default:
153
+		d.ignoreNextType = true
154
+		d.dump(ve)
155
+	}
156
+	d.w.Write(closeParenBytes)
157
+}
158
+
159
+// dumpSlice handles formatting of arrays and slices.  Byte (uint8 under
160
+// reflection) arrays and slices are dumped in hexdump -C fashion.
161
+func (d *dumpState) dumpSlice(v reflect.Value) {
162
+	// Determine whether this type should be hex dumped or not.  Also,
163
+	// for types which should be hexdumped, try to use the underlying data
164
+	// first, then fall back to trying to convert them to a uint8 slice.
165
+	var buf []uint8
166
+	doConvert := false
167
+	doHexDump := false
168
+	numEntries := v.Len()
169
+	if numEntries > 0 {
170
+		vt := v.Index(0).Type()
171
+		vts := vt.String()
172
+		switch {
173
+		// C types that need to be converted.
174
+		case cCharRE.MatchString(vts):
175
+			fallthrough
176
+		case cUnsignedCharRE.MatchString(vts):
177
+			fallthrough
178
+		case cUint8tCharRE.MatchString(vts):
179
+			doConvert = true
180
+
181
+		// Try to use existing uint8 slices and fall back to converting
182
+		// and copying if that fails.
183
+		case vt.Kind() == reflect.Uint8:
184
+			// We need an addressable interface to convert the type
185
+			// to a byte slice.  However, the reflect package won't
186
+			// give us an interface on certain things like
187
+			// unexported struct fields in order to enforce
188
+			// visibility rules.  We use unsafe, when available, to
189
+			// bypass these restrictions since this package does not
190
+			// mutate the values.
191
+			vs := v
192
+			if !vs.CanInterface() || !vs.CanAddr() {
193
+				vs = unsafeReflectValue(vs)
194
+			}
195
+			if !UnsafeDisabled {
196
+				vs = vs.Slice(0, numEntries)
197
+
198
+				// Use the existing uint8 slice if it can be
199
+				// type asserted.
200
+				iface := vs.Interface()
201
+				if slice, ok := iface.([]uint8); ok {
202
+					buf = slice
203
+					doHexDump = true
204
+					break
205
+				}
206
+			}
207
+
208
+			// The underlying data needs to be converted if it can't
209
+			// be type asserted to a uint8 slice.
210
+			doConvert = true
211
+		}
212
+
213
+		// Copy and convert the underlying type if needed.
214
+		if doConvert && vt.ConvertibleTo(uint8Type) {
215
+			// Convert and copy each element into a uint8 byte
216
+			// slice.
217
+			buf = make([]uint8, numEntries)
218
+			for i := 0; i < numEntries; i++ {
219
+				vv := v.Index(i)
220
+				buf[i] = uint8(vv.Convert(uint8Type).Uint())
221
+			}
222
+			doHexDump = true
223
+		}
224
+	}
225
+
226
+	// Hexdump the entire slice as needed.
227
+	if doHexDump {
228
+		indent := strings.Repeat(d.cs.Indent, d.depth)
229
+		str := indent + hex.Dump(buf)
230
+		str = strings.Replace(str, "\n", "\n"+indent, -1)
231
+		str = strings.TrimRight(str, d.cs.Indent)
232
+		d.w.Write([]byte(str))
233
+		return
234
+	}
235
+
236
+	// Recursively call dump for each item.
237
+	for i := 0; i < numEntries; i++ {
238
+		d.dump(d.unpackValue(v.Index(i)))
239
+		if i < (numEntries - 1) {
240
+			d.w.Write(commaNewlineBytes)
241
+		} else {
242
+			d.w.Write(newlineBytes)
243
+		}
244
+	}
245
+}
246
+
247
+// dump is the main workhorse for dumping a value.  It uses the passed reflect
248
+// value to figure out what kind of object we are dealing with and formats it
249
+// appropriately.  It is a recursive function, however circular data structures
250
+// are detected and handled properly.
251
+func (d *dumpState) dump(v reflect.Value) {
252
+	// Handle invalid reflect values immediately.
253
+	kind := v.Kind()
254
+	if kind == reflect.Invalid {
255
+		d.w.Write(invalidAngleBytes)
256
+		return
257
+	}
258
+
259
+	// Handle pointers specially.
260
+	if kind == reflect.Ptr {
261
+		d.indent()
262
+		d.dumpPtr(v)
263
+		return
264
+	}
265
+
266
+	// Print type information unless already handled elsewhere.
267
+	if !d.ignoreNextType {
268
+		d.indent()
269
+		d.w.Write(openParenBytes)
270
+		d.w.Write([]byte(v.Type().String()))
271
+		d.w.Write(closeParenBytes)
272
+		d.w.Write(spaceBytes)
273
+	}
274
+	d.ignoreNextType = false
275
+
276
+	// Display length and capacity if the built-in len and cap functions
277
+	// work with the value's kind and the len/cap itself is non-zero.
278
+	valueLen, valueCap := 0, 0
279
+	switch v.Kind() {
280
+	case reflect.Array, reflect.Slice, reflect.Chan:
281
+		valueLen, valueCap = v.Len(), v.Cap()
282
+	case reflect.Map, reflect.String:
283
+		valueLen = v.Len()
284
+	}
285
+	if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 {
286
+		d.w.Write(openParenBytes)
287
+		if valueLen != 0 {
288
+			d.w.Write(lenEqualsBytes)
289
+			printInt(d.w, int64(valueLen), 10)
290
+		}
291
+		if !d.cs.DisableCapacities && valueCap != 0 {
292
+			if valueLen != 0 {
293
+				d.w.Write(spaceBytes)
294
+			}
295
+			d.w.Write(capEqualsBytes)
296
+			printInt(d.w, int64(valueCap), 10)
297
+		}
298
+		d.w.Write(closeParenBytes)
299
+		d.w.Write(spaceBytes)
300
+	}
301
+
302
+	// Call Stringer/error interfaces if they exist and the handle methods flag
303
+	// is enabled
304
+	if !d.cs.DisableMethods {
305
+		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
306
+			if handled := handleMethods(d.cs, d.w, v); handled {
307
+				return
308
+			}
309
+		}
310
+	}
311
+
312
+	switch kind {
313
+	case reflect.Invalid:
314
+		// Do nothing.  We should never get here since invalid has already
315
+		// been handled above.
316
+
317
+	case reflect.Bool:
318
+		printBool(d.w, v.Bool())
319
+
320
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
321
+		printInt(d.w, v.Int(), 10)
322
+
323
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
324
+		printUint(d.w, v.Uint(), 10)
325
+
326
+	case reflect.Float32:
327
+		printFloat(d.w, v.Float(), 32)
328
+
329
+	case reflect.Float64:
330
+		printFloat(d.w, v.Float(), 64)
331
+
332
+	case reflect.Complex64:
333
+		printComplex(d.w, v.Complex(), 32)
334
+
335
+	case reflect.Complex128:
336
+		printComplex(d.w, v.Complex(), 64)
337
+
338
+	case reflect.Slice:
339
+		if v.IsNil() {
340
+			d.w.Write(nilAngleBytes)
341
+			break
342
+		}
343
+		fallthrough
344
+
345
+	case reflect.Array:
346
+		d.w.Write(openBraceNewlineBytes)
347
+		d.depth++
348
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
349
+			d.indent()
350
+			d.w.Write(maxNewlineBytes)
351
+		} else {
352
+			d.dumpSlice(v)
353
+		}
354
+		d.depth--
355
+		d.indent()
356
+		d.w.Write(closeBraceBytes)
357
+
358
+	case reflect.String:
359
+		d.w.Write([]byte(strconv.Quote(v.String())))
360
+
361
+	case reflect.Interface:
362
+		// The only time we should get here is for nil interfaces due to
363
+		// unpackValue calls.
364
+		if v.IsNil() {
365
+			d.w.Write(nilAngleBytes)
366
+		}
367
+
368
+	case reflect.Ptr:
369
+		// Do nothing.  We should never get here since pointers have already
370
+		// been handled above.
371
+
372
+	case reflect.Map:
373
+		// nil maps should be indicated as different than empty maps
374
+		if v.IsNil() {
375
+			d.w.Write(nilAngleBytes)
376
+			break
377
+		}
378
+
379
+		d.w.Write(openBraceNewlineBytes)
380
+		d.depth++
381
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
382
+			d.indent()
383
+			d.w.Write(maxNewlineBytes)
384
+		} else {
385
+			numEntries := v.Len()
386
+			keys := v.MapKeys()
387
+			if d.cs.SortKeys {
388
+				sortValues(keys, d.cs)
389
+			}
390
+			for i, key := range keys {
391
+				d.dump(d.unpackValue(key))
392
+				d.w.Write(colonSpaceBytes)
393
+				d.ignoreNextIndent = true
394
+				d.dump(d.unpackValue(v.MapIndex(key)))
395
+				if i < (numEntries - 1) {
396
+					d.w.Write(commaNewlineBytes)
397
+				} else {
398
+					d.w.Write(newlineBytes)
399
+				}
400
+			}
401
+		}
402
+		d.depth--
403
+		d.indent()
404
+		d.w.Write(closeBraceBytes)
405
+
406
+	case reflect.Struct:
407
+		d.w.Write(openBraceNewlineBytes)
408
+		d.depth++
409
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
410
+			d.indent()
411
+			d.w.Write(maxNewlineBytes)
412
+		} else {
413
+			vt := v.Type()
414
+			numFields := v.NumField()
415
+			for i := 0; i < numFields; i++ {
416
+				d.indent()
417
+				vtf := vt.Field(i)
418
+				d.w.Write([]byte(vtf.Name))
419
+				d.w.Write(colonSpaceBytes)
420
+				d.ignoreNextIndent = true
421
+				d.dump(d.unpackValue(v.Field(i)))
422
+				if i < (numFields - 1) {
423
+					d.w.Write(commaNewlineBytes)
424
+				} else {
425
+					d.w.Write(newlineBytes)
426
+				}
427
+			}
428
+		}
429
+		d.depth--
430
+		d.indent()
431
+		d.w.Write(closeBraceBytes)
432
+
433
+	case reflect.Uintptr:
434
+		printHexPtr(d.w, uintptr(v.Uint()))
435
+
436
+	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
437
+		printHexPtr(d.w, v.Pointer())
438
+
439
+	// There were not any other types at the time this code was written, but
440
+	// fall back to letting the default fmt package handle it in case any new
441
+	// types are added.
442
+	default:
443
+		if v.CanInterface() {
444
+			fmt.Fprintf(d.w, "%v", v.Interface())
445
+		} else {
446
+			fmt.Fprintf(d.w, "%v", v.String())
447
+		}
448
+	}
449
+}
450
+
451
+// fdump is a helper function to consolidate the logic from the various public
452
+// methods which take varying writers and config states.
453
+func fdump(cs *ConfigState, w io.Writer, a ...interface{}) {
454
+	for _, arg := range a {
455
+		if arg == nil {
456
+			w.Write(interfaceBytes)
457
+			w.Write(spaceBytes)
458
+			w.Write(nilAngleBytes)
459
+			w.Write(newlineBytes)
460
+			continue
461
+		}
462
+
463
+		d := dumpState{w: w, cs: cs}
464
+		d.pointers = make(map[uintptr]int)
465
+		d.dump(reflect.ValueOf(arg))
466
+		d.w.Write(newlineBytes)
467
+	}
468
+}
469
+
470
+// Fdump formats and displays the passed arguments to io.Writer w.  It formats
471
+// exactly the same as Dump.
472
+func Fdump(w io.Writer, a ...interface{}) {
473
+	fdump(&Config, w, a...)
474
+}
475
+
476
+// Sdump returns a string with the passed arguments formatted exactly the same
477
+// as Dump.
478
+func Sdump(a ...interface{}) string {
479
+	var buf bytes.Buffer
480
+	fdump(&Config, &buf, a...)
481
+	return buf.String()
482
+}
483
+
484
+/*
485
+Dump displays the passed parameters to standard out with newlines, customizable
486
+indentation, and additional debug information such as complete types and all
487
+pointer addresses used to indirect to the final value.  It provides the
488
+following features over the built-in printing facilities provided by the fmt
489
+package:
490
+
491
+	* Pointers are dereferenced and followed
492
+	* Circular data structures are detected and handled properly
493
+	* Custom Stringer/error interfaces are optionally invoked, including
494
+	  on unexported types
495
+	* Custom types which only implement the Stringer/error interfaces via
496
+	  a pointer receiver are optionally invoked when passing non-pointer
497
+	  variables
498
+	* Byte arrays and slices are dumped like the hexdump -C command which
499
+	  includes offsets, byte values in hex, and ASCII output
500
+
501
+The configuration options are controlled by an exported package global,
502
+spew.Config.  See ConfigState for options documentation.
503
+
504
+See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
505
+get the formatted result as a string.
506
+*/
507
+func Dump(a ...interface{}) {
508
+	fdump(&Config, os.Stdout, a...)
509
+}

+ 419
- 0
vendor/github.com/davecgh/go-spew/spew/format.go View File

@@ -0,0 +1,419 @@
1
+/*
2
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
3
+ *
4
+ * Permission to use, copy, modify, and distribute this software for any
5
+ * purpose with or without fee is hereby granted, provided that the above
6
+ * copyright notice and this permission notice appear in all copies.
7
+ *
8
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15
+ */
16
+
17
+package spew
18
+
19
+import (
20
+	"bytes"
21
+	"fmt"
22
+	"reflect"
23
+	"strconv"
24
+	"strings"
25
+)
26
+
27
+// supportedFlags is a list of all the character flags supported by fmt package.
28
+const supportedFlags = "0-+# "
29
+
30
+// formatState implements the fmt.Formatter interface and contains information
31
+// about the state of a formatting operation.  The NewFormatter function can
32
+// be used to get a new Formatter which can be used directly as arguments
33
+// in standard fmt package printing calls.
34
+type formatState struct {
35
+	value          interface{}
36
+	fs             fmt.State
37
+	depth          int
38
+	pointers       map[uintptr]int
39
+	ignoreNextType bool
40
+	cs             *ConfigState
41
+}
42
+
43
+// buildDefaultFormat recreates the original format string without precision
44
+// and width information to pass in to fmt.Sprintf in the case of an
45
+// unrecognized type.  Unless new types are added to the language, this
46
+// function won't ever be called.
47
+func (f *formatState) buildDefaultFormat() (format string) {
48
+	buf := bytes.NewBuffer(percentBytes)
49
+
50
+	for _, flag := range supportedFlags {
51
+		if f.fs.Flag(int(flag)) {
52
+			buf.WriteRune(flag)
53
+		}
54
+	}
55
+
56
+	buf.WriteRune('v')
57
+
58
+	format = buf.String()
59
+	return format
60
+}
61
+
62
+// constructOrigFormat recreates the original format string including precision
63
+// and width information to pass along to the standard fmt package.  This allows
64
+// automatic deferral of all format strings this package doesn't support.
65
+func (f *formatState) constructOrigFormat(verb rune) (format string) {
66
+	buf := bytes.NewBuffer(percentBytes)
67
+
68
+	for _, flag := range supportedFlags {
69
+		if f.fs.Flag(int(flag)) {
70
+			buf.WriteRune(flag)
71
+		}
72
+	}
73
+
74
+	if width, ok := f.fs.Width(); ok {
75
+		buf.WriteString(strconv.Itoa(width))
76
+	}
77
+
78
+	if precision, ok := f.fs.Precision(); ok {
79
+		buf.Write(precisionBytes)
80
+		buf.WriteString(strconv.Itoa(precision))
81
+	}
82
+
83
+	buf.WriteRune(verb)
84
+
85
+	format = buf.String()
86
+	return format
87
+}
88
+
89
+// unpackValue returns values inside of non-nil interfaces when possible and
90
+// ensures that types for values which have been unpacked from an interface
91
+// are displayed when the show types flag is also set.
92
+// This is useful for data types like structs, arrays, slices, and maps which
93
+// can contain varying types packed inside an interface.
94
+func (f *formatState) unpackValue(v reflect.Value) reflect.Value {
95
+	if v.Kind() == reflect.Interface {
96
+		f.ignoreNextType = false
97
+		if !v.IsNil() {
98
+			v = v.Elem()
99
+		}
100
+	}
101
+	return v
102
+}
103
+
104
+// formatPtr handles formatting of pointers by indirecting them as necessary.
105
+func (f *formatState) formatPtr(v reflect.Value) {
106
+	// Display nil if top level pointer is nil.
107
+	showTypes := f.fs.Flag('#')
108
+	if v.IsNil() && (!showTypes || f.ignoreNextType) {
109
+		f.fs.Write(nilAngleBytes)
110
+		return
111
+	}
112
+
113
+	// Remove pointers at or below the current depth from map used to detect
114
+	// circular refs.
115
+	for k, depth := range f.pointers {
116
+		if depth >= f.depth {
117
+			delete(f.pointers, k)
118
+		}
119
+	}
120
+
121
+	// Keep list of all dereferenced pointers to possibly show later.
122
+	pointerChain := make([]uintptr, 0)
123
+
124
+	// Figure out how many levels of indirection there are by derferencing
125
+	// pointers and unpacking interfaces down the chain while detecting circular
126
+	// references.
127
+	nilFound := false
128
+	cycleFound := false
129
+	indirects := 0
130
+	ve := v
131
+	for ve.Kind() == reflect.Ptr {
132
+		if ve.IsNil() {
133
+			nilFound = true
134
+			break
135
+		}
136
+		indirects++
137
+		addr := ve.Pointer()
138
+		pointerChain = append(pointerChain, addr)
139
+		if pd, ok := f.pointers[addr]; ok && pd < f.depth {
140
+			cycleFound = true
141
+			indirects--
142
+			break
143
+		}
144
+		f.pointers[addr] = f.depth
145
+
146
+		ve = ve.Elem()
147
+		if ve.Kind() == reflect.Interface {
148
+			if ve.IsNil() {
149
+				nilFound = true
150
+				break
151
+			}
152
+			ve = ve.Elem()
153
+		}
154
+	}
155
+
156
+	// Display type or indirection level depending on flags.
157
+	if showTypes && !f.ignoreNextType {
158
+		f.fs.Write(openParenBytes)
159
+		f.fs.Write(bytes.Repeat(asteriskBytes, indirects))
160
+		f.fs.Write([]byte(ve.Type().String()))
161
+		f.fs.Write(closeParenBytes)
162
+	} else {
163
+		if nilFound || cycleFound {
164
+			indirects += strings.Count(ve.Type().String(), "*")
165
+		}
166
+		f.fs.Write(openAngleBytes)
167
+		f.fs.Write([]byte(strings.Repeat("*", indirects)))
168
+		f.fs.Write(closeAngleBytes)
169
+	}
170
+
171
+	// Display pointer information depending on flags.
172
+	if f.fs.Flag('+') && (len(pointerChain) > 0) {
173
+		f.fs.Write(openParenBytes)
174
+		for i, addr := range pointerChain {
175
+			if i > 0 {
176
+				f.fs.Write(pointerChainBytes)
177
+			}
178
+			printHexPtr(f.fs, addr)
179
+		}
180
+		f.fs.Write(closeParenBytes)
181
+	}
182
+
183
+	// Display dereferenced value.
184
+	switch {
185
+	case nilFound:
186
+		f.fs.Write(nilAngleBytes)
187
+
188
+	case cycleFound:
189
+		f.fs.Write(circularShortBytes)
190
+
191
+	default:
192
+		f.ignoreNextType = true
193
+		f.format(ve)
194
+	}
195
+}
196
+
197
+// format is the main workhorse for providing the Formatter interface.  It
198
+// uses the passed reflect value to figure out what kind of object we are
199
+// dealing with and formats it appropriately.  It is a recursive function,
200
+// however circular data structures are detected and handled properly.
201
+func (f *formatState) format(v reflect.Value) {
202
+	// Handle invalid reflect values immediately.
203
+	kind := v.Kind()
204
+	if kind == reflect.Invalid {
205
+		f.fs.Write(invalidAngleBytes)
206
+		return
207
+	}
208
+
209
+	// Handle pointers specially.
210
+	if kind == reflect.Ptr {
211
+		f.formatPtr(v)
212
+		return
213
+	}
214
+
215
+	// Print type information unless already handled elsewhere.
216
+	if !f.ignoreNextType && f.fs.Flag('#') {
217
+		f.fs.Write(openParenBytes)
218
+		f.fs.Write([]byte(v.Type().String()))
219
+		f.fs.Write(closeParenBytes)
220
+	}
221
+	f.ignoreNextType = false
222
+
223
+	// Call Stringer/error interfaces if they exist and the handle methods
224
+	// flag is enabled.
225
+	if !f.cs.DisableMethods {
226
+		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
227
+			if handled := handleMethods(f.cs, f.fs, v); handled {
228
+				return
229
+			}
230
+		}
231
+	}
232
+
233
+	switch kind {
234
+	case reflect.Invalid:
235
+		// Do nothing.  We should never get here since invalid has already
236
+		// been handled above.
237
+
238
+	case reflect.Bool:
239
+		printBool(f.fs, v.Bool())
240
+
241
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
242
+		printInt(f.fs, v.Int(), 10)
243
+
244
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
245
+		printUint(f.fs, v.Uint(), 10)
246
+
247
+	case reflect.Float32:
248
+		printFloat(f.fs, v.Float(), 32)
249
+
250
+	case reflect.Float64:
251
+		printFloat(f.fs, v.Float(), 64)
252
+
253
+	case reflect.Complex64:
254
+		printComplex(f.fs, v.Complex(), 32)
255
+
256
+	case reflect.Complex128:
257
+		printComplex(f.fs, v.Complex(), 64)
258
+
259
+	case reflect.Slice:
260
+		if v.IsNil() {
261
+			f.fs.Write(nilAngleBytes)
262
+			break
263
+		}
264
+		fallthrough
265
+
266
+	case reflect.Array:
267
+		f.fs.Write(openBracketBytes)
268
+		f.depth++
269
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
270
+			f.fs.Write(maxShortBytes)
271
+		} else {
272
+			numEntries := v.Len()
273
+			for i := 0; i < numEntries; i++ {
274
+				if i > 0 {
275
+					f.fs.Write(spaceBytes)
276
+				}
277
+				f.ignoreNextType = true
278
+				f.format(f.unpackValue(v.Index(i)))
279
+			}
280
+		}
281
+		f.depth--
282
+		f.fs.Write(closeBracketBytes)
283
+
284
+	case reflect.String:
285
+		f.fs.Write([]byte(v.String()))
286
+
287
+	case reflect.Interface:
288
+		// The only time we should get here is for nil interfaces due to
289
+		// unpackValue calls.
290
+		if v.IsNil() {
291
+			f.fs.Write(nilAngleBytes)
292
+		}
293
+
294
+	case reflect.Ptr:
295
+		// Do nothing.  We should never get here since pointers have already
296
+		// been handled above.
297
+
298
+	case reflect.Map:
299
+		// nil maps should be indicated as different than empty maps
300
+		if v.IsNil() {
301
+			f.fs.Write(nilAngleBytes)
302
+			break
303
+		}
304
+
305
+		f.fs.Write(openMapBytes)
306
+		f.depth++
307
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
308
+			f.fs.Write(maxShortBytes)
309
+		} else {
310
+			keys := v.MapKeys()
311
+			if f.cs.SortKeys {
312
+				sortValues(keys, f.cs)
313
+			}
314
+			for i, key := range keys {
315
+				if i > 0 {
316
+					f.fs.Write(spaceBytes)
317
+				}
318
+				f.ignoreNextType = true
319
+				f.format(f.unpackValue(key))
320
+				f.fs.Write(colonBytes)
321
+				f.ignoreNextType = true
322
+				f.format(f.unpackValue(v.MapIndex(key)))
323
+			}
324
+		}
325
+		f.depth--
326
+		f.fs.Write(closeMapBytes)
327
+
328
+	case reflect.Struct:
329
+		numFields := v.NumField()
330
+		f.fs.Write(openBraceBytes)
331
+		f.depth++
332
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
333
+			f.fs.Write(maxShortBytes)
334
+		} else {
335
+			vt := v.Type()
336
+			for i := 0; i < numFields; i++ {
337
+				if i > 0 {
338
+					f.fs.Write(spaceBytes)
339
+				}
340
+				vtf := vt.Field(i)
341
+				if f.fs.Flag('+') || f.fs.Flag('#') {
342
+					f.fs.Write([]byte(vtf.Name))
343
+					f.fs.Write(colonBytes)
344
+				}
345
+				f.format(f.unpackValue(v.Field(i)))
346
+			}
347
+		}
348
+		f.depth--
349
+		f.fs.Write(closeBraceBytes)
350
+
351
+	case reflect.Uintptr:
352
+		printHexPtr(f.fs, uintptr(v.Uint()))
353
+
354
+	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
355
+		printHexPtr(f.fs, v.Pointer())
356
+
357
+	// There were not any other types at the time this code was written, but
358
+	// fall back to letting the default fmt package handle it if any get added.
359
+	default:
360
+		format := f.buildDefaultFormat()
361
+		if v.CanInterface() {
362
+			fmt.Fprintf(f.fs, format, v.Interface())
363
+		} else {
364
+			fmt.Fprintf(f.fs, format, v.String())
365
+		}
366
+	}
367
+}
368
+
369
+// Format satisfies the fmt.Formatter interface. See NewFormatter for usage
370
+// details.
371
+func (f *formatState) Format(fs fmt.State, verb rune) {
372
+	f.fs = fs
373
+
374
+	// Use standard formatting for verbs that are not v.
375
+	if verb != 'v' {
376
+		format := f.constructOrigFormat(verb)
377
+		fmt.Fprintf(fs, format, f.value)
378
+		return
379
+	}
380
+
381
+	if f.value == nil {
382
+		if fs.Flag('#') {
383
+			fs.Write(interfaceBytes)
384
+		}
385
+		fs.Write(nilAngleBytes)
386
+		return
387
+	}
388
+
389
+	f.format(reflect.ValueOf(f.value))
390
+}
391
+
392
+// newFormatter is a helper function to consolidate the logic from the various
393
+// public methods which take varying config states.
394
+func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter {
395
+	fs := &formatState{value: v, cs: cs}
396
+	fs.pointers = make(map[uintptr]int)
397
+	return fs
398
+}
399
+
400
+/*
401
+NewFormatter returns a custom formatter that satisfies the fmt.Formatter
402
+interface.  As a result, it integrates cleanly with standard fmt package
403
+printing functions.  The formatter is useful for inline printing of smaller data
404
+types similar to the standard %v format specifier.
405
+
406
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
407
+addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
408
+combinations.  Any other verbs such as %x and %q will be sent to the the
409
+standard fmt package for formatting.  In addition, the custom formatter ignores
410
+the width and precision arguments (however they will still work on the format
411
+specifiers not handled by the custom formatter).
412
+
413
+Typically this function shouldn't be called directly.  It is much easier to make
414
+use of the custom formatter by calling one of the convenience functions such as
415
+Printf, Println, or Fprintf.
416
+*/
417
+func NewFormatter(v interface{}) fmt.Formatter {
418
+	return newFormatter(&Config, v)
419
+}

+ 148
- 0
vendor/github.com/davecgh/go-spew/spew/spew.go View File

@@ -0,0 +1,148 @@
1
+/*
2
+ * Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
3
+ *
4
+ * Permission to use, copy, modify, and distribute this software for any
5
+ * purpose with or without fee is hereby granted, provided that the above
6
+ * copyright notice and this permission notice appear in all copies.
7
+ *
8
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15
+ */
16
+
17
+package spew
18
+
19
+import (
20
+	"fmt"
21
+	"io"
22
+)
23
+
24
+// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
25
+// passed with a default Formatter interface returned by NewFormatter.  It
26
+// returns the formatted string as a value that satisfies error.  See
27
+// NewFormatter for formatting details.
28
+//
29
+// This function is shorthand for the following syntax:
30
+//
31
+//	fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b))
32
+func Errorf(format string, a ...interface{}) (err error) {
33
+	return fmt.Errorf(format, convertArgs(a)...)
34
+}
35
+
36
+// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
37
+// passed with a default Formatter interface returned by NewFormatter.  It
38
+// returns the number of bytes written and any write error encountered.  See
39
+// NewFormatter for formatting details.
40
+//
41
+// This function is shorthand for the following syntax:
42
+//
43
+//	fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b))
44
+func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
45
+	return fmt.Fprint(w, convertArgs(a)...)
46
+}
47
+
48
+// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
49
+// passed with a default Formatter interface returned by NewFormatter.  It
50
+// returns the number of bytes written and any write error encountered.  See
51
+// NewFormatter for formatting details.
52
+//
53
+// This function is shorthand for the following syntax:
54
+//
55
+//	fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b))
56
+func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
57
+	return fmt.Fprintf(w, format, convertArgs(a)...)
58
+}
59
+
60
+// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
61
+// passed with a default Formatter interface returned by NewFormatter.  See
62
+// NewFormatter for formatting details.
63
+//
64
+// This function is shorthand for the following syntax:
65
+//
66
+//	fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b))
67
+func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
68
+	return fmt.Fprintln(w, convertArgs(a)...)
69
+}
70
+
71
+// Print is a wrapper for fmt.Print that treats each argument as if it were
72
+// passed with a default Formatter interface returned by NewFormatter.  It
73
+// returns the number of bytes written and any write error encountered.  See
74
+// NewFormatter for formatting details.
75
+//
76
+// This function is shorthand for the following syntax:
77
+//
78
+//	fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b))
79
+func Print(a ...interface{}) (n int, err error) {
80
+	return fmt.Print(convertArgs(a)...)
81
+}
82
+
83
+// Printf is a wrapper for fmt.Printf that treats each argument as if it were
84
+// passed with a default Formatter interface returned by NewFormatter.  It
85
+// returns the number of bytes written and any write error encountered.  See
86
+// NewFormatter for formatting details.
87
+//
88
+// This function is shorthand for the following syntax:
89
+//
90
+//	fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b))
91
+func Printf(format string, a ...interface{}) (n int, err error) {
92
+	return fmt.Printf(format, convertArgs(a)...)
93
+}
94
+
95
+// Println is a wrapper for fmt.Println that treats each argument as if it were
96
+// passed with a default Formatter interface returned by NewFormatter.  It
97
+// returns the number of bytes written and any write error encountered.  See
98
+// NewFormatter for formatting details.
99
+//
100
+// This function is shorthand for the following syntax:
101
+//
102
+//	fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b))
103
+func Println(a ...interface{}) (n int, err error) {
104
+	return fmt.Println(convertArgs(a)...)
105
+}
106
+
107
+// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
108
+// passed with a default Formatter interface returned by NewFormatter.  It
109
+// returns the resulting string.  See NewFormatter for formatting details.
110
+//
111
+// This function is shorthand for the following syntax:
112
+//
113
+//	fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b))
114
+func Sprint(a ...interface{}) string {
115
+	return fmt.Sprint(convertArgs(a)...)
116
+}
117
+
118
+// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
119
+// passed with a default Formatter interface returned by NewFormatter.  It
120
+// returns the resulting string.  See NewFormatter for formatting details.
121
+//
122
+// This function is shorthand for the following syntax:
123
+//
124
+//	fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b))
125
+func Sprintf(format string, a ...interface{}) string {
126
+	return fmt.Sprintf(format, convertArgs(a)...)
127
+}
128
+
129
+// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
130
+// were passed with a default Formatter interface returned by NewFormatter.  It
131
+// returns the resulting string.  See NewFormatter for formatting details.
132
+//
133
+// This function is shorthand for the following syntax:
134
+//
135
+//	fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b))
136
+func Sprintln(a ...interface{}) string {
137
+	return fmt.Sprintln(convertArgs(a)...)
138
+}
139
+
140
+// convertArgs accepts a slice of arguments and returns a slice of the same
141
+// length with each argument converted to a default spew Formatter interface.
142
+func convertArgs(args []interface{}) (formatters []interface{}) {
143
+	formatters = make([]interface{}, len(args))
144
+	for index, arg := range args {
145
+		formatters[index] = NewFormatter(arg)
146
+	}
147
+	return formatters
148
+}

+ 27
- 0
vendor/github.com/pmezard/go-difflib/LICENSE View File

@@ -0,0 +1,27 @@
1
+Copyright (c) 2013, Patrick Mezard
2
+All rights reserved.
3
+
4
+Redistribution and use in source and binary forms, with or without
5
+modification, are permitted provided that the following conditions are
6
+met:
7
+
8
+    Redistributions of source code must retain the above copyright
9
+notice, this list of conditions and the following disclaimer.
10
+    Redistributions in binary form must reproduce the above copyright
11
+notice, this list of conditions and the following disclaimer in the
12
+documentation and/or other materials provided with the distribution.
13
+    The names of its contributors may not be used to endorse or promote
14
+products derived from this software without specific prior written
15
+permission.
16
+
17
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
18
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
20
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
23
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ 772
- 0
vendor/github.com/pmezard/go-difflib/difflib/difflib.go View File

@@ -0,0 +1,772 @@
1
+// Package difflib is a partial port of Python difflib module.
2
+//
3
+// It provides tools to compare sequences of strings and generate textual diffs.
4
+//
5
+// The following class and functions have been ported:
6
+//
7
+// - SequenceMatcher
8
+//
9
+// - unified_diff
10
+//
11
+// - context_diff
12
+//
13
+// Getting unified diffs was the main goal of the port. Keep in mind this code
14
+// is mostly suitable to output text differences in a human friendly way, there
15
+// are no guarantees generated diffs are consumable by patch(1).
16
+package difflib
17
+
18
+import (
19
+	"bufio"
20
+	"bytes"
21
+	"fmt"
22
+	"io"
23
+	"strings"
24
+)
25
+
26
+func min(a, b int) int {
27
+	if a < b {
28
+		return a
29
+	}
30
+	return b
31
+}
32
+
33
+func max(a, b int) int {
34
+	if a > b {
35
+		return a
36
+	}
37
+	return b
38
+}
39
+
40
+func calculateRatio(matches, length int) float64 {
41
+	if length > 0 {
42
+		return 2.0 * float64(matches) / float64(length)
43
+	}
44
+	return 1.0
45
+}
46
+
47
+type Match struct {
48
+	A    int
49
+	B    int
50
+	Size int
51
+}
52
+
53
+type OpCode struct {
54
+	Tag byte
55
+	I1  int
56
+	I2  int
57
+	J1  int
58
+	J2  int
59
+}
60
+
61
+// SequenceMatcher compares sequence of strings. The basic
62
+// algorithm predates, and is a little fancier than, an algorithm
63
+// published in the late 1980's by Ratcliff and Obershelp under the
64
+// hyperbolic name "gestalt pattern matching".  The basic idea is to find
65
+// the longest contiguous matching subsequence that contains no "junk"
66
+// elements (R-O doesn't address junk).  The same idea is then applied
67
+// recursively to the pieces of the sequences to the left and to the right
68
+// of the matching subsequence.  This does not yield minimal edit
69
+// sequences, but does tend to yield matches that "look right" to people.
70
+//
71
+// SequenceMatcher tries to compute a "human-friendly diff" between two
72
+// sequences.  Unlike e.g. UNIX(tm) diff, the fundamental notion is the
73
+// longest *contiguous* & junk-free matching subsequence.  That's what
74
+// catches peoples' eyes.  The Windows(tm) windiff has another interesting
75
+// notion, pairing up elements that appear uniquely in each sequence.
76
+// That, and the method here, appear to yield more intuitive difference
77
+// reports than does diff.  This method appears to be the least vulnerable
78
+// to synching up on blocks of "junk lines", though (like blank lines in
79
+// ordinary text files, or maybe "<P>" lines in HTML files).  That may be
80
+// because this is the only method of the 3 that has a *concept* of
81
+// "junk" <wink>.
82
+//
83
+// Timing:  Basic R-O is cubic time worst case and quadratic time expected
84
+// case.  SequenceMatcher is quadratic time for the worst case and has
85
+// expected-case behavior dependent in a complicated way on how many
86
+// elements the sequences have in common; best case time is linear.
87
+type SequenceMatcher struct {
88
+	a              []string
89
+	b              []string
90
+	b2j            map[string][]int
91
+	IsJunk         func(string) bool
92
+	autoJunk       bool
93
+	bJunk          map[string]struct{}
94
+	matchingBlocks []Match
95
+	fullBCount     map[string]int
96
+	bPopular       map[string]struct{}
97
+	opCodes        []OpCode
98
+}
99
+
100
+func NewMatcher(a, b []string) *SequenceMatcher {
101
+	m := SequenceMatcher{autoJunk: true}
102
+	m.SetSeqs(a, b)
103
+	return &m
104
+}
105
+
106
+func NewMatcherWithJunk(a, b []string, autoJunk bool,
107
+	isJunk func(string) bool) *SequenceMatcher {
108
+
109
+	m := SequenceMatcher{IsJunk: isJunk, autoJunk: autoJunk}
110
+	m.SetSeqs(a, b)
111
+	return &m
112
+}
113
+
114
+// Set two sequences to be compared.
115
+func (m *SequenceMatcher) SetSeqs(a, b []string) {
116
+	m.SetSeq1(a)
117
+	m.SetSeq2(b)
118
+}
119
+
120
+// Set the first sequence to be compared. The second sequence to be compared is
121
+// not changed.
122
+//
123
+// SequenceMatcher computes and caches detailed information about the second
124
+// sequence, so if you want to compare one sequence S against many sequences,
125
+// use .SetSeq2(s) once and call .SetSeq1(x) repeatedly for each of the other
126
+// sequences.
127
+//
128
+// See also SetSeqs() and SetSeq2().
129
+func (m *SequenceMatcher) SetSeq1(a []string) {
130
+	if &a == &m.a {
131
+		return
132
+	}
133
+	m.a = a
134
+	m.matchingBlocks = nil
135
+	m.opCodes = nil
136
+}
137
+
138
+// Set the second sequence to be compared. The first sequence to be compared is
139
+// not changed.
140
+func (m *SequenceMatcher) SetSeq2(b []string) {
141
+	if &b == &m.b {
142
+		return
143
+	}
144
+	m.b = b
145
+	m.matchingBlocks = nil
146
+	m.opCodes = nil
147
+	m.fullBCount = nil
148
+	m.chainB()
149
+}
150
+
151
+func (m *SequenceMatcher) chainB() {
152
+	// Populate line -> index mapping
153
+	b2j := map[string][]int{}
154
+	for i, s := range m.b {
155
+		indices := b2j[s]
156
+		indices = append(indices, i)
157
+		b2j[s] = indices
158
+	}
159
+
160
+	// Purge junk elements
161
+	m.bJunk = map[string]struct{}{}
162
+	if m.IsJunk != nil {
163
+		junk := m.bJunk
164
+		for s, _ := range b2j {
165
+			if m.IsJunk(s) {
166
+				junk[s] = struct{}{}
167
+			}
168
+		}
169
+		for s, _ := range junk {
170
+			delete(b2j, s)
171
+		}
172
+	}
173
+
174
+	// Purge remaining popular elements
175
+	popular := map[string]struct{}{}
176
+	n := len(m.b)
177
+	if m.autoJunk && n >= 200 {
178
+		ntest := n/100 + 1
179
+		for s, indices := range b2j {
180
+			if len(indices) > ntest {
181
+				popular[s] = struct{}{}
182
+			}
183
+		}
184
+		for s, _ := range popular {
185
+			delete(b2j, s)
186
+		}
187
+	}
188
+	m.bPopular = popular
189
+	m.b2j = b2j
190
+}
191
+
192
+func (m *SequenceMatcher) isBJunk(s string) bool {
193
+	_, ok := m.bJunk[s]
194
+	return ok
195
+}
196
+
197
+// Find longest matching block in a[alo:ahi] and b[blo:bhi].
198
+//
199
+// If IsJunk is not defined:
200
+//
201
+// Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where
202
+//     alo <= i <= i+k <= ahi
203
+//     blo <= j <= j+k <= bhi
204
+// and for all (i',j',k') meeting those conditions,
205
+//     k >= k'
206
+//     i <= i'
207
+//     and if i == i', j <= j'
208
+//
209
+// In other words, of all maximal matching blocks, return one that
210
+// starts earliest in a, and of all those maximal matching blocks that
211
+// start earliest in a, return the one that starts earliest in b.
212
+//
213
+// If IsJunk is defined, first the longest matching block is
214
+// determined as above, but with the additional restriction that no
215
+// junk element appears in the block.  Then that block is extended as
216
+// far as possible by matching (only) junk elements on both sides.  So
217
+// the resulting block never matches on junk except as identical junk
218
+// happens to be adjacent to an "interesting" match.
219
+//
220
+// If no blocks match, return (alo, blo, 0).
221
+func (m *SequenceMatcher) findLongestMatch(alo, ahi, blo, bhi int) Match {
222
+	// CAUTION:  stripping common prefix or suffix would be incorrect.
223
+	// E.g.,
224
+	//    ab
225
+	//    acab
226
+	// Longest matching block is "ab", but if common prefix is
227
+	// stripped, it's "a" (tied with "b").  UNIX(tm) diff does so
228
+	// strip, so ends up claiming that ab is changed to acab by
229
+	// inserting "ca" in the middle.  That's minimal but unintuitive:
230
+	// "it's obvious" that someone inserted "ac" at the front.
231
+	// Windiff ends up at the same place as diff, but by pairing up
232
+	// the unique 'b's and then matching the first two 'a's.
233
+	besti, bestj, bestsize := alo, blo, 0
234
+
235
+	// find longest junk-free match
236
+	// during an iteration of the loop, j2len[j] = length of longest
237
+	// junk-free match ending with a[i-1] and b[j]
238
+	j2len := map[int]int{}
239
+	for i := alo; i != ahi; i++ {
240
+		// look at all instances of a[i] in b; note that because
241
+		// b2j has no junk keys, the loop is skipped if a[i] is junk
242
+		newj2len := map[int]int{}
243
+		for _, j := range m.b2j[m.a[i]] {
244
+			// a[i] matches b[j]
245
+			if j < blo {
246
+				continue
247
+			}
248
+			if j >= bhi {
249
+				break
250
+			}
251
+			k := j2len[j-1] + 1
252
+			newj2len[j] = k
253
+			if k > bestsize {
254
+				besti, bestj, bestsize = i-k+1, j-k+1, k
255
+			}
256
+		}
257
+		j2len = newj2len
258
+	}
259
+
260
+	// Extend the best by non-junk elements on each end.  In particular,
261
+	// "popular" non-junk elements aren't in b2j, which greatly speeds
262
+	// the inner loop above, but also means "the best" match so far
263
+	// doesn't contain any junk *or* popular non-junk elements.
264
+	for besti > alo && bestj > blo && !m.isBJunk(m.b[bestj-1]) &&
265
+		m.a[besti-1] == m.b[bestj-1] {
266
+		besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
267
+	}
268
+	for besti+bestsize < ahi && bestj+bestsize < bhi &&
269
+		!m.isBJunk(m.b[bestj+bestsize]) &&
270
+		m.a[besti+bestsize] == m.b[bestj+bestsize] {
271
+		bestsize += 1
272
+	}
273
+
274
+	// Now that we have a wholly interesting match (albeit possibly
275
+	// empty!), we may as well suck up the matching junk on each
276
+	// side of it too.  Can't think of a good reason not to, and it
277
+	// saves post-processing the (possibly considerable) expense of
278
+	// figuring out what to do with it.  In the case of an empty
279
+	// interesting match, this is clearly the right thing to do,
280
+	// because no other kind of match is possible in the regions.
281
+	for besti > alo && bestj > blo && m.isBJunk(m.b[bestj-1]) &&
282
+		m.a[besti-1] == m.b[bestj-1] {
283
+		besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
284
+	}
285
+	for besti+bestsize < ahi && bestj+bestsize < bhi &&
286
+		m.isBJunk(m.b[bestj+bestsize]) &&
287
+		m.a[besti+bestsize] == m.b[bestj+bestsize] {
288
+		bestsize += 1
289
+	}
290
+
291
+	return Match{A: besti, B: bestj, Size: bestsize}
292
+}
293
+
294
+// Return list of triples describing matching subsequences.
295
+//
296
+// Each triple is of the form (i, j, n), and means that
297
+// a[i:i+n] == b[j:j+n].  The triples are monotonically increasing in
298
+// i and in j. It's also guaranteed that if (i, j, n) and (i', j', n') are
299
+// adjacent triples in the list, and the second is not the last triple in the
300
+// list, then i+n != i' or j+n != j'. IOW, adjacent triples never describe
301
+// adjacent equal blocks.
302
+//
303
+// The last triple is a dummy, (len(a), len(b), 0), and is the only
304
+// triple with n==0.
305
+func (m *SequenceMatcher) GetMatchingBlocks() []Match {
306
+	if m.matchingBlocks != nil {
307
+		return m.matchingBlocks
308
+	}
309
+
310
+	var matchBlocks func(alo, ahi, blo, bhi int, matched []Match) []Match
311
+	matchBlocks = func(alo, ahi, blo, bhi int, matched []Match) []Match {
312
+		match := m.findLongestMatch(alo, ahi, blo, bhi)
313
+		i, j, k := match.A, match.B, match.Size
314
+		if match.Size > 0 {
315
+			if alo < i && blo < j {
316
+				matched = matchBlocks(alo, i, blo, j, matched)
317
+			}
318
+			matched = append(matched, match)
319
+			if i+k < ahi && j+k < bhi {
320
+				matched = matchBlocks(i+k, ahi, j+k, bhi, matched)
321
+			}
322
+		}
323
+		return matched
324
+	}
325
+	matched := matchBlocks(0, len(m.a), 0, len(m.b), nil)
326
+
327
+	// It's possible that we have adjacent equal blocks in the
328
+	// matching_blocks list now.
329
+	nonAdjacent := []Match{}
330
+	i1, j1, k1 := 0, 0, 0
331
+	for _, b := range matched {
332
+		// Is this block adjacent to i1, j1, k1?
333
+		i2, j2, k2 := b.A, b.B, b.Size
334
+		if i1+k1 == i2 && j1+k1 == j2 {
335
+			// Yes, so collapse them -- this just increases the length of
336
+			// the first block by the length of the second, and the first
337
+			// block so lengthened remains the block to compare against.
338
+			k1 += k2
339
+		} else {
340
+			// Not adjacent.  Remember the first block (k1==0 means it's
341
+			// the dummy we started with), and make the second block the
342
+			// new block to compare against.
343
+			if k1 > 0 {
344
+				nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
345
+			}
346
+			i1, j1, k1 = i2, j2, k2
347
+		}
348
+	}
349
+	if k1 > 0 {
350
+		nonAdjacent = append(nonAdjacent, Match{i1, j1, k1})
351
+	}
352
+
353
+	nonAdjacent = append(nonAdjacent, Match{len(m.a), len(m.b), 0})
354
+	m.matchingBlocks = nonAdjacent
355
+	return m.matchingBlocks
356
+}
357
+
358
+// Return list of 5-tuples describing how to turn a into b.
359
+//
360
+// Each tuple is of the form (tag, i1, i2, j1, j2).  The first tuple
361
+// has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the
362
+// tuple preceding it, and likewise for j1 == the previous j2.
363
+//
364
+// The tags are characters, with these meanings:
365
+//
366
+// 'r' (replace):  a[i1:i2] should be replaced by b[j1:j2]
367
+//
368
+// 'd' (delete):   a[i1:i2] should be deleted, j1==j2 in this case.
369
+//
370
+// 'i' (insert):   b[j1:j2] should be inserted at a[i1:i1], i1==i2 in this case.
371
+//
372
+// 'e' (equal):    a[i1:i2] == b[j1:j2]
373
+func (m *SequenceMatcher) GetOpCodes() []OpCode {
374
+	if m.opCodes != nil {
375
+		return m.opCodes
376
+	}
377
+	i, j := 0, 0
378
+	matching := m.GetMatchingBlocks()
379
+	opCodes := make([]OpCode, 0, len(matching))
380
+	for _, m := range matching {
381
+		//  invariant:  we've pumped out correct diffs to change
382
+		//  a[:i] into b[:j], and the next matching block is
383
+		//  a[ai:ai+size] == b[bj:bj+size]. So we need to pump
384
+		//  out a diff to change a[i:ai] into b[j:bj], pump out
385
+		//  the matching block, and move (i,j) beyond the match
386
+		ai, bj, size := m.A, m.B, m.Size
387
+		tag := byte(0)
388
+		if i < ai && j < bj {
389
+			tag = 'r'
390
+		} else if i < ai {
391
+			tag = 'd'
392
+		} else if j < bj {
393
+			tag = 'i'
394
+		}
395
+		if tag > 0 {
396
+			opCodes = append(opCodes, OpCode{tag, i, ai, j, bj})
397
+		}
398
+		i, j = ai+size, bj+size
399
+		// the list of matching blocks is terminated by a
400
+		// sentinel with size 0
401
+		if size > 0 {
402
+			opCodes = append(opCodes, OpCode{'e', ai, i, bj, j})
403
+		}
404