From 41685022c0e45e885934c65bb4bb4de3d81ffbe8 Mon Sep 17 00:00:00 2001 From: dudaodong Date: Sat, 19 Feb 2022 21:51:58 +0800 Subject: [PATCH 1/3] refactor: rename files *_util.go to *_internal.go --- cryptor/crypt_util.go | 37 ------- formatter/formatter_util.go | 40 -------- function/function_util.go | 39 -------- netutil/http_util.go | 186 ------------------------------------ slice/slice_util.go | 65 ------------- strutil/string_util.go | 40 -------- 6 files changed, 407 deletions(-) delete mode 100644 cryptor/crypt_util.go delete mode 100644 formatter/formatter_util.go delete mode 100644 function/function_util.go delete mode 100644 netutil/http_util.go delete mode 100644 slice/slice_util.go delete mode 100644 strutil/string_util.go diff --git a/cryptor/crypt_util.go b/cryptor/crypt_util.go deleted file mode 100644 index 6005346..0000000 --- a/cryptor/crypt_util.go +++ /dev/null @@ -1,37 +0,0 @@ -package cryptor - -import "bytes" - -func generateAesKey(key []byte) []byte { - genKey := make([]byte, 16) - copy(genKey, key) - for i := 16; i < len(key); { - for j := 0; j < 16 && i < len(key); j, i = j+1, i+1 { - genKey[j] ^= key[i] - } - } - return genKey -} - -func generateDesKey(key []byte) []byte { - genKey := make([]byte, 8) - copy(genKey, key) - for i := 8; i < len(key); { - for j := 0; j < 8 && i < len(key); j, i = j+1, i+1 { - genKey[j] ^= key[i] - } - } - return genKey -} - -func pkcs7Padding(src []byte, blockSize int) []byte { - padding := blockSize - len(src)%blockSize - padText := bytes.Repeat([]byte{byte(padding)}, padding) - return append(src, padText...) -} - -func pkcs7UnPadding(src []byte) []byte { - length := len(src) - unPadding := int(src[length-1]) - return src[:(length - unPadding)] -} diff --git a/formatter/formatter_util.go b/formatter/formatter_util.go deleted file mode 100644 index 4928147..0000000 --- a/formatter/formatter_util.go +++ /dev/null @@ -1,40 +0,0 @@ -package formatter - -import ( - "fmt" - "reflect" - "strconv" - "strings" -) - -func commaString(s string) string { - if len(s) <= 3 { - return s - } - return commaString(s[:len(s)-3]) + "," + commaString(s[len(s)-3:]) -} - -func numString(value interface{}) string { - switch reflect.TypeOf(value).Kind() { - case reflect.Int, reflect.Int64, reflect.Float32, reflect.Float64: - return fmt.Sprintf("%v", value) - case reflect.String: - { - sv := fmt.Sprintf("%v", value) - if strings.Contains(sv, ".") { - _, err := strconv.ParseFloat(sv, 64) - if err == nil { - return sv - } - } else { - _, err := strconv.ParseInt(sv, 10, 64) - if err == nil { - return sv - } - } - } - default: - return "" - } - return "" -} diff --git a/function/function_util.go b/function/function_util.go deleted file mode 100644 index b819d95..0000000 --- a/function/function_util.go +++ /dev/null @@ -1,39 +0,0 @@ -package function - -import ( - "fmt" - "reflect" -) - -func invokeFunc(fn interface{}, args ...interface{}) []reflect.Value { - fv := functionValue(fn) - params := make([]reflect.Value, len(args)) - for i, item := range args { - params[i] = reflect.ValueOf(item) - } - return fv.Call(params) -} - -func unsafeInvokeFunc(fn interface{}, args ...interface{}) []reflect.Value { - fv := reflect.ValueOf(fn) - params := make([]reflect.Value, len(args)) - for i, item := range args { - params[i] = reflect.ValueOf(item) - } - return fv.Call(params) -} - -func functionValue(function interface{}) reflect.Value { - v := reflect.ValueOf(function) - if v.Kind() != reflect.Func { - panic(fmt.Sprintf("Invalid function type, value of type %T", function)) - } - return v -} - -func mustBeFunction(function interface{}) { - v := reflect.ValueOf(function) - if v.Kind() != reflect.Func { - panic(fmt.Sprintf("Invalid function type, value of type %T", function)) - } -} diff --git a/netutil/http_util.go b/netutil/http_util.go deleted file mode 100644 index de98f49..0000000 --- a/netutil/http_util.go +++ /dev/null @@ -1,186 +0,0 @@ -package netutil - -import ( - "bytes" - "errors" - "fmt" - "io/ioutil" - "net/http" - "net/url" - "strings" -) - -func doHttpRequest(method, reqUrl string, params ...interface{}) (*http.Response, error) { - if len(reqUrl) == 0 { - return nil, errors.New("url should be specified") - } - - req := &http.Request{ - Method: method, - Header: make(http.Header), - Proto: "HTTP/1.1", - ProtoMajor: 1, - ProtoMinor: 1, - } - - client := &http.Client{} - err := setUrl(req, reqUrl) - if err != nil { - return nil, err - } - - switch len(params) { - case 1: - err = setHeader(req, params[0]) - if err != nil { - return nil, err - } - case 2: - err := setHeaderAndQueryParam(req, reqUrl, params[0], params[1]) - if err != nil { - return nil, err - } - case 3: - err := setHeaderAndQueryAndBody(req, reqUrl, params[0], params[1], params[2]) - if err != nil { - return nil, err - } - case 4: - err := setHeaderAndQueryAndBody(req, reqUrl, params[0], params[1], params[2]) - if err != nil { - return nil, err - } - client, err = getClient(params[3]) - if err != nil { - return nil, err - } - } - - resp, e := client.Do(req) - return resp, e -} - -func setHeaderAndQueryParam(req *http.Request, reqUrl string, header, queryParam interface{}) error { - err := setHeader(req, header) - if err != nil { - return err - } - err = setQueryParam(req, reqUrl, queryParam) - if err != nil { - return err - } - return nil -} - -func setHeaderAndQueryAndBody(req *http.Request, reqUrl string, header, queryParam, body interface{}) error { - err := setHeader(req, header) - if err != nil { - return err - } - err = setQueryParam(req, reqUrl, queryParam) - if err != nil { - return err - } - err = setBodyByte(req, body) - if err != nil { - return err - } - return nil -} - -func setHeader(req *http.Request, header interface{}) error { - if header != nil { - switch v := header.(type) { - case map[string]string: - for k := range v { - req.Header.Add(k, v[k]) - } - case http.Header: - for k, vv := range v { - for _, vvv := range vv { - req.Header.Add(k, vvv) - } - } - default: - return errors.New("header params type should be http.Header or map[string]string") - } - } - - if host := req.Header.Get("Host"); host != "" { - req.Host = host - } - - return nil -} - -func setUrl(req *http.Request, reqUrl string) error { - u, err := url.Parse(reqUrl) - if err != nil { - return err - } - req.URL = u - return nil -} - -func setQueryParam(req *http.Request, reqUrl string, queryParam interface{}) error { - var values url.Values - if queryParam != nil { - switch v := queryParam.(type) { - case map[string]interface{}: - values = url.Values{} - for k := range v { - values.Set(k, fmt.Sprintf("%v", v[k])) - } - case url.Values: - values = v - default: - return errors.New("query params type should be url.Values or map[string]interface{}") - } - } - - // set url - if values != nil { - if !strings.Contains(reqUrl, "?") { - reqUrl = reqUrl + "?" + values.Encode() - } else { - reqUrl = reqUrl + "&" + values.Encode() - } - } - u, err := url.Parse(reqUrl) - if err != nil { - return err - } - req.URL = u - - return nil -} - -func setBodyByte(req *http.Request, body interface{}) error { - if body != nil { - var bodyByte []byte - if body != nil { - switch v := body.(type) { - case []byte: - bodyByte = v - default: - return errors.New("body type should be []byte") - } - } - req.Body = ioutil.NopCloser(bytes.NewReader(bodyByte)) - } - return nil -} - -func getClient(client interface{}) (*http.Client, error) { - c := http.Client{} - if client != nil { - switch v := client.(type) { - case http.Client: - c = v - default: - return nil, errors.New("client type should be http.Client") - } - } - - return &c, nil -} diff --git a/slice/slice_util.go b/slice/slice_util.go deleted file mode 100644 index b3113f1..0000000 --- a/slice/slice_util.go +++ /dev/null @@ -1,65 +0,0 @@ -package slice - -import ( - "fmt" - "reflect" -) - -// sliceValue return the reflect value of a slice -func sliceValue(slice interface{}) reflect.Value { - v := reflect.ValueOf(slice) - if v.Kind() != reflect.Slice { - panic(fmt.Sprintf("Invalid slice type, value of type %T", slice)) - } - return v -} - -// functionValue return the reflect value of a function -func functionValue(function interface{}) reflect.Value { - v := reflect.ValueOf(function) - if v.Kind() != reflect.Func { - panic(fmt.Sprintf("Invalid function type, value of type %T", function)) - } - return v -} - -// checkSliceCallbackFuncSignature Check func sign : s :[]type1{} -> func(i int, data type1) type2 -// see https://coolshell.cn/articles/21164.html#%E6%B3%9B%E5%9E%8BMap-Reduce -func checkSliceCallbackFuncSignature(fn reflect.Value, types ...reflect.Type) bool { - //Check it is a function - if fn.Kind() != reflect.Func { - return false - } - // NumIn() - returns a function type's input parameter count. - // NumOut() - returns a function type's output parameter count. - if (fn.Type().NumIn() != len(types)-1) || (fn.Type().NumOut() != 1) { - return false - } - // In() - returns the type of a function type's i'th input parameter. - // first input param type should be int - if fn.Type().In(0) != reflect.TypeOf(1) { - return false - } - for i := 0; i < len(types)-1; i++ { - if fn.Type().In(i) != types[i] { - return false - } - } - // Out() - returns the type of a function type's i'th output parameter. - outType := types[len(types)-1] - if outType != nil && fn.Type().Out(0) != outType { - return false - } - return true -} - -// sliceElemType get slice element type -func sliceElemType(reflectType reflect.Type) reflect.Type { - for { - if reflectType.Kind() != reflect.Slice { - return reflectType - } - - reflectType = reflectType.Elem() - } -} diff --git a/strutil/string_util.go b/strutil/string_util.go deleted file mode 100644 index 6776d43..0000000 --- a/strutil/string_util.go +++ /dev/null @@ -1,40 +0,0 @@ -package strutil - -import "strings" - -// splitWordsToLower split a string into worlds by uppercase char -func splitWordsToLower(s string) []string { - var res []string - - upperIndexes := upperIndex(s) - l := len(upperIndexes) - if upperIndexes == nil || l == 0 { - if s != "" { - res = append(res, s) - } - return res - } - for i := 0; i < l; i++ { - if i < l-1 { - res = append(res, strings.ToLower(s[upperIndexes[i]:upperIndexes[i+1]])) - } else { - res = append(res, strings.ToLower(s[upperIndexes[i]:])) - } - } - return res -} - -// upperIndex get a int slice which elements are all the uppercase char index of a string -func upperIndex(s string) []int { - var res []int - for i := 0; i < len(s); i++ { - if 64 < s[i] && s[i] < 91 { - res = append(res, i) - } - } - if len(s) > 0 && res != nil && res[0] != 0 { - res = append([]int{0}, res...) - } - - return res -} From b48155c2498c07b343404a29e8afa4fd88261eb5 Mon Sep 17 00:00:00 2001 From: dudaodong Date: Sat, 19 Feb 2022 21:52:10 +0800 Subject: [PATCH 2/3] refactor: rename files *_util.go to *_internal.go --- cryptor/crypto_internal.go | 37 +++++++ formatter/formatter_internal.go | 40 +++++++ function/function_internal.go | 39 +++++++ netutil/net_internal.go | 186 ++++++++++++++++++++++++++++++++ slice/slice_internal.go | 65 +++++++++++ strutil/string_internal.go | 40 +++++++ 6 files changed, 407 insertions(+) create mode 100644 cryptor/crypto_internal.go create mode 100644 formatter/formatter_internal.go create mode 100644 function/function_internal.go create mode 100644 netutil/net_internal.go create mode 100644 slice/slice_internal.go create mode 100644 strutil/string_internal.go diff --git a/cryptor/crypto_internal.go b/cryptor/crypto_internal.go new file mode 100644 index 0000000..6005346 --- /dev/null +++ b/cryptor/crypto_internal.go @@ -0,0 +1,37 @@ +package cryptor + +import "bytes" + +func generateAesKey(key []byte) []byte { + genKey := make([]byte, 16) + copy(genKey, key) + for i := 16; i < len(key); { + for j := 0; j < 16 && i < len(key); j, i = j+1, i+1 { + genKey[j] ^= key[i] + } + } + return genKey +} + +func generateDesKey(key []byte) []byte { + genKey := make([]byte, 8) + copy(genKey, key) + for i := 8; i < len(key); { + for j := 0; j < 8 && i < len(key); j, i = j+1, i+1 { + genKey[j] ^= key[i] + } + } + return genKey +} + +func pkcs7Padding(src []byte, blockSize int) []byte { + padding := blockSize - len(src)%blockSize + padText := bytes.Repeat([]byte{byte(padding)}, padding) + return append(src, padText...) +} + +func pkcs7UnPadding(src []byte) []byte { + length := len(src) + unPadding := int(src[length-1]) + return src[:(length - unPadding)] +} diff --git a/formatter/formatter_internal.go b/formatter/formatter_internal.go new file mode 100644 index 0000000..4928147 --- /dev/null +++ b/formatter/formatter_internal.go @@ -0,0 +1,40 @@ +package formatter + +import ( + "fmt" + "reflect" + "strconv" + "strings" +) + +func commaString(s string) string { + if len(s) <= 3 { + return s + } + return commaString(s[:len(s)-3]) + "," + commaString(s[len(s)-3:]) +} + +func numString(value interface{}) string { + switch reflect.TypeOf(value).Kind() { + case reflect.Int, reflect.Int64, reflect.Float32, reflect.Float64: + return fmt.Sprintf("%v", value) + case reflect.String: + { + sv := fmt.Sprintf("%v", value) + if strings.Contains(sv, ".") { + _, err := strconv.ParseFloat(sv, 64) + if err == nil { + return sv + } + } else { + _, err := strconv.ParseInt(sv, 10, 64) + if err == nil { + return sv + } + } + } + default: + return "" + } + return "" +} diff --git a/function/function_internal.go b/function/function_internal.go new file mode 100644 index 0000000..b819d95 --- /dev/null +++ b/function/function_internal.go @@ -0,0 +1,39 @@ +package function + +import ( + "fmt" + "reflect" +) + +func invokeFunc(fn interface{}, args ...interface{}) []reflect.Value { + fv := functionValue(fn) + params := make([]reflect.Value, len(args)) + for i, item := range args { + params[i] = reflect.ValueOf(item) + } + return fv.Call(params) +} + +func unsafeInvokeFunc(fn interface{}, args ...interface{}) []reflect.Value { + fv := reflect.ValueOf(fn) + params := make([]reflect.Value, len(args)) + for i, item := range args { + params[i] = reflect.ValueOf(item) + } + return fv.Call(params) +} + +func functionValue(function interface{}) reflect.Value { + v := reflect.ValueOf(function) + if v.Kind() != reflect.Func { + panic(fmt.Sprintf("Invalid function type, value of type %T", function)) + } + return v +} + +func mustBeFunction(function interface{}) { + v := reflect.ValueOf(function) + if v.Kind() != reflect.Func { + panic(fmt.Sprintf("Invalid function type, value of type %T", function)) + } +} diff --git a/netutil/net_internal.go b/netutil/net_internal.go new file mode 100644 index 0000000..de98f49 --- /dev/null +++ b/netutil/net_internal.go @@ -0,0 +1,186 @@ +package netutil + +import ( + "bytes" + "errors" + "fmt" + "io/ioutil" + "net/http" + "net/url" + "strings" +) + +func doHttpRequest(method, reqUrl string, params ...interface{}) (*http.Response, error) { + if len(reqUrl) == 0 { + return nil, errors.New("url should be specified") + } + + req := &http.Request{ + Method: method, + Header: make(http.Header), + Proto: "HTTP/1.1", + ProtoMajor: 1, + ProtoMinor: 1, + } + + client := &http.Client{} + err := setUrl(req, reqUrl) + if err != nil { + return nil, err + } + + switch len(params) { + case 1: + err = setHeader(req, params[0]) + if err != nil { + return nil, err + } + case 2: + err := setHeaderAndQueryParam(req, reqUrl, params[0], params[1]) + if err != nil { + return nil, err + } + case 3: + err := setHeaderAndQueryAndBody(req, reqUrl, params[0], params[1], params[2]) + if err != nil { + return nil, err + } + case 4: + err := setHeaderAndQueryAndBody(req, reqUrl, params[0], params[1], params[2]) + if err != nil { + return nil, err + } + client, err = getClient(params[3]) + if err != nil { + return nil, err + } + } + + resp, e := client.Do(req) + return resp, e +} + +func setHeaderAndQueryParam(req *http.Request, reqUrl string, header, queryParam interface{}) error { + err := setHeader(req, header) + if err != nil { + return err + } + err = setQueryParam(req, reqUrl, queryParam) + if err != nil { + return err + } + return nil +} + +func setHeaderAndQueryAndBody(req *http.Request, reqUrl string, header, queryParam, body interface{}) error { + err := setHeader(req, header) + if err != nil { + return err + } + err = setQueryParam(req, reqUrl, queryParam) + if err != nil { + return err + } + err = setBodyByte(req, body) + if err != nil { + return err + } + return nil +} + +func setHeader(req *http.Request, header interface{}) error { + if header != nil { + switch v := header.(type) { + case map[string]string: + for k := range v { + req.Header.Add(k, v[k]) + } + case http.Header: + for k, vv := range v { + for _, vvv := range vv { + req.Header.Add(k, vvv) + } + } + default: + return errors.New("header params type should be http.Header or map[string]string") + } + } + + if host := req.Header.Get("Host"); host != "" { + req.Host = host + } + + return nil +} + +func setUrl(req *http.Request, reqUrl string) error { + u, err := url.Parse(reqUrl) + if err != nil { + return err + } + req.URL = u + return nil +} + +func setQueryParam(req *http.Request, reqUrl string, queryParam interface{}) error { + var values url.Values + if queryParam != nil { + switch v := queryParam.(type) { + case map[string]interface{}: + values = url.Values{} + for k := range v { + values.Set(k, fmt.Sprintf("%v", v[k])) + } + case url.Values: + values = v + default: + return errors.New("query params type should be url.Values or map[string]interface{}") + } + } + + // set url + if values != nil { + if !strings.Contains(reqUrl, "?") { + reqUrl = reqUrl + "?" + values.Encode() + } else { + reqUrl = reqUrl + "&" + values.Encode() + } + } + u, err := url.Parse(reqUrl) + if err != nil { + return err + } + req.URL = u + + return nil +} + +func setBodyByte(req *http.Request, body interface{}) error { + if body != nil { + var bodyByte []byte + if body != nil { + switch v := body.(type) { + case []byte: + bodyByte = v + default: + return errors.New("body type should be []byte") + } + } + req.Body = ioutil.NopCloser(bytes.NewReader(bodyByte)) + } + return nil +} + +func getClient(client interface{}) (*http.Client, error) { + c := http.Client{} + if client != nil { + switch v := client.(type) { + case http.Client: + c = v + default: + return nil, errors.New("client type should be http.Client") + } + } + + return &c, nil +} diff --git a/slice/slice_internal.go b/slice/slice_internal.go new file mode 100644 index 0000000..b3113f1 --- /dev/null +++ b/slice/slice_internal.go @@ -0,0 +1,65 @@ +package slice + +import ( + "fmt" + "reflect" +) + +// sliceValue return the reflect value of a slice +func sliceValue(slice interface{}) reflect.Value { + v := reflect.ValueOf(slice) + if v.Kind() != reflect.Slice { + panic(fmt.Sprintf("Invalid slice type, value of type %T", slice)) + } + return v +} + +// functionValue return the reflect value of a function +func functionValue(function interface{}) reflect.Value { + v := reflect.ValueOf(function) + if v.Kind() != reflect.Func { + panic(fmt.Sprintf("Invalid function type, value of type %T", function)) + } + return v +} + +// checkSliceCallbackFuncSignature Check func sign : s :[]type1{} -> func(i int, data type1) type2 +// see https://coolshell.cn/articles/21164.html#%E6%B3%9B%E5%9E%8BMap-Reduce +func checkSliceCallbackFuncSignature(fn reflect.Value, types ...reflect.Type) bool { + //Check it is a function + if fn.Kind() != reflect.Func { + return false + } + // NumIn() - returns a function type's input parameter count. + // NumOut() - returns a function type's output parameter count. + if (fn.Type().NumIn() != len(types)-1) || (fn.Type().NumOut() != 1) { + return false + } + // In() - returns the type of a function type's i'th input parameter. + // first input param type should be int + if fn.Type().In(0) != reflect.TypeOf(1) { + return false + } + for i := 0; i < len(types)-1; i++ { + if fn.Type().In(i) != types[i] { + return false + } + } + // Out() - returns the type of a function type's i'th output parameter. + outType := types[len(types)-1] + if outType != nil && fn.Type().Out(0) != outType { + return false + } + return true +} + +// sliceElemType get slice element type +func sliceElemType(reflectType reflect.Type) reflect.Type { + for { + if reflectType.Kind() != reflect.Slice { + return reflectType + } + + reflectType = reflectType.Elem() + } +} diff --git a/strutil/string_internal.go b/strutil/string_internal.go new file mode 100644 index 0000000..6776d43 --- /dev/null +++ b/strutil/string_internal.go @@ -0,0 +1,40 @@ +package strutil + +import "strings" + +// splitWordsToLower split a string into worlds by uppercase char +func splitWordsToLower(s string) []string { + var res []string + + upperIndexes := upperIndex(s) + l := len(upperIndexes) + if upperIndexes == nil || l == 0 { + if s != "" { + res = append(res, s) + } + return res + } + for i := 0; i < l; i++ { + if i < l-1 { + res = append(res, strings.ToLower(s[upperIndexes[i]:upperIndexes[i+1]])) + } else { + res = append(res, strings.ToLower(s[upperIndexes[i]:])) + } + } + return res +} + +// upperIndex get a int slice which elements are all the uppercase char index of a string +func upperIndex(s string) []int { + var res []int + for i := 0; i < len(s); i++ { + if 64 < s[i] && s[i] < 91 { + res = append(res, i) + } + } + if len(s) > 0 && res != nil && res[0] != 0 { + res = append([]int{0}, res...) + } + + return res +} From 96d57a6d24f9f1822e6cc4a96c8b240087c676df Mon Sep 17 00:00:00 2001 From: dudaodong Date: Sat, 19 Feb 2022 21:53:27 +0800 Subject: [PATCH 3/3] docs: remove duplicated --- docs/function.md | 1 - docs/function_zh-CN.md | 1 - 2 files changed, 2 deletions(-) diff --git a/docs/function.md b/docs/function.md index c05ad53..8ca3d9a 100644 --- a/docs/function.md +++ b/docs/function.md @@ -26,7 +26,6 @@ import ( - [Compose](#Compose) - [Debounced](#Debounced) - [Delay](#Delay) -- [Delay](#Delay) - [Watcher](#Watcher)
diff --git a/docs/function_zh-CN.md b/docs/function_zh-CN.md index 6331be8..8fdfaaa 100644 --- a/docs/function_zh-CN.md +++ b/docs/function_zh-CN.md @@ -26,7 +26,6 @@ import ( - [Compose](#Compose) - [Debounced](#Debounced) - [Delay](#Delay) -- [Delay](#Delay) - [Watcher](#Watcher)