feat(boards2): add gno.land/p/gnoland/boards package

examples/gno.land/p/gnoland/boards/board.gno

@@ -0,0 +1,48 @@
+package boards
+
+import "time"
+
+// Board defines a type for boards.
+type Board struct {
+	// ID is the unique identifier of the board.
+	ID ID
+
+	// Name is the current name of the board.
+	Name string
+
+	// Aliases contains a list of alternative names for the board.
+	Aliases []string
+
+	// Readonly indicates that the board is readonly.
+	Readonly bool
+
+	// Threads contains all board threads.
+	Threads PostStorage
+
+	// ThreadsSequence generates sequential ID for new threads.
+	ThreadsSequence IdentifierGenerator
+
+	// Permissions enables support for permissioned boards.
+	// This type of boards allows managing members with roles and permissions.
+	// It also enables the implementation of permissioned execution of board related features.
+	Permissions Permissions
+
+	// Creator is the account address that created the board.
+	Creator address
+
+	// CreatedAt is the board's creation time.
+	CreatedAt time.Time
+
+	// UpdatedAt is the board's update time.
+	UpdatedAt time.Time
+}
+
+// New creates a new basic non permissioned board.
+func New(id ID) *Board {
+	return &Board{
+		ID:              id,
+		Threads:         NewPostStorage(),
+		ThreadsSequence: NewIdentifierGenerator(),
+		CreatedAt:       time.Now(),
+	}
+}

examples/gno.land/p/gnoland/boards/board_test.gno

@@ -0,0 +1,18 @@
+package boards_test
+
+import (
+	"testing"
+
+	"gno.land/p/nt/urequire"
+
+	"gno.land/p/gnoland/boards"
+)
+
+func TestNew(t *testing.T) {
+	board := boards.New(42)
+
+	urequire.Equal(t, 42, int(board.ID), "expect board ID to match")
+	urequire.True(t, board.Threads != nil, "expect board to support threads")
+	urequire.True(t, board.ThreadsSequence != nil, "expect board to initialize a thread ID generator")
+	urequire.False(t, board.CreatedAt.IsZero(), "expect board to have a creation date")
+}

examples/gno.land/p/gnoland/boards/flag_storage.gno

@@ -0,0 +1,105 @@
+package boards
+
+import (
+	"strings"
+
+	"gno.land/p/nt/avl"
+	"gno.land/p/nt/ufmt"
+)
+
+type (
+	// Flag defines a type for post flags
+	Flag struct {
+		// User is the user that flagged the post.
+		User address
+
+		// Reason is the reason that describes why post is flagged.
+		Reason string
+	}
+
+	// FlagIterFn defines a function type to iterate post flags.
+	FlagIterFn func(Flag) bool
+
+	// FlagStorage defines an interface for storing posts flagging information.
+	FlagStorage interface {
+		// Exists checks if a flag from a user exists
+		Exists(address) bool
+
+		// Add adds a new flag from a user.
+		Add(Flag) error
+
+		// Remove removes a user flag.
+		Remove(address) (removed bool)
+
+		// Size returns the number of flags in the storage.
+		Size() int
+
+		// Iterate iterates post flags.
+		// To reverse iterate flags use a negative count.
+		// If the callback returns true, the iteration is stopped.
+		Iterate(start, count int, fn FlagIterFn) bool
+	}
+)
+
+// NewFlagStorage creates a new storage for post flags.
+// The new storage uses an AVL tree to store flagging info.
+func NewFlagStorage() FlagStorage {
+	return &flagStorage{avl.NewTree()}
+}
+
+type flagStorage struct {
+	flags *avl.Tree // address -> string(reason)
+}
+
+// Exists checks if a flag from a user exists
+func (s flagStorage) Exists(addr address) bool {
+	return s.flags.Has(addr.String())
+}
+
+// Add adds a new flag from a user.
+// It fails if a flag from the same user exists.
+func (s *flagStorage) Add(f Flag) error {
+	if !f.User.IsValid() {
+		return ufmt.Errorf("post flagging error, invalid user address: %s", f.User)
+	}
+
+	k := f.User.String()
+	if s.flags.Has(k) {
+		return ufmt.Errorf("flag from user already exists: %s", f.User)
+	}
+
+	s.flags.Set(k, strings.TrimSpace(f.Reason))
+	return nil
+}
+
+// Remove removes a user flag.
+func (s *flagStorage) Remove(addr address) bool {
+	_, removed := s.flags.Remove(addr.String())
+	return removed
+}
+
+// Size returns the number of flags in the storage.
+func (s flagStorage) Size() int {
+	return s.flags.Size()
+}
+
+// Iterate iterates post flags.
+// To reverse iterate flags use a negative count.
+// If the callback returns true, the iteration is stopped.
+func (s flagStorage) Iterate(start, count int, fn FlagIterFn) bool {
+	if count < 0 {
+		return s.flags.ReverseIterateByOffset(start, -count, func(k string, v any) bool {
+			return fn(Flag{
+				User:   address(k),
+				Reason: v.(string),
+			})
+		})
+	}
+
+	return s.flags.IterateByOffset(start, count, func(k string, v any) bool {
+		return fn(Flag{
+			User:   address(k),
+			Reason: v.(string),
+		})
+	})
+}