feat(examples): hall of fame

examples/gno.land/p/demo/fqname/fqname.gno

@@ -4,7 +4,9 @@
 // package-level declaration.
 package fqname
 
-import "strings"
+import (
+	"strings"
+)
 
 // Parse splits a fully qualified identifier into its package path and name
 // components. It handles cases with and without slashes in the package path.
@@ -63,10 +65,26 @@ func RenderLink(pkgPath, slug string) string {
 		if slug != "" {
 			return "[" + pkgPath + "](" + pkgLink + ")." + slug
 		}
+
 		return "[" + pkgPath + "](" + pkgLink + ")"
 	}
+
 	if slug != "" {
 		return pkgPath + "." + slug
 	}
+
 	return pkgPath
 }
+
+// ShortPath returns the part of the pkgpath after the base domain.
+// sp := fqname.ShortPath("gno.land/r/gnoland/home")
+// fmt.Println(sp)
+// // Output: /r/gnoland/home
+func ShortPath(pkgPath string) string {
+	idx := strings.Index(pkgPath, "/")
+	if idx == -1 {
+		return ""
+	}
+
+	return pkgPath[idx:]
+}

examples/gno.land/p/demo/fqname/fqname_test.gno

@@ -72,3 +72,22 @@ func TestRenderLink(t *testing.T) {
 		uassert.Equal(t, tt.expected, result, "Rendered link did not match expected")
 	}
 }
+
+func TestShortPath(t *testing.T) {
+	tests := []struct {
+		pkgPath  string
+		expected string
+	}{
+		{"gno.land/p/demo/avl", "/p/demo/avl"},
+		{"github.com/a/b", "/a/b"},
+		{"example.com/pkg", "/pkg"},
+		{"gno.land/r/demo/foo20", "/r/demo/foo20"},
+		{"gno.land/r/demo/foo20", "/r/demo/foo20"},
+		{"", ""},
+	}
+
+	for _, tt := range tests {
+		result := ShortPath(tt.pkgPath)
+		uassert.Equal(t, tt.expected, result, "Rendered link did not match expected")
+	}
+}

examples/gno.land/p/demo/ownable/ownable.gno

@@ -58,7 +58,7 @@ func (o *Ownable) DropOwnership() error {
 
 	std.Emit(
 		OwnershipTransferEvent,
-		"from", string(prevOwner),
+		"from", prevOwner.String(),
 		"to", "",
 	)
 

examples/gno.land/p/demo/pausable/pausable.gno

@@ -1,6 +1,10 @@
 package pausable
 
-import "gno.land/p/demo/ownable"
+import (
+	"std"
+
+	"gno.land/p/demo/ownable"
+)
 
 type Pausable struct {
 	*ownable.Ownable
@@ -35,6 +39,8 @@ func (p *Pausable) Pause() error {
 	}
 
 	p.paused = true
+	std.Emit("Paused", "account", p.Owner().String())
+
 	return nil
 }
 
@@ -45,5 +51,7 @@ func (p *Pausable) Unpause() error {
 	}
 
 	p.paused = false
+	std.Emit("Unpaused", "account", p.Owner().String())
+
 	return nil
 }

examples/gno.land/r/demo/hof/administration.gno

@@ -0,0 +1,24 @@
+package hof
+
+import "std"
+
+// Exposing the ownable & pausable APIs
+// Should not be needed as soon as MsgCall supports calling methods on exported variables
+
+func Pause() error {
+	return exhibition.Pause()
+}
+
+func Unpause() error {
+	return exhibition.Unpause()
+}
+
+func GetOwner() std.Address {
+	return owner.Owner()
+}
+
+func TransferOwnership(newOwner std.Address) {
+	if err := owner.TransferOwnership(newOwner); err != nil {
+		panic(err)
+	}
+}

examples/gno.land/r/demo/hof/errors.gno

@@ -0,0 +1,14 @@
+package hof
+
+import (
+	"errors"
+)
+
+var (
+	ErrNoSuchItem     = errors.New("hof: no such item exists")
+	ErrAlreadyExists  = errors.New("hof: alerady exists")
+	ErrDoubleUpvote   = errors.New("hof: cannot upvote twice")
+	ErrDoubleDownvote = errors.New("hof: cannot downvote twice")
+	ErrNonCodeCall    = errors.New("hof: non-code call")
+	ErrPaused         = errors.New("hof: registering is paused")
+)

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

