mirror of https://github.com/kubevela/kubevela.git
143 lines
3.2 KiB
Go
143 lines
3.2 KiB
Go
/*
|
|
Copyright 2021 The KubeVela 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 utils
|
|
|
|
import (
|
|
"reflect"
|
|
"sort"
|
|
"strings"
|
|
)
|
|
|
|
// StringsContain strings contain
|
|
func StringsContain(items []string, source string) bool {
|
|
for _, item := range items {
|
|
if item == source {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ThreeWaySliceCompare will compare two string slice, with the three return values: [both in A and B], [only in A], [only in B]
|
|
func ThreeWaySliceCompare(a []string, b []string) ([]string, []string, []string) {
|
|
m := make(map[string]struct{})
|
|
for _, k := range b {
|
|
m[k] = struct{}{}
|
|
}
|
|
|
|
var AB, AO, BO []string
|
|
for _, k := range a {
|
|
_, ok := m[k]
|
|
if !ok {
|
|
AO = append(AO, k)
|
|
continue
|
|
}
|
|
AB = append(AB, k)
|
|
delete(m, k)
|
|
}
|
|
for k := range m {
|
|
BO = append(BO, k)
|
|
}
|
|
sort.Strings(AB)
|
|
sort.Strings(AO)
|
|
sort.Strings(BO)
|
|
return AB, AO, BO
|
|
}
|
|
|
|
// EqualSlice checks if two slice are equal
|
|
func EqualSlice(a, b []string) bool {
|
|
sort.Strings(a)
|
|
sort.Strings(b)
|
|
return reflect.DeepEqual(a, b)
|
|
}
|
|
|
|
// SliceIncludeSlice the a slice include the b slice
|
|
func SliceIncludeSlice(a, b []string) bool {
|
|
if EqualSlice(a, b) {
|
|
return true
|
|
}
|
|
for _, item := range b {
|
|
if !StringsContain(a, item) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// MapKey2Array convery map keys to array
|
|
func MapKey2Array(source map[string]string) []string {
|
|
var list []string
|
|
for k := range source {
|
|
list = append(list, k)
|
|
}
|
|
return list
|
|
}
|
|
|
|
// GetBoxDrawingString get line drawing string, see https://en.wikipedia.org/wiki/Box-drawing_character
|
|
// nolint:gocyclo
|
|
func GetBoxDrawingString(up bool, down bool, left bool, right bool, padLeft int, padRight int) string {
|
|
var c rune
|
|
switch {
|
|
case up && down && left && right:
|
|
c = '┼'
|
|
case up && down && left && !right:
|
|
c = '┤'
|
|
case up && down && !left && right:
|
|
c = '├'
|
|
case up && down && !left && !right:
|
|
c = '│'
|
|
case up && !down && left && right:
|
|
c = '┴'
|
|
case up && !down && left && !right:
|
|
c = '┘'
|
|
case up && !down && !left && right:
|
|
c = '└'
|
|
case up && !down && !left && !right:
|
|
c = '╵'
|
|
case !up && down && left && right:
|
|
c = '┬'
|
|
case !up && down && left && !right:
|
|
c = '┐'
|
|
case !up && down && !left && right:
|
|
c = '┌'
|
|
case !up && down && !left && !right:
|
|
c = '╷'
|
|
case !up && !down && left && right:
|
|
c = '─'
|
|
case !up && !down && left && !right:
|
|
c = '╴'
|
|
case !up && !down && !left && right:
|
|
c = '╶'
|
|
case !up && !down && !left && !right:
|
|
c = ' '
|
|
}
|
|
sb := strings.Builder{}
|
|
writePadding := func(connect bool, width int) {
|
|
for i := 0; i < width; i++ {
|
|
if connect {
|
|
sb.WriteRune('─')
|
|
} else {
|
|
sb.WriteRune(' ')
|
|
}
|
|
}
|
|
}
|
|
writePadding(left, padLeft)
|
|
sb.WriteRune(c)
|
|
writePadding(right, padRight)
|
|
return sb.String()
|
|
}
|