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

cryptor/crypt_util.go

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

formatter/formatter_util.go

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

function/function_util.go

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

netutil/http_util.go

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

slice/slice_util.go

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

strutil/string_util.go

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