@@ -0,0 +1,10 @@
+module gno.land/r/demo/hof
+
+require (
+	gno.land/p/demo/avl v0.0.0-latest
+	gno.land/p/demo/fqname v0.0.0-latest
+	gno.land/p/demo/ownable v0.0.0-latest
+	gno.land/p/demo/pausable v0.0.0-latest
+	gno.land/p/demo/seqid v0.0.0-latest
+	gno.land/p/demo/ufmt v0.0.0-latest
+)

examples/gno.land/r/demo/hof/hof.gno

@@ -0,0 +1,131 @@
+// Package hof is the hall of fame realm.
+// The Hall of Fame is an exhibition that holds items. Users can add their realms to the Hall of Fame by
+// importing the Hall of Fame realm and calling hof.Register() from their init function.
+package hof
+
+import (
+	"std"
+
+	"gno.land/p/demo/avl"
+	"gno.land/p/demo/ownable"
+	"gno.land/p/demo/pausable"
+	"gno.land/p/demo/seqid"
+)
+
+var (
+	exhibition *Exhibition
+	owner      *ownable.Ownable
+)
+
+type (
+	Exhibition struct {
+		itemCounter seqid.ID
+		description string
+		items       *avl.Tree // pkgPath > Item
+		itemsSorted *avl.Tree // same data but sorted, storing pointers
+		*pausable.Pausable
+	}
+
+	Item struct {
+		id       seqid.ID
+		pkgpath  string
+		deployer std.Address
+		blockNum int64
+		upvote   *avl.Tree // std.Addr > struct{}{}
+		downvote *avl.Tree // std.Addr > struct{}{}
+	}
+)
+
+func init() {
+	exhibition = &Exhibition{
+		items:       avl.NewTree(),
+		itemsSorted: avl.NewTree(),
+	}
+
+	owner = ownable.NewWithAddress(std.Address("g125em6arxsnj49vx35f0n0z34putv5ty3376fg5"))
+	exhibition.Pausable = pausable.NewFromOwnable(owner)
+}
+
+// Register registers your realm to the Hall of Fame
+// Should be called from within code
+func Register() {
+	if exhibition.IsPaused() {
+		panic(ErrPaused.Error())
+	}
+
+	submission := std.PrevRealm()
+	pkgpath := submission.PkgPath()
+
+	// Must not yet exist and must be called from code
+	if submission.IsUser() {
+		panic(ErrNonCodeCall.Error())
+	}
+
+	if exhibition.items.Has(pkgpath) {
+		panic(ErrAlreadyExists.Error())
+	}
+
+	id := exhibition.itemCounter.Next()
+	i := &Item{
+		id:       id,
+		pkgpath:  pkgpath,
+		deployer: std.GetOrigCaller(),
+		blockNum: std.GetHeight(),
+		upvote:   avl.NewTree(),
+		downvote: avl.NewTree(),
+	}
+
+	exhibition.items.Set(pkgpath, i)
+	exhibition.itemsSorted.Set(id.String(), i)
+}
+
+func Upvote(pkgpath string) {
+	rawItem, ok := exhibition.items.Get(pkgpath)
+	if !ok {
+		panic(ErrNoSuchItem.Error())
+	}
+
+	item := rawItem.(*Item)
+	caller := std.PrevRealm().Addr().String()
+
+	if item.upvote.Has(caller) {
+		panic(ErrDoubleUpvote.Error())
+	}
+
+	item.upvote.Set(caller, struct{}{})
+}
+
+func Downvote(pkgpath string) {
+	rawItem, ok := exhibition.items.Get(pkgpath)
+	if !ok {
+		panic(ErrNoSuchItem.Error())
+	}
+
+	item := rawItem.(*Item)
+	caller := std.PrevRealm().Addr().String()
+
+	if item.downvote.Has(caller) {
+		panic(ErrDoubleDownvote.Error())
+	}
+
+	item.downvote.Set(caller, struct{}{})
+}
+
+func Delete(pkgpath string) {
+	if err := owner.CallerIsOwner(); err != nil {
+		panic(err)
+	}
+
+	i, ok := exhibition.items.Get(pkgpath)
+	if !ok {
+		panic(ErrNoSuchItem.Error())
+	}
+
+	if _, removed := exhibition.itemsSorted.Remove(i.(*Item).id.String()); !removed {
+		panic(ErrNoSuchItem.Error())
+	}
+
+	if _, removed := exhibition.items.Remove(pkgpath); !removed {
+		panic(ErrNoSuchItem.Error())
+	}
+}

