diff options
Diffstat (limited to 'vendor/github.com/hashicorp/go-multierror')
-rw-r--r-- | vendor/github.com/hashicorp/go-multierror/LICENSE | 353 | ||||
-rw-r--r-- | vendor/github.com/hashicorp/go-multierror/README.md | 91 | ||||
-rw-r--r-- | vendor/github.com/hashicorp/go-multierror/append.go | 37 | ||||
-rw-r--r-- | vendor/github.com/hashicorp/go-multierror/flatten.go | 26 | ||||
-rw-r--r-- | vendor/github.com/hashicorp/go-multierror/format.go | 23 | ||||
-rw-r--r-- | vendor/github.com/hashicorp/go-multierror/multierror.go | 51 | ||||
-rw-r--r-- | vendor/github.com/hashicorp/go-multierror/prefix.go | 37 |
7 files changed, 618 insertions, 0 deletions
diff --git a/vendor/github.com/hashicorp/go-multierror/LICENSE b/vendor/github.com/hashicorp/go-multierror/LICENSE new file mode 100644 index 0000000..82b4de9 --- /dev/null +++ b/vendor/github.com/hashicorp/go-multierror/LICENSE | |||
@@ -0,0 +1,353 @@ | |||
1 | Mozilla Public License, version 2.0 | ||
2 | |||
3 | 1. Definitions | ||
4 | |||
5 | 1.1. “Contributor” | ||
6 | |||
7 | means each individual or legal entity that creates, contributes to the | ||
8 | creation of, or owns Covered Software. | ||
9 | |||
10 | 1.2. “Contributor Version” | ||
11 | |||
12 | means the combination of the Contributions of others (if any) used by a | ||
13 | Contributor and that particular Contributor’s Contribution. | ||
14 | |||
15 | 1.3. “Contribution” | ||
16 | |||
17 | means Covered Software of a particular Contributor. | ||
18 | |||
19 | 1.4. “Covered Software” | ||
20 | |||
21 | means Source Code Form to which the initial Contributor has attached the | ||
22 | notice in Exhibit A, the Executable Form of such Source Code Form, and | ||
23 | Modifications of such Source Code Form, in each case including portions | ||
24 | thereof. | ||
25 | |||
26 | 1.5. “Incompatible With Secondary Licenses” | ||
27 | means | ||
28 | |||
29 | a. that the initial Contributor has attached the notice described in | ||
30 | Exhibit B to the Covered Software; or | ||
31 | |||
32 | b. that the Covered Software was made available under the terms of version | ||
33 | 1.1 or earlier of the License, but not also under the terms of a | ||
34 | Secondary License. | ||
35 | |||
36 | 1.6. “Executable Form” | ||
37 | |||
38 | means any form of the work other than Source Code Form. | ||
39 | |||
40 | 1.7. “Larger Work” | ||
41 | |||
42 | means a work that combines Covered Software with other material, in a separate | ||
43 | file or files, that is not Covered Software. | ||
44 | |||
45 | 1.8. “License” | ||
46 | |||
47 | means this document. | ||
48 | |||
49 | 1.9. “Licensable” | ||
50 | |||
51 | means having the right to grant, to the maximum extent possible, whether at the | ||
52 | time of the initial grant or subsequently, any and all of the rights conveyed by | ||
53 | this License. | ||
54 | |||
55 | 1.10. “Modifications” | ||
56 | |||
57 | means any of the following: | ||
58 | |||
59 | a. any file in Source Code Form that results from an addition to, deletion | ||
60 | from, or modification of the contents of Covered Software; or | ||
61 | |||
62 | b. any new file in Source Code Form that contains any Covered Software. | ||
63 | |||
64 | 1.11. “Patent Claims” of a Contributor | ||
65 | |||
66 | means any patent claim(s), including without limitation, method, process, | ||
67 | and apparatus claims, in any patent Licensable by such Contributor that | ||
68 | would be infringed, but for the grant of the License, by the making, | ||
69 | using, selling, offering for sale, having made, import, or transfer of | ||
70 | either its Contributions or its Contributor Version. | ||
71 | |||
72 | 1.12. “Secondary License” | ||
73 | |||
74 | means either the GNU General Public License, Version 2.0, the GNU Lesser | ||
75 | General Public License, Version 2.1, the GNU Affero General Public | ||
76 | License, Version 3.0, or any later versions of those licenses. | ||
77 | |||
78 | 1.13. “Source Code Form” | ||
79 | |||
80 | means the form of the work preferred for making modifications. | ||
81 | |||
82 | 1.14. “You” (or “Your”) | ||
83 | |||
84 | means an individual or a legal entity exercising rights under this | ||
85 | License. For legal entities, “You” includes any entity that controls, is | ||
86 | controlled by, or is under common control with You. For purposes of this | ||
87 | definition, “control” means (a) the power, direct or indirect, to cause | ||
88 | the direction or management of such entity, whether by contract or | ||
89 | otherwise, or (b) ownership of more than fifty percent (50%) of the | ||
90 | outstanding shares or beneficial ownership of such entity. | ||
91 | |||
92 | |||
93 | 2. License Grants and Conditions | ||
94 | |||
95 | 2.1. Grants | ||
96 | |||
97 | Each Contributor hereby grants You a world-wide, royalty-free, | ||
98 | non-exclusive license: | ||
99 | |||
100 | a. under intellectual property rights (other than patent or trademark) | ||
101 | Licensable by such Contributor to use, reproduce, make available, | ||
102 | modify, display, perform, distribute, and otherwise exploit its | ||
103 | Contributions, either on an unmodified basis, with Modifications, or as | ||
104 | part of a Larger Work; and | ||
105 | |||
106 | b. under Patent Claims of such Contributor to make, use, sell, offer for | ||
107 | sale, have made, import, and otherwise transfer either its Contributions | ||
108 | or its Contributor Version. | ||
109 | |||
110 | 2.2. Effective Date | ||
111 | |||
112 | The licenses granted in Section 2.1 with respect to any Contribution become | ||
113 | effective for each Contribution on the date the Contributor first distributes | ||
114 | such Contribution. | ||
115 | |||
116 | 2.3. Limitations on Grant Scope | ||
117 | |||
118 | The licenses granted in this Section 2 are the only rights granted under this | ||
119 | License. No additional rights or licenses will be implied from the distribution | ||
120 | or licensing of Covered Software under this License. Notwithstanding Section | ||
121 | 2.1(b) above, no patent license is granted by a Contributor: | ||
122 | |||
123 | a. for any code that a Contributor has removed from Covered Software; or | ||
124 | |||
125 | b. for infringements caused by: (i) Your and any other third party’s | ||
126 | modifications of Covered Software, or (ii) the combination of its | ||
127 | Contributions with other software (except as part of its Contributor | ||
128 | Version); or | ||
129 | |||
130 | c. under Patent Claims infringed by Covered Software in the absence of its | ||
131 | Contributions. | ||
132 | |||
133 | This License does not grant any rights in the trademarks, service marks, or | ||
134 | logos of any Contributor (except as may be necessary to comply with the | ||
135 | notice requirements in Section 3.4). | ||
136 | |||
137 | 2.4. Subsequent Licenses | ||
138 | |||
139 | No Contributor makes additional grants as a result of Your choice to | ||
140 | distribute the Covered Software under a subsequent version of this License | ||
141 | (see Section 10.2) or under the terms of a Secondary License (if permitted | ||
142 | under the terms of Section 3.3). | ||
143 | |||
144 | 2.5. Representation | ||
145 | |||
146 | Each Contributor represents that the Contributor believes its Contributions | ||
147 | are its original creation(s) or it has sufficient rights to grant the | ||
148 | rights to its Contributions conveyed by this License. | ||
149 | |||
150 | 2.6. Fair Use | ||
151 | |||
152 | This License is not intended to limit any rights You have under applicable | ||
153 | copyright doctrines of fair use, fair dealing, or other equivalents. | ||
154 | |||
155 | 2.7. Conditions | ||
156 | |||
157 | Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in | ||
158 | Section 2.1. | ||
159 | |||
160 | |||
161 | 3. Responsibilities | ||
162 | |||
163 | 3.1. Distribution of Source Form | ||
164 | |||
165 | All distribution of Covered Software in Source Code Form, including any | ||
166 | Modifications that You create or to which You contribute, must be under the | ||
167 | terms of this License. You must inform recipients that the Source Code Form | ||
168 | of the Covered Software is governed by the terms of this License, and how | ||
169 | they can obtain a copy of this License. You may not attempt to alter or | ||
170 | restrict the recipients’ rights in the Source Code Form. | ||
171 | |||
172 | 3.2. Distribution of Executable Form | ||
173 | |||
174 | If You distribute Covered Software in Executable Form then: | ||
175 | |||
176 | a. such Covered Software must also be made available in Source Code Form, | ||
177 | as described in Section 3.1, and You must inform recipients of the | ||
178 | Executable Form how they can obtain a copy of such Source Code Form by | ||
179 | reasonable means in a timely manner, at a charge no more than the cost | ||
180 | of distribution to the recipient; and | ||
181 | |||
182 | b. You may distribute such Executable Form under the terms of this License, | ||
183 | or sublicense it under different terms, provided that the license for | ||
184 | the Executable Form does not attempt to limit or alter the recipients’ | ||
185 | rights in the Source Code Form under this License. | ||
186 | |||
187 | 3.3. Distribution of a Larger Work | ||
188 | |||
189 | You may create and distribute a Larger Work under terms of Your choice, | ||
190 | provided that You also comply with the requirements of this License for the | ||
191 | Covered Software. If the Larger Work is a combination of Covered Software | ||
192 | with a work governed by one or more Secondary Licenses, and the Covered | ||
193 | Software is not Incompatible With Secondary Licenses, this License permits | ||
194 | You to additionally distribute such Covered Software under the terms of | ||
195 | such Secondary License(s), so that the recipient of the Larger Work may, at | ||
196 | their option, further distribute the Covered Software under the terms of | ||
197 | either this License or such Secondary License(s). | ||
198 | |||
199 | 3.4. Notices | ||
200 | |||
201 | You may not remove or alter the substance of any license notices (including | ||
202 | copyright notices, patent notices, disclaimers of warranty, or limitations | ||
203 | of liability) contained within the Source Code Form of the Covered | ||
204 | Software, except that You may alter any license notices to the extent | ||
205 | required to remedy known factual inaccuracies. | ||
206 | |||
207 | 3.5. Application of Additional Terms | ||
208 | |||
209 | You may choose to offer, and to charge a fee for, warranty, support, | ||
210 | indemnity or liability obligations to one or more recipients of Covered | ||
211 | Software. However, You may do so only on Your own behalf, and not on behalf | ||
212 | of any Contributor. You must make it absolutely clear that any such | ||
213 | warranty, support, indemnity, or liability obligation is offered by You | ||
214 | alone, and You hereby agree to indemnify every Contributor for any | ||
215 | liability incurred by such Contributor as a result of warranty, support, | ||
216 | indemnity or liability terms You offer. You may include additional | ||
217 | disclaimers of warranty and limitations of liability specific to any | ||
218 | jurisdiction. | ||
219 | |||
220 | 4. Inability to Comply Due to Statute or Regulation | ||
221 | |||
222 | If it is impossible for You to comply with any of the terms of this License | ||
223 | with respect to some or all of the Covered Software due to statute, judicial | ||
224 | order, or regulation then You must: (a) comply with the terms of this License | ||
225 | to the maximum extent possible; and (b) describe the limitations and the code | ||
226 | they affect. Such description must be placed in a text file included with all | ||
227 | distributions of the Covered Software under this License. Except to the | ||
228 | extent prohibited by statute or regulation, such description must be | ||
229 | sufficiently detailed for a recipient of ordinary skill to be able to | ||
230 | understand it. | ||
231 | |||
232 | 5. Termination | ||
233 | |||
234 | 5.1. The rights granted under this License will terminate automatically if You | ||
235 | fail to comply with any of its terms. However, if You become compliant, | ||
236 | then the rights granted under this License from a particular Contributor | ||
237 | are reinstated (a) provisionally, unless and until such Contributor | ||
238 | explicitly and finally terminates Your grants, and (b) on an ongoing basis, | ||
239 | if such Contributor fails to notify You of the non-compliance by some | ||
240 | reasonable means prior to 60 days after You have come back into compliance. | ||
241 | Moreover, Your grants from a particular Contributor are reinstated on an | ||
242 | ongoing basis if such Contributor notifies You of the non-compliance by | ||
243 | some reasonable means, this is the first time You have received notice of | ||
244 | non-compliance with this License from such Contributor, and You become | ||
245 | compliant prior to 30 days after Your receipt of the notice. | ||
246 | |||
247 | 5.2. If You initiate litigation against any entity by asserting a patent | ||
248 | infringement claim (excluding declaratory judgment actions, counter-claims, | ||
249 | and cross-claims) alleging that a Contributor Version directly or | ||
250 | indirectly infringes any patent, then the rights granted to You by any and | ||
251 | all Contributors for the Covered Software under Section 2.1 of this License | ||
252 | shall terminate. | ||
253 | |||
254 | 5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user | ||
255 | license agreements (excluding distributors and resellers) which have been | ||
256 | validly granted by You or Your distributors under this License prior to | ||
257 | termination shall survive termination. | ||
258 | |||
259 | 6. Disclaimer of Warranty | ||
260 | |||
261 | Covered Software is provided under this License on an “as is” basis, without | ||
262 | warranty of any kind, either expressed, implied, or statutory, including, | ||
263 | without limitation, warranties that the Covered Software is free of defects, | ||
264 | merchantable, fit for a particular purpose or non-infringing. The entire | ||
265 | risk as to the quality and performance of the Covered Software is with You. | ||
266 | Should any Covered Software prove defective in any respect, You (not any | ||
267 | Contributor) assume the cost of any necessary servicing, repair, or | ||
268 | correction. This disclaimer of warranty constitutes an essential part of this | ||
269 | License. No use of any Covered Software is authorized under this License | ||
270 | except under this disclaimer. | ||
271 | |||
272 | 7. Limitation of Liability | ||
273 | |||
274 | Under no circumstances and under no legal theory, whether tort (including | ||
275 | negligence), contract, or otherwise, shall any Contributor, or anyone who | ||
276 | distributes Covered Software as permitted above, be liable to You for any | ||
277 | direct, indirect, special, incidental, or consequential damages of any | ||
278 | character including, without limitation, damages for lost profits, loss of | ||
279 | goodwill, work stoppage, computer failure or malfunction, or any and all | ||
280 | other commercial damages or losses, even if such party shall have been | ||
281 | informed of the possibility of such damages. This limitation of liability | ||
282 | shall not apply to liability for death or personal injury resulting from such | ||
283 | party’s negligence to the extent applicable law prohibits such limitation. | ||
284 | Some jurisdictions do not allow the exclusion or limitation of incidental or | ||
285 | consequential damages, so this exclusion and limitation may not apply to You. | ||
286 | |||
287 | 8. Litigation | ||
288 | |||
289 | Any litigation relating to this License may be brought only in the courts of | ||
290 | a jurisdiction where the defendant maintains its principal place of business | ||
291 | and such litigation shall be governed by laws of that jurisdiction, without | ||
292 | reference to its conflict-of-law provisions. Nothing in this Section shall | ||
293 | prevent a party’s ability to bring cross-claims or counter-claims. | ||
294 | |||
295 | 9. Miscellaneous | ||
296 | |||
297 | This License represents the complete agreement concerning the subject matter | ||
298 | hereof. If any provision of this License is held to be unenforceable, such | ||
299 | provision shall be reformed only to the extent necessary to make it | ||
300 | enforceable. Any law or regulation which provides that the language of a | ||
301 | contract shall be construed against the drafter shall not be used to construe | ||
302 | this License against a Contributor. | ||
303 | |||
304 | |||
305 | 10. Versions of the License | ||
306 | |||
307 | 10.1. New Versions | ||
308 | |||
309 | Mozilla Foundation is the license steward. Except as provided in Section | ||
310 | 10.3, no one other than the license steward has the right to modify or | ||
311 | publish new versions of this License. Each version will be given a | ||
312 | distinguishing version number. | ||
313 | |||
314 | 10.2. Effect of New Versions | ||
315 | |||
316 | You may distribute the Covered Software under the terms of the version of | ||
317 | the License under which You originally received the Covered Software, or | ||
318 | under the terms of any subsequent version published by the license | ||
319 | steward. | ||
320 | |||
321 | 10.3. Modified Versions | ||
322 | |||
323 | If you create software not governed by this License, and you want to | ||
324 | create a new license for such software, you may create and use a modified | ||
325 | version of this License if you rename the license and remove any | ||
326 | references to the name of the license steward (except to note that such | ||
327 | modified license differs from this License). | ||
328 | |||
329 | 10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses | ||
330 | If You choose to distribute Source Code Form that is Incompatible With | ||
331 | Secondary Licenses under the terms of this version of the License, the | ||
332 | notice described in Exhibit B of this License must be attached. | ||
333 | |||
334 | Exhibit A - Source Code Form License Notice | ||
335 | |||
336 | This Source Code Form is subject to the | ||
337 | terms of the Mozilla Public License, v. | ||
338 | 2.0. If a copy of the MPL was not | ||
339 | distributed with this file, You can | ||
340 | obtain one at | ||
341 | http://mozilla.org/MPL/2.0/. | ||
342 | |||
343 | If it is not possible or desirable to put the notice in a particular file, then | ||
344 | You may include the notice in a location (such as a LICENSE file in a relevant | ||
345 | directory) where a recipient would be likely to look for such a notice. | ||
346 | |||
347 | You may add additional accurate notices of copyright ownership. | ||
348 | |||
349 | Exhibit B - “Incompatible With Secondary Licenses” Notice | ||
350 | |||
351 | This Source Code Form is “Incompatible | ||
352 | With Secondary Licenses”, as defined by | ||
353 | the Mozilla Public License, v. 2.0. | ||
diff --git a/vendor/github.com/hashicorp/go-multierror/README.md b/vendor/github.com/hashicorp/go-multierror/README.md new file mode 100644 index 0000000..e81be50 --- /dev/null +++ b/vendor/github.com/hashicorp/go-multierror/README.md | |||
@@ -0,0 +1,91 @@ | |||
1 | # go-multierror | ||
2 | |||
3 | `go-multierror` is a package for Go that provides a mechanism for | ||
4 | representing a list of `error` values as a single `error`. | ||
5 | |||
6 | This allows a function in Go to return an `error` that might actually | ||
7 | be a list of errors. If the caller knows this, they can unwrap the | ||
8 | list and access the errors. If the caller doesn't know, the error | ||
9 | formats to a nice human-readable format. | ||
10 | |||
11 | `go-multierror` implements the | ||
12 | [errwrap](https://github.com/hashicorp/errwrap) interface so that it can | ||
13 | be used with that library, as well. | ||
14 | |||
15 | ## Installation and Docs | ||
16 | |||
17 | Install using `go get github.com/hashicorp/go-multierror`. | ||
18 | |||
19 | Full documentation is available at | ||
20 | http://godoc.org/github.com/hashicorp/go-multierror | ||
21 | |||
22 | ## Usage | ||
23 | |||
24 | go-multierror is easy to use and purposely built to be unobtrusive in | ||
25 | existing Go applications/libraries that may not be aware of it. | ||
26 | |||
27 | **Building a list of errors** | ||
28 | |||
29 | The `Append` function is used to create a list of errors. This function | ||
30 | behaves a lot like the Go built-in `append` function: it doesn't matter | ||
31 | if the first argument is nil, a `multierror.Error`, or any other `error`, | ||
32 | the function behaves as you would expect. | ||
33 | |||
34 | ```go | ||
35 | var result error | ||
36 | |||
37 | if err := step1(); err != nil { | ||
38 | result = multierror.Append(result, err) | ||
39 | } | ||
40 | if err := step2(); err != nil { | ||
41 | result = multierror.Append(result, err) | ||
42 | } | ||
43 | |||
44 | return result | ||
45 | ``` | ||
46 | |||
47 | **Customizing the formatting of the errors** | ||
48 | |||
49 | By specifying a custom `ErrorFormat`, you can customize the format | ||
50 | of the `Error() string` function: | ||
51 | |||
52 | ```go | ||
53 | var result *multierror.Error | ||
54 | |||
55 | // ... accumulate errors here, maybe using Append | ||
56 | |||
57 | if result != nil { | ||
58 | result.ErrorFormat = func([]error) string { | ||
59 | return "errors!" | ||
60 | } | ||
61 | } | ||
62 | ``` | ||
63 | |||
64 | **Accessing the list of errors** | ||
65 | |||
66 | `multierror.Error` implements `error` so if the caller doesn't know about | ||
67 | multierror, it will work just fine. But if you're aware a multierror might | ||
68 | be returned, you can use type switches to access the list of errors: | ||
69 | |||
70 | ```go | ||
71 | if err := something(); err != nil { | ||
72 | if merr, ok := err.(*multierror.Error); ok { | ||
73 | // Use merr.Errors | ||
74 | } | ||
75 | } | ||
76 | ``` | ||
77 | |||
78 | **Returning a multierror only if there are errors** | ||
79 | |||
80 | If you build a `multierror.Error`, you can use the `ErrorOrNil` function | ||
81 | to return an `error` implementation only if there are errors to return: | ||
82 | |||
83 | ```go | ||
84 | var result *multierror.Error | ||
85 | |||
86 | // ... accumulate errors here | ||
87 | |||
88 | // Return the `error` only if errors were added to the multierror, otherwise | ||
89 | // return nil since there are no errors. | ||
90 | return result.ErrorOrNil() | ||
91 | ``` | ||
diff --git a/vendor/github.com/hashicorp/go-multierror/append.go b/vendor/github.com/hashicorp/go-multierror/append.go new file mode 100644 index 0000000..00afa9b --- /dev/null +++ b/vendor/github.com/hashicorp/go-multierror/append.go | |||
@@ -0,0 +1,37 @@ | |||
1 | package multierror | ||
2 | |||
3 | // Append is a helper function that will append more errors | ||
4 | // onto an Error in order to create a larger multi-error. | ||
5 | // | ||
6 | // If err is not a multierror.Error, then it will be turned into | ||
7 | // one. If any of the errs are multierr.Error, they will be flattened | ||
8 | // one level into err. | ||
9 | func Append(err error, errs ...error) *Error { | ||
10 | switch err := err.(type) { | ||
11 | case *Error: | ||
12 | // Typed nils can reach here, so initialize if we are nil | ||
13 | if err == nil { | ||
14 | err = new(Error) | ||
15 | } | ||
16 | |||
17 | // Go through each error and flatten | ||
18 | for _, e := range errs { | ||
19 | switch e := e.(type) { | ||
20 | case *Error: | ||
21 | err.Errors = append(err.Errors, e.Errors...) | ||
22 | default: | ||
23 | err.Errors = append(err.Errors, e) | ||
24 | } | ||
25 | } | ||
26 | |||
27 | return err | ||
28 | default: | ||
29 | newErrs := make([]error, 0, len(errs)+1) | ||
30 | if err != nil { | ||
31 | newErrs = append(newErrs, err) | ||
32 | } | ||
33 | newErrs = append(newErrs, errs...) | ||
34 | |||
35 | return Append(&Error{}, newErrs...) | ||
36 | } | ||
37 | } | ||
diff --git a/vendor/github.com/hashicorp/go-multierror/flatten.go b/vendor/github.com/hashicorp/go-multierror/flatten.go new file mode 100644 index 0000000..aab8e9a --- /dev/null +++ b/vendor/github.com/hashicorp/go-multierror/flatten.go | |||
@@ -0,0 +1,26 @@ | |||
1 | package multierror | ||
2 | |||
3 | // Flatten flattens the given error, merging any *Errors together into | ||
4 | // a single *Error. | ||
5 | func Flatten(err error) error { | ||
6 | // If it isn't an *Error, just return the error as-is | ||
7 | if _, ok := err.(*Error); !ok { | ||
8 | return err | ||
9 | } | ||
10 | |||
11 | // Otherwise, make the result and flatten away! | ||
12 | flatErr := new(Error) | ||
13 | flatten(err, flatErr) | ||
14 | return flatErr | ||
15 | } | ||
16 | |||
17 | func flatten(err error, flatErr *Error) { | ||
18 | switch err := err.(type) { | ||
19 | case *Error: | ||
20 | for _, e := range err.Errors { | ||
21 | flatten(e, flatErr) | ||
22 | } | ||
23 | default: | ||
24 | flatErr.Errors = append(flatErr.Errors, err) | ||
25 | } | ||
26 | } | ||
diff --git a/vendor/github.com/hashicorp/go-multierror/format.go b/vendor/github.com/hashicorp/go-multierror/format.go new file mode 100644 index 0000000..bb65a12 --- /dev/null +++ b/vendor/github.com/hashicorp/go-multierror/format.go | |||
@@ -0,0 +1,23 @@ | |||
1 | package multierror | ||
2 | |||
3 | import ( | ||
4 | "fmt" | ||
5 | "strings" | ||
6 | ) | ||
7 | |||
8 | // ErrorFormatFunc is a function callback that is called by Error to | ||
9 | // turn the list of errors into a string. | ||
10 | type ErrorFormatFunc func([]error) string | ||
11 | |||
12 | // ListFormatFunc is a basic formatter that outputs the number of errors | ||
13 | // that occurred along with a bullet point list of the errors. | ||
14 | func ListFormatFunc(es []error) string { | ||
15 | points := make([]string, len(es)) | ||
16 | for i, err := range es { | ||
17 | points[i] = fmt.Sprintf("* %s", err) | ||
18 | } | ||
19 | |||
20 | return fmt.Sprintf( | ||
21 | "%d error(s) occurred:\n\n%s", | ||
22 | len(es), strings.Join(points, "\n")) | ||
23 | } | ||
diff --git a/vendor/github.com/hashicorp/go-multierror/multierror.go b/vendor/github.com/hashicorp/go-multierror/multierror.go new file mode 100644 index 0000000..2ea0827 --- /dev/null +++ b/vendor/github.com/hashicorp/go-multierror/multierror.go | |||
@@ -0,0 +1,51 @@ | |||
1 | package multierror | ||
2 | |||
3 | import ( | ||
4 | "fmt" | ||
5 | ) | ||
6 | |||
7 | // Error is an error type to track multiple errors. This is used to | ||
8 | // accumulate errors in cases and return them as a single "error". | ||
9 | type Error struct { | ||
10 | Errors []error | ||
11 | ErrorFormat ErrorFormatFunc | ||
12 | } | ||
13 | |||
14 | func (e *Error) Error() string { | ||
15 | fn := e.ErrorFormat | ||
16 | if fn == nil { | ||
17 | fn = ListFormatFunc | ||
18 | } | ||
19 | |||
20 | return fn(e.Errors) | ||
21 | } | ||
22 | |||
23 | // ErrorOrNil returns an error interface if this Error represents | ||
24 | // a list of errors, or returns nil if the list of errors is empty. This | ||
25 | // function is useful at the end of accumulation to make sure that the value | ||
26 | // returned represents the existence of errors. | ||
27 | func (e *Error) ErrorOrNil() error { | ||
28 | if e == nil { | ||
29 | return nil | ||
30 | } | ||
31 | if len(e.Errors) == 0 { | ||
32 | return nil | ||
33 | } | ||
34 | |||
35 | return e | ||
36 | } | ||
37 | |||
38 | func (e *Error) GoString() string { | ||
39 | return fmt.Sprintf("*%#v", *e) | ||
40 | } | ||
41 | |||
42 | // WrappedErrors returns the list of errors that this Error is wrapping. | ||
43 | // It is an implementatin of the errwrap.Wrapper interface so that | ||
44 | // multierror.Error can be used with that library. | ||
45 | // | ||
46 | // This method is not safe to be called concurrently and is no different | ||
47 | // than accessing the Errors field directly. It is implementd only to | ||
48 | // satisfy the errwrap.Wrapper interface. | ||
49 | func (e *Error) WrappedErrors() []error { | ||
50 | return e.Errors | ||
51 | } | ||
diff --git a/vendor/github.com/hashicorp/go-multierror/prefix.go b/vendor/github.com/hashicorp/go-multierror/prefix.go new file mode 100644 index 0000000..5c477ab --- /dev/null +++ b/vendor/github.com/hashicorp/go-multierror/prefix.go | |||
@@ -0,0 +1,37 @@ | |||
1 | package multierror | ||
2 | |||
3 | import ( | ||
4 | "fmt" | ||
5 | |||
6 | "github.com/hashicorp/errwrap" | ||
7 | ) | ||
8 | |||
9 | // Prefix is a helper function that will prefix some text | ||
10 | // to the given error. If the error is a multierror.Error, then | ||
11 | // it will be prefixed to each wrapped error. | ||
12 | // | ||
13 | // This is useful to use when appending multiple multierrors | ||
14 | // together in order to give better scoping. | ||
15 | func Prefix(err error, prefix string) error { | ||
16 | if err == nil { | ||
17 | return nil | ||
18 | } | ||
19 | |||
20 | format := fmt.Sprintf("%s {{err}}", prefix) | ||
21 | switch err := err.(type) { | ||
22 | case *Error: | ||
23 | // Typed nils can reach here, so initialize if we are nil | ||
24 | if err == nil { | ||
25 | err = new(Error) | ||
26 | } | ||
27 | |||
28 | // Wrap each of the errors | ||
29 | for i, e := range err.Errors { | ||
30 | err.Errors[i] = errwrap.Wrapf(format, e) | ||
31 | } | ||
32 | |||
33 | return err | ||
34 | default: | ||
35 | return errwrap.Wrapf(format, err) | ||
36 | } | ||
37 | } | ||