Add HTTP middleware for retry handling (#4)

* feat(http): add HTTP middleware for retry handling

* feat(examples): add router integration examples for chi and routegroup

* fix(http): address golangci-lint issues and nil pointer dereference

- Fix bodyclose linter warning by properly closing response body
- Handle error return values to satisfy errcheck linter
- Prevent nil pointer dereference by checking result.Body before Close()
- Fix formatting issues in examples

Author: flaticols

README.md

@@ -143,6 +143,60 @@ req, _ := http.NewRequest("GET", "https://api.example.com/data", nil)
 resp, err := ebo.HTTPDo(req, http.DefaultClient, ebo.API())
 ```
 
+### HTTP Middleware
+
+EBO provides HTTP middleware that automatically retries requests based on response codes.
+
+```go
+// Create a handler
+handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+    // Your API logic here
+})
+
+// Wrap with retry middleware (retries on 5xx and 429 by default)
+retryHandler := ebo.NewRetryMiddleware(handler, ebo.DefaultResponseChecker,
+    ebo.Initial(500*time.Millisecond),
+    ebo.Tries(5),
+    ebo.Jitter(0.3),
+)
+
+// Use with standard HTTP server
+http.ListenAndServe(":8080", retryHandler)
+
+// Or use the middleware function for router compatibility
+middleware := ebo.Middleware(ebo.DefaultResponseChecker, ebo.API())
+http.Handle("/api/", middleware(handler))
+
+// Custom response checker
+customChecker := func(resp *http.Response) bool {
+    return resp.StatusCode >= 500 || resp.StatusCode == 404
+}
+customMiddleware := ebo.Middleware(customChecker, ebo.Quick())
+```
+
+### Router Integration
+
+EBO's middleware works seamlessly with popular Go routers:
+
+```go
+// Chi router
+import "github.com/go-chi/chi/v5"
+
+r := chi.NewRouter()
+r.Use(ebo.Middleware(ebo.DefaultResponseChecker, ebo.API()))
+r.Get("/api/users", usersHandler)
+
+// RouteGroup
+import "github.com/go-pkgz/routegroup"
+
+router := routegroup.New(http.NewServeMux())
+apiGroup := router.Group()
+apiGroup.Use(ebo.Middleware(ebo.DefaultResponseChecker, ebo.Quick()))
+apiGroup.HandleFunc("GET /api/data", dataHandler)
+```
+
+See [examples/router-integration](examples/router-integration) for complete examples with chi and routegroup.
+
 ## Iterator Pattern (Go 1.23+)
 
 EBO now supports the new Go iterator pattern for more flexible and elegant retry loops.

doc.go

@@ -27,13 +27,13 @@
 //
 //	// Quick retries for fast operations
 //	err := ebo.Retry(checkCache, ebo.Quick())
-//	
+//
 //	// API calls with moderate retry
 //	err := ebo.Retry(callAPI, ebo.API())
-//	
+//
 //	// Database operations with longer timeouts
 //	err := ebo.Retry(connectDB, ebo.Database())
-//	
+//
 //	// HTTP requests with status code awareness
 //	client := ebo.NewHTTPClient(ebo.HTTPStatus())
 //
@@ -46,4 +46,4 @@
 //   - Iterator pattern for stateful retries (using Go 1.23+ iter package)
 //
 // For more examples and documentation, visit https://github.com/flaticols/ebo
-package ebo
+package ebo

example_doc_test.go

@@ -15,7 +15,7 @@ func ExampleRetry() {
 		fmt.Println("Attempting operation...")
 		return errors.New("temporary failure")
 	}, ebo.Tries(1))
-	
+
 	if err != nil {
 		fmt.Printf("Operation failed: %v\n", err)
 	}
@@ -33,7 +33,7 @@ func ExampleQuickRetry() {
 		}
 		return nil
 	})
-	
+
 	if err == nil {
 		fmt.Println("Success after", attempts, "attempts")
 	}
@@ -44,12 +44,12 @@ func ExampleQuickRetry() {
 func ExampleRetryWithContext() {
 	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
 	defer cancel()
-	
+
 	err := ebo.RetryWithContext(ctx, func() error {
 		fmt.Println("Trying with context...")
 		return nil
 	}, ebo.Initial(100*time.Millisecond))
-	
+
 	if err == nil {
 		fmt.Println("Success!")
 	}
@@ -84,12 +84,12 @@ func ExampleInitial() {
 	// Show configuration with Initial option
 	err := ebo.Retry(func() error {
 		return nil
-	}, 
+	},
 		ebo.Initial(1*time.Second),
 		ebo.Tries(3),
 		ebo.NoJitter(),
 	)
-	
+
 	if err == nil {
 		fmt.Println("Configured successfully")
 	}
@@ -103,7 +103,7 @@ func ExampleAPI() {
 		fmt.Println("Using API preset")
 		return nil
 	}, ebo.API())
-	
+
 	if err == nil {
 		fmt.Println("API preset works")
 	}
@@ -114,7 +114,7 @@ func ExampleAPI() {
 
 func ExampleRetryWithLogging() {
 	logger := log.New(log.Writer(), "[RETRY] ", 0)
-	
+
 	attempts := 0
 	err := ebo.RetryWithLogging(func() error {
 		attempts++
@@ -123,10 +123,10 @@ func ExampleRetryWithLogging() {
 		}
 		return nil
 	}, logger, ebo.Tries(3), ebo.Initial(10*time.Millisecond))
-	
+
 	if err == nil {
 		fmt.Println("Success with logging")
 	}
 	// Output:
 	// Success with logging
-}
+}

example_test.go

@@ -1,16 +1,16 @@
 package ebo
 
 import (
-	"fmt"
 	"errors"
+	"fmt"
 	"net/http"
 	"time"
 )
 
 func ExampleRetry() {
 	// Example: Retry an HTTP request with custom options
 	var response *http.Response
-	
+
 	err := Retry(func() error {
 		resp, err := http.Get("https://api.example.com/data")
 		if err != nil {
@@ -33,7 +33,7 @@ func ExampleRetry() {
 		fmt.Printf("Failed after retries: %v\n", err)
 		return
 	}
-	
+
 	defer func() { _ = response.Body.Close() }()
 	// Process response...
 }
@@ -48,7 +48,7 @@ func ExampleRetry_withTimeout() {
 		MaxTime(5*time.Second),
 		Tries(0), // No retry limit, only time limit
 	)
-	
+
 	if err != nil {
 		fmt.Printf("Operation failed within timeout: %v\n", err)
 	}
@@ -63,9 +63,9 @@ func ExampleRetry_customBackoff() {
 		Initial(100*time.Millisecond),
 		Max(10*time.Second),
 		Multiplier(3.0), // Triple the interval each time
-		Jitter(0), // No jitter
+		Jitter(0),       // No jitter
 	)
-	
+
 	if err != nil {
 		fmt.Printf("Operation failed: %v\n", err)
 	}
@@ -77,7 +77,7 @@ func ExampleQuickRetry() {
 		// Your operation here
 		return errors.New("temporary failure")
 	})
-	
+
 	if err != nil {
 		fmt.Printf("Operation failed: %v\n", err)
 	}
@@ -89,7 +89,7 @@ func ExampleRetryWithBackoff() {
 		// Your operation here
 		return nil
 	}, 3)
-	
+
 	if err != nil {
 		fmt.Printf("Failed after 3 attempts: %v\n", err)
 	}
@@ -98,38 +98,38 @@ func ExampleRetryWithBackoff() {
 func ExampleOption() {
 	// Example: Creating reusable option sets
 	fastRetryOptions := []Option{
-		Initial(50*time.Millisecond),
-		Max(500*time.Millisecond),
+		Initial(50 * time.Millisecond),
+		Max(500 * time.Millisecond),
 		Tries(3),
 		Multiplier(2.0),
 	}
-	
+
 	robustRetryOptions := []Option{
-		Initial(1*time.Second),
-		Max(1*time.Minute),
+		Initial(1 * time.Second),
+		Max(1 * time.Minute),
 		Tries(10),
 		Multiplier(2.0),
 		Jitter(0.5),
-		MaxTime(10*time.Minute),
+		MaxTime(10 * time.Minute),
 	}
-	
+
 	// Use fast retry for quick operations
 	err := Retry(func() error {
 		// Quick operation
 		return nil
 	}, fastRetryOptions...)
-	
+
 	if err != nil {
 		fmt.Printf("Fast retry failed: %v\n", err)
 	}
-	
+
 	// Use robust retry for critical operations
 	err = Retry(func() error {
 		// Critical operation
 		return nil
 	}, robustRetryOptions...)
-	
+
 	if err != nil {
 		fmt.Printf("Robust retry failed: %v\n", err)
 	}
-}
+}