Update examples to use simplified API and fix linting issues

- Updated all examples to use new config-based API instead of removed builder methods
- Fixed compression examples to use WithCompression(&compression.Config{...})
- Fixed redis examples to use WithRedis(&obcache.RedisConfig{...})
- Fixed metrics examples to use WithMetrics(&obcache.MetricsConfig{...})
- Removed deprecated WithContext usage from examples
- Fixed context parameter ordering in cache hit/miss functions
- Removed unused test functions and imports
- Cleaned up unused parameters in wrap functions

All examples now compile and run correctly with the simplified API.
All linting checks pass.

Author: vnykmshr

examples/advanced_hooks_example.go

@@ -127,29 +127,24 @@ func demonstrateHookComposition() {
 func testScenario1(cache *obcache.Cache) {
 	fmt.Println("\n--- Scenario 1: Metrics key with production context ---")
 
-	prodCtx := context.WithValue(context.Background(), "env", "production")
 	key := "metrics:api_requests"
 
 	// Set and get to trigger hooks
 	_ = cache.Set(key, 150, time.Hour)
-	_, _ = cache.Get(key, obcache.WithContext(prodCtx))
+	_, _ = cache.Get(key)
 
 	// Test miss scenario
-	_, _ = cache.Get("metrics:missing_key", obcache.WithContext(prodCtx))
+	_, _ = cache.Get("metrics:missing_key")
 }
 
 func testScenario2(cache *obcache.Cache) {
 	fmt.Println("\n--- Scenario 2: Debug key with debug context ---")
 
-	debugCtx := context.WithValue(
-		context.WithValue(context.Background(), "debug", true),
-		"env", "staging",
-	)
 	key := "debug:session_data"
 
 	// Set and get to trigger hooks
 	_ = cache.Set(key, map[string]string{"user": "alice", "session": "abc123"}, time.Hour)
-	_, _ = cache.Get(key, obcache.WithContext(debugCtx))
+	_, _ = cache.Get(key)
 }
 
 func testScenario3(cache *obcache.Cache) {

examples/basic/basic

@@ -120,12 +120,15 @@ func noCompressionExample() {
 
 func gzipCompressionExample() {
 	// Create cache with gzip compression
-	cache, err := obcache.New(obcache.NewDefaultConfig().
+	config := obcache.NewDefaultConfig().
 		WithMaxEntries(100).
-		WithCompressionEnabled(true).
-		WithCompressionAlgorithm(compression.CompressorGzip).
-		WithCompressionMinSize(500). // Compress values larger than 500 bytes
-		WithCompressionLevel(6))     // Balanced compression level
+		WithCompression(&compression.Config{
+			Enabled:   true,
+			Algorithm: compression.CompressorGzip,
+			MinSize:   500, // Compress values larger than 500 bytes
+			Level:     6,   // Balanced compression level
+		})
+	cache, err := obcache.New(config)
 	if err != nil {
 		log.Fatalf("Failed to create cache: %v", err)
 	}
@@ -171,12 +174,15 @@ func gzipCompressionExample() {
 
 func deflateCompressionExample() {
 	// Create cache with deflate compression
-	cache, err := obcache.New(obcache.NewDefaultConfig().
+	config := obcache.NewDefaultConfig().
 		WithMaxEntries(100).
-		WithCompressionEnabled(true).
-		WithCompressionAlgorithm(compression.CompressorDeflate).
-		WithCompressionMinSize(1000). // Higher threshold
-		WithCompressionLevel(9))      // Maximum compression
+		WithCompression(&compression.Config{
+			Enabled:   true,
+			Algorithm: compression.CompressorDeflate,
+			MinSize:   1000, // Higher threshold
+			Level:     9,    // Maximum compression
+		})
+	cache, err := obcache.New(config) // Maximum compression
 	if err != nil {
 		log.Fatalf("Failed to create cache: %v", err)
 	}
@@ -212,11 +218,14 @@ func compressionThresholdExample() {
 	for _, minSize := range testSizes {
 		fmt.Printf("\n  Testing with minimum size: %d bytes\n", minSize)
 
-		cache, err := obcache.New(obcache.NewDefaultConfig().
+		config := obcache.NewDefaultConfig().
 			WithMaxEntries(50).
-			WithCompressionEnabled(true).
-			WithCompressionAlgorithm(compression.CompressorGzip).
-			WithCompressionMinSize(minSize))
+			WithCompression(&compression.Config{
+				Enabled:   true,
+				Algorithm: compression.CompressorGzip,
+				MinSize:   minSize,
+			})
+		cache, err := obcache.New(config)
 		if err != nil {
 			log.Printf("Failed to create cache: %v", err)
 			continue
@@ -274,11 +283,14 @@ func performanceComparisonExample() {
 	fmt.Printf("  Testing %d operations with gzip compression...\n", iterations)
 	start = time.Now()
 
-	compressedCache, _ := obcache.New(obcache.NewDefaultConfig().
+	config := obcache.NewDefaultConfig().
 		WithMaxEntries(200).
-		WithCompressionEnabled(true).
-		WithCompressionAlgorithm(compression.CompressorGzip).
-		WithCompressionMinSize(1000))
+		WithCompression(&compression.Config{
+			Enabled:   true,
+			Algorithm: compression.CompressorGzip,
+			MinSize:   1000,
+		})
+	compressedCache, _ := obcache.New(config)
 
 	for i := 0; i < iterations; i++ {
 		key := fmt.Sprintf("test_%d", i)

examples/compression/main.go

@@ -84,8 +84,12 @@ func prometheusExample() {
 
 	// Create cache with Prometheus metrics
 	cacheConfig := obcache.NewDefaultConfig().
-		WithDefaultTTL(5*time.Minute).
-		WithMetricsExporter(prometheusExporter, "user-cache")
+		WithDefaultTTL(5 * time.Minute).
+		WithMetrics(&obcache.MetricsConfig{
+			Exporter:  prometheusExporter,
+			Enabled:   true,
+			CacheName: "user-cache",
+		})
 
 	cache, err := obcache.New(cacheConfig)
 	if err != nil {
@@ -158,9 +162,12 @@ func opentelemetryExample() {
 
 	// Create cache with OpenTelemetry metrics
 	cacheConfig := obcache.NewDefaultConfig().
-		WithDefaultTTL(10*time.Minute).
-		WithMetricsExporter(otelExporter, "product-cache").
-		WithMetricsReportingInterval(5 * time.Second)
+		WithDefaultTTL(10 * time.Minute).
+		WithMetrics(&obcache.MetricsConfig{
+			Exporter:  otelExporter,
+			Enabled:   true,
+			CacheName: "product-cache",
+		})
 
 	cache, err := obcache.New(cacheConfig)
 	if err != nil {
@@ -226,10 +233,14 @@ func multiExporterExample() {
 
 	// Create cache with multi-exporter
 	cacheConfig := obcache.NewDefaultConfig().
-		WithMetricsExporter(multiExporter, "multi-cache").
-		WithMetricsLabels(metrics.Labels{
-			"component": "multi-example",
-			"tier":      "cache",
+		WithMetrics(&obcache.MetricsConfig{
+			Exporter:  multiExporter,
+			Enabled:   true,
+			CacheName: "multi-cache",
+			Labels: metrics.Labels{
+				"component": "multi-example",
+				"tier":      "cache",
+			},
 		})
 
 	cache, err := obcache.New(cacheConfig)

examples/metrics/main.go

@@ -52,7 +52,9 @@ func main() {
 func basicRedisExample() {
 	// Create a Redis cache with simple address
 	config := obcache.NewRedisConfig("localhost:6379").
-		WithRedisKeyPrefix("example:").
+		WithRedis(&obcache.RedisConfig{
+			KeyPrefix: "example:",
+		}).
 		WithDefaultTTL(30 * time.Minute)
 
 	cache, err := obcache.New(config)
@@ -87,7 +89,9 @@ func basicRedisExample() {
 func functionWrappingExample() {
 	// Create Redis cache configuration
 	config := obcache.NewRedisConfig("localhost:6379").
-		WithRedisKeyPrefix("func:").
+		WithRedis(&obcache.RedisConfig{
+			KeyPrefix: "func:",
+		}).
 		WithDefaultTTL(15 * time.Minute)
 
 	cache, err := obcache.New(config)
@@ -151,7 +155,9 @@ func distributedCachingExample() {
 
 	// Create cache configuration with the custom client
 	config := obcache.NewRedisConfigWithClient(client).
-		WithRedisKeyPrefix("distributed:").
+		WithRedis(&obcache.RedisConfig{
+			KeyPrefix: "distributed:",
+		}).
 		WithDefaultTTL(1 * time.Hour)
 
 	cache, err := obcache.New(config)

examples/redis-cache/main.go

@@ -19,7 +19,6 @@ import (
 	"github.com/vnykmshr/obcache-go/pkg/metrics"
 )
 
-
 func (c *Cache) rlock(fn func()) {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
@@ -32,14 +31,14 @@ func (c *Cache) lock(fn func()) {
 	fn()
 }
 
-func (c *Cache) hit(key string, value any, ctx context.Context) {
+func (c *Cache) hit(ctx context.Context, key string, value any) {
 	c.stats.incHits()
 	if c.hooks != nil {
 		c.hooks.invokeOnHitWithCtx(ctx, key, value, nil)
 	}
 }
 
-func (c *Cache) miss(key string, ctx context.Context) {
+func (c *Cache) miss(ctx context.Context, key string) {
 	c.stats.incMisses()
 	if c.hooks != nil {
 		c.hooks.invokeOnMissWithCtx(ctx, key, nil)
@@ -212,17 +211,17 @@ func (c *Cache) Get(key string) (any, bool) {
 	c.rlock(func() {
 		entry, ok := c.store.Get(key)
 		if !ok {
-			c.miss(key, ctx)
+			c.miss(ctx, key)
 			return
 		}
 
 		value, err := c.decompressValue(entry)
 		if err != nil {
-			c.miss(key, ctx)
+			c.miss(ctx, key)
 			return
 		}
 
-		c.hit(key, value, ctx)
+		c.hit(ctx, key, value)
 		result = value
 		found = true
 	})

pkg/obcache/cache.go

@@ -265,30 +265,6 @@ func TestLoggingHooksIntegration(t *testing.T) {
 	}
 }
 
-func testLoggingWithContext(t *testing.T) { // Disabled: context API was simplified
-	testLogger := NewTestLogger()
-	hooks := CreateLoggingHooks(&LoggingConfig{
-		Logger:       testLogger,
-		LogCacheHits: true,
-	})
-
-	cache, err := New(NewDefaultConfig().WithHooks(hooks))
-	if err != nil {
-		t.Fatalf("Failed to create cache: %v", err)
-	}
-
-	// Set value and get with context
-	_ = cache.Set("user-key", "user-data", time.Hour)
-
-	// Test basic cache operation logging
-	_, _ = cache.Get("user-key")
-
-	// Verify logging occurred (context features were simplified in API)
-	if !testLogger.HasLogWithMessage("Cache miss") {
-		t.Error("Expected cache operation to be logged")
-	}
-}
-
 func TestLoggingHookBuilder(t *testing.T) {
 	// Test fluent builder interface
 	hooks := NewLoggingHookBuilder().

pkg/obcache/logging_test.go

@@ -105,7 +105,7 @@ func wrapFunction[T any](cache *Cache, fn T, opts *WrapOptions) T {
 
 // executeWrappedFunction handles the core wrapping logic
 func executeWrappedFunction(cache *Cache, fnValue reflect.Value, fnType reflect.Type, opts *WrapOptions, args []reflect.Value) []reflect.Value {
-	ctx, keyArgs := extractContextAndArgs(fnType, args)
+	_, keyArgs := extractContextAndArgs(fnType, args)
 	key := opts.KeyFunc(keyArgs)
 
 	// If caching is disabled, call original function directly
@@ -120,7 +120,7 @@ func executeWrappedFunction(cache *Cache, fnValue reflect.Value, fnType reflect.
 		return convertCachedValue(cachedValue, fnType, hasErrorReturn)
 	}
 
-	return executeFunctionWithSingleflight(cache, fnValue, fnType, opts, args, ctx, keyArgs, key, hasErrorReturn)
+	return executeFunctionWithSingleflight(cache, fnValue, fnType, opts, args, key, hasErrorReturn)
 }
 
 // extractContextAndArgs extracts context and key args from function arguments
@@ -155,7 +155,7 @@ func hasErrorReturn(fnType reflect.Type) bool {
 }
 
 // executeFunctionWithSingleflight executes the function with singleflight pattern
-func executeFunctionWithSingleflight(cache *Cache, fnValue reflect.Value, fnType reflect.Type, opts *WrapOptions, args []reflect.Value, ctx context.Context, keyArgs []any, key string, hasErrorReturn bool) []reflect.Value {
+func executeFunctionWithSingleflight(cache *Cache, fnValue reflect.Value, fnType reflect.Type, opts *WrapOptions, args []reflect.Value, key string, hasErrorReturn bool) []reflect.Value {
 	// Use singleflight to prevent duplicate calls
 	compute := func() (any, error) {
 		results := fnValue.Call(args)

pkg/obcache/wrap.go

@@ -1,7 +1,6 @@
 package obcache
 
 import (
-	"context"
 	"errors"
 	"fmt"
 	"sync"
@@ -413,87 +412,6 @@ func TestWrapConvenienceFunctions(t *testing.T) {
 	}
 }
 
-func testWrapContextAwareFunctions(t *testing.T) { // Disabled: context API was simplified
-	// Test context-aware wrapped functions with hooks
-	var hitCtx context.Context
-	var hitArgs []any
-	var missCtx context.Context
-	var missArgs []any
-
-	hooks := &Hooks{}
-	hooks.AddOnHitCtx(func(ctx context.Context, _ string, _ any, args []any) {
-		hitCtx = ctx
-		hitArgs = args
-	})
-	hooks.AddOnMissCtx(func(ctx context.Context, _ string, args []any) {
-		missCtx = ctx
-		missArgs = args
-	})
-
-	cache, err := New(NewDefaultConfig().WithHooks(hooks))
-	if err != nil {
-		t.Fatalf("Failed to create cache: %v", err)
-	}
-
-	// Test function with context.Context as first parameter
-	callCount := int32(0)
-	contextFunc := func(_ context.Context, x int) int {
-		atomic.AddInt32(&callCount, 1)
-		return x * 2
-	}
-
-	wrappedCtxFunc := Wrap(cache, contextFunc)
-
-	// Create context with test value
-	type testKey string
-	ctx := context.WithValue(context.Background(), testKey("testKey"), "testValue")
-
-	// First call - should miss and call original function
-	result1 := wrappedCtxFunc(ctx, 5)
-	if result1 != 10 {
-		t.Fatalf("Expected result 10, got %d", result1)
-	}
-	if callCount != 1 {
-		t.Fatalf("Expected function to be called once, called %d times", callCount)
-	}
-
-	// Check miss hook was called with correct context and args
-	if missCtx != ctx {
-		t.Fatal("Miss hook should have received the context")
-	}
-	if len(missArgs) != 1 || missArgs[0] != 5 {
-		t.Fatalf("Expected args [5], got %v", missArgs)
-	}
-
-	// Second call - should hit cache
-	result2 := wrappedCtxFunc(ctx, 5)
-	if result2 != 10 {
-		t.Fatalf("Expected cached result 10, got %d", result2)
-	}
-	if callCount != 1 {
-		t.Fatalf("Expected function to be called only once, called %d times", callCount)
-	}
-
-	// Check hit hook was called with correct context and args
-	if hitCtx != ctx {
-		t.Fatal("Hit hook should have received the context")
-	}
-	if len(hitArgs) != 1 || hitArgs[0] != 5 {
-		t.Fatalf("Expected args [5], got %v", hitArgs)
-	}
-
-	// Test function without context (should still work)
-	normalFunc := func(x int) int {
-		return x * 3
-	}
-	wrappedNormalFunc := Wrap(cache, normalFunc)
-
-	result3 := wrappedNormalFunc(4)
-	if result3 != 12 {
-		t.Fatalf("Expected result 12, got %d", result3)
-	}
-}
-
 //nolint:gocyclo // Test function complexity is acceptable
 func TestErrorCaching(t *testing.T) {
 	cache, err := New(NewDefaultConfig())