feat(boards2): add pagination

examples/gno.land/r/demo/boards2/board.gno

@@ -7,9 +7,17 @@ import (
 	"time"
 
 	"gno.land/p/demo/avl"
+	"gno.land/p/demo/avl/pager"
 	"gno.land/p/moul/txlink"
 )
 
+const boardsPageSize = 50
+
+type Pagination struct {
+	PageNumber int
+	PageSize   int
+}
+
 type BoardID uint64
 
 func (id BoardID) String() string {
@@ -88,16 +96,32 @@ func (board *Board) DeleteThread(pid PostID) {
 	}
 }
 
-func (board *Board) Render() string {
-	s := "\\[" + newLink("post", board.GetPostFormURL()) + "]\n\n"
-	if board.threads.Size() > 0 {
-		board.threads.Iterate("", "", func(_ string, v interface{}) bool {
-			s += "----------------------------------------\n"
-			s += v.(*Post).RenderSummary() + "\n"
-			return false
-		})
+func (board *Board) Render(p Pagination) string {
+	var sb strings.Builder
+
+	sb.WriteString("\\[")
+	sb.WriteString(newLink("post", board.GetPostFormURL()))
+	sb.WriteString("]\n\n")
+	if board.threads.Size() == 0 {
+		sb.WriteString("*No posts*")
+		return sb.String()
 	}
-	return s
+
+	pg := pager.NewPager(&board.threads, p.PageSize)
+	page := pg.GetPage(p.PageNumber)
+	for _, v := range page.Items {
+		post := v.Value.(*Post)
+		sb.WriteString("----------------------------------------\n")
+		sb.WriteString(post.RenderSummary())
+		sb.WriteString("\n")
+	}
+
+	if page.TotalPages > 1 {
+		sb.WriteString("\n---\n\n")
+		sb.WriteString(page.Selector())
+	}
+
+	return sb.String()
 }
 
 func (board *Board) incGetPostID() PostID {

examples/gno.land/r/demo/boards2/gno.mod

@@ -2,6 +2,7 @@ module gno.land/r/demo/boards2
 
 require (
 	gno.land/p/demo/avl v0.0.0-latest
+	gno.land/p/demo/avl/pager v0.0.0-latest
 	gno.land/p/demo/boards2/admindao v0.0.0-latest
 	gno.land/p/demo/mux v0.0.0-latest
 	gno.land/p/demo/testutils v0.0.0-latest

examples/gno.land/r/demo/boards2/post.gno

@@ -4,9 +4,11 @@ import (
 	"errors"
 	"std"
 	"strconv"
+	"strings"
 	"time"
 
 	"gno.land/p/demo/avl"
+	"gno.land/p/demo/avl/pager"
 	"gno.land/p/moul/txlink"
 )
 
@@ -240,7 +242,7 @@ func (post *Post) RenderSummary() string {
 	return s
 }
 
-func (post *Post) Render(indent string, levels int) string {
+func (post *Post) Render(indent string, levels int, pagination *Pagination) string {
 	if post == nil {
 		return "nil post"
 	}
@@ -263,20 +265,48 @@ func (post *Post) Render(indent string, levels int) string {
 		s += " \\[" + newLink("repost", post.GetRepostFormURL()) + "]"
 	}
 	s += " \\[" + newLink("x", post.GetDeleteFormURL()) + "]\n"
+	s += post.renderReplies(indent, levels, pagination)
 
-	if levels > 0 {
-		if post.replies.Size() > 0 {
-			post.replies.Iterate("", "", func(_ string, value interface{}) bool {
-				s += indent + "\n"
-				s += value.(*Post).Render(indent+"> ", levels-1)
-				return false
-			})
-		}
-	} else if post.replies.Size() > 0 {
-		s += indent + "\n"
+	return s
+}
+
+func (post *Post) renderReplies(indent string, levels int, p *Pagination) string {
+	if post.replies.Size() == 0 {
+		return ""
+	}
+
+	if levels == 0 {
+		postURL := post.GetURL()
+		s := indent + "\n"
 		s += indent + "_" + newLink("see all "+strconv.Itoa(post.replies.Size())+" replies", postURL) + "_\n"
+
+		return s
 	}
-	return s
+
+	sb := new(strings.Builder)
+	callback := func(_ string, value interface{}) bool {
+		sb.WriteString(indent)
+		sb.WriteString("\n")
+		sb.WriteString(value.(*Post).Render(indent+"> ", levels-1, nil))
+		return false
+	}
+
+	if p == nil {
+		post.replies.Iterate("", "", callback)
+	} else {
+		pg := pager.NewPager(&post.replies, p.PageSize)
+		page := pg.GetPage(p.PageNumber)
+		for _, v := range page.Items {
+			callback(v.Key, v.Value)
+		}
+
+		if page.TotalPages > 1 {
+			sb.WriteString("\n\n---\n\n")
+			sb.WriteString(page.Selector())
+		}
+	}
+
+	return sb.String()
 }
 
 func (post *Post) RenderInner() string {
@@ -298,7 +328,7 @@ func (post *Post) RenderInner() string {
 	}
 
 	s := "_" + newLink("see thread", post.board.GetURLFromThreadID(threadID)) + "_\n\n"
-	s += parent.Render("", 0) + "\n"
-	s += post.Render("> ", 5)
+	s += parent.Render("", 0, nil) + "\n"
+	s += post.Render("> ", 5, nil)
 	return s
 }

examples/gno.land/r/demo/boards2/render.gno

@@ -3,11 +3,18 @@ package boards2
 import (
 	"strconv"
 
+	"gno.land/p/demo/avl/pager"
 	"gno.land/p/demo/mux"
 )
 
+const (
+	defaultPageSize   = 50
+	threadRenderDepth = 5
+)
+
 func Render(path string) string {
-	router := mux.NewRouter()
+	// TODO: remove this when query strings PR will be merged: https://github.com/gnolang/gno/pull/2594
+	router := newWrappedRouter(mux.NewRouter())
 	router.HandleFunc("", renderBoardsList)
 	router.HandleFunc("{board}", renderBoard)
 	router.HandleFunc("{board}/{thread}", renderThread)
@@ -20,29 +27,44 @@ func Render(path string) string {
 	return router.Render(path)
 }
 
-func renderBoardsList(res *mux.ResponseWriter, _ *mux.Request) {
+func renderBoardsList(res *mux.ResponseWriter, r *mux.Request) {
 	res.Write("These are all the boards of this realm:\n\n")
-	gBoardsByID.Iterate("", "", func(_ string, value interface{}) bool {
-		board := value.(*Board)
+
+	pg := pager.NewPager(&gBoardsByID, defaultPageSize)
+	pageNum, limit, err := pg.ParseQuery(r.Path)
+	if err != nil {
+		panic(err)
+	}
+
+	page := pg.GetPageWithSize(pageNum, limit)
+	for _, item := range page.Items {
+		board := item.Value.(*Board)
 		url := board.GetURL()
 		res.Write(" * " + newLink(url, url) + "\n")
-		return false
-	})
+	}
+
+	if page.TotalPages > 1 {
+		res.Write("\n\n---\n\n")
+		res.Write(page.Selector())
+	}
 }
 
 func renderBoard(res *mux.ResponseWriter, req *mux.Request) {
 	name := req.GetVar("board")
 	v, found := gBoardsByName.Get(name)
 	if !found {
 		res.Write("Board does not exist: " + name)
-	} else {
-		board := v.(*Board)
-		res.Write(board.Render())
+		return
 	}
+
+	board := v.(*Board)
+	p := getPagination(req, defaultPageSize)
+	res.Write(board.Render(p))
 }
 
 func renderThread(res *mux.ResponseWriter, req *mux.Request) {
 	name := req.GetVar("board")
+
 	v, found := gBoardsByName.Get(name)
 	if !found {
 		res.Write("Board does not exist: " + name)
@@ -60,9 +82,11 @@ func renderThread(res *mux.ResponseWriter, req *mux.Request) {
 	thread, found := board.GetThread(PostID(tID))
 	if !found {
 		res.Write("Thread does not exist with ID: " + req.GetVar("thread"))
-	} else {
-		res.Write(thread.Render("", 5))
+		return
 	}
+
+	p := getPagination(req, defaultPageSize)
+	res.Write(thread.Render("", threadRenderDepth, &p))
 }
 
 func renderReply(res *mux.ResponseWriter, req *mux.Request) {

examples/gno.land/r/demo/boards2/router.gno

@@ -0,0 +1,63 @@
+package boards2
+
+import (
+	"strings"
+
+	"gno.land/p/demo/avl/pager"
+	"gno.land/p/demo/mux"
+)
+
+type wrappedRouter struct {
+	*mux.Router
+
+	requestURI string
+}
+
+// newWrappedRouter returns a wrapped mux router that supports query strings.
+//
+// TODO: remove this when query strings PR will be merged: https://github.com/gnolang/gno/pull/2594
+func newWrappedRouter(r *mux.Router) *wrappedRouter {
+	return &wrappedRouter{
+		Router: r,
+	}
+}
+
+func (r *wrappedRouter) Render(path string) string {
+	reqPath := trimRequestPath(path)
+	r.requestURI = path
+	return r.Router.Render(reqPath)
+}
+
+func (r *wrappedRouter) HandleFunc(pattern string, fn mux.HandlerFunc) {
+	r.Router.HandleFunc(pattern, func(rw *mux.ResponseWriter, req *mux.Request) {
+		fn(rw, &mux.Request{
+			Path:        r.requestURI,
+			HandlerPath: req.HandlerPath,
+		})
+	})
+}
+
+// trimRequestPath returns request path without query params
+func trimRequestPath(path string) string {
+	i := strings.Index(path, "?")
+	if i == -1 {
+		return path
+	}
+
+	return path[:i]
+}
+
+func getPagination(r *mux.Request, defaultPageSize int) Pagination {
+	// reuse query parameter extract logic from pager.
+	pg := pager.NewPager(nil, defaultPageSize)
+	pg.SizeQueryParam = ""
+	pageNum, limit, err := pg.ParseQuery(r.Path)
+	if err != nil {
+		panic(err)
+	}
+
+	return Pagination{
+		PageNumber: pageNum,
+		PageSize:   limit,
+	}
+}