wrap tui list item

group/group_test.go

@@ -42,7 +42,7 @@ func TestGroupService_Save(t *testing.T) {
 			a.NoError(err)
 		}
 	}
-	savedGroups, err := gs.LoadGroups()
+	savedGroups, err := gs.loadGroups()
 	a.NoError(err)
 	for i := range savedGroups {
 		fmt.Println("wtf", savedGroups[i])
@@ -52,13 +52,13 @@ func TestGroupService_Save(t *testing.T) {
 func TestGroupService_BuildTree(t *testing.T) {
 	a := assert.New(t)
 	gs := NewService()
-	groups, err := gs.LoadGroups()
+	groups, err := gs.loadGroups()
 	a.NoError(err)
 	for i := range groups {
 		fmt.Println(groups[i])
 	}
-	gs.BuildTree(groups)
-	for _, node := range gs.Tree {
+	gs.buildTree(groups)
+	for _, node := range gs.tree {
 		fmt.Println(node)
 	}
 }

group/service.go

@@ -19,19 +19,23 @@ func Service() *service {
 	return instance
 }
 
-type service struct {
-	Groups map[uint]*Node
-	Tree   []*Node
-}
-
 func NewService() *service {
 	return &service{
-		Groups: make(map[uint]*Node, 0),
-		Tree:   make([]*Node, 0),
+		groups: make(map[uint]*Node, 0),
+		tree:   make([]*Node, 0),
 	}
 }
 
-func (gs *service) LoadGroups() ([]Group, error) {
+type service struct {
+	groups map[uint]*Node
+	tree   []*Node
+}
+
+func (gs *service) Tree() []*Node {
+	return gs.tree
+}
+
+func (gs *service) loadGroups() ([]Group, error) {
 	var groups []Group
 	if err := store.Store().Find(&groups, &bolthold.Query{}); err != nil {
 		if errors.Is(bolthold.ErrNotFound, err) {
@@ -43,31 +47,40 @@ func (gs *service) LoadGroups() ([]Group, error) {
 	return groups, nil
 }
 
-func (gs *service) BuildTree(groups []Group) {
-	if len(gs.Groups) == 0 {
+func (gs *service) buildTree(groups []Group) {
+	if len(groups) == 0 {
 		return
 	}
 	for _, group := range groups {
-		gs.Groups[group.ID] = NewGroupNode(group)
+		gs.groups[group.ID] = NewGroupNode(group)
 	}
-	for _, node := range gs.Groups {
-		p, exist := gs.Groups[node.Parent]
+	for _, node := range gs.groups {
+		p, exist := gs.groups[node.Parent]
 		if !exist {
-			gs.Tree = append(gs.Tree, node)
+			gs.tree = append(gs.tree, node)
 			continue
 		}
 		p.Children = append(p.Children, node)
 	}
 }
 
+func (gs *service) Load() error {
+	groups, err := gs.loadGroups()
+	if err != nil {
+		return err
+	}
+	gs.buildTree(groups)
+	return nil
+}
+
 func (gs *service) Save(group Group) error {
-	if _, exist := gs.Groups[group.ID]; exist {
+	if _, exist := gs.groups[group.ID]; exist {
 		return ErrGroupExist
 	}
 	err := store.Store().Insert(group.ID, group)
 	if err != nil {
 		return err
 	}
-	gs.Groups[group.ID] = NewGroupNode(group)
+	gs.groups[group.ID] = NewGroupNode(group)
 	return nil
 }

host/service.go

@@ -0,0 +1,22 @@
+package host
+
+import "sync"
+
+var (
+	instance *service
+	once     sync.Once
+)
+
+func Service() *service {
+	once.Do(func() {
+		instance = newService()
+	})
+	return instance
+}
+
+type service struct {
+}
+
+func newService() *service {
+	return &service{}
+}

tui/item.go

@@ -0,0 +1,19 @@
+package tui
+
+import (
+	"github.com/charmbracelet/bubbles/list"
+	"reflect"
+)
+
+func wrapListItems(slice any) []list.Item {
+	v := reflect.ValueOf(slice)
+	if v.Kind() != reflect.Slice {
+		return nil
+	}
+	items := make([]list.Item, v.Len())
+	for i := 0; i < v.Len(); i++ {
+		item := v.Index(i).Interface()
+		items[i] = item.(list.Item)
+	}
+	return items
+}

tui/model.go

@@ -18,7 +18,7 @@ const (
 )
 
 var (
-	docStyle          = lipgloss.NewStyle().Margin(1, 2)
+	docStyle          = lipgloss.NewStyle().Margin(1, 1)
 	modelStyle        = lipgloss.NewStyle().Padding(1, 2).BorderStyle(lipgloss.HiddenBorder())
 	focusedModelStyle = lipgloss.NewStyle().Padding(1, 2).BorderStyle(lipgloss.NormalBorder()).BorderForeground(lipgloss.Color("69"))
 )
@@ -34,20 +34,15 @@ type Model struct {
 
 func NewModel() (*Model, error) {
 	groupService := group.Service()
-	groups, err := groupService.LoadGroups()
-	if err != nil {
+	if err := groupService.Load(); err != nil {
 		return nil, err
 	}
-	groupItems := make([]list.Item, len(groups))
-	for i := range groups {
-		groupItems[i] = groups[i]
-	}
-	groupService.BuildTree(groups)
+	groups := wrapListItems(groupService.Tree())
 
 	keys := newKeys()
 	m := &Model{
 		keys:      keys,
-		groupList: list.New(groupItems, list.NewDefaultDelegate(), 0, 0),
+		groupList: list.New(groups, list.NewDefaultDelegate(), 0, 0),
 		help:      help.New(),
 	}