150 lines
3.7 KiB
Go
150 lines
3.7 KiB
Go
// Package notes implements a data structure for reasoning about and rendering
|
|
// markdown notes
|
|
package notes
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/base64"
|
|
"errors"
|
|
"fmt"
|
|
"html/template"
|
|
"log"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
"forgejo.gwairfelin.com/max/gonotes/internal/conf"
|
|
markdown "github.com/teekennedy/goldmark-markdown"
|
|
"github.com/yuin/goldmark"
|
|
"github.com/yuin/goldmark/ast"
|
|
"github.com/yuin/goldmark/extension"
|
|
astext "github.com/yuin/goldmark/extension/ast"
|
|
"github.com/yuin/goldmark/parser"
|
|
"github.com/yuin/goldmark/text"
|
|
"github.com/yuin/goldmark/util"
|
|
)
|
|
|
|
// Note is the central data structure. It can be Saved, Rendered and Loaded
|
|
// using the Save, Render and LoadNote functions.
|
|
type Note struct {
|
|
Title string
|
|
BodyRendered template.HTML
|
|
Body []byte
|
|
}
|
|
|
|
func fmtPath(path string) string {
|
|
return fmt.Sprintf("%s.%s", path, conf.Conf.Extension)
|
|
}
|
|
|
|
// Save a note to a path derived from the title
|
|
func (n *Note) Save() error {
|
|
filename := filepath.Join(conf.Conf.NotesDir, fmtPath(n.EncodedTitle()))
|
|
return os.WriteFile(filename, n.Body, 0600)
|
|
}
|
|
|
|
// Render the markdown content of the note to HTML
|
|
func (n *Note) Render() {
|
|
var buf bytes.Buffer
|
|
md := goldmark.New(
|
|
goldmark.WithExtensions(
|
|
extension.TaskList,
|
|
),
|
|
)
|
|
err := md.Convert(n.Body, &buf)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
n.BodyRendered = template.HTML(buf.String())
|
|
}
|
|
|
|
// LoadNote from the disk. The path is derived from the title
|
|
func LoadNote(encodedTitle string) (*Note, error) {
|
|
filename := filepath.Join(conf.Conf.NotesDir, fmtPath(encodedTitle))
|
|
body, err := os.ReadFile(filename)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
title := DecodeTitle(encodedTitle)
|
|
return &Note{Title: title, Body: body}, nil
|
|
}
|
|
|
|
func DeleteNote(title string) error {
|
|
filename := filepath.Join(conf.Conf.NotesDir, fmtPath(title))
|
|
return os.Remove(filename)
|
|
}
|
|
|
|
func (n *Note) EncodedTitle() string {
|
|
return base64.StdEncoding.EncodeToString([]byte(n.Title))
|
|
}
|
|
|
|
type toggleCheckboxTransformer struct{ nthBox int }
|
|
|
|
func (t *toggleCheckboxTransformer) Transform(node *ast.Document, reader text.Reader, pc parser.Context) {
|
|
boxesFound := 0
|
|
|
|
// Walk to find checkbox, toggle checked status
|
|
ast.Walk(node, func(n ast.Node, entering bool) (ast.WalkStatus, error) {
|
|
if !entering {
|
|
return ast.WalkContinue, nil
|
|
}
|
|
|
|
box, ok := n.(*astext.TaskCheckBox)
|
|
if !ok {
|
|
return ast.WalkContinue, nil
|
|
}
|
|
|
|
if boxesFound < t.nthBox {
|
|
boxesFound += 1
|
|
return ast.WalkContinue, nil
|
|
}
|
|
|
|
box.IsChecked = !box.IsChecked
|
|
return ast.WalkStop, nil
|
|
})
|
|
}
|
|
|
|
func renderTaskCheckBox(writer util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {
|
|
var err error
|
|
var _ int
|
|
n, ok := node.(*astext.TaskCheckBox)
|
|
if !ok {
|
|
return ast.WalkContinue, errors.New("not a TaskCheckBox")
|
|
}
|
|
if entering {
|
|
// Render a box if necessary
|
|
if n.IsChecked {
|
|
_, err = writer.Write([]byte("[x] "))
|
|
} else {
|
|
_, err = writer.Write([]byte("[ ] "))
|
|
}
|
|
}
|
|
return ast.WalkContinue, err
|
|
}
|
|
|
|
func (n *Note) ToggleBox(nthBox int) {
|
|
checkboxTransformer := toggleCheckboxTransformer{nthBox: nthBox}
|
|
transformer := util.Prioritized(&checkboxTransformer, 0)
|
|
|
|
renderer := markdown.NewRenderer()
|
|
renderer.Register(astext.KindTaskCheckBox, renderTaskCheckBox)
|
|
|
|
var buf bytes.Buffer
|
|
md := goldmark.New(goldmark.WithRenderer(renderer))
|
|
|
|
md.Parser().AddOptions(parser.WithInlineParsers(
|
|
util.Prioritized(extension.NewTaskCheckBoxParser(), 0),
|
|
), parser.WithASTTransformers(transformer))
|
|
|
|
md.Convert(n.Body, &buf)
|
|
n.Body = buf.Bytes()
|
|
n.Save()
|
|
}
|
|
|
|
func DecodeTitle(encodedTitle string) string {
|
|
title, err := base64.StdEncoding.DecodeString(encodedTitle)
|
|
if err != nil {
|
|
log.Printf("Couldn't decode base64 string '%s': %s", encodedTitle, err)
|
|
}
|
|
|
|
return string(title)
|
|
}
|