Refactor rate limiting code for style and clarity

This commit applies consistent formatting, improves code readability, and fixes minor whitespace issues across rate limiting middleware, algorithms, and example/test files. No functional changes were made; the update is purely stylistic to enhance maintainability.

Author: heyOnuoha

packages/pharaoh_rate_limit/example/basic_rate_limiting.dart

@@ -33,7 +33,7 @@ void main() async {
     message: 'Too many authentication attempts, please try again later.',
     statusCode: 429,
   );
-  
+
   app.use(authLimiter);
 
   app.post('/auth/login', (req, res) {

packages/pharaoh_rate_limit/lib/src/rate_limit_middleware.dart

@@ -9,28 +9,28 @@ import 'sliding_window.dart';
 class RateLimitOptions {
   /// Maximum number of requests allowed
   final int max;
-  
+
   /// Time window for rate limiting
   final Duration windowMs;
-  
+
   /// Custom message when rate limit is exceeded
   final String? message;
-  
+
   /// Custom status code when rate limit is exceeded (default: 429)
   final int statusCode;
-  
+
   /// Function to generate a unique key for each client
   final String Function(Request req)? keyGenerator;
-  
+
   /// Function to skip rate limiting for certain requests
   final bool Function(Request req)? skip;
-  
+
   /// Headers to include in the response
   final bool standardHeaders;
-  
+
   /// Legacy headers (X-RateLimit-*)
   final bool legacyHeaders;
-  
+
   /// Rate limiting algorithm to use
   final RateLimitAlgorithm algorithm;
 
@@ -54,7 +54,7 @@ enum RateLimitAlgorithm {
 }
 
 /// Rate limiting middleware for Pharaoh
-/// 
+///
 /// Example usage:
 /// ```dart
 /// app.use(rateLimit(
@@ -85,7 +85,7 @@ Middleware rateLimit({
     legacyHeaders: legacyHeaders,
     algorithm: algorithm,
   );
-  
+
   return RateLimitMiddleware(options).middleware;
 }
 
@@ -94,11 +94,11 @@ Middleware rateLimit({
 class RateLimitMiddleware {
   final RateLimitOptions options;
   late final RateLimiter _limiter;
-  
+
   RateLimitMiddleware(this.options) {
     _limiter = _createLimiter();
   }
-  
+
   RateLimiter _createLimiter() {
     switch (options.algorithm) {
       case RateLimitAlgorithm.tokenBucket:
@@ -114,56 +114,59 @@ class RateLimitMiddleware {
         );
     }
   }
-  
+
   Middleware get middleware => (req, res, next) async {
-    // Skip rate limiting if skip function returns true
-    if (options.skip?.call(req) == true) {
-      return next(req);
-    }
-    
-    final key = _generateKey(req);
-    final allowed = _limiter.allowRequest(key);
-    
-    // Add rate limit headers
-    _addHeaders(res, key);
-    
-    if (!allowed) {
-      final message = options.message ?? 'Too many requests, please try again later.';
-      return next(res.status(options.statusCode).json({'error': message}));
-    }
-    
-    return next(req);
-  };
-  
+        // Skip rate limiting if skip function returns true
+        if (options.skip?.call(req) == true) {
+          return next(req);
+        }
+
+        final key = _generateKey(req);
+        final allowed = _limiter.allowRequest(key);
+
+        // Add rate limit headers
+        _addHeaders(res, key);
+
+        if (!allowed) {
+          final message =
+              options.message ?? 'Too many requests, please try again later.';
+          return next(res.status(options.statusCode).json({'error': message}));
+        }
+
+        return next(req);
+      };
+
   String _generateKey(Request req) {
     if (options.keyGenerator != null) {
       return options.keyGenerator!(req);
     }
-    
+
     // Default key generation based on IP address
     return req.ipAddr;
   }
-  
+
   void _addHeaders(Response res, String key) {
     final remaining = _limiter.getRemainingRequests(key);
     final resetTime = _limiter.getResetTime(key);
-    
+
     if (options.standardHeaders) {
       res.header('RateLimit-Limit', options.max.toString());
       res.header('RateLimit-Remaining', remaining.toString());
       if (resetTime != null) {
-        res.header('RateLimit-Reset', (resetTime.millisecondsSinceEpoch ~/ 1000).toString());
+        res.header('RateLimit-Reset',
+            (resetTime.millisecondsSinceEpoch ~/ 1000).toString());
       }
     }
-    
+
     if (options.legacyHeaders) {
       res.header('X-RateLimit-Limit', options.max.toString());
       res.header('X-RateLimit-Remaining', remaining.toString());
       if (resetTime != null) {
-        res.header('X-RateLimit-Reset', (resetTime.millisecondsSinceEpoch ~/ 1000).toString());
+        res.header('X-RateLimit-Reset',
+            (resetTime.millisecondsSinceEpoch ~/ 1000).toString());
       }
     }
-    
+
     // Add Retry-After header when rate limited
     if (remaining <= 0 && resetTime != null) {
       final retryAfter = resetTime.difference(DateTime.now()).inSeconds;

packages/pharaoh_rate_limit/lib/src/rate_limiter.dart

@@ -3,13 +3,13 @@ abstract class RateLimiter {
   /// Check if a request should be allowed
   /// Returns true if allowed, false if rate limited
   bool allowRequest(String key);
-  
+
   /// Get remaining requests for the given key
   int getRemainingRequests(String key);
-  
+
   /// Get reset time for the given key
   DateTime? getResetTime(String key);
-  
+
   /// Clean up expired entries
   void cleanup();
 }

packages/pharaoh_rate_limit/lib/src/sliding_window.dart

@@ -1,19 +1,19 @@
 import 'rate_limiter.dart';
 
 /// Sliding window rate limiter implementation
-/// 
+///
 /// Tracks requests in a sliding time window and enforces limits
 /// based on the number of requests within that window.
 class SlidingWindowRateLimiter implements RateLimiter {
   final int _maxRequests;
   final Duration _windowSize;
   final Map<String, _SlidingWindow> _windows = {};
-  
+
   SlidingWindowRateLimiter({
     required int maxRequests,
     required Duration windowSize,
-  }) : _maxRequests = maxRequests,
-       _windowSize = windowSize;
+  })  : _maxRequests = maxRequests,
+        _windowSize = windowSize;
 
   @override
   bool allowRequest(String key) {
@@ -37,11 +37,10 @@ class SlidingWindowRateLimiter implements RateLimiter {
   void cleanup() {
     final now = DateTime.now();
     final cutoff = now.subtract(_windowSize.multiply(2));
-    
+
     _windows.removeWhere((key, window) {
       window._cleanup();
-      return window.requests.isEmpty || 
-             window.requests.first.isBefore(cutoff);
+      return window.requests.isEmpty || window.requests.first.isBefore(cutoff);
     });
   }
 
@@ -50,7 +49,7 @@ class SlidingWindowRateLimiter implements RateLimiter {
     if (window == null) {
       return _windows[key] = _SlidingWindow(_maxRequests, _windowSize);
     }
-    
+
     window._cleanup();
     return window;
   }
@@ -65,12 +64,12 @@ class _SlidingWindow {
 
   bool allowRequest() {
     _cleanup();
-    
+
     if (requests.length < maxRequests) {
       requests.add(DateTime.now());
       return true;
     }
-    
+
     return false;
   }
 
@@ -81,7 +80,7 @@ class _SlidingWindow {
   void _cleanup() {
     final now = DateTime.now();
     final cutoff = now.subtract(windowSize);
-    
+
     requests.removeWhere((timestamp) => timestamp.isBefore(cutoff));
   }
 }

packages/pharaoh_rate_limit/lib/src/token_bucket.dart

@@ -3,22 +3,22 @@ import 'dart:math';
 import 'rate_limiter.dart';
 
 /// Token bucket rate limiter implementation
-/// 
+///
 /// Uses the token bucket algorithm where tokens are added to a bucket
 /// at a fixed rate and requests consume tokens from the bucket.
 class TokenBucketRateLimiter implements RateLimiter {
   final int _capacity;
   final int _refillRate;
   final Duration _refillInterval;
   final Map<String, _TokenBucket> _buckets = {};
-  
+
   TokenBucketRateLimiter({
     required int capacity,
     required int refillRate,
     Duration refillInterval = const Duration(seconds: 1),
-  }) : _capacity = capacity,
-       _refillRate = refillRate,
-       _refillInterval = refillInterval;
+  })  : _capacity = capacity,
+        _refillRate = refillRate,
+        _refillInterval = refillInterval;
 
   @override
   bool allowRequest(String key) {
@@ -36,29 +36,31 @@ class TokenBucketRateLimiter implements RateLimiter {
   DateTime? getResetTime(String key) {
     final bucket = _getBucket(key);
     if (bucket.tokens >= _capacity) return null;
-    
+
     final tokensNeeded = _capacity - bucket.tokens;
     final timeToRefill = Duration(
-      milliseconds: (_refillInterval.inMilliseconds * tokensNeeded / _refillRate).round()
-    );
-    
+        milliseconds:
+            (_refillInterval.inMilliseconds * tokensNeeded / _refillRate)
+                .round());
+
     return bucket.lastRefill.add(timeToRefill);
   }
 
   @override
   void cleanup() {
     final now = DateTime.now();
     final cutoff = now.subtract(Duration(hours: 1));
-    
+
     _buckets.removeWhere((key, bucket) => bucket.lastRefill.isBefore(cutoff));
   }
 
   _TokenBucket _getBucket(String key) {
     final bucket = _buckets[key];
     if (bucket == null) {
-      return _buckets[key] = _TokenBucket(_capacity, _refillRate, _refillInterval);
+      return _buckets[key] =
+          _TokenBucket(_capacity, _refillRate, _refillInterval);
     }
-    
+
     bucket._refill();
     return bucket;
   }
@@ -68,7 +70,7 @@ class _TokenBucket {
   final int capacity;
   final int refillRate;
   final Duration refillInterval;
-  
+
   int tokens;
   DateTime lastRefill;
 
@@ -88,11 +90,12 @@ class _TokenBucket {
   void _refill() {
     final now = DateTime.now();
     final timeSinceLastRefill = now.difference(lastRefill);
-    
+
     if (timeSinceLastRefill >= refillInterval) {
-      final intervalsElapsed = timeSinceLastRefill.inMilliseconds / refillInterval.inMilliseconds;
+      final intervalsElapsed =
+          timeSinceLastRefill.inMilliseconds / refillInterval.inMilliseconds;
       final tokensToAdd = (intervalsElapsed * refillRate).floor();
-      
+
       tokens = min(capacity, tokens + tokensToAdd);
       lastRefill = now;
     }

packages/pharaoh_rate_limit/test/sliding_window_test.dart

@@ -25,10 +25,10 @@ void main() {
       );
 
       expect(limiter.getRemainingRequests('test-key'), equals(2));
-      
+
       limiter.allowRequest('test-key');
       expect(limiter.getRemainingRequests('test-key'), equals(1));
-      
+
       limiter.allowRequest('test-key');
       expect(limiter.getRemainingRequests('test-key'), equals(0));
     });

packages/pharaoh_rate_limit/test/token_bucket_test.dart

@@ -27,13 +27,13 @@ void main() {
       );
 
       expect(limiter.getRemainingRequests('test-key'), equals(3));
-      
+
       limiter.allowRequest('test-key');
       expect(limiter.getRemainingRequests('test-key'), equals(2));
-      
+
       limiter.allowRequest('test-key');
       expect(limiter.getRemainingRequests('test-key'), equals(1));
-      
+
       limiter.allowRequest('test-key');
       expect(limiter.getRemainingRequests('test-key'), equals(0));
     });
@@ -106,7 +106,7 @@ void main() {
 
       // Cleanup should work without errors
       limiter.cleanup();
-      
+
       // Verify cleanup method exists and runs
       expect(limiter, isA<TokenBucketRateLimiter>());
     });