refactor: rename files *_util.go to *_internal.go

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)]
+}

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 ""
+}

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))
+	}
+}

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
+}

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()
+	}
+}

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
+}