github
/
k3s
mirror of https://github.com/k3s-io/k3s
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

clean pkg/util/strings

pull/564/head
danielqsj 2019-01-29 17:52:34 +08:00
parent 093328e57f
commit 6535689680
9 changed files with 0 additions and 413 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
pkg/util/BUILD
View File

@ -52,7 +52,6 @@ filegroup(
"//pkg/util/rlimit:all-srcs",
"//pkg/util/selinux:all-srcs",
"//pkg/util/slice:all-srcs",
"//pkg/util/strings:all-srcs",
"//pkg/util/sysctl:all-srcs",
"//pkg/util/system:all-srcs",
"//pkg/util/tail:all-srcs",

40
pkg/util/strings/BUILD
View File

@ -1,40 +0,0 @@
package(default_visibility = ["//visibility:public"])
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",
],
importpath = "k8s.io/kubernetes/pkg/util/strings",
)
go_test(
name = "go_default_test",
srcs = [
"escape_test.go",
"line_delimiter_test.go",
"strings_test.go",
],
embed = [":go_default_library"],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
)

49
pkg/util/strings/escape.go
View File

@ -1,49 +0,0 @@
/*
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)
}
// UnescapePluginName 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)
}

63
pkg/util/strings/escape_test.go
View File

@ -1,63 +0,0 @@
/*
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)
}
}
}

64
pkg/util/strings/line_delimiter.go
View File

@ -1,64 +0,0 @@
/*
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"
)
// LineDelimiter is a filter that will split input on lines
// and bracket each line with the delimiter string.
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
}

40
pkg/util/strings/line_delimiter_test.go
View File

@ -1,40 +0,0 @@
/*
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 |
}

58
pkg/util/strings/strings.go
View File

@ -1,58 +0,0 @@
/*
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"
)
// SplitQualifiedName 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]
}
// JoinQualifiedName 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)
}
// ShortenString returns the first N slice of a string.
func ShortenString(str string, n int) string {
if len(str) <= n {
return str
}
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
}

97
pkg/util/strings/strings_test.go
View File

@ -1,97 +0,0 @@
/*
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
outLen 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.outLen)
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)
}
}
}

1
test/test_owners.csv
View File

@ -802,7 +802,6 @@ k8s.io/kubernetes/pkg/util/oom,vishh,0,
k8s.io/kubernetes/pkg/util/parsers,derekwaynecarr,1,
k8s.io/kubernetes/pkg/util/procfs,roberthbailey,1,
k8s.io/kubernetes/pkg/util/slice,quinton-hoole,0,
k8s.io/kubernetes/pkg/util/strings,quinton-hoole,0,
k8s.io/kubernetes/pkg/util/system,mwielgus,0,
k8s.io/kubernetes/pkg/util/tail,zmerlynn,1,
k8s.io/kubernetes/pkg/util/taints,rrati,0,

1 name owner auto-assigned sig
802 k8s.io/kubernetes/pkg/util/parsers derekwaynecarr 1
803 k8s.io/kubernetes/pkg/util/procfs roberthbailey 1
804 k8s.io/kubernetes/pkg/util/slice quinton-hoole 0
k8s.io/kubernetes/pkg/util/strings quinton-hoole 0
805 k8s.io/kubernetes/pkg/util/system mwielgus 0
806 k8s.io/kubernetes/pkg/util/tail zmerlynn 1
807 k8s.io/kubernetes/pkg/util/taints rrati 0