feat: r/system/names public functions and checks with AddPackage

examples/gno.land/r/system/names/enable.gno

@@ -0,0 +1,5 @@
+package names
+
+// if enabled is true, `HasPerm` will check the permissions of names.
+// todo: this is a temporary solution, we should use a more robust
+var enabled bool = false

examples/gno.land/r/system/names/gno.mod

@@ -2,4 +2,5 @@ module gno.land/r/system/names
 
 require (
         "gno.land/p/demo/avl" v0.0.0-latest
+        "gno.land/p/demo/ufmt" v0.0.0-latest
 )

examples/gno.land/r/system/names/names.gno

@@ -2,6 +2,8 @@
 package names
 
 import (
+	"errors"
+	"regexp"
 	"std"
 
 	"gno.land/p/demo/avl"
@@ -12,49 +14,71 @@ import (
 // determine if an address can publish a package or not.
 var namespaces avl.Tree // name(string) -> Space
 
+// TODO: more accurate.
+var reNamespace = regexp.MustCompile(`^[a-z][a-z0-9_]{2,30}$`)
+
 type Space struct {
 	Admins  []std.Address
 	Editors []std.Address
 	InPause bool
 }
 
-func Register(namespace string) {
-	// TODO: input sanitization:
-	// - already exists / reserved.
-	// - min/max length, format.
-	// - fees (dynamic, based on length).
-	panic("not implemented")
+func (s *Space) isAdmin(addr std.Address) bool {
+	return containsAddress(s.Admins, addr)
 }
 
-func AddAdmin(namespace string, newAdmin std.Address) {
-	// TODO: assertIsAdmin()
-	panic("not implemented")
+func (s *Space) addAdmin(newAdmin std.Address) {
+	if !containsAddress(s.Admins, newAdmin) {
+		s.Admins = append(s.Admins, newAdmin)
+	}
 }
 
-func RemoveAdmin(namespace string, newAdmin std.Address) {
-	// TODO: assertIsAdmin()
-	// TODO: check if self.
-	panic("not implemented")
+func (s *Space) removeAdmin(admin std.Address) error {
+	if len(s.Admins) == 1 {
+		return errors.New("namespace at least needs one admin")
+	}
+	if isCallerAddress(admin) {
+		return errors.New("cannot remove self")
+	}
+	admins := removeAddress(s.Admins, admin)
+	s.Admins = admins
+	return nil
 }
 
-func AddEditor(namespace string, newAdmin std.Address) {
-	// TODO: assertIsAdmin()
-	panic("not implemented")
+func (s *Space) addEditor(newEditor std.Address) {
+	if !containsAddress(s.Editors, newEditor) {
+		s.Editors = append(s.Editors, newEditor)
+	}
 }
 
-func RemoveEditor(namespace string, newAdmin std.Address) {
-	// TODO: assertIsAdmin()
-	// TODO: check if self.
-	panic("not implemented")
+func (s *Space) removeEditor(editor std.Address) error {
+	if isCallerAddress(editor) {
+		return errors.New("cannot remove self")
+	}
+	editors := removeAddress(s.Editors, editor)
+	s.Editors = editors
+	return nil
 }
 
-func SetInPause(namespace string, state bool) {
-	// TODO: assertIsAdmin()
-	panic("not implemented")
+func (s *Space) hasPerm(caller std.Address) bool {
+	if s.InPause {
+		return false
+	}
+
+	if containsAddress(s.Admins, caller) {
+		return true
+	}
+
+	if containsAddress(s.Editors, caller) {
+		return true
+	}
+
+	return false
 }
 
-func Render(path string) string {
-	// TODO: by namespace.
-	// TODO: by address.
-	return "not implemented"
+func validateNamespace(namespace string) error {
+	if !reNamespace.MatchString(namespace) {
+		return errors.New("invalid namespace")
+	}
+	return nil
 }

examples/gno.land/r/system/names/public.gno

@@ -0,0 +1,124 @@
+package names
+
+import (
+	"std"
+
+	"gno.land/p/demo/ufmt"
+)
+
+func Register(namespace string) {
+	// TODO: input sanitization:
+	// - already exists / reserved.
+	// - min/max length, format.
+	// - fees (dynamic, based on length).
+	if existsNamespace(namespace) {
+		panic("namespace already exists")
+	}
+
+	err := validateNamespace(namespace)
+	checkErr(err)
+
+	caller := std.GetOrigCaller()
+	namespaces.Set(namespace, &Space{
+		Admins: []std.Address{caller},
+	})
+}
+
+func AddAdmin(namespace string, newAdmin std.Address) {
+	space := getSpace(namespace)
+	assertIsAdmin(space)
+	space.addAdmin(newAdmin)
+}
+
+func RemoveAdmin(namespace string, admin std.Address) {
+	space := getSpace(namespace)
+	assertIsAdmin(space)
+	err := space.removeAdmin(admin)
+	checkErr(err)
+}
+
+func AddEditor(namespace string, newEditor std.Address) {
+	space := getSpace(namespace)
+	assertIsAdmin(space)
+	space.addEditor(newEditor)
+}
+
+func RemoveEditor(namespace string, editor std.Address) {
+	space := getSpace(namespace)
+	assertIsAdmin(space)
+	err := space.removeEditor(editor)
+	checkErr(err)
+}
+
+func SetInPause(namespace string, state bool) {
+	space := getSpace(namespace)
+	assertIsAdmin(space)
+	space.InPause = state
+}
+
+// HasPerm returns true if the caller has permission of the namespace.
+// If the namespace does not exist, it will return panic.
+// If the namespace exists but the caller is not an admin or editor,
+// it will return false.
+// The vm keeper will use this function to check to add package
+func HasPerm(namespace string) bool {
+	// if enabled is false, it always returns true for dev and testing.
+	if !enabled {
+		return true
+	}
+	caller := std.GetOrigCaller()
+	space := getSpace(namespace)
+	return space.hasPerm(caller)
+}
+
+func Render(path string) string {
+	// TODO: by address.
+
+	if path == "" {
+		return renderIndex()
+	} else if path[:2] == "n/" {
+		return renderNamespace(path[2:])
+	}
+	return ""
+}
+
+func renderNamespace(namespace string) string {
+	space := getSpace(namespace)
+	output := ufmt.Sprintf(`
+# %s
+
+## Admins
+
+%s
+
+## Editors
+
+%s
+
+## InPause
+
+%s
+
+`, namespace, renderAddresses(space.Admins), renderAddresses(space.Editors), formatBool(space.InPause))
+	return output
+}
+
+func renderIndex() string {
+	output := "## Namespaces \n"
+	namespaces.Iterate("", "", func(namespace string, value interface{}) bool {
+		space := value.(*Space)
+		output += ufmt.Sprintf("* [%s](/r/system/names:n/%s) -	admins: %d editors: %d inPause: %s \n",
+			namespace, namespace, len(space.Admins), len(space.Editors), formatBool(space.InPause))
+		return false
+	})
+
+	return output
+}
+
+func renderAddresses(addresses []std.Address) string {
+	output := ""
+	for _, address := range addresses {
+		output += ufmt.Sprintf("* %s \n", string(address))
+	}
+	return output
+}

examples/gno.land/r/system/names/public_test.gno

@@ -0,0 +1,74 @@
+package names
+
+import (
+	"std"
+	"testing"
+)
+
+func TestRegisterNamespace(t *testing.T) {
+	std.TestSetOrigCaller(std.Address("g1u7y667z64x2h7vc6fmpcprgey4ck233jaww9zq"))
+	creator := std.GetOrigCaller()
+
+	n := "test2"
+	Register(n)
+	s := getSpace(n)
+	assertTrue(t, containsAddress(s.Admins, creator))
+}
+
+func TestAdminFuncs(t *testing.T) {
+	std.TestSetOrigCaller(std.Address("g1u7y667z64x2h7vc6fmpcprgey4ck233jaww9zq"))
+	creator := std.GetOrigCaller()
+
+	test1 := std.Address("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5")
+	test2 := std.Address("g1r6casl322p5adkmmjjkjea404e7f6w29y6gzwg")
+
+	ns := "test3"
+
+	Register(ns)
+	s := getSpace(ns)
+
+	AddAdmin(ns, test1)
+	AddAdmin(ns, test2)
+	assertTrue(t, containsAddress(s.Admins, test1))
+	assertTrue(t, containsAddress(s.Admins, test2))
+
+	RemoveAdmin(ns, test1)
+	assertFalse(t, containsAddress(s.Admins, test1))
+	assertTrue(t, containsAddress(s.Admins, test2))
+
+	AddEditor(ns, test1)
+	assertTrue(t, containsAddress(s.Editors, test1))
+
+	RemoveEditor(ns, test1)
+	assertTrue(t, !containsAddress(s.Editors, test1))
+}
+
+func TestSpaceMethods(t *testing.T) {
+	std.TestSetOrigCaller(std.Address("g1u7y667z64x2h7vc6fmpcprgey4ck233jaww9zq"))
+	creator := std.GetOrigCaller()
+
+	test1 := std.Address("g1jg8mtutu9khhfwc4nxmuhcpftf0pajdhfvsqf5")
+	test2 := std.Address("g1r6casl322p5adkmmjjkjea404e7f6w29y6gzwg")
+
+	ns := "test4"
+	Register(ns)
+	s := getSpace(ns)
+
+	assertTrue(t, s.isAdmin(creator))
+	assertTrue(t, s.removeAdmin(creator) != nil)
+
+	s.addAdmin(test1)
+	assertTrue(t, s.removeAdmin(test1) == nil)
+}
+
+func assertTrue(t *testing.T, b bool) {
+	if !b {
+		t.Fail()
+	}
+}
+
+func assertFalse(t *testing.T, b bool) {
+	if b {
+		t.Fail()
+	}
+}

examples/gno.land/r/system/names/utils.gno

@@ -0,0 +1,64 @@
+package names
+
+import (
+	"std"
+)
+
+func getSpace(namespace string) *Space {
+	s, ok := namespaces.Get(namespace)
+	if !ok {
+		panic("namespace does not exist")
+	}
+	return s.(*Space)
+}
+
+func existsNamespace(name string) bool {
+	_, ok := namespaces.Get(name)
+	return ok
+}
+
+func assertIsAdmin(space *Space) {
+	caller := std.GetOrigCaller()
+	if !space.isAdmin(caller) {
+		panic("Only admins can call this function")
+	}
+}
+
+func removeAddress(addrs []std.Address, addr std.Address) []std.Address {
+	var newAddrs []std.Address
+	for _, a := range addrs {
+		if a != addr {
+			newAddrs = append(newAddrs, a)
+		}
+	}
+	return newAddrs
+}
+
+func containsAddress(addrs []std.Address, addr std.Address) bool {
+	for _, a := range addrs {
+		if a == addr {
+			return true
+		}
+	}
+	return false
+}
+
+func isCallerAddress(addr std.Address) bool {
+	if addr == std.GetOrigCaller() {
+		return true
+	}
+	return false
+}
+
+func checkErr(err error) {
+	if err != nil {
+		panic(err)
+	}
+}
+
+func formatBool(b bool) string {
+	if b {
+		return "true"
+	}
+	return "false"
+}