Use time values instead of pointers

examples/aws_cognito/main.go

@@ -31,9 +31,9 @@ func main() {
 		RefreshErrorHandler: func(err error) {
 			log.Printf("There was an error with the jwt.Keyfunc\nError: %s", err.Error())
 		},
-		RefreshInterval:   &refreshInterval,
-		RefreshRateLimit:  &refreshRateLimit,
-		RefreshTimeout:    &refreshTimeout,
+		RefreshInterval:   refreshInterval,
+		RefreshRateLimit:  refreshRateLimit,
+		RefreshTimeout:    refreshTimeout,
 		RefreshUnknownKID: &refreshUnknownKID,
 	}
 

examples/ctx/main.go

@@ -20,7 +20,7 @@ func main() {
 	// seconds. This timeout is also used to create the initial context.Context for keyfunc.Get.
 	refreshTimeout := time.Second * 10
 	options := keyfunc.Options{
-		RefreshTimeout: &refreshTimeout,
+		RefreshTimeout: refreshTimeout,
 		RefreshErrorHandler: func(err error) {
 			log.Printf("There was an error with the jwt.Keyfunc\nError: %s", err.Error())
 		},

examples/given/main.go

@@ -47,9 +47,9 @@ func main() {
 		RefreshErrorHandler: func(err error) {
 			log.Printf("There was an error with the jwt.Keyfunc\nError: %s", err.Error())
 		},
-		RefreshInterval:   &refreshInterval,
-		RefreshRateLimit:  &refreshRateLimit,
-		RefreshTimeout:    &refreshTimeout,
+		RefreshInterval:   refreshInterval,
+		RefreshRateLimit:  refreshRateLimit,
+		RefreshTimeout:    refreshTimeout,
 		RefreshUnknownKID: &refreshUnknownKID,
 	}
 

examples/interval/main.go

@@ -21,8 +21,8 @@ func main() {
 	refreshInterval := time.Hour
 	refreshTimeout := time.Second * 10
 	options := keyfunc.Options{
-		RefreshInterval: &refreshInterval,
-		RefreshTimeout:  &refreshTimeout,
+		RefreshInterval: refreshInterval,
+		RefreshTimeout:  refreshTimeout,
 		RefreshErrorHandler: func(err error) {
 			log.Printf("There was an error with the jwt.Keyfunc\nError: %s", err.Error())
 		},

examples/recommended_options/main.go

@@ -32,9 +32,9 @@ func main() {
 		RefreshErrorHandler: func(err error) {
 			log.Printf("There was an error with the jwt.Keyfunc\nError: %s", err.Error())
 		},
-		RefreshInterval:   &refreshInterval,
-		RefreshRateLimit:  &refreshRateLimit,
-		RefreshTimeout:    &refreshTimeout,
+		RefreshInterval:   refreshInterval,
+		RefreshRateLimit:  refreshRateLimit,
+		RefreshTimeout:    refreshTimeout,
 		RefreshUnknownKID: &refreshUnknownKID,
 	}
 

get.go

@@ -33,8 +33,8 @@ func Get(jwksURL string, options ...Options) (jwks *JWKs, err error) {
 	if jwks.client == nil {
 		jwks.client = http.DefaultClient
 	}
-	if jwks.refreshTimeout == nil {
-		jwks.refreshTimeout = &defaultRefreshTimeout
+	if jwks.refreshTimeout == 0 {
+		jwks.refreshTimeout = defaultRefreshTimeout
 	}
 
 	// Get the keys for the JWKs.
@@ -43,7 +43,7 @@ func Get(jwksURL string, options ...Options) (jwks *JWKs, err error) {
 	}
 
 	// Check to see if a background refresh of the JWKs should happen.
-	if jwks.refreshInterval != nil || jwks.refreshUnknownKID {
+	if jwks.refreshInterval != 0 || jwks.refreshUnknownKID {
 
 		// Attach a context used to end the background goroutine.
 		jwks.ctx, jwks.cancel = context.WithCancel(context.Background())
@@ -66,8 +66,8 @@ func (j *JWKs) backgroundRefresh() {
 	var lastRefresh time.Time
 	var queueOnce sync.Once
 	var refreshMux sync.Mutex
-	if j.refreshRateLimit != nil {
-		lastRefresh = time.Now().Add(-*j.refreshRateLimit)
+	if j.refreshRateLimit != 0 {
+		lastRefresh = time.Now().Add(-j.refreshRateLimit)
 	}
 
 	// Create a channel that will never send anything unless there is a refresh interval.
@@ -77,8 +77,8 @@ func (j *JWKs) backgroundRefresh() {
 	for {
 
 		// If there is a refresh interval, create the channel for it.
-		if j.refreshInterval != nil {
-			refreshInterval = time.After(*j.refreshInterval)
+		if j.refreshInterval != 0 {
+			refreshInterval = time.After(j.refreshInterval)
 		}
 
 		// Wait for a refresh to occur or the background to end.
@@ -98,7 +98,7 @@ func (j *JWKs) backgroundRefresh() {
 
 			// Rate limit, if needed.
 			refreshMux.Lock()
-			if j.refreshRateLimit != nil && lastRefresh.Add(*j.refreshRateLimit).After(time.Now()) {
+			if j.refreshRateLimit != 0 && lastRefresh.Add(j.refreshRateLimit).After(time.Now()) {
 
 				// Don't make the JWT parsing goroutine wait for the JWKs to refresh.
 				cancel()
@@ -111,7 +111,7 @@ func (j *JWKs) backgroundRefresh() {
 
 						// Wait for the next time to refresh.
 						refreshMux.Lock()
-						wait := time.Until(lastRefresh.Add(*j.refreshRateLimit))
+						wait := time.Until(lastRefresh.Add(j.refreshRateLimit))
 						refreshMux.Unlock()
 						select {
 						case <-j.ctx.Done():
@@ -162,9 +162,9 @@ func (j *JWKs) refresh() (err error) {
 	var ctx context.Context
 	var cancel context.CancelFunc
 	if j.ctx != nil {
-		ctx, cancel = context.WithTimeout(j.ctx, *j.refreshTimeout)
+		ctx, cancel = context.WithTimeout(j.ctx, j.refreshTimeout)
 	} else {
-		ctx, cancel = context.WithTimeout(context.Background(), *j.refreshTimeout)
+		ctx, cancel = context.WithTimeout(context.Background(), j.refreshTimeout)
 	}
 	defer cancel()
 

jwks.go

@@ -44,10 +44,10 @@ type JWKs struct {
 	keys                map[string]*jsonKey
 	mux                 sync.RWMutex
 	refreshErrorHandler ErrorHandler
-	refreshInterval     *time.Duration
-	refreshRateLimit    *time.Duration
+	refreshInterval     time.Duration
+	refreshRateLimit    time.Duration
 	refreshRequests     chan context.CancelFunc
-	refreshTimeout      *time.Duration
+	refreshTimeout      time.Duration
 	refreshUnknownKID   bool
 }
 

jwks_test.go

@@ -53,7 +53,7 @@ func TestInvalidServer(t *testing.T) {
 	// Set the options to refresh KID when unknown.
 	refreshInterval := time.Second
 	options := keyfunc.Options{
-		RefreshInterval:     &refreshInterval,
+		RefreshInterval:     refreshInterval,
 		RefreshErrorHandler: testingRefreshErrorHandler,
 	}
 
@@ -117,13 +117,13 @@ func TestJWKs(t *testing.T) {
 			RefreshErrorHandler: testingRefreshErrorHandler,
 		},
 		{
-			RefreshInterval: &testingRefreshInterval,
+			RefreshInterval: testingRefreshInterval,
 		},
 		{
-			RefreshRateLimit: &testingRateLimit,
+			RefreshRateLimit: testingRateLimit,
 		},
 		{
-			RefreshTimeout: &testingRefreshTimeout,
+			RefreshTimeout: testingRefreshTimeout,
 		},
 	}
 
@@ -156,8 +156,8 @@ func TestJWKs(t *testing.T) {
 		}
 
 		// Wait for the interval to pass, if required.
-		if opts.RefreshInterval != nil {
-			time.Sleep(*opts.RefreshInterval)
+		if opts.RefreshInterval != 0 {
+			time.Sleep(opts.RefreshInterval)
 		}
 
 		// Iterate through the test cases.
@@ -280,9 +280,9 @@ func TestRateLimit(t *testing.T) {
 		RefreshErrorHandler: func(err error) {
 			t.Errorf("The package itself had an error.\nError: %s", err.Error())
 		},
-		RefreshInterval:   &refreshInterval,
-		RefreshRateLimit:  &refreshRateLimit,
-		RefreshTimeout:    &refreshTimeout,
+		RefreshInterval:   refreshInterval,
+		RefreshRateLimit:  refreshRateLimit,
+		RefreshTimeout:    refreshTimeout,
 		RefreshUnknownKID: &refreshUnknownKID,
 	}
 

options.go

@@ -39,16 +39,16 @@ type Options struct {
 	// RefreshInterval is the duration to refresh the JWKs in the background via a new HTTP request. If this is not nil,
 	// then a background goroutine will be used to refresh the JWKs once per the given interval. Make sure to call the
 	// JWKs.EndBackground method to end this goroutine when it's no longer needed.
-	RefreshInterval *time.Duration
+	RefreshInterval time.Duration
 
 	// RefreshRateLimit limits the rate at which refresh requests are granted. Only one refresh request can be queued
 	// at a time any refresh requests received while there is already a queue are ignored. It does not make sense to
 	// have RefreshInterval's value shorter than this.
-	RefreshRateLimit *time.Duration
+	RefreshRateLimit time.Duration
 
 	// RefreshTimeout is the duration for the context timeout used to create the HTTP request for a refresh of the JWKs.
 	// This defaults to one minute. This is only effectual if RefreshInterval is not nil.
-	RefreshTimeout *time.Duration
+	RefreshTimeout time.Duration
 
 	// RefreshUnknownKID indicates that the JWKs refresh request will occur every time a kid that isn't cached is seen.
 	// This is done through a background goroutine. Without specifying a RefreshInterval a malicious client could
@@ -79,13 +79,13 @@ func applyOptions(jwks *JWKs, options Options) {
 	if options.RefreshErrorHandler != nil {
 		jwks.refreshErrorHandler = options.RefreshErrorHandler
 	}
-	if options.RefreshInterval != nil {
+	if options.RefreshInterval != 0 {
 		jwks.refreshInterval = options.RefreshInterval
 	}
-	if options.RefreshRateLimit != nil {
+	if options.RefreshRateLimit != 0 {
 		jwks.refreshRateLimit = options.RefreshRateLimit
 	}
-	if options.RefreshTimeout != nil {
+	if options.RefreshTimeout != 0 {
 		jwks.refreshTimeout = options.RefreshTimeout
 	}
 	if options.RefreshUnknownKID != nil {