fix: comment (#8)

apiaccessor/accessor.go

@@ -4,17 +4,18 @@ import (
 	"errors"
 )
 
+// Accessor is the interface use to check the availability of the request's arguments
 type Accessor interface {
 	CheckSignature() error
 	CheckTimestamp() error
 	CheckNonce() error
 }
 
 var (
-	ErrArgLack            = errors.New("arg lack")
-	ErrSignatureUnmatched = errors.New("signature is unmatched")
-	ErrTimestampTimeout   = errors.New("timestamp time out")
-	ErrNonceUsed          = errors.New("nonce is used")
+	errArgLack            = errors.New("arg lack")
+	errSignatureUnmatched = errors.New("signature is unmatched")
+	errTimestampTimeout   = errors.New("timestamp time out")
+	errNonceUsed          = errors.New("nonce is used")
 )
 
 const (
@@ -46,8 +47,11 @@ func (a *args) append(k, v string) {
 	a.l = append(a.l, &arg{k: k, v: v})
 }
 
+// EvalSignature evaluating the signature of the request's arguments
 type EvalSignature func(origin string) (signature string)
 
+// TimestampChecker checking the availability of the request's timestamp argument
 type TimestampChecker func(timestamp int64) error
 
+// NonceChecker checking the availability of the request's nonce argument
 type NonceChecker func(nonce string) error

apiaccessor/base_accessor.go

@@ -30,7 +30,7 @@ func defTimestampChecker(timestamp int64) error {
 	const sec = 5
 	dt := time.Now().Unix() - timestamp
 	if dt > sec || dt < -sec {
-		return ErrTimestampTimeout
+		return errTimestampTimeout
 	}
 	return nil
 }
@@ -49,6 +49,7 @@ func newBaseAccessor() baseAccessor {
 	}
 }
 
+// CheckSignature implements the Accessor CheckSignature interface
 func (a *baseAccessor) CheckSignature() error {
 	// 参数排序
 	sort.Slice(a.args.l, func(i, j int) bool {
@@ -75,11 +76,12 @@ func (a *baseAccessor) CheckSignature() error {
 	signature := a.evalSignatureFunc(argText)
 	argSignature := a.args.kv[signatureTag]
 	if signature != argSignature {
-		return fmt.Errorf("%w: want %s, get %s", ErrSignatureUnmatched, signature, argSignature)
+		return fmt.Errorf("%w: want %s, get %s", errSignatureUnmatched, signature, argSignature)
 	}
 	return nil
 }
 
+// CheckTimestamp implements the Accessor CheckTimestamp interface
 func (a *baseAccessor) CheckTimestamp() error {
 	timestampStr := a.args.kv[timestampTag]
 	timestamp, err := strconv.ParseInt(timestampStr, 10, 64)
@@ -89,6 +91,7 @@ func (a *baseAccessor) CheckTimestamp() error {
 	return a.timestampChecker(timestamp)
 }
 
+// CheckNonce implements the Accessor CheckNonce interface
 func (a *baseAccessor) CheckNonce() error {
 	return a.nonceChecker(a.args.kv[nonceTag])
 }

apiaccessor/query_accessor.go

@@ -5,30 +5,32 @@ import (
 	"net/url"
 )
 
+// QueryAccessor use to check the availability of the request's query arguments
 type QueryAccessor struct {
 	baseAccessor
 }
 
+// NewQueryAccessor creates a new QueryAccessor.
 func NewQueryAccessor(query url.Values, secretKey string, setters ...Setter) (*QueryAccessor, error) {
 	qa := &QueryAccessor{
 		baseAccessor: newBaseAccessor(),
 	}
 	for key, vs := range query {
 		v := vs[0]
 		if len(v) == 0 {
-			return nil, fmt.Errorf("%w: %s", ErrArgLack, key)
+			return nil, fmt.Errorf("%w: %s", errArgLack, key)
 		}
 		qa.args.append(key, v)
 	}
 	qa.args.append(secretKeyTag, secretKey)
 	if len(qa.args.kv[nonceTag]) == 0 {
-		return nil, fmt.Errorf("%w: %s", ErrArgLack, nonceTag)
+		return nil, fmt.Errorf("%w: %s", errArgLack, nonceTag)
 	}
 	if len(qa.args.kv[timestampTag]) == 0 {
-		return nil, fmt.Errorf("%w: %s", ErrArgLack, timestampTag)
+		return nil, fmt.Errorf("%w: %s", errArgLack, timestampTag)
 	}
 	if len(qa.args.kv[signatureTag]) == 0 {
-		return nil, fmt.Errorf("%w: %s", ErrArgLack, signatureTag)
+		return nil, fmt.Errorf("%w: %s", errArgLack, signatureTag)
 	}
 
 	for _, setter := range setters {

apiaccessor/query_accessor_test.go

@@ -13,13 +13,13 @@ import (
 func TestNewQueryAccessor(t *testing.T) {
 	query := url.Values{}
 	_, err := NewQueryAccessor(query, "123")
-	assert.Equal(t, errors.Is(err, ErrArgLack), true)
+	assert.Equal(t, errors.Is(err, errArgLack), true)
 
 	query = url.Values{
 		nonceTag: []string{"12345"},
 	}
 	_, err = NewQueryAccessor(query, "123")
-	assert.Equal(t, errors.Is(err, ErrArgLack), true)
+	assert.Equal(t, errors.Is(err, errArgLack), true)
 
 	query = url.Values{
 		nonceTag:     []string{"12345"},
@@ -52,7 +52,7 @@ func TestCheckSignature(t *testing.T) {
 	qa, err := NewQueryAccessor(query, "123")
 	assert.Equal(t, err, nil)
 	err = qa.CheckSignature()
-	assert.Equal(t, errors.Is(err, ErrSignatureUnmatched), true)
+	assert.Equal(t, errors.Is(err, errSignatureUnmatched), true)
 
 	query = url.Values{
 		nonceTag:     []string{"12345"},
@@ -78,7 +78,7 @@ func TestCheckTimestamp(t *testing.T) {
 	qa, err := NewQueryAccessor(query, "123")
 	assert.Equal(t, err, nil)
 	err = qa.CheckTimestamp()
-	assert.Equal(t, errors.Is(err, ErrTimestampTimeout), true)
+	assert.Equal(t, errors.Is(err, errTimestampTimeout), true)
 
 	query = url.Values{
 		nonceTag:     []string{"12345"},
@@ -97,7 +97,7 @@ func TestCheckNonce(t *testing.T) {
 	nonceMap := make(map[string]bool)
 	mockNonceChecker := func(nonce string) error {
 		if _, ok := nonceMap[nonce]; ok {
-			return ErrNonceUsed
+			return errNonceUsed
 		}
 		nonceMap[nonce] = true
 		return nil
@@ -115,5 +115,5 @@ func TestCheckNonce(t *testing.T) {
 	err = qa.CheckNonce()
 	assert.Equal(t, err, nil)
 	err = qa.CheckNonce()
-	assert.Equal(t, errors.Is(err, ErrNonceUsed), true)
+	assert.Equal(t, errors.Is(err, errNonceUsed), true)
 }

apiaccessor/setter.go

@@ -2,8 +2,10 @@ package apiaccessor
 
 import "github.com/go-redis/redis/v7"
 
+// Setter is the option of creating the Accessor
 type Setter func(b *baseAccessor) error
 
+// WithEvalSignatureFunc set a custom EvalSignature for the Accessor
 func WithEvalSignatureFunc(e EvalSignature) Setter {
 	return func(b *baseAccessor) error {
 		b.evalSignatureFunc = e
@@ -31,8 +33,10 @@ end
 return no
 `)
 
+// KeyGen use to generate a redis key which is using in the WithGeneralRedisNonceChecker
 type KeyGen func(nonce string) (key string)
 
+// WithGeneralRedisNonceChecker set a redis-base NonceChecker for the Accessor
 func WithGeneralRedisNonceChecker(client redis.Cmdable, sec int64, keyGenFunc KeyGen) Setter {
 	return func(b *baseAccessor) error {
 		b.nonceChecker = func(nonce string) error {
@@ -42,14 +46,15 @@ func WithGeneralRedisNonceChecker(client redis.Cmdable, sec int64, keyGenFunc Ke
 				return err
 			}
 			if re == 1 {
-				return ErrNonceUsed
+				return errNonceUsed
 			}
 			return nil
 		}
 		return nil
 	}
 }
 
+// WithNonceChecker set a custom NonceChecker for the Accessor
 func WithNonceChecker(nc NonceChecker) Setter {
 	return func(b *baseAccessor) error {
 		b.nonceChecker = nc