3 files changed, 133 insertions, 0 deletions

diff --git a/vendor/github.com/mitchellh/go-wordwrap/LICENSE.md b/vendor/github.com/mitchellh/go-wordwrap/LICENSE.md
new file mode 100644
index 0000000..2298515
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-wordwrap/LICENSE.md
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Mitchell Hashimoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/mitchellh/go-wordwrap/README.md b/vendor/github.com/mitchellh/go-wordwrap/README.md
new file mode 100644
index 0000000..60ae311
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-wordwrap/README.md
@@ -0,0 +1,39 @@
+# go-wordwrap
+
+`go-wordwrap` (Golang package: `wordwrap`) is a package for Go that
+automatically wraps words into multiple lines. The primary use case for this
+is in formatting CLI output, but of course word wrapping is a generally useful
+thing to do.
+
+## Installation and Usage
+
+Install using `go get github.com/mitchellh/go-wordwrap`.
+
+Full documentation is available at
+http://godoc.org/github.com/mitchellh/go-wordwrap
+
+Below is an example of its usage ignoring errors:
+
+```go
+wrapped := wordwrap.WrapString("foo bar baz", 3)
+fmt.Println(wrapped)
+```
+
+Would output:
+
+```
+foo
+bar
+baz
+```
+
+## Word Wrap Algorithm
+
+This library doesn't use any clever algorithm for word wrapping. The wrapping
+is actually very naive: whenever there is whitespace or an explicit linebreak.
+The goal of this library is for word wrapping CLI output, so the input is
+typically pretty well controlled human language. Because of this, the naive
+approach typically works just fine.
+
+In the future, we'd like to make the algorithm more advanced. We would do
+so without breaking the API.
diff --git a/vendor/github.com/mitchellh/go-wordwrap/wordwrap.go b/vendor/github.com/mitchellh/go-wordwrap/wordwrap.go
new file mode 100644
index 0000000..ac67205
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-wordwrap/wordwrap.go
@@ -0,0 +1,73 @@
+package wordwrap
+
+import (
+        "bytes"
+        "unicode"
+)
+
+// WrapString wraps the given string within lim width in characters.
+//
+// Wrapping is currently naive and only happens at white-space. A future
+// version of the library will implement smarter wrapping. This means that
+// pathological cases can dramatically reach past the limit, such as a very
+// long word.
+func WrapString(s string, lim uint) string {
+        // Initialize a buffer with a slightly larger size to account for breaks
+        init := make([]byte, 0, len(s))
+        buf := bytes.NewBuffer(init)
+
+        var current uint
+        var wordBuf, spaceBuf bytes.Buffer
+
+        for _, char := range s {
+                if char == '\n' {
+                        if wordBuf.Len() == 0 {
+                                if current+uint(spaceBuf.Len()) > lim {
+                                        current = 0
+                                } else {
+                                        current += uint(spaceBuf.Len())
+                                        spaceBuf.WriteTo(buf)
+                                }
+                                spaceBuf.Reset()
+                        } else {
+                                current += uint(spaceBuf.Len() + wordBuf.Len())
+                                spaceBuf.WriteTo(buf)
+                                spaceBuf.Reset()
+                                wordBuf.WriteTo(buf)
+                                wordBuf.Reset()
+                        }
+                        buf.WriteRune(char)
+                        current = 0
+                } else if unicode.IsSpace(char) {
+                        if spaceBuf.Len() == 0 || wordBuf.Len() > 0 {
+                                current += uint(spaceBuf.Len() + wordBuf.Len())
+                                spaceBuf.WriteTo(buf)
+                                spaceBuf.Reset()
+                                wordBuf.WriteTo(buf)
+                                wordBuf.Reset()
+                        }
+
+                        spaceBuf.WriteRune(char)
+                } else {
+
+                        wordBuf.WriteRune(char)
+
+                        if current+uint(spaceBuf.Len()+wordBuf.Len()) > lim && uint(wordBuf.Len()) < lim {
+                                buf.WriteRune('\n')
+                                current = 0
+                                spaceBuf.Reset()
+                        }
+                }
+        }
+
+        if wordBuf.Len() == 0 {
+                if current+uint(spaceBuf.Len()) <= lim {
+                        spaceBuf.WriteTo(buf)
+                }
+        } else {
+                spaceBuf.WriteTo(buf)
+                wordBuf.WriteTo(buf)
+        }
+
+        return buf.String()
+}