kanban

Kanban client in Gio
Log | Files | Refs | README | LICENSE

mem.go (2390B)

      1 package mem
      2 
      3 import (
      4 	"fmt"
      5 
      6 	"github.com/google/uuid"
      7 
      8 	"git.sr.ht/~jackmordaunt/kanban"
      9 )
     10 
     11 // var _ storage.Storer = (*Storer)(nil)
     12 
     13 // Storer implements in-memory storage for Projects.
     14 type Storer struct {
     15 	Active   Bucket
     16 	Archived Bucket
     17 }
     18 
     19 type Bucket struct {
     20 	Data  map[uuid.UUID]kanban.Project
     21 	Order []uuid.UUID
     22 }
     23 
     24 func New() *Storer {
     25 	return &Storer{
     26 		Active: Bucket{
     27 			Data: make(map[uuid.UUID]kanban.Project),
     28 		},
     29 		Archived: Bucket{
     30 			Data: make(map[uuid.UUID]kanban.Project),
     31 		},
     32 	}
     33 }
     34 
     35 func (s *Storer) Create(p kanban.Project) error {
     36 	if _, ok := s.Active.Data[p.ID]; ok {
     37 		return fmt.Errorf("project %q exists", p.Name)
     38 	}
     39 	s.Active.Add(p)
     40 	return nil
     41 }
     42 
     43 func (s *Storer) Save(projects ...kanban.Project) error {
     44 	for _, p := range projects {
     45 		if _, ok := s.Active.Data[p.ID]; ok {
     46 			s.Active.Data[p.ID] = p.Clone()
     47 		} else {
     48 			return fmt.Errorf("project %q does not exist", p.Name)
     49 		}
     50 	}
     51 	return nil
     52 }
     53 
     54 func (s *Storer) Find(id uuid.UUID) (p kanban.Project, ok bool, err error) {
     55 	p, ok = s.Active.Data[id]
     56 	return p.Clone(), ok, nil
     57 }
     58 
     59 func (s *Storer) Count() (int, error) {
     60 	return len(s.Active.Data), nil
     61 }
     62 
     63 func (s *Storer) List() (list []kanban.Project, err error) {
     64 	return s.Active.List(), nil
     65 }
     66 
     67 func (s *Storer) Load(projects []kanban.Project) error {
     68 	for ii := range projects {
     69 		projects[ii] = s.Active.Data[projects[ii].ID].Clone()
     70 	}
     71 	return nil
     72 }
     73 
     74 func (s *Storer) Archive(id uuid.UUID) error {
     75 	p, ok := s.Active.Data[id]
     76 	if !ok {
     77 		return nil
     78 	}
     79 	s.Active.Delete(id)
     80 	s.Archived.Add(p)
     81 	return nil
     82 }
     83 
     84 func (s *Storer) Restore(id uuid.UUID) error {
     85 	p, ok := s.Archived.Data[id]
     86 	if !ok {
     87 		return nil
     88 	}
     89 	s.Archived.Delete(id)
     90 	s.Active.Add(p)
     91 	return nil
     92 }
     93 
     94 func (s *Storer) ListArchived() (list []kanban.Project, err error) {
     95 	return s.Archived.List(), nil
     96 }
     97 
     98 func (s *Storer) Clear() {
     99 	s.Active = Bucket{
    100 		Data: make(map[uuid.UUID]kanban.Project),
    101 	}
    102 	s.Archived = Bucket{
    103 		Data: make(map[uuid.UUID]kanban.Project),
    104 	}
    105 }
    106 
    107 func (b *Bucket) Add(p kanban.Project) {
    108 	b.Data[p.ID] = p
    109 	b.Order = append(b.Order, p.ID)
    110 }
    111 
    112 func (b *Bucket) Delete(id uuid.UUID) {
    113 	delete(b.Data, id)
    114 	for ii := range b.Order {
    115 		if b.Order[ii] == id {
    116 			b.Order = append(b.Order[:ii], b.Order[ii+1:]...)
    117 			break
    118 		}
    119 	}
    120 }
    121 
    122 func (b *Bucket) List() (list []kanban.Project) {
    123 	for _, id := range b.Order {
    124 		list = append(list, b.Data[id])
    125 	}
    126 	return list
    127 }