Feat/cache (#72)

Author: cnlangzi

ext/cache/cache.go

@@ -0,0 +1,34 @@
+// Package cache provides HTTP caching middleware for xun web applications.
+// It allows setting Cache-Control headers based on configurable rules and paths.
+package cache
+
+import (
+	"strconv"
+
+	"github.com/yaitoo/xun"
+)
+
+// New creates a xun middleware that applies caching rules to HTTP responses.
+// It accepts optional configurations through Option functions and returns
+// a middleware that sets Cache-Control headers based on request URL paths.
+func New(opts ...Option) xun.Middleware { // skipcq: GO-R1005
+	options := &Options{}
+
+	for _, opt := range opts {
+		opt(options)
+	}
+
+	return func(next xun.HandleFunc) xun.HandleFunc {
+		return func(c *xun.Context) error {
+			// Apply caching rules based on request path
+			for _, rule := range options.Rules {
+				if rule.Match(c.Request.URL.Path) {
+					c.WriteHeader("Cache-Control", "public, max-age="+strconv.Itoa(int(rule.Duration.Seconds())))
+					break
+				}
+			}
+
+			return next(c)
+		}
+	}
+}

ext/cache/cache_test.go

@@ -0,0 +1,79 @@
+package cache
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"github.com/yaitoo/xun"
+)
+
+func TestCache(t *testing.T) {
+	mux := http.NewServeMux()
+	srv := httptest.NewServer(mux)
+	defer srv.Close()
+
+	app := xun.New(xun.WithMux(mux))
+
+	app.Use(New(Match("/starts", "", 1*time.Second),
+		Match("", "banner.jpg", 2*time.Second),
+		Match("/assets", "app.js", 3*time.Second)))
+
+	app.Get("/starts", func(c *xun.Context) error {
+		return c.View(nil)
+	})
+
+	app.Get("/banner.jpg", func(c *xun.Context) error {
+		return c.View(nil)
+	})
+
+	app.Get("/assets/app.js", func(c *xun.Context) error {
+		return c.View(nil)
+	})
+
+	app.Get("/assets/app.css", func(c *xun.Context) error {
+		return c.View(nil)
+	})
+
+	app.Get("/logo", func(c *xun.Context) error {
+		return c.View(nil)
+	})
+
+	resp, err := http.Get(srv.URL + "/starts")
+	require.NoError(t, err)
+	require.Equal(t, http.StatusOK, resp.StatusCode)
+
+	cacheControl := resp.Header.Get("Cache-Control")
+	require.Equal(t, "public, max-age=1", cacheControl)
+	resp.Body.Close()
+
+	resp, err = http.Get(srv.URL + "/banner.jpg")
+	require.NoError(t, err)
+	require.Equal(t, http.StatusOK, resp.StatusCode)
+	cacheControl = resp.Header.Get("Cache-Control")
+	require.Equal(t, "public, max-age=2", cacheControl)
+	resp.Body.Close()
+
+	resp, err = http.Get(srv.URL + "/assets/app.js")
+	require.NoError(t, err)
+	require.Equal(t, http.StatusOK, resp.StatusCode)
+	cacheControl = resp.Header.Get("Cache-Control")
+	require.Equal(t, "public, max-age=3", cacheControl)
+	resp.Body.Close()
+
+	resp, err = http.Get(srv.URL + "/assets/app.css")
+	require.NoError(t, err)
+	require.Equal(t, http.StatusOK, resp.StatusCode)
+	cacheControl = resp.Header.Get("Cache-Control")
+	require.Empty(t, cacheControl)
+	resp.Body.Close()
+
+	resp, err = http.Get(srv.URL + "/logo")
+	require.NoError(t, err)
+	require.Equal(t, http.StatusOK, resp.StatusCode)
+	cacheControl = resp.Header.Get("Cache-Control")
+	require.Empty(t, cacheControl)
+	resp.Body.Close()
+}

ext/cache/option.go

@@ -0,0 +1,67 @@
+package cache
+
+import (
+	"strings"
+	"time"
+)
+
+// Rule defines a caching rule with path matching criteria and cache duration.
+// It can match request paths by prefix, suffix, or both.
+type Rule struct {
+	StartsWith string        // Path prefix to match
+	EndsWith   string        // Path suffix to match
+	Duration   time.Duration // Cache duration to apply
+}
+
+// Match checks if the provided path matches the rule's criteria.
+// A path matches when it satisfies both StartsWith and EndsWith conditions.
+func (r *Rule) Match(path string) bool {
+	if r.StartsWith != "" && !hasPrefix(path, r.StartsWith) {
+		return false
+	}
+
+	if r.EndsWith != "" && !hasSuffix(path, r.EndsWith) {
+		return false
+	}
+
+	return true
+}
+
+// Options stores configuration for the cache middleware.
+type Options struct {
+	Rules []Rule // Collection of caching rules to apply
+}
+
+// Option is a function that configures the cache Options.
+type Option func(o *Options)
+
+// Match creates an Option that adds a new caching rule.
+// The rule matches paths that start with 'startsWith' and end with 'endsWith',
+// applying the specified cache duration.
+func Match(startsWith, endsWith string, duration time.Duration) Option {
+	return func(o *Options) {
+		if (startsWith != "" || endsWith != "") && duration > 0 {
+			o.Rules = append(o.Rules, Rule{
+				StartsWith: startsWith,
+				EndsWith:   endsWith,
+				Duration:   duration,
+			})
+		}
+	}
+}
+
+// hasPrefix checks if string s starts with prefix, ignoring case.
+func hasPrefix(s string, prefix string) bool {
+	if len(s) < len(prefix) {
+		return false
+	}
+	return strings.EqualFold(s[:len(prefix)], prefix)
+}
+
+// hasSuffix checks if string s ends with suffix, ignoring case.
+func hasSuffix(s string, suffix string) bool {
+	if len(s) < len(suffix) {
+		return false
+	}
+	return strings.EqualFold(s[len(s)-len(suffix):], suffix)
+}