💾 Archived View for source.community › ckaznocha › cliftons-capsule › blob › main › gemlog.go captured on 2024-02-05 at 09:54:16. Gemini links have been rewritten to link to archived content

-=-=-=-=-=-=-

                                                         .
,-. ,-. . . ,-. ,-. ,-.    ,-. ,-. ,-,-. ,-,-. . . ,-. . |- . .
`-. | | | | |   |   |-'    |   | | | | | | | | | | | | | |  | |
`-' `-' `-^ '   `-' `-' :: `-' `-' ' ' ' ' ' ' `-^ ' ' ' `' `-|
                                                             /|
                                                            `-'

ckaznocha / cliftons-capsule

git clone https://source.community/ckaznocha/cliftons-capsule.git

Branches

Log

Tree

/gemlog.go (main)

↑ /

blob

View raw contents of /gemlog.go (main)

────╮
   1│ package main
   2│ 
   3│ import (
   4│ 	"bufio"
   5│ 	"bytes"
   6│ 	"fmt"
   7│ 	"io/fs"
   8│ 	"net/url"
   9│ 	"sort"
  10│ 	"strings"
  11│ 	"sync"
  12│ 	"time"
  13│ )
  14│ 
  15│ type entryMetadata struct {
  16│ 	Filename string
  17│ 	Date     time.Time
  18│ 	Title    []byte
  19│ }
  20│ 
  21│ type entry struct {
  22│ 	Metadata *entryMetadata
  23│ 	Body     []byte
  24│ }
  25│ 
  26│ type gemlog struct {
  27│ 	gemlogFS  fs.FS
  28│ 	entrySet  map[string]*entryMetadata
  29│ 	entryList []*entryMetadata
  30│ 	mu        sync.RWMutex
  31│ }
  32│ 
  33│ func (g *gemlog) list() ([]*entryMetadata, error) {
  34│ 	g.mu.Lock()
  35│ 	defer g.mu.Unlock()
  36│ 
  37│ 	if err := g.populate(); err != nil {
  38│ 		return nil, err
  39│ 	}
  40│ 
  41│ 	return g.entryList, nil
  42│ }
  43│ 
  44│ func (g *gemlog) entry(path string) (*entry, bool) {
  45│ 	g.mu.RLock()
  46│ 	defer g.mu.RUnlock()
  47│ 
  48│ 	path, err := url.QueryUnescape(strings.TrimPrefix(path, "/"))
  49│ 	if err != nil {
  50│ 		return nil, false
  51│ 	}
  52│ 
  53│ 	metadata, ok := g.entrySet[path]
  54│ 	if !ok {
  55│ 		return nil, false
  56│ 	}
  57│ 
  58│ 	f, err := fs.ReadFile(g.gemlogFS, path)
  59│ 	if err != nil {
  60│ 		return nil, false
  61│ 	}
  62│ 
  63│ 	return &entry{
  64│ 		Metadata: metadata,
  65│ 		Body:     bytes.TrimSpace(f[bytes.Index(f, []byte{'\n'})+1:]),
  66│ 	}, true
  67│ }
  68│ 
  69│ func (g *gemlog) populate() error {
  70│ 	dirInfo, err := fs.ReadDir(g.gemlogFS, "gemlog")
  71│ 	if err != nil {
  72│ 		return fmt.Errorf("cannot read gemlog dir: %w", err)
  73│ 	}
  74│ 
  75│ 	if len(g.entryList) == len(dirInfo) {
  76│ 		return nil
  77│ 	}
  78│ 
  79│ 	g.entryList = []*entryMetadata{}
  80│ 	g.entrySet = map[string]*entryMetadata{}
  81│ 
  82│ 	if err := fs.WalkDir(g.gemlogFS, "gemlog", g.walkFS); err != nil {
  83│ 		return fmt.Errorf("cannot walk gemlog dir: %w", err)
  84│ 	}
  85│ 
  86│ 	sort.Stable(g)
  87│ 
  88│ 	return nil
  89│ }
  90│ 
  91│ func (g *gemlog) Len() int           { return len(g.entryList) }
  92│ func (g *gemlog) Swap(i, j int)      { g.entryList[i], g.entryList[j] = g.entryList[j], g.entryList[i] }
  93│ func (g *gemlog) Less(i, j int) bool { return g.entryList[i].Filename >= g.entryList[j].Filename }
  94│ 
  95│ func (g *gemlog) walkFS(path string, d fs.DirEntry, e error) error {
  96│ 	if e != nil {
  97│ 		return e
  98│ 	}
  99│ 
 100│ 	if d.IsDir() {
 101│ 		return nil
 102│ 	}
 103│ 
 104│ 	t, err := time.Parse(time.RFC3339[:10], d.Name()[:10])
 105│ 	if err != nil {
 106│ 		return fmt.Errorf("unable to parse time stamp: %w", err)
 107│ 	}
 108│ 
 109│ 	f, err := g.gemlogFS.Open(path)
 110│ 	if err != nil {
 111│ 		return fmt.Errorf("unable to open file: %w", err)
 112│ 	}
 113│ 
 114│ 	title, err := bufio.NewReader(f).ReadBytes('\n')
 115│ 	if err != nil {
 116│ 		return fmt.Errorf("unable to read title: %w", err)
 117│ 	}
 118│ 
 119│ 	metadata := &entryMetadata{
 120│ 		Filename: d.Name(),
 121│ 		Date:     t,
 122│ 		Title:    bytes.TrimSpace(bytes.TrimPrefix(title, []byte{'#'})),
 123│ 	}
 124│ 
 125│ 	g.entrySet[path] = metadata
 126│ 	g.entryList = append(g.entryList, metadata)
 127│ 
 128│ 	return nil
 129│ }
────╯

· · ·

info@source.community