examples/gno.land/r/demo/hof/hof_test.gno

@@ -0,0 +1,110 @@
+package hof
+
+import (
+	"std"
+	"testing"
+
+	"gno.land/p/demo/uassert"
+	"gno.land/p/demo/urequire"
+)
+
+const rlm1Path = "gno.land/r/leon/home"
+
+var admin = std.Address("g125em6arxsnj49vx35f0n0z34putv5ty3376fg5")
+
+func TestRegister(t *testing.T) {
+	userRealm := std.NewUserRealm(admin)
+	std.TestSetRealm(userRealm)
+	uassert.PanicsWithMessage(t, ErrNonCodeCall.Error(), Register)
+
+	rlm1 := std.NewCodeRealm(rlm1Path)
+	std.TestSetRealm(rlm1)
+	urequire.NotPanics(t, Register)
+	uassert.PanicsWithMessage(t, ErrAlreadyExists.Error(), Register)
+
+	// Find registered items
+	i, ok := exhibition.items.Get(rlm1Path)
+	uassert.True(t, ok)
+
+	_, ok = exhibition.itemsSorted.Get(i.(*Item).id.String())
+	uassert.True(t, ok)
+
+	// Check paused
+	std.TestSetRealm(userRealm)
+	urequire.NotPanics(t, func() { exhibition.Pause() })
+	uassert.PanicsWithMessage(t, ErrPaused.Error(), Register)
+}
+
+func TestUpvote(t *testing.T) {
+	raw, _ := exhibition.items.Get(rlm1Path)
+	item := raw.(*Item)
+
+	rawSorted, _ := exhibition.itemsSorted.Get(item.id.String())
+	itemSorted := rawSorted.(*Item)
+
+	// 0 upvotes by default
+	urequire.Equal(t, item.upvote.Size(), 0)
+
+	userRealm := std.NewUserRealm(admin)
+	std.TestSetRealm(userRealm)
+
+	urequire.NotPanics(t, func() {
+		Upvote(rlm1Path)
+	})
+
+	// Check both trees for 1 upvote
+	uassert.Equal(t, item.upvote.Size(), 1)
+	uassert.Equal(t, itemSorted.upvote.Size(), 1)
+
+	// Check double upvote
+	uassert.PanicsWithMessage(t, ErrDoubleUpvote.Error(), func() {
+		Upvote(rlm1Path)
+	})
+}
+
+func TestDownvote(t *testing.T) {
+	raw, _ := exhibition.items.Get(rlm1Path)
+	item := raw.(*Item)
+
+	rawSorted, _ := exhibition.itemsSorted.Get(item.id.String())
+	itemSorted := rawSorted.(*Item)
+
+	// 0 upvotes by default
+	urequire.Equal(t, item.downvote.Size(), 0)
+
+	userRealm := std.NewUserRealm(admin)
+	std.TestSetRealm(userRealm)
+
+	urequire.NotPanics(t, func() {
+		Downvote(rlm1Path)
+	})
+
+	// Check both trees for 1 upvote
+	uassert.Equal(t, item.downvote.Size(), 1)
+	uassert.Equal(t, itemSorted.downvote.Size(), 1)
+
+	// Check double upvote
+	uassert.PanicsWithMessage(t, ErrDoubleDownvote.Error(), func() {
+		Downvote(rlm1Path)
+	})
+}
+
+func TestDelete(t *testing.T) {
+	userRealm := std.NewUserRealm(admin)
+	std.TestSetRealm(userRealm)
+	std.TestSetOrigCaller(admin)
+
+	uassert.PanicsWithMessage(t, ErrNoSuchItem.Error(), func() {
+		Delete("nonexistentpkgpath")
+	})
+
+	i, ok := exhibition.items.Get(rlm1Path)
+	id := i.(*Item).id
+
+	uassert.NotPanics(t, func() {
+		Delete(rlm1Path)
+	})
+
+	uassert.False(t, exhibition.items.Has(rlm1Path))
+	uassert.False(t, exhibition.itemsSorted.Has(id.String()))
+}