check this out
`, + }, + { + name: "Markdown, some link", + markdown: `# Test 2 +## 01/24/26 09:14:20 - some entry (bare link) +Check this out http://tatata.toto here +`, + want: `Check this out http://tatata.toto here
`, + }, + { + name: "Markdown, some link with description", + markdown: `# Test 2 +## 01/24/26 09:14:20 - some entry (bare link) +Check this out [here](http://tatata.toto) +`, + want: `Check this out here
`, + }, + } + + for _, test := range cases { + got, err := RenderMarkdown([]byte(test.markdown)) + if err != nil { + t.Errorf("Error rendering markdown: '%s'\n", err) + } + strip := strings.ReplaceAll(string(got), "\n", "") + strip = strings.Trim(strip, " ") + + if strip != test.want { + t.Errorf("Rendering markdown: Wanted '%s', got '%s'.\n", test.want, strip) + } + } +} + +func TestTemplateManagerGetTemplate_Caches(t *testing.T) { + baseDir := t.TempDir() + writeTemplate(t, baseDir, "base.tmpl", `{{ define "base" }}base{{ end }}`) + writeTemplate(t, baseDir, "index.tmpl", `{{ define "content" }}index{{ end }}`) + + tm := NewTemplateManager(baseDir) + td := &TemplateData{ + Name: "index", + FileNameSet: []string{"base", "index"}, + } + + first, err := tm.GetTemplate(td) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + second, err := tm.GetTemplate(td) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + if first != second { + t.Fatalf("expected cached template instance") + } +} + +func TestTemplateManagerGetTemplate_Missing(t *testing.T) { + baseDir := t.TempDir() + tm := NewTemplateManager(baseDir) + + td := &TemplateData{ + Name: "missing", + FileNameSet: []string{"missing"}, + } + + if _, err := tm.GetTemplate(td); err == nil { + t.Fatalf("expected error for missing template") + } +} + +func TestTemplateManagerRender(t *testing.T) { + baseDir := t.TempDir() + writeTemplate(t, baseDir, "base.tmpl", `{{ define "base" }}{{ template "content" . }}{{ end }}`) + writeTemplate(t, baseDir, "noteList.tmpl", `{{ define "noteList" }}notes{{ end }}`) + writeTemplate(t, baseDir, "metadata.tmpl", `{{ define "metadata" }}meta{{ end }}`) + writeTemplate(t, baseDir, "index.tmpl", `{{ define "content" }}hello{{ end }}`) + writeTemplate(t, baseDir, "metadata.tmpl", `{{ define "noteList" }}notes{{ end }}`) + + tm := NewTemplateManager(baseDir) + rec := httptest.NewRecorder() + + err := tm.Render(rec, "index", map[string]string{"msg": "hi"}) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + if ct := rec.Header().Get("Content-Type"); ct != "text/html; charset=utf-8" { + t.Fatalf("expected content-type text/html; charset=utf-8, got %q", ct) + } + + if rec.Code != http.StatusOK { + t.Fatalf("expected status 200, got %d", rec.Code) + } + + if !strings.Contains(rec.Body.String(), "hello") { + t.Fatalf("expected rendered template content") + } +} + +func TestTemplateManagerRender_MissingTemplate(t *testing.T) { + baseDir := t.TempDir() + writeTemplate(t, baseDir, "base.tmpl", `{{ define "base" }}{{ template "content" . }}{{ end }}`) + writeTemplate(t, baseDir, "noteList.tmpl", `{{ define "noteList" }}notes{{ end }}`) + writeTemplate(t, baseDir, "metadata.tmpl", `{{ define "metadata" }}meta{{ end }}`) + writeTemplate(t, baseDir, "metadata.tmpl", `{{ define "noteList" }}notes{{ end }}`) + + tm := NewTemplateManager(baseDir) + rec := httptest.NewRecorder() + + if err := tm.Render(rec, "index", nil); err == nil { + t.Fatalf("expected error for missing template") + } +} + +func writeTemplate(t *testing.T, dir, name, contents string) { + t.Helper() + + path := filepath.Join(dir, name) + if err := os.WriteFile(path, []byte(contents), 0o600); err != nil { + t.Fatalf("write template %s: %v", name, err) + } +} diff --git a/internal/scanner/handler.go b/internal/scanner/handler.go new file mode 100644 index 0000000..f397401 --- /dev/null +++ b/internal/scanner/handler.go @@ -0,0 +1,70 @@ +package scanner + +import ( + "path/filepath" + + "donniemarko/internal/note" + "donniemarko/internal/storage" + "log" + "os" +) + +type NotesHandler struct { + storage storage.Storage +} + +func NewNotesHandler(storage storage.Storage) *NotesHandler { + return &NotesHandler{storage: storage} +} + +func (h *NotesHandler) HandleCreate(path string) error { + note, err := ParseNoteFile(path) + if err != nil { + return err + } + if err := h.storage.Create(note); err != nil { + return err + } + log.Printf("Created or updated note '%s'\n", path) + return nil +} + +func (h *NotesHandler) HandleModify(path string) error { + return h.HandleCreate(path) +} + +func (h *NotesHandler) HandleDelete(path string) error { + id := note.GenerateNoteID(path) + h.storage.Delete(id) + log.Printf("Deleted note '%s' from index\n", path) + return nil +} + +// ParseNoteFile reads a note file on the file system and returns a note struct +// populated with the metadata and content extracted from the file +func ParseNoteFile(path string) (*note.Note, error) { + content, err := os.ReadFile(path) + if err != nil { + return nil, err + } + + // Get file info to get modification time + fileInfo, err := os.Stat(path) + if err != nil { + return nil, err + } + + id := note.GenerateNoteID(path) + nn := note.NewNote() + nn.ID = id + nn.Path = path + nn.Content = string(content) + nn.Title = note.ExtractTitle(nn.Content) + // Use filename as title if no heading found + if nn.Title == "" { + nn.Title = filepath.Base(path) + } + nn.UpdatedAt = fileInfo.ModTime() + nn.Size = fileInfo.Size() + return nn, nil +} diff --git a/internal/scanner/scanner.go b/internal/scanner/scanner.go new file mode 100644 index 0000000..f65903b --- /dev/null +++ b/internal/scanner/scanner.go @@ -0,0 +1,168 @@ +package scanner + +import ( + "context" + "log" + "os" + "path/filepath" + "strings" + "time" +) + +type ChangeType int + +const ( + Unchanged ChangeType = iota + Created + Modified + Deleted +) + +type ChangeHandler interface { + HandleCreate(path string) error + HandleModify(path string) error + HandleDelete(path string) error +} + +type Change struct { + Type ChangeType + Path string + ModTime time.Time +} + +type ScannerService struct { + RootDir string + Interval time.Duration + LastStates map[string]time.Time + handler ChangeHandler +} + +func NewScanner(path string) *ScannerService { + return &ScannerService{ + RootDir: path, + Interval: 5 * time.Second, + LastStates: make(map[string]time.Time), + } +} + +func (s *ScannerService) SetHandler(handler ChangeHandler) { + s.handler = handler +} + +// Scan walks the root folder and update the states of each notes if +// it has changed since the last time a scan occured +func (s *ScannerService) Scan() ([]Change, error) { + var changes []Change + currentStates := make(map[string]time.Time) + + // Walk filesystem + filepath.Walk(s.RootDir, func(path string, info os.FileInfo, err error) error { + + // skip the root dir itself + if s.RootDir == path { + return nil + } + + // ignore anything that isn't a note + if !isValidNoteFile(path, info) { + return nil + } + + currentStates[path] = info.ModTime() + + lastMod, existed := s.LastStates[path] + if !existed { + // create the note if it didn't exist yet + // s.handler.HandleCreate(path) + changes = append(changes, Change{Type: Created, Path: path, ModTime: lastMod}) + } else if info.ModTime().After(lastMod) { + changes = append(changes, Change{Type: Modified, Path: path, ModTime: info.ModTime()}) + } + + return nil + }) + + // Check for deletions + for path := range s.LastStates { + if _, exists := currentStates[path]; !exists { + changes = append(changes, Change{Type: Deleted, Path: path}) + } + } + + s.LastStates = currentStates + return changes, nil +} + +// Monitor rescan the root folder at each new tick and handle state modifications +func (s *ScannerService) Monitor(ctx context.Context) error { + ticker := time.NewTicker(s.Interval) + defer ticker.Stop() + + applyChanges := func(changes []Change) { + for _, change := range changes { + var err error + switch change.Type { + case Created: + err = s.handler.HandleCreate(change.Path) + case Modified: + err = s.handler.HandleModify(change.Path) + case Deleted: + err = s.handler.HandleDelete(change.Path) + } + + if err != nil { + log.Printf("handler error for %s: %v", change.Path, err) + } + } + } + + changes, err := s.Scan() + if err != nil { + log.Printf("scan error: %v", err) + } else { + applyChanges(changes) + } + + for { + select { + case <-ticker.C: + changes, err := s.Scan() + if err != nil { + log.Printf("scan error: %v", err) + continue + } + + applyChanges(changes) + + case <-ctx.Done(): + return ctx.Err() + } + } +} + +func isValidNoteFile(path string, info os.FileInfo) bool { + // ignore temp and backup files + for _, nono := range []string{".#", "~"} { + if strings.Contains(path, nono) { + return false + } + } + + // ignore files that are not markdown + if info.IsDir() || filepath.Ext(path) != ".md" { + return false + } + + // ignore empty folder + if info.IsDir() { + files, err := os.ReadDir(path) + if err != nil { + log.Println(err.Error()) + } + if len(files) == 0 { + return false + } + } + + return true +} diff --git a/internal/scanner/scanner_test.go b/internal/scanner/scanner_test.go new file mode 100644 index 0000000..bf15096 --- /dev/null +++ b/internal/scanner/scanner_test.go @@ -0,0 +1,58 @@ +package scanner + +import ( + "os" + "path/filepath" + "testing" + "time" +) + +func TestScanner_DetectsNewFile(t *testing.T) { + tmpDir := t.TempDir() + scanner := NewScanner(tmpDir) + + scanner.Scan() // Initial scan + + os.WriteFile(filepath.Join(tmpDir, "new.md"), []byte("# New"), 0644) + + changes, _ := scanner.Scan() + + if len(changes) != 1 || changes[0].Type != Created { + t.Error("should detect new file") + } +} + +func TestScanner_DetectChanges(t *testing.T) { + tmpDir := t.TempDir() + filePath := filepath.Join(tmpDir, "test.md") + + // Initial state + os.WriteFile(filePath, []byte("# Original"), 0644) + + scanner := NewScanner(tmpDir) + changes, _ := scanner.Scan() + originalModTime := changes[0].ModTime + + // Wait and modify + time.Sleep(10 * time.Millisecond) + os.WriteFile(filePath, []byte("# Modified"), 0644) + + changes, _ = scanner.Scan() + newModTime := changes[0].ModTime + + if !newModTime.After(originalModTime) { + t.Error("should detect file modification") + } + + if changes[0].Type != Modified { + t.Errorf("Last state should be modified, got '%v'\n", changes[0].Type) + } + + newPath := filepath.Join(tmpDir, "test_renamed.md") + os.Rename(filePath, newPath) + changes, _ = scanner.Scan() + + if changes[0].Path != newPath { + t.Errorf("Should find renamed file '%s'. Got '%s'\n", newPath, changes[0].Path) + } +} diff --git a/internal/service/note.go b/internal/service/note.go new file mode 100644 index 0000000..fa5a6b3 --- /dev/null +++ b/internal/service/note.go @@ -0,0 +1,124 @@ +package service + +import ( + "donniemarko/internal/note" + "donniemarko/internal/storage" + "sort" + "strings" +) + +type NotesService struct { + storage storage.Storage +} + +type SortOption func([]*note.Note) + +type QueryOptions struct { + SearchTerm string + SortBy string +} + +func NewNoteService() *NotesService { + return &NotesService{} +} + +func (s *NotesService) SetStorage(storage storage.Storage) { + s.storage = storage +} + +func SortByDate(notes []*note.Note) { + sort.Slice(notes, func(i, j int) bool { + return notes[i].UpdatedAt.After(notes[j].UpdatedAt) + }) +} + +func SortByDateAsc(notes []*note.Note) { + sort.Slice(notes, func(i, j int) bool { + return notes[i].UpdatedAt.Before(notes[j].UpdatedAt) + }) +} + +func SortByTitle(notes []*note.Note) { + sort.Slice(notes, func(i, j int) bool { + return notes[i].Title < notes[j].Title + }) +} + +func SortByTitleAsc(notes []*note.Note) { + sort.Slice(notes, func(i, j int) bool { + return notes[i].Title > notes[j].Title + }) +} + +func (s *NotesService) GetNotesWithSort(sortBy SortOption) ([]*note.Note, error) { + notes := s.storage.GetAll() + + if sortBy != nil { + sortBy(notes) + } + + return notes, nil +} + +func (s *NotesService) QueryNotes(opts QueryOptions) ([]*note.Note, error) { + var notes []*note.Note + + // Search or get all + if opts.SearchTerm != "" { + notes = s.storage.Search(opts.SearchTerm) + } else { + notes = s.storage.GetAll() + } + + // Apply sorting + switch opts.SortBy { + case "recent": + SortByDate(notes) + case "alpha": + SortByTitle(notes) + case "oldest": + SortByDateAsc(notes) + default: + SortByDate(notes) // Default sort + } + + return notes, nil +} + +func (s *NotesService) GetNoteByHash(hash string) (*note.Note, error) { + return s.storage.Get(hash) +} + +func (s *NotesService) GetNotes() []*note.Note { + return s.storage.GetAll() +} + +func (s *NotesService) AddTag(noteID, tag string) error { + tag = normalizeTag(tag) + if tag == "" { + return nil + } + + if _, err := s.storage.Get(noteID); err != nil { + return err + } + + return s.storage.AddTag(noteID, tag) +} + +func (s *NotesService) RemoveTag(noteID, tag string) error { + tag = normalizeTag(tag) + if tag == "" { + return nil + } + + if _, err := s.storage.Get(noteID); err != nil { + return err + } + + return s.storage.RemoveTag(noteID, tag) +} + +func normalizeTag(tag string) string { + return strings.ToLower(strings.TrimSpace(tag)) +} diff --git a/internal/service/note_test.go b/internal/service/note_test.go new file mode 100644 index 0000000..883738f --- /dev/null +++ b/internal/service/note_test.go @@ -0,0 +1,76 @@ +package service + +import ( + "testing" + + "donniemarko/internal/note" + "donniemarko/internal/storage" +) + +var service *NotesService + +func TestMain(m *testing.M) { + storage := storage.NewNoteStorage() + + notes := []*note.Note{ + {ID: "test1", Title: "Golang Tutorial", Content: "Learn Go"}, + {ID: "test2", Title: "Rust Guide", Content: "Learn Rust"}, + } + for _, note := range notes { + storage.Create(note) + } + + service = NewNoteService() + service.SetStorage(storage) + m.Run() +} + +func TestQueryNotes_WithSearch(t *testing.T) { + + opts := QueryOptions{ + SearchTerm: "Go", + SortBy: "alpha", + } + + results, err := service.QueryNotes(opts) + + if err != nil { + t.Fatal(err) + } + + if len(results) != 1 { + t.Errorf("expected 1 result, got %d", len(results)) + } + + if results[0].Title != "Golang Tutorial" { + t.Error("wrong note returned") + } +} + +func TestTags_NormalizationAndRemove(t *testing.T) { + err := service.AddTag("test1", " Go ") + if err != nil { + t.Fatalf("add tag: %v", err) + } + + n, err := service.GetNoteByHash("test1") + if err != nil { + t.Fatalf("get note: %v", err) + } + if len(n.Tags) != 1 || n.Tags[0] != "go" { + t.Fatalf("expected normalized tag, got %+v", n.Tags) + } + + err = service.RemoveTag("test1", "GO") + if err != nil { + t.Fatalf("remove tag: %v", err) + } + + n, err = service.GetNoteByHash("test1") + if err != nil { + t.Fatalf("get note: %v", err) + } + if len(n.Tags) != 0 { + t.Fatalf("expected tag to be removed, got %+v", n.Tags) + } +} diff --git a/internal/storage/sqlite.go b/internal/storage/sqlite.go new file mode 100644 index 0000000..a879e77 --- /dev/null +++ b/internal/storage/sqlite.go @@ -0,0 +1,336 @@ +package storage + +import ( + "database/sql" + "fmt" + "time" + + "donniemarko/internal/note" + + _ "modernc.org/sqlite" +) + +type SQLiteStorage struct { + db *sql.DB +} + +const sqliteSchema = ` +PRAGMA foreign_keys = ON; + +CREATE TABLE IF NOT EXISTS notes ( + id TEXT PRIMARY KEY, + path TEXT NOT NULL UNIQUE, + title TEXT NOT NULL, + content TEXT NOT NULL, + updated_at INTEGER NOT NULL, + size INTEGER NOT NULL, + published INTEGER NOT NULL +); + +CREATE TABLE IF NOT EXISTS tags ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT NOT NULL UNIQUE +); + +CREATE TABLE IF NOT EXISTS note_tags ( + note_id TEXT NOT NULL, + tag_id INTEGER NOT NULL, + UNIQUE(note_id, tag_id), + FOREIGN KEY(note_id) REFERENCES notes(id) ON DELETE CASCADE, + FOREIGN KEY(tag_id) REFERENCES tags(id) ON DELETE CASCADE +); + +CREATE INDEX IF NOT EXISTS notes_updated_at_idx ON notes(updated_at); +CREATE INDEX IF NOT EXISTS notes_path_idx ON notes(path); +CREATE INDEX IF NOT EXISTS note_tags_note_idx ON note_tags(note_id); +CREATE INDEX IF NOT EXISTS note_tags_tag_idx ON note_tags(tag_id); +` + +func NewSQLiteStorage(dbPath string) (*SQLiteStorage, error) { + db, err := sql.Open("sqlite", dbPath) + if err != nil { + return nil, fmt.Errorf("open sqlite: %w", err) + } + + if _, err := db.Exec(sqliteSchema); err != nil { + _ = db.Close() + return nil, fmt.Errorf("init schema: %w", err) + } + + return &SQLiteStorage{db: db}, nil +} + +func (s *SQLiteStorage) Close() error { + if s.db == nil { + return nil + } + return s.db.Close() +} + +func (s *SQLiteStorage) GetAll() []*note.Note { + rows, err := s.db.Query(` + SELECT id, path, title, content, updated_at, size, published + FROM notes + `) + if err != nil { + return []*note.Note{} + } + defer rows.Close() + + var notes []*note.Note + for rows.Next() { + n, err := scanNote(rows) + if err != nil { + continue + } + n.Tags = s.GetTags(n.ID) + notes = append(notes, n) + } + + return notes +} + +func (s *SQLiteStorage) Get(id string) (*note.Note, error) { + row := s.db.QueryRow(` + SELECT id, path, title, content, updated_at, size, published + FROM notes + WHERE id = ? + `, id) + + n, err := scanNote(row) + if err != nil { + if err == sql.ErrNoRows { + return nil, fmt.Errorf("No note with id '%s'", id) + } + return nil, err + } + + n.Tags = s.GetTags(n.ID) + return n, nil +} + +func (s *SQLiteStorage) Create(n *note.Note) error { + _, err := s.db.Exec(` + INSERT INTO notes (id, path, title, content, updated_at, size, published) + VALUES (?, ?, ?, ?, ?, ?, ?) + ON CONFLICT(id) DO UPDATE SET + path = excluded.path, + title = excluded.title, + content = excluded.content, + updated_at = excluded.updated_at, + size = excluded.size, + published = excluded.published + `, + n.ID, + n.Path, + n.Title, + n.Content, + toUnix(n.UpdatedAt), + n.Size, + boolToInt(n.Published), + ) + if err != nil { + return fmt.Errorf("insert note: %w", err) + } + + return nil +} + +func (s *SQLiteStorage) Delete(id string) { + _, _ = s.db.Exec(`DELETE FROM notes WHERE id = ?`, id) +} + +func (s *SQLiteStorage) Update(id string, n *note.Note) { + _, _ = s.db.Exec(` + UPDATE notes + SET path = ?, title = ?, content = ?, updated_at = ?, size = ?, published = ? + WHERE id = ? + `, + n.Path, + n.Title, + n.Content, + toUnix(n.UpdatedAt), + n.Size, + boolToInt(n.Published), + id, + ) +} + +func (s *SQLiteStorage) Search(query string) []*note.Note { + pattern := "%" + query + "%" + rows, err := s.db.Query(` + SELECT id, path, title, content, updated_at, size, published + FROM notes + WHERE lower(content) LIKE lower(?) + OR id IN ( + SELECT nt.note_id + FROM note_tags nt + JOIN tags t ON t.id = nt.tag_id + WHERE lower(t.name) LIKE lower(?) + ) + `, pattern, pattern) + if err != nil { + return []*note.Note{} + } + defer rows.Close() + + var notes []*note.Note + for rows.Next() { + n, err := scanNote(rows) + if err != nil { + continue + } + n.Tags = s.GetTags(n.ID) + notes = append(notes, n) + } + + return notes +} + +func (s *SQLiteStorage) Count() int { + row := s.db.QueryRow(`SELECT COUNT(*) FROM notes`) + var count int + if err := row.Scan(&count); err != nil { + return 0 + } + return count +} + +func (s *SQLiteStorage) AddTag(noteID, tag string) error { + tx, err := s.db.Begin() + if err != nil { + return fmt.Errorf("begin tx: %w", err) + } + + if _, err := tx.Exec(`INSERT OR IGNORE INTO tags (name) VALUES (?)`, tag); err != nil { + _ = tx.Rollback() + return fmt.Errorf("insert tag: %w", err) + } + + var tagID int64 + if err := tx.QueryRow(`SELECT id FROM tags WHERE name = ?`, tag).Scan(&tagID); err != nil { + _ = tx.Rollback() + return fmt.Errorf("lookup tag: %w", err) + } + + if _, err := tx.Exec(`INSERT OR IGNORE INTO note_tags (note_id, tag_id) VALUES (?, ?)`, noteID, tagID); err != nil { + _ = tx.Rollback() + return fmt.Errorf("attach tag: %w", err) + } + + if err := tx.Commit(); err != nil { + return fmt.Errorf("commit: %w", err) + } + + return nil +} + +func (s *SQLiteStorage) RemoveTag(noteID, tag string) error { + tx, err := s.db.Begin() + if err != nil { + return fmt.Errorf("begin tx: %w", err) + } + + var tagID int64 + err = tx.QueryRow(`SELECT id FROM tags WHERE name = ?`, tag).Scan(&tagID) + if err != nil { + if err == sql.ErrNoRows { + _ = tx.Rollback() + return nil + } + _ = tx.Rollback() + return fmt.Errorf("lookup tag: %w", err) + } + + if _, err := tx.Exec(`DELETE FROM note_tags WHERE note_id = ? AND tag_id = ?`, noteID, tagID); err != nil { + _ = tx.Rollback() + return fmt.Errorf("detach tag: %w", err) + } + + if _, err := tx.Exec(`DELETE FROM tags WHERE id = ? AND NOT EXISTS (SELECT 1 FROM note_tags WHERE tag_id = ?)`, tagID, tagID); err != nil { + _ = tx.Rollback() + return fmt.Errorf("cleanup tag: %w", err) + } + + if err := tx.Commit(); err != nil { + return fmt.Errorf("commit: %w", err) + } + + return nil +} + +func (s *SQLiteStorage) GetTags(noteID string) []string { + rows, err := s.db.Query(` + SELECT t.name + FROM tags t + JOIN note_tags nt ON nt.tag_id = t.id + WHERE nt.note_id = ? + ORDER BY t.name + `, noteID) + if err != nil { + return []string{} + } + defer rows.Close() + + var tags []string + for rows.Next() { + var name string + if err := rows.Scan(&name); err != nil { + continue + } + tags = append(tags, name) + } + + return tags +} + +type scanner interface { + Scan(dest ...interface{}) error +} + +func scanNote(row scanner) (*note.Note, error) { + var ( + id string + path string + title string + content string + updated int64 + size int64 + published int + ) + + if err := row.Scan(&id, &path, &title, &content, &updated, &size, &published); err != nil { + return nil, err + } + + return ¬e.Note{ + ID: id, + Path: path, + Title: title, + Content: content, + UpdatedAt: fromUnix(updated), + Size: size, + Published: published != 0, + }, nil +} + +func toUnix(t time.Time) int64 { + if t.IsZero() { + return 0 + } + return t.UTC().Unix() +} + +func fromUnix(v int64) time.Time { + if v == 0 { + return time.Time{} + } + return time.Unix(v, 0).UTC() +} + +func boolToInt(v bool) int { + if v { + return 1 + } + return 0 +} diff --git a/internal/storage/sqlite_test.go b/internal/storage/sqlite_test.go new file mode 100644 index 0000000..e16ab32 --- /dev/null +++ b/internal/storage/sqlite_test.go @@ -0,0 +1,238 @@ +package storage + +import ( + "path/filepath" + "testing" + "time" + + "donniemarko/internal/note" +) + +func newSQLiteStorage(t *testing.T) *SQLiteStorage { + t.Helper() + + dbPath := filepath.Join(t.TempDir(), "notes.db") + st, err := NewSQLiteStorage(dbPath) + if err != nil { + t.Fatalf("new sqlite storage: %v", err) + } + t.Cleanup(func() { + _ = st.Close() + }) + + return st +} + +func sampleNote(id, path, title, content string, tstamp time.Time) *note.Note { + return ¬e.Note{ + ID: id, + Path: path, + Title: title, + Content: content, + UpdatedAt: tstamp.Add(2 * time.Hour), + Size: int64(len(content)), + Published: true, + } +} + +func TestSQLiteStorage_CreateGet(t *testing.T) { + st := newSQLiteStorage(t) + + ts := time.Date(2026, 2, 3, 12, 0, 0, 0, time.UTC) + n := sampleNote("n1", "notes/alpha.md", "Alpha", "# Alpha", ts) + + if err := st.Create(n); err != nil { + t.Fatalf("create note: %v", err) + } + + got, err := st.Get("n1") + if err != nil { + t.Fatalf("get note: %v", err) + } + + if got.Title != n.Title || got.Path != n.Path || got.Content != n.Content { + t.Fatalf("unexpected note fields: %+v", got) + } + if !got.UpdatedAt.Equal(n.UpdatedAt) || got.Size != n.Size { + t.Fatalf("unexpected time fields: %+v", got) + } + if !got.Published { + t.Fatalf("expected published to be true") + } +} + +func TestSQLiteStorage_GetAll(t *testing.T) { + st := newSQLiteStorage(t) + + ts := time.Date(2026, 2, 3, 12, 0, 0, 0, time.UTC) + if err := st.Create(sampleNote("n1", "notes/alpha.md", "Alpha", "one", ts)); err != nil { + t.Fatalf("create note: %v", err) + } + if err := st.Create(sampleNote("n2", "notes/beta.md", "Beta", "two", ts)); err != nil { + t.Fatalf("create note: %v", err) + } + + all := st.GetAll() + if len(all) != 2 { + t.Fatalf("expected 2 notes, got %d", len(all)) + } +} + +func TestSQLiteStorage_Update(t *testing.T) { + st := newSQLiteStorage(t) + + ts := time.Date(2026, 2, 3, 12, 0, 0, 0, time.UTC) + n := sampleNote("n1", "notes/alpha.md", "Alpha", "one", ts) + if err := st.Create(n); err != nil { + t.Fatalf("create note: %v", err) + } + + updated := sampleNote("n1", "notes/alpha.md", "Alpha Updated", "two", ts.Add(24*time.Hour)) + st.Update("n1", updated) + + got, err := st.Get("n1") + if err != nil { + t.Fatalf("get note: %v", err) + } + if got.Title != "Alpha Updated" || got.Content != "two" { + t.Fatalf("update did not persist: %+v", got) + } +} + +func TestSQLiteStorage_Delete(t *testing.T) { + st := newSQLiteStorage(t) + + ts := time.Date(2026, 2, 3, 12, 0, 0, 0, time.UTC) + if err := st.Create(sampleNote("n1", "notes/alpha.md", "Alpha", "one", ts)); err != nil { + t.Fatalf("create note: %v", err) + } + + st.Delete("n1") + + if st.Count() != 0 { + t.Fatalf("expected count 0 after delete") + } + + if _, err := st.Get("n1"); err == nil { + t.Fatalf("expected error for missing note") + } +} + +func TestSQLiteStorage_Search(t *testing.T) { + st := newSQLiteStorage(t) + + ts := time.Date(2026, 2, 3, 12, 0, 0, 0, time.UTC) + if err := st.Create(sampleNote("n1", "notes/alpha.md", "Alpha", "Rust tips", ts)); err != nil { + t.Fatalf("create note: %v", err) + } + if err := st.Create(sampleNote("n2", "notes/beta.md", "Beta", "Golang tutorial", ts)); err != nil { + t.Fatalf("create note: %v", err) + } + + results := st.Search("rust") + if len(results) != 1 { + t.Fatalf("expected 1 result, got %d", len(results)) + } + if results[0].ID != "n1" { + t.Fatalf("expected rust match to be n1") + } +} + +func TestSQLiteStorage_Count(t *testing.T) { + st := newSQLiteStorage(t) + + if st.Count() != 0 { + t.Fatalf("expected empty count to be 0") + } + + ts := time.Date(2026, 2, 3, 12, 0, 0, 0, time.UTC) + if err := st.Create(sampleNote("n1", "notes/alpha.md", "Alpha", "one", ts)); err != nil { + t.Fatalf("create note: %v", err) + } + if err := st.Create(sampleNote("n2", "notes/beta.md", "Beta", "two", ts)); err != nil { + t.Fatalf("create note: %v", err) + } + + if st.Count() != 2 { + t.Fatalf("expected count 2") + } +} + +func TestSQLiteStorage_Tags(t *testing.T) { + st := newSQLiteStorage(t) + + ts := time.Date(2026, 2, 3, 12, 0, 0, 0, time.UTC) + if err := st.Create(sampleNote("n1", "notes/alpha.md", "Alpha", "one", ts)); err != nil { + t.Fatalf("create note: %v", err) + } + + if err := st.AddTag("n1", "go"); err != nil { + t.Fatalf("add tag: %v", err) + } + if err := st.AddTag("n1", "rust"); err != nil { + t.Fatalf("add tag: %v", err) + } + + tags := st.GetTags("n1") + if len(tags) != 2 { + t.Fatalf("expected 2 tags, got %d", len(tags)) + } + + if err := st.RemoveTag("n1", "go"); err != nil { + t.Fatalf("remove tag: %v", err) + } + + tags = st.GetTags("n1") + if len(tags) != 1 || tags[0] != "rust" { + t.Fatalf("expected remaining tag rust, got %+v", tags) + } +} + +func TestSQLiteStorage_SearchByTag(t *testing.T) { + st := newSQLiteStorage(t) + + ts := time.Date(2026, 2, 3, 12, 0, 0, 0, time.UTC) + if err := st.Create(sampleNote("n1", "notes/alpha.md", "Alpha", "no match", ts)); err != nil { + t.Fatalf("create note: %v", err) + } + if err := st.Create(sampleNote("n2", "notes/beta.md", "Beta", "content", ts)); err != nil { + t.Fatalf("create note: %v", err) + } + + if err := st.AddTag("n2", "Go"); err != nil { + t.Fatalf("add tag: %v", err) + } + + results := st.Search("go") + if len(results) != 1 { + t.Fatalf("expected 1 result, got %d", len(results)) + } + if results[0].ID != "n2" { + t.Fatalf("expected tag match to be n2") + } +} + +func TestSQLiteStorage_Create_Upsert(t *testing.T) { + st := newSQLiteStorage(t) + + ts := time.Date(2026, 2, 3, 12, 0, 0, 0, time.UTC) + n := sampleNote("n1", "notes/alpha.md", "Alpha", "one", ts) + if err := st.Create(n); err != nil { + t.Fatalf("create note: %v", err) + } + + n.Content = "updated" + n.Title = "Alpha Updated" + n.UpdatedAt = ts.Add(2 * time.Hour) + if err := st.Create(n); err != nil { + t.Fatalf("upsert note: %v", err) + } + + got, err := st.Get("n1") + if err != nil { + t.Fatalf("get note: %v", err) + } + if got.Title != "Alpha Updated" || got.Content != "updated" { + t.Fatalf("expected note to be updated, got %+v", got) + } +} diff --git a/internal/storage/storage.go b/internal/storage/storage.go new file mode 100644 index 0000000..71a8120 --- /dev/null +++ b/internal/storage/storage.go @@ -0,0 +1,130 @@ +package storage + +import ( + "donniemarko/internal/note" + "fmt" + "strings" +) + +type Storage interface { + GetAll() []*note.Note + Get(id string) (*note.Note, error) + Create(n *note.Note) error + Delete(id string) + Update(id string, n *note.Note) + Search(query string) []*note.Note + Count() int + AddTag(noteID, tag string) error + RemoveTag(noteID, tag string) error + GetTags(noteID string) []string +} + +type NoteStorage struct { + Index map[string]*note.Note +} + +func NewNoteStorage() *NoteStorage { + return &NoteStorage{Index: make(map[string]*note.Note)} +} + +// GetAll returns all notes stored in the index +func (ns *NoteStorage) GetAll() []*note.Note { + var notes []*note.Note + + for _, value := range ns.Index { + notes = append(notes, value) + } + return notes +} + +func (ns *NoteStorage) Get(id string) (*note.Note, error) { + n, ok := ns.Index[id] + if ok { + return n, nil + } + return nil, fmt.Errorf("No note with id '%s'", id) +} + +func (ns *NoteStorage) Create(n *note.Note) error { + ns.Index[n.ID] = n + return nil +} + +func (ns *NoteStorage) Count() int { + return len(ns.Index) +} + +func (ns *NoteStorage) Delete(id string) { + delete(ns.Index, id) +} + +func (ns *NoteStorage) Update(id string, n *note.Note) { + ns.Index[id] = n +} + +func (ns *NoteStorage) Search(query string) []*note.Note { + results := []*note.Note{} + for _, note := range ns.Index { + lowContent := strings.ToLower(string(note.Content)) + lowQuery := strings.ToLower(query) + if strings.Contains(lowContent, lowQuery) || tagsContain(note.Tags, lowQuery) { + results = append(results, note) + } + } + return results +} + +func tagsContain(tags []string, query string) bool { + if query == "" { + return false + } + for _, tag := range tags { + if strings.Contains(strings.ToLower(tag), query) { + return true + } + } + return false +} + +func (ns *NoteStorage) AddTag(noteID, tag string) error { + n, ok := ns.Index[noteID] + if !ok { + return fmt.Errorf("No note with id '%s'", noteID) + } + + for _, existing := range n.Tags { + if existing == tag { + return nil + } + } + + n.Tags = append(n.Tags, tag) + return nil +} + +func (ns *NoteStorage) RemoveTag(noteID, tag string) error { + n, ok := ns.Index[noteID] + if !ok { + return fmt.Errorf("No note with id '%s'", noteID) + } + + updated := n.Tags[:0] + for _, existing := range n.Tags { + if existing != tag { + updated = append(updated, existing) + } + } + n.Tags = updated + return nil +} + +func (ns *NoteStorage) GetTags(noteID string) []string { + n, ok := ns.Index[noteID] + if !ok { + return []string{} + } + + tags := make([]string, len(n.Tags)) + copy(tags, n.Tags) + return tags +} diff --git a/internal/storage/storage_test.go b/internal/storage/storage_test.go new file mode 100644 index 0000000..b56135f --- /dev/null +++ b/internal/storage/storage_test.go @@ -0,0 +1,70 @@ +package storage + +import ( + "donniemarko/internal/note" + "testing" +) + +var ns *NoteStorage +var n1, n2 *note.Note + +func TestMain(m *testing.M) { + ns = NewNoteStorage() + n1 = note.NewNote() + n1.Path = "test/note1.md" + n1.ID = note.GenerateNoteID(n1.Path) + n1.Content = "# hola amigo" + + n2 = note.NewNote() + n2.Path = "note2.md" + n2.ID = note.GenerateNoteID(n2.Path) + n2.Content = "# ah si ?" + m.Run() +} + +func TestNoteStorageCreate(t *testing.T) { + ns.Create(n1) + ns.Create(n2) + + if len(ns.Index) < 2 { + t.Errorf("Creating notes should add them to the storage. Wanted 2, got '%v'", len(ns.Index)) + } +} + +func TestNoteStorageDelete(t *testing.T) { + ns.Delete(n1.ID) + + if len(ns.Index) > 1 { + t.Errorf("Deleting notes should remove them from to the storage. Wanted 1, got '%v'", len(ns.Index)) + } +} + +func TestNoteStorageGetUpdate(t *testing.T) { + ns.Update(n2.ID, n1) + + nn2, err := ns.Get(n2.ID) + if err != nil { + t.Errorf("Error retrieving note with id '%s': '%v'", n2.ID, err) + } + + if nn2.Content != n1.Content { + t.Errorf("Updating a note should reflect it in storage. Wanted '%s', got '%s'\n", n1.Content, nn2.Content) + } +} + +func TestNoteStorageSearch_Tags(t *testing.T) { + ns = NewNoteStorage() + + n := note.NewNote() + n.Path = "note3.md" + n.ID = note.GenerateNoteID(n.Path) + n.Content = "no tag here" + n.Tags = []string{"devops", "go"} + + ns.Create(n) + + results := ns.Search("go") + if len(results) != 1 { + t.Fatalf("expected 1 result, got %d", len(results)) + } +} diff --git a/internal/web/handler.go b/internal/web/handler.go new file mode 100644 index 0000000..8e91811 --- /dev/null +++ b/internal/web/handler.go @@ -0,0 +1,250 @@ +package web + +import ( + "donniemarko/internal/note" + "donniemarko/internal/render" + "donniemarko/internal/service" + "html/template" + "net/http" + "net/url" + "strings" +) + +type Handler struct { + notesService *service.NotesService + templates *render.TemplateManager + mux *http.ServeMux +} + +func NewHandler(ns *service.NotesService, tm *render.TemplateManager) *Handler { + return &Handler{ + notesService: ns, + templates: tm, + mux: http.NewServeMux(), + } +} + +func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + + // Handle root and note list + if path == "/" { + h.handleRoot(w, r) + return + } + + // Handle individual notes + if strings.HasPrefix(path, "/notes/") { + if strings.Contains(path, "/tags") { + h.handleTags(w, r) + return + } + h.handleNotes(w, r) + return + } + + // Handle 404 for other paths + http.NotFound(w, r) +} + +// ViewState is built per-request, not shared +type ViewState struct { + Notes []*note.Note + Note *note.Note + RenderedNote template.HTML + SortBy string + SearchTerm string + TagFilter string + LastActive string +} + +func (h *Handler) handleRoot(w http.ResponseWriter, r *http.Request) { + // Build view state from query params + state, err := h.buildViewState(r) + if err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return + } + + // Render with state + h.templates.Render(w, "index", state) +} + +func (h *Handler) buildViewState(r *http.Request) (*ViewState, error) { + query := r.URL.Query() + + // Extract params + sortBy := query.Get("sort") + if sortBy == "" { + sortBy = "recent" + } + + searchTerm := query.Get("search") + tagFilter := query.Get("tag") + + // Get notes from service + var notes []*note.Note + var err error + + if searchTerm != "" { + opts := service.QueryOptions{ + SearchTerm: searchTerm, + SortBy: sortBy, + } + notes, err = h.notesService.QueryNotes(opts) + if err != nil { + return nil, err + } + } else { + notes = h.notesService.GetNotes() + + // Apply sorting + switch sortBy { + case "recent": + service.SortByDate(notes) + case "oldest": + service.SortByDateAsc(notes) + case "alpha": + service.SortByTitle(notes) + case "ralpha": + service.SortByTitleAsc(notes) + default: + service.SortByDate(notes) + } + } + + if tagFilter != "" { + notes = filterNotesByTag(notes, tagFilter) + } + + return &ViewState{ + Notes: notes, + SortBy: sortBy, + SearchTerm: searchTerm, + TagFilter: tagFilter, + }, nil +} + +func (h *Handler) SetupRoutes() { + // Set the handler as the main handler for http.DefaultServeMux + http.Handle("/", h) + http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("internal/web/static")))) +} + +func extractHash(path string) string { + // Extract hash from /notes/{hash} + parts := strings.Split(strings.Trim(path, "/"), "/") + if len(parts) < 2 || parts[0] != "notes" { + return "" + } + return parts[1] +} + +func (h *Handler) handleNotes(w http.ResponseWriter, r *http.Request) { + // Build base state + state, err := h.buildViewState(r) + if err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return + } + + // Extract hash from URL + hash := extractHash(r.URL.Path) + + // Get specific note + note, err := h.notesService.GetNoteByHash(hash) + if err != nil { + http.Error(w, "Note not found", http.StatusNotFound) + return + } + + // Convert markdown to HTML + htmlContent, err := render.RenderMarkdown([]byte(note.Content)) + if err != nil { + http.Error(w, "Failed to render markdown", http.StatusInternalServerError) + return + } + + // Add to state + state.Note = note + state.RenderedNote = htmlContent + state.LastActive = hash + + h.templates.Render(w, "index", state) +} + +func filterNotesByTag(notes []*note.Note, tag string) []*note.Note { + tag = strings.ToLower(strings.TrimSpace(tag)) + if tag == "" { + return notes + } + + filtered := make([]*note.Note, 0, len(notes)) + for _, n := range notes { + for _, t := range n.Tags { + if strings.EqualFold(t, tag) { + filtered = append(filtered, n) + break + } + } + } + return filtered +} + +func (h *Handler) handleTags(w http.ResponseWriter, r *http.Request) { + if r.Method != http.MethodPost { + http.Error(w, "Method not allowed", http.StatusMethodNotAllowed) + return + } + + noteID, tag, isRemove := parseTagRoute(r.URL.Path) + if noteID == "" { + http.NotFound(w, r) + return + } + + if isRemove { + if tag == "" { + http.Error(w, "Missing tag", http.StatusBadRequest) + return + } + if err := h.notesService.RemoveTag(noteID, tag); err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return + } + } else { + if err := r.ParseForm(); err != nil { + http.Error(w, "Invalid form", http.StatusBadRequest) + return + } + tag := r.FormValue("tag") + if tag == "" { + http.Error(w, "Missing tag", http.StatusBadRequest) + return + } + if err := h.notesService.AddTag(noteID, tag); err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return + } + } + + http.Redirect(w, r, "/notes/"+noteID, http.StatusSeeOther) +} + +func parseTagRoute(path string) (noteID string, tag string, isRemove bool) { + parts := strings.Split(strings.Trim(path, "/"), "/") + if len(parts) < 3 || parts[0] != "notes" || parts[2] != "tags" { + return "", "", false + } + + noteID = parts[1] + if len(parts) >= 4 { + decoded, err := url.PathUnescape(parts[3]) + if err != nil { + return noteID, "", true + } + return noteID, decoded, true + } + + return noteID, "", false +} diff --git a/internal/web/handler_test.go b/internal/web/handler_test.go new file mode 100644 index 0000000..0e2974f --- /dev/null +++ b/internal/web/handler_test.go @@ -0,0 +1,307 @@ +package web + +import ( + "net/http" + "net/http/httptest" + "net/url" + "strings" + "testing" + "time" + + "donniemarko/internal/note" + "donniemarko/internal/render" + "donniemarko/internal/service" + "donniemarko/internal/storage" +) + +type testEnv struct { + handler *Handler + storage *storage.NoteStorage +} + +func newTestEnv(t *testing.T) *testEnv { + t.Helper() + + ns := storage.NewNoteStorage() + + notes := []*note.Note{ + { + ID: "a1", + Title: "Alpha", + Content: "# Alpha\ncontent", + UpdatedAt: time.Date(2025, 12, 31, 10, 0, 0, 0, time.UTC), + }, + { + ID: "b2", + Title: "Beta", + Content: "# Beta\nRust tips", + UpdatedAt: time.Date(2026, 1, 1, 10, 0, 0, 0, time.UTC), + }, + { + ID: "z9", + Title: "Zulu", + Content: "# Zulu\nRust book", + UpdatedAt: time.Date(2026, 1, 2, 10, 0, 0, 0, time.UTC), + }, + } + + for _, n := range notes { + if err := ns.Create(n); err != nil { + t.Fatalf("create note: %v", err) + } + } + + svc := service.NewNoteService() + svc.SetStorage(ns) + + tm := render.NewTemplateManager("templates") + handler := NewHandler(svc, tm) + + return &testEnv{ + handler: handler, + storage: ns, + } +} + +func assertOrder(t *testing.T, body string, want []string) { + t.Helper() + + prev := -1 + for _, title := range want { + idx := strings.Index(body, title) + if idx == -1 { + t.Fatalf("expected to find %q in response body", title) + } + if idx <= prev { + t.Fatalf("expected %q to appear after previous title", title) + } + prev = idx + } +} + +func noteMarker(id string) string { + return `data-hash="` + id + `"` +} + +func TestHandlerRoot_DefaultSortRecent(t *testing.T) { + env := newTestEnv(t) + + req := httptest.NewRequest(http.MethodGet, "/", nil) + rec := httptest.NewRecorder() + + env.handler.ServeHTTP(rec, req) + + if rec.Code != http.StatusOK { + t.Fatalf("expected status 200, got %d", rec.Code) + } + + if ct := rec.Header().Get("Content-Type"); ct != "text/html; charset=utf-8" { + t.Fatalf("expected content-type text/html; charset=utf-8, got %q", ct) + } + + body := rec.Body.String() + assertOrder(t, body, []string{noteMarker("z9"), noteMarker("b2"), noteMarker("a1")}) +} + +func TestHandlerRoot_SortAlpha(t *testing.T) { + env := newTestEnv(t) + + req := httptest.NewRequest(http.MethodGet, "/?sort=alpha", nil) + rec := httptest.NewRecorder() + + env.handler.ServeHTTP(rec, req) + + if rec.Code != http.StatusOK { + t.Fatalf("expected status 200, got %d", rec.Code) + } + + body := rec.Body.String() + assertOrder(t, body, []string{noteMarker("a1"), noteMarker("b2"), noteMarker("z9")}) +} + +func TestHandlerRoot_Search(t *testing.T) { + env := newTestEnv(t) + + req := httptest.NewRequest(http.MethodGet, "/?search=rust&sort=alpha", nil) + rec := httptest.NewRecorder() + + env.handler.ServeHTTP(rec, req) + + if rec.Code != http.StatusOK { + t.Fatalf("expected status 200, got %d", rec.Code) + } + + body := rec.Body.String() + if !strings.Contains(body, "Matching results for query 'rust'") { + t.Fatalf("expected search header to be rendered") + } + + if strings.Contains(body, `data-hash="a1"`) { + t.Fatalf("expected non-matching note to be excluded") + } + + assertOrder(t, body, []string{noteMarker("b2"), noteMarker("z9")}) +} + +func TestHandlerNotes_Success(t *testing.T) { + env := newTestEnv(t) + + req := httptest.NewRequest(http.MethodGet, "/notes/b2", nil) + rec := httptest.NewRecorder() + + env.handler.ServeHTTP(rec, req) + + if rec.Code != http.StatusOK { + t.Fatalf("expected status 200, got %d", rec.Code) + } + + body := rec.Body.String() + if !strings.Contains(body, "