context.go

@@ -1,12 +1,8 @@
 package router
 
 import (
-	"bytes"
 	"encoding/json"
-	"io"
-	"net"
 	"net/http"
-	"strings"
 
 	"github.com/julienschmidt/httprouter"
 )
@@ -20,29 +16,11 @@ type Context struct {
 	store    map[string]interface{}
 }
 
-// NewContext creates a new context, this function is only exported for use in tests
+func newContext(router *Router, res http.ResponseWriter, req *http.Request, param httprouter.Params) *Context {
-func NewContext(router *Router, res http.ResponseWriter, req *http.Request, param httprouter.Params) *Context {
 	return &Context{router, req, res, param.ByName, make(map[string]interface{})}
 }
 
-// QueryParam returns the specified parameter from the query string.
+// String returns the given status code and writes the bytes to the body
-// Returns an empty string if it doesn't exist. Returns the first parameter if multiple instances exist
-func (c *Context) QueryParam(param string) string {
-	params := c.Request.URL.Query()[param]
-	if params == nil {
-		return ``
-	}
-
-	return params[0]
-}
-
-// Redirect sends a redirect to the client
-func (c *Context) Redirect(code int, url string) error {
-	http.Redirect(c.Response, c.Request, url, code)
-	return nil
-}
-
-// Bytes returns the given status code and writes the bytes to the body
 func (c *Context) Bytes(code int, b []byte) error {
 	c.Response.WriteHeader(code)
 	_, err := c.Response.Write(b)
@@ -70,35 +48,19 @@ func (c *Context) NoContent(code int) error {
 
 // JSON returns the given status code and writes JSON to the body
 func (c *Context) JSON(code int, data interface{}) error {
-	// write to buffer first in case of error
-	var buf bytes.Buffer
-	err := json.NewEncoder(&buf).Encode(data)
-	if err != nil {
-		return err
-	}
-
 	c.Response.Header().Set(`Content-Type`, `application/json`)
 	c.Response.WriteHeader(code)
-	_, err = io.Copy(c.Response, &buf)
+	return json.NewEncoder(c.Response).Encode(data) // TODO: Encode to buffer first to prevent partial responses on error
-	return err
 }
 
-// Render renders a templating using the Renderer set in router
 func (c *Context) Render(code int, template string, data interface{}) error {
 	if c.router.Renderer == nil {
 		panic(`Cannot call render without a renderer set`)
 	}
 
-	var b bytes.Buffer
-	err := c.router.Renderer.Render(&b, template, data, c)
-	if err != nil {
-		return err
-	}
-
 	c.Response.Header().Set(`Content-Type`, `text/html`)
 	c.Response.WriteHeader(code)
-	_, _ = io.Copy(c.Response, &b)
+	return c.router.Renderer.Render(c.Response, template, data, c)
-	return nil
 }
 
 // Set sets a value in the context. Set is not safe to be used concurrently
@@ -110,20 +72,3 @@ func (c *Context) Set(key string, value interface{}) {
 func (c *Context) Get(key string) interface{} {
 	return c.store[key]
 }
-
-// RealIP uses proxy headers for the real ip, if none exist the IP of the current connection is returned
-func (c *Context) RealIP() string {
-	reqIP := c.Request.RemoteAddr
-
-	if ip := c.Request.Header.Get(`X-Forwarded-For`); ip != `` {
-		reqIP = strings.Split(ip, `, `)[0]
-	} else if ip := c.Request.Header.Get(`X-Real-IP`); ip != `` {
-		reqIP = ip
-	}
-
-	ra, _, _ := net.SplitHostPort(reqIP)
-	if ra != `` {
-		reqIP = ra
-	}
-	return reqIP
-}

default.go

@@ -13,7 +13,7 @@ func defaultMethodNotAllowedHandler(c *Context) error {
 	return c.StatusText(http.StatusMethodNotAllowed)
 }
 
-func defaultErrorHandler(c *Context, _ interface{}) {
+func defaultErrorHandler(c *Context, err interface{}) {
 	_ = c.StatusText(http.StatusInternalServerError)
 }
 

go.mod

@@ -1,5 +0,0 @@
-module git.fuyu.moe/Fuyu/router
-
-go 1.22.0
-
-require github.com/julienschmidt/httprouter v1.3.0

go.sum

@@ -1,2 +0,0 @@
-github.com/julienschmidt/httprouter v1.3.0 h1:U0609e9tgbseu3rBINet9P48AI/D3oJs4dN7jwJOQ1U=
-github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=

group.go

@@ -1,9 +1,6 @@
 package router
 
-import (
+import urlpath "path"
-	urlpath "path"
-	"slices"
-)
 
 func join(prefix, path string) string {
 	return urlpath.Join(prefix, urlpath.Clean(path))
@@ -18,40 +15,40 @@ type Group struct {
 
 // Group creates a new router group with a shared prefix and set of middlewares
 func (g *Group) Group(prefix string, middleware ...Middleware) *Group {
-	return &Group{prefix: join(g.prefix, prefix), router: g.router, middleware: slices.Concat(g.middleware, middleware)}
+	return &Group{prefix: join(g.prefix, prefix), router: g.router, middleware: append(g.middleware, middleware...)}
 }
 
 // GET adds a GET route
 func (g *Group) GET(path string, handle Handle, middleware ...Middleware) {
-	g.router.GET(join(g.prefix, path), handle, slices.Concat(g.middleware, middleware)...)
+	g.router.GET(join(g.prefix, path), handle, append(g.middleware, middleware...)...)
 }
 
 // POST adds a POST route
 func (g *Group) POST(path string, handle interface{}, middleware ...Middleware) {
-	g.router.POST(join(g.prefix, path), handle, slices.Concat(g.middleware, middleware)...)
+	g.router.POST(join(g.prefix, path), handle, append(g.middleware, middleware...)...)
 }
 
 // DELETE adds a DELETE route
 func (g *Group) DELETE(path string, handle Handle, middleware ...Middleware) {
-	g.router.DELETE(join(g.prefix, path), handle, slices.Concat(g.middleware, middleware)...)
+	g.router.DELETE(join(g.prefix, path), handle, append(g.middleware, middleware...)...)
 }
 
 // PUT adds a PUT route
 func (g *Group) PUT(path string, handle interface{}, middleware ...Middleware) {
-	g.router.PUT(join(g.prefix, path), handle, slices.Concat(g.middleware, middleware)...)
+	g.router.PUT(join(g.prefix, path), handle, append(g.middleware, middleware...)...)
 }
 
 // PATCH adds a PATCH route
 func (g *Group) PATCH(path string, handle interface{}, middleware ...Middleware) {
-	g.router.PATCH(join(g.prefix, path), handle, slices.Concat(g.middleware, middleware)...)
+	g.router.PATCH(join(g.prefix, path), handle, append(g.middleware, middleware...)...)
 }
 
 // HEAD adds a HEAD route
 func (g *Group) HEAD(path string, handle Handle, middleware ...Middleware) {
-	g.router.HEAD(join(g.prefix, path), handle, slices.Concat(g.middleware, middleware)...)
+	g.router.HEAD(join(g.prefix, path), handle, append(g.middleware, middleware...)...)
 }
 
 // OPTIONS adds a OPTIONS route
 func (g *Group) OPTIONS(path string, handle Handle, middleware ...Middleware) {
-	g.router.OPTIONS(join(g.prefix, path), handle, slices.Concat(g.middleware, middleware)...)
+	g.router.OPTIONS(join(g.prefix, path), handle, append(g.middleware, middleware...)...)
 }

router.go

@@ -1,13 +1,8 @@
 package router
 
 import (
-	"context"
-	"crypto/tls"
-	"errors"
 	"net/http"
 	"reflect"
-	"slices"
-	"time"
 
 	"github.com/julienschmidt/httprouter"
 )
@@ -28,7 +23,7 @@ type ErrorHandle func(*Context, interface{})
 // Middleware is a function that runs before your route, it gets the next handler as a parameter
 type Middleware func(Handle) Handle
 
-// Reader reads input to dst, returns true if successful
+// Binder reads input to dst, returns true is successful
 type Reader func(c *Context, dst interface{}) (bool, error)
 
 // Router is the router itself
@@ -40,18 +35,11 @@ type Router struct {
 	NotFoundHandler         Handle
 	MethodNotAllowedHandler Handle
 	ErrorHandler            ErrorHandle
-	TrimTrailingSlashes     bool
-	server                  *http.Server
 }
 
 // New returns a new Router
 func New() *Router {
-	return &Router{
+	return &Router{Reader: defaultReader, NotFoundHandler: defaultNotFoundHandler, MethodNotAllowedHandler: defaultMethodNotAllowedHandler, ErrorHandler: defaultErrorHandler}
-		Reader:                  defaultReader,
-		NotFoundHandler:         defaultNotFoundHandler,
-		MethodNotAllowedHandler: defaultMethodNotAllowedHandler,
-		ErrorHandler:            defaultErrorHandler,
-	}
 }
 
 // Use adds a global middleware
@@ -106,36 +94,10 @@ func (r *Router) OPTIONS(path string, handle Handle, middleware ...Middleware) {
 func (r *Router) Start(addr string) error {
 	httpr := r.getHttpr()
 
-	r.server = &http.Server{Addr: addr, Handler: httpr}
+	return http.ListenAndServe(addr, httpr)
-	return r.server.ListenAndServe()
 }
 
-// StartTLS starts a TLS web server using the given key, cert and config and binds to the given address
+func (r *Router) getHttpr() *httprouter.Router {
-func (r *Router) StartTLS(addr, certFile, keyFile string, conf *tls.Config) error {
-	httpr := r.getHttpr()
-
-	r.server = &http.Server{Addr: addr, Handler: httpr, TLSConfig: conf}
-	return r.server.ListenAndServeTLS(certFile, keyFile)
-}
-
-// Stop stops the web server
-func (r *Router) Stop() error {
-	if r.server == nil {
-		return nil
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
-	defer cancel()
-	err := r.server.Shutdown(ctx)
-	if errors.Is(err, context.DeadlineExceeded) {
-		err = r.server.Close()
-	}
-	r.server = nil
-
-	return err
-}
-
-func (r *Router) getHttpr() http.Handler {
 	httpr := httprouter.New()
 
 	for _, v := range r.routes {
@@ -144,9 +106,7 @@ func (r *Router) getHttpr() http.Handler {
 			handle = handlePOST(r, v.Handle)
 		}
 
-		httpr.Handle(v.Method, v.Path, handleReq(r, handle,
+		httpr.Handle(v.Method, v.Path, handleReq(r, handle, append(r.middleware, v.Middleware...)))
-			slices.Concat(r.middleware, v.Middleware),
-		))
 	}
 
 	httpr.NotFound = http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
@@ -158,25 +118,20 @@ func (r *Router) getHttpr() http.Handler {
 	})
 
 	httpr.PanicHandler = func(res http.ResponseWriter, req *http.Request, err interface{}) {
-		c := NewContext(r, res, req, nil)
+		c := newContext(r, res, req, nil)
 		r.ErrorHandler(c, err)
 	}
 
-	if r.TrimTrailingSlashes {
-		httpr.RedirectTrailingSlash = false
-
-		return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-			l := len(req.URL.Path)
-			if l > 1 && req.URL.Path[l-1] == '/' {
-				req.URL.Path = req.URL.Path[:l-1]
-			}
-			httpr.ServeHTTP(w, req)
-		})
-	}
-
 	return httpr
 }
 
+func handleErr(errHandler ErrorHandle, err interface{}) Handle {
+	return func(c *Context) error {
+		errHandler(c, err)
+		return nil
+	}
+}
+
 func checkInterfaceHandle(f interface{}) {
 	if _, ok := f.(Handle); ok {
 		return
@@ -199,6 +154,8 @@ func checkInterfaceHandle(f interface{}) {
 	if rt.In(0) != reflect.TypeOf(&Context{}) {
 		panic(`handle should accept Context as first argument`)
 	}
+
+	return
 }
 
 func handlePOST(r *Router, f interface{}) Handle {
@@ -209,7 +166,7 @@ func handlePOST(r *Router, f interface{}) Handle {
 
 		if r.Reader != nil {
 			ok, err := r.Reader(c, data.Interface())
-			_ = c.Request.Body.Close()
+			c.Request.Body.Close()
 			if err != nil {
 				return err
 			}
@@ -229,14 +186,15 @@ func handlePOST(r *Router, f interface{}) Handle {
 
 func handleReq(r *Router, handle Handle, m []Middleware) httprouter.Handle {
 	return func(res http.ResponseWriter, req *http.Request, param httprouter.Params) {
-		c := NewContext(r, res, req, param)
+		c := newContext(r, res, req, param)
 
 		f := handle
-		for i := len(m) - 1; i >= 0; i-- {
+		for i := len(m) - 1; i >= 0; i-- { // TODO: 1,2,3 of 3,2,1
 			f = m[i](f)
 		}
 
 		err := f(c)
+
 		if err != nil {
 			r.ErrorHandler(c, err)
 		}

type.go

@@ -4,7 +4,6 @@ import (
 	"io"
 )
 
-// Renderer renders a template
 type Renderer interface {
 	Render(w io.Writer, template string, data interface{}, c *Context) error
 }