Switch to github.com/golang/dep for vendoring

Signed-off-by: Mrunal Patel <mrunalp@gmail.com>

vendor/k8s.io/kubernetes/pkg/util/strings/BUILD

@@ -0,0 +1,43 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "escape.go",
+        "line_delimiter.go",
+        "strings.go",
+    ],
+    tags = ["automanaged"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "escape_test.go",
+        "line_delimiter_test.go",
+        "strings_test.go",
+    ],
+    library = ":go_default_library",
+    tags = ["automanaged"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

vendor/k8s.io/kubernetes/pkg/util/strings/escape.go

@@ -0,0 +1,49 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package strings
+
+import (
+	"strings"
+)
+
+// EscapePluginName converts a plugin name in the format
+// vendor/pluginname into a proper ondisk vendor~pluginname plugin directory
+// format.
+func EscapePluginName(in string) string {
+	return strings.Replace(in, "/", "~", -1)
+}
+
+// EscapeQualifiedPluginName converts a plugin directory name in the format
+// vendor~pluginname into a proper vendor/pluginname.
+func UnescapePluginName(in string) string {
+	return strings.Replace(in, "~", "/", -1)
+}
+
+// EscapeQualifiedNameForDisk converts a plugin name, which might contain a / into a
+// string that is safe to use on-disk.  This assumes that the input has already
+// been validates as a qualified name.  we use "~" rather than ":" here in case
+// we ever use a filesystem that doesn't allow ":".
+func EscapeQualifiedNameForDisk(in string) string {
+	return strings.Replace(in, "/", "~", -1)
+}
+
+// UnescapeQualifiedNameForDisk converts an escaped plugin name (as per EscapeQualifiedNameForDisk)
+// back to its normal form.  This assumes that the input has already been
+// validates as a qualified name.
+func UnescapeQualifiedNameForDisk(in string) string {
+	return strings.Replace(in, "~", "/", -1)
+}

vendor/k8s.io/kubernetes/pkg/util/strings/escape_test.go

@@ -0,0 +1,63 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package strings
+
+import (
+	"testing"
+)
+
+func TestEscapePluginName(t *testing.T) {
+	testCases := []struct {
+		input  string
+		output string
+	}{
+		{"kubernetes.io/blah", "kubernetes.io~blah"},
+		{"blah/blerg/borg", "blah~blerg~borg"},
+		{"kubernetes.io", "kubernetes.io"},
+	}
+	for i, tc := range testCases {
+		escapee := EscapePluginName(tc.input)
+		if escapee != tc.output {
+			t.Errorf("case[%d]: expected (%q), got (%q)", i, tc.output, escapee)
+		}
+		original := UnescapePluginName(escapee)
+		if original != tc.input {
+			t.Errorf("case[%d]: expected (%q), got (%q)", i, tc.input, original)
+		}
+	}
+}
+
+func TestEscapeQualifiedNameForDisk(t *testing.T) {
+	testCases := []struct {
+		input  string
+		output string
+	}{
+		{"kubernetes.io/blah", "kubernetes.io~blah"},
+		{"blah/blerg/borg", "blah~blerg~borg"},
+		{"kubernetes.io", "kubernetes.io"},
+	}
+	for i, tc := range testCases {
+		escapee := EscapeQualifiedNameForDisk(tc.input)
+		if escapee != tc.output {
+			t.Errorf("case[%d]: expected (%q), got (%q)", i, tc.output, escapee)
+		}
+		original := UnescapeQualifiedNameForDisk(escapee)
+		if original != tc.input {
+			t.Errorf("case[%d]: expected (%q), got (%q)", i, tc.input, original)
+		}
+	}
+}

vendor/k8s.io/kubernetes/pkg/util/strings/line_delimiter.go

@@ -0,0 +1,63 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package strings
+
+import (
+	"bytes"
+	"io"
+	"strings"
+)
+
+// A Line Delimiter is a filter that will
+type LineDelimiter struct {
+	output    io.Writer
+	delimiter []byte
+	buf       bytes.Buffer
+}
+
+// NewLineDelimiter allocates a new io.Writer that will split input on lines
+// and bracket each line with the delimiter string.  This can be useful in
+// output tests where it is difficult to see and test trailing whitespace.
+func NewLineDelimiter(output io.Writer, delimiter string) *LineDelimiter {
+	return &LineDelimiter{output: output, delimiter: []byte(delimiter)}
+}
+
+// Write writes buf to the LineDelimiter ld. The only errors returned are ones
+// encountered while writing to the underlying output stream.
+func (ld *LineDelimiter) Write(buf []byte) (n int, err error) {
+	return ld.buf.Write(buf)
+}
+
+// Flush all lines up until now.  This will assume insert a linebreak at the current point of the stream.
+func (ld *LineDelimiter) Flush() (err error) {
+	lines := strings.Split(ld.buf.String(), "\n")
+	for _, line := range lines {
+		if _, err = ld.output.Write(ld.delimiter); err != nil {
+			return
+		}
+		if _, err = ld.output.Write([]byte(line)); err != nil {
+			return
+		}
+		if _, err = ld.output.Write(ld.delimiter); err != nil {
+			return
+		}
+		if _, err = ld.output.Write([]byte("\n")); err != nil {
+			return
+		}
+	}
+	return
+}

vendor/k8s.io/kubernetes/pkg/util/strings/line_delimiter_test.go

@@ -0,0 +1,40 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package strings
+
+import (
+	"fmt"
+	"os"
+)
+
+func Example_trailingNewline() {
+	ld := NewLineDelimiter(os.Stdout, "|")
+	defer ld.Flush()
+	fmt.Fprint(ld, "  Hello  \n  World  \n")
+	// Output:
+	// |  Hello  |
+	// |  World  |
+	// ||
+}
+func Example_noTrailingNewline() {
+	ld := NewLineDelimiter(os.Stdout, "|")
+	defer ld.Flush()
+	fmt.Fprint(ld, "  Hello  \n  World  ")
+	// Output:
+	// |  Hello  |
+	// |  World  |
+}

vendor/k8s.io/kubernetes/pkg/util/strings/strings.go

@@ -0,0 +1,59 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package strings
+
+import (
+	"path"
+	"strings"
+	"unicode"
+)
+
+// Splits a fully qualified name and returns its namespace and name.
+// Assumes that the input 'str' has been validated.
+func SplitQualifiedName(str string) (string, string) {
+	parts := strings.Split(str, "/")
+	if len(parts) < 2 {
+		return "", str
+	}
+	return parts[0], parts[1]
+}
+
+// Joins 'namespace' and 'name' and returns a fully qualified name
+// Assumes that the input is valid.
+func JoinQualifiedName(namespace, name string) string {
+	return path.Join(namespace, name)
+}
+
+// Returns the first N slice of a string.
+func ShortenString(str string, n int) string {
+	if len(str) <= n {
+		return str
+	} else {
+		return str[:n]
+	}
+}
+
+// isVowel returns true if the rune is a vowel (case insensitive).
+func isVowel(c rune) bool {
+	vowels := []rune{'a', 'e', 'i', 'o', 'u'}
+	for _, value := range vowels {
+		if value == unicode.ToLower(c) {
+			return true
+		}
+	}
+	return false
+}

vendor/k8s.io/kubernetes/pkg/util/strings/strings_test.go

@@ -0,0 +1,97 @@
+/*
+Copyright 2014 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package strings
+
+import (
+	"testing"
+)
+
+func TestSplitQualifiedName(t *testing.T) {
+	testCases := []struct {
+		input  string
+		output []string
+	}{
+		{"kubernetes.io/blah", []string{"kubernetes.io", "blah"}},
+		{"blah", []string{"", "blah"}},
+		{"kubernetes.io/blah/blah", []string{"kubernetes.io", "blah"}},
+	}
+	for i, tc := range testCases {
+		namespace, name := SplitQualifiedName(tc.input)
+		if namespace != tc.output[0] || name != tc.output[1] {
+			t.Errorf("case[%d]: expected (%q, %q), got (%q, %q)", i, tc.output[0], tc.output[1], namespace, name)
+		}
+	}
+}
+
+func TestJoinQualifiedName(t *testing.T) {
+	testCases := []struct {
+		input  []string
+		output string
+	}{
+		{[]string{"kubernetes.io", "blah"}, "kubernetes.io/blah"},
+		{[]string{"blah", ""}, "blah"},
+		{[]string{"kubernetes.io", "blah"}, "kubernetes.io/blah"},
+	}
+	for i, tc := range testCases {
+		res := JoinQualifiedName(tc.input[0], tc.input[1])
+		if res != tc.output {
+			t.Errorf("case[%d]: expected %q, got %q", i, tc.output, res)
+		}
+	}
+}
+
+func TestShortenString(t *testing.T) {
+	testCases := []struct {
+		input   string
+		out_len int
+		output  string
+	}{
+		{"kubernetes.io", 5, "kuber"},
+		{"blah", 34, "blah"},
+		{"kubernetes.io", 13, "kubernetes.io"},
+	}
+	for i, tc := range testCases {
+		res := ShortenString(tc.input, tc.out_len)
+		if res != tc.output {
+			t.Errorf("case[%d]: expected %q, got %q", i, tc.output, res)
+		}
+	}
+}
+
+func TestIsVowel(t *testing.T) {
+	tests := []struct {
+		name string
+		arg  rune
+		want bool
+	}{
+		{
+			name: "yes",
+			arg:  'E',
+			want: true,
+		},
+		{
+			name: "no",
+			arg:  'n',
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		if got := isVowel(tt.arg); got != tt.want {
+			t.Errorf("%q. IsVowel() = %v, want %v", tt.name, got, tt.want)
+		}
+	}
+}