feat(recurrence): repeating tasks as RRULE, in Danish and English
"vand planterne hver mandag" becomes FREQ=WEEKLY;BYDAY=MO. The stored form is RFC 5545, not a private format, so the same field will drive the CalDAV server and the ICS feed without a translation layer. Ticking off a repeating task advances it instead of closing it, keeping the same row — so its sub-tasks and comments stay attached. A weekly review is one thing that recurs, not fifty-two things. The clock time survives the move, and the completion is still written to the activity log, because "what did I get done this week" has to include the chores that repeat. Recurrence is parsed before dates, and that ordering is load-bearing: "hver mandag" contains a weekday, so a date parser reading it first would claim Monday as a one-off and strand "hver" in the title. It is also resolved before the time-only case, or "hver mandag kl 9" typed after nine would land tomorrow morning instead of on Monday. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Kristian Wind
co-authored by
Claude Opus 5
Claude Opus 5
parent
3efc3754af
commit
a96aae57ec
@@ -0,0 +1,354 @@
|
||||
// Package recurrence turns "hver anden mandag" into an RRULE, and an RRULE into
|
||||
// the next date a task is due.
|
||||
//
|
||||
// The stored form is an RFC 5545 recurrence rule, not a private format. That is
|
||||
// what lets the same field drive the CalDAV server and the ICS feed later without
|
||||
// a translation layer, and it means a task exported to Apple Reminders keeps
|
||||
// repeating there.
|
||||
//
|
||||
// Only the RRULE part is stored — "FREQ=WEEKLY;BYDAY=MO" — with no DTSTART. The
|
||||
// task's own due date is the anchor, so moving a task also moves its series,
|
||||
// which is what somebody rescheduling a repeating chore means to happen.
|
||||
package recurrence
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/teambition/rrule-go"
|
||||
)
|
||||
|
||||
// Parse reads a recurrence phrase in Danish or English and returns an RRULE.
|
||||
//
|
||||
// It returns "" when the text does not describe a repetition, which is the common
|
||||
// case — most tasks are not recurring, and a parser that guessed would turn
|
||||
// "ring til mor på mandag" into a weekly obligation.
|
||||
func Parse(text string) string {
|
||||
t := normalise(text)
|
||||
if t == "" {
|
||||
return ""
|
||||
}
|
||||
|
||||
for _, rule := range rules {
|
||||
m := rule.pattern.FindStringSubmatch(t)
|
||||
if m == nil {
|
||||
continue
|
||||
}
|
||||
if out := rule.build(m); out != "" {
|
||||
return out
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func normalise(text string) string {
|
||||
t := strings.ToLower(strings.TrimSpace(text))
|
||||
// "hver anden" and "every other" are ordinary ways of saying "every 2".
|
||||
// Rewriting them here keeps the interval logic in one place instead of
|
||||
// duplicating every frequency pattern for the word form.
|
||||
r := strings.NewReplacer(
|
||||
"hvert andet", "hver 2.",
|
||||
"hver anden", "hver 2.",
|
||||
"hvert tredje", "hver 3.",
|
||||
"hver tredje", "hver 3.",
|
||||
"every other", "every 2",
|
||||
"each ", "every ",
|
||||
)
|
||||
return r.Replace(t)
|
||||
}
|
||||
|
||||
// weekdays maps every spelling somebody might type — Danish and English, full and
|
||||
// short — onto the two-letter codes RFC 5545 uses.
|
||||
var weekdays = map[string]string{
|
||||
"mandag": "MO", "man": "MO", "monday": "MO", "mon": "MO",
|
||||
"tirsdag": "TU", "tir": "TU", "tue": "TU", "tuesday": "TU", "tues": "TU",
|
||||
"onsdag": "WE", "ons": "WE", "wednesday": "WE", "wed": "WE",
|
||||
"torsdag": "TH", "tor": "TH", "thursday": "TH", "thu": "TH", "thur": "TH",
|
||||
"fredag": "FR", "fre": "FR", "friday": "FR", "fri": "FR",
|
||||
"lørdag": "SA", "lor": "SA", "saturday": "SA", "sat": "SA",
|
||||
"søndag": "SU", "son": "SU", "sunday": "SU", "sun": "SU",
|
||||
}
|
||||
|
||||
var months = map[string]int{
|
||||
"januar": 1, "january": 1, "jan": 1,
|
||||
"februar": 2, "february": 2, "feb": 2,
|
||||
"marts": 3, "march": 3, "mar": 3,
|
||||
"april": 4, "apr": 4,
|
||||
"maj": 5, "may": 5,
|
||||
"juni": 6, "june": 6, "jun": 6,
|
||||
"juli": 7, "july": 7, "jul": 7,
|
||||
"august": 8, "aug": 8,
|
||||
"september": 9, "sep": 9, "sept": 9,
|
||||
"oktober": 10, "october": 10, "okt": 10, "oct": 10,
|
||||
"november": 11, "nov": 11,
|
||||
"december": 12, "dec": 12,
|
||||
}
|
||||
|
||||
type rule struct {
|
||||
pattern *regexp.Regexp
|
||||
build func([]string) string
|
||||
}
|
||||
|
||||
// The order matters: the most specific pattern that can match must be tried first,
|
||||
// or "hver 2. mandag" is claimed by the plain weekday rule and loses its interval.
|
||||
var rules = []rule{
|
||||
// "hverdage", "weekdays", "every weekday" — Monday to Friday.
|
||||
{
|
||||
pattern: regexp.MustCompile(`^(?:hver\s+)?(?:hverdag(?:e)?|ugedag(?:e)?)$|^every\s+weekday$|^weekdays?$`),
|
||||
build: func([]string) string { return "FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR" },
|
||||
},
|
||||
// "hver weekend", "every weekend"
|
||||
{
|
||||
pattern: regexp.MustCompile(`^(?:hver\s+)?weekend$|^every\s+weekend$`),
|
||||
build: func([]string) string { return "FREQ=WEEKLY;BYDAY=SA,SU" },
|
||||
},
|
||||
// A list of weekdays: "hver mandag og torsdag", "every monday, wednesday and friday"
|
||||
{
|
||||
pattern: regexp.MustCompile(`^(?:hver|every)\s+(\d+\.?\s+)?(.+)$`),
|
||||
build: func(m []string) string {
|
||||
days := parseWeekdayList(m[2])
|
||||
if len(days) == 0 {
|
||||
return ""
|
||||
}
|
||||
return withInterval("FREQ=WEEKLY;BYDAY="+strings.Join(days, ","), m[1])
|
||||
},
|
||||
},
|
||||
// "hver 3. dag", "every 2 days", "dagligt", "daily"
|
||||
{
|
||||
pattern: regexp.MustCompile(`^(?:hver|every)\s+(\d+\.?\s+)?(dag|dage|day|days)$|^(?:dagligt|daily)$`),
|
||||
build: func(m []string) string {
|
||||
if len(m) > 1 {
|
||||
return withInterval("FREQ=DAILY", m[1])
|
||||
}
|
||||
return "FREQ=DAILY"
|
||||
},
|
||||
},
|
||||
// "hver 2. uge", "every 3 weeks", "ugentligt", "weekly"
|
||||
{
|
||||
pattern: regexp.MustCompile(`^(?:hver|every)\s+(\d+\.?\s+)?(uge|uger|week|weeks)$|^(?:ugentligt|weekly)$`),
|
||||
build: func(m []string) string {
|
||||
if len(m) > 1 {
|
||||
return withInterval("FREQ=WEEKLY", m[1])
|
||||
}
|
||||
return "FREQ=WEEKLY"
|
||||
},
|
||||
},
|
||||
// "hver måned", "every 3 months", "månedligt", "monthly"
|
||||
{
|
||||
pattern: regexp.MustCompile(`^(?:hver|every)\s+(\d+\.?\s+)?(måned|måneder|maaned|maaneder|month|months)$|^(?:månedligt|maanedligt|monthly)$`),
|
||||
build: func(m []string) string {
|
||||
if len(m) > 1 {
|
||||
return withInterval("FREQ=MONTHLY", m[1])
|
||||
}
|
||||
return "FREQ=MONTHLY"
|
||||
},
|
||||
},
|
||||
// "den 1. i måneden", "on the 1st of the month"
|
||||
{
|
||||
pattern: regexp.MustCompile(`^(?:den\s+)?(\d{1,2})\.?\s+(?:i\s+(?:hver\s+)?måned(?:en)?|of\s+(?:the\s+|every\s+)?month)$`),
|
||||
build: func(m []string) string {
|
||||
day, err := strconv.Atoi(m[1])
|
||||
if err != nil || day < 1 || day > 31 {
|
||||
return ""
|
||||
}
|
||||
return fmt.Sprintf("FREQ=MONTHLY;BYMONTHDAY=%d", day)
|
||||
},
|
||||
},
|
||||
// "hvert år", "yearly", "hver 15. marts"
|
||||
{
|
||||
pattern: regexp.MustCompile(`^(?:hver|hvert|every)\s+(?:(\d{1,2})\.?\s+)?(\p{L}+)$`),
|
||||
build: func(m []string) string {
|
||||
month, ok := months[m[2]]
|
||||
if !ok {
|
||||
return ""
|
||||
}
|
||||
if m[1] == "" {
|
||||
return fmt.Sprintf("FREQ=YEARLY;BYMONTH=%d", month)
|
||||
}
|
||||
day, err := strconv.Atoi(m[1])
|
||||
if err != nil || day < 1 || day > 31 {
|
||||
return ""
|
||||
}
|
||||
return fmt.Sprintf("FREQ=YEARLY;BYMONTH=%d;BYMONTHDAY=%d", month, day)
|
||||
},
|
||||
},
|
||||
{
|
||||
pattern: regexp.MustCompile(`^(?:hvert\s+år|hvert\s+aar|årligt|aarligt|every\s+year|yearly|annually)$`),
|
||||
build: func([]string) string { return "FREQ=YEARLY" },
|
||||
},
|
||||
}
|
||||
|
||||
// parseWeekdayList reads "mandag og torsdag" or "monday, wednesday and friday".
|
||||
// Every word has to be a weekday: a list with something else in it is not a list
|
||||
// of weekdays, and half-understanding it would be worse than not matching.
|
||||
func parseWeekdayList(text string) []string {
|
||||
separators := regexp.MustCompile(`\s*(?:,|\bog\b|\band\b|&)\s*`)
|
||||
var days []string
|
||||
seen := map[string]bool{}
|
||||
|
||||
for _, part := range separators.Split(text, -1) {
|
||||
part = strings.TrimSpace(part)
|
||||
if part == "" {
|
||||
continue
|
||||
}
|
||||
code, ok := weekdays[part]
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
if !seen[code] {
|
||||
seen[code] = true
|
||||
days = append(days, code)
|
||||
}
|
||||
}
|
||||
return days
|
||||
}
|
||||
|
||||
// withInterval appends INTERVAL when the phrase carried a number. INTERVAL=1 is the
|
||||
// default and is left out, so "hver uge" and "hver 1. uge" produce the same rule.
|
||||
func withInterval(base, raw string) string {
|
||||
raw = strings.TrimSpace(strings.TrimSuffix(strings.TrimSpace(raw), "."))
|
||||
if raw == "" {
|
||||
return base
|
||||
}
|
||||
n, err := strconv.Atoi(raw)
|
||||
if err != nil || n <= 1 {
|
||||
return base
|
||||
}
|
||||
return fmt.Sprintf("%s;INTERVAL=%d", base, n)
|
||||
}
|
||||
|
||||
// Valid reports whether a rule can be parsed by the RRULE library, so an invalid
|
||||
// one is refused at the API boundary rather than discovered when a task is ticked
|
||||
// off and cannot be advanced.
|
||||
func Valid(rule string) bool {
|
||||
if rule == "" {
|
||||
return true
|
||||
}
|
||||
_, err := compile(rule, time.Now())
|
||||
return err == nil
|
||||
}
|
||||
|
||||
// Next returns the first occurrence strictly after `after`.
|
||||
//
|
||||
// Strictly after matters: the anchor is the task's current due date, and an
|
||||
// implementation that included it would return the same day forever and make
|
||||
// completing a daily task do nothing at all.
|
||||
func Next(rule string, after time.Time) (time.Time, error) {
|
||||
set, err := compile(rule, after)
|
||||
if err != nil {
|
||||
return time.Time{}, err
|
||||
}
|
||||
// A whole day is added rather than a nanosecond so that a rule anchored at
|
||||
// midnight does not return its own anchor back through a rounding difference.
|
||||
next := set.After(after, false)
|
||||
if next.IsZero() {
|
||||
// A finite rule (COUNT or UNTIL) that has run out. The series is over.
|
||||
return time.Time{}, ErrSeriesEnded
|
||||
}
|
||||
return next, nil
|
||||
}
|
||||
|
||||
// ErrSeriesEnded means a bounded rule has produced its last occurrence.
|
||||
var ErrSeriesEnded = fmt.Errorf("recurrence: the series has ended")
|
||||
|
||||
func compile(rule string, anchor time.Time) (*rrule.RRule, error) {
|
||||
if rule == "" {
|
||||
return nil, fmt.Errorf("recurrence: empty rule")
|
||||
}
|
||||
// The stored rule carries no DTSTART; the task's due date supplies it. Dates
|
||||
// are anchored at midnight in the anchor's own location so that adding days
|
||||
// never drifts across a daylight-saving boundary into the previous evening.
|
||||
option, err := rrule.StrToROption("RRULE:" + strings.TrimPrefix(rule, "RRULE:"))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
option.Dtstart = time.Date(anchor.Year(), anchor.Month(), anchor.Day(), 0, 0, 0, 0, anchor.Location())
|
||||
return rrule.NewRRule(*option)
|
||||
}
|
||||
|
||||
// Describe renders a rule back into Danish, for showing on a task without making
|
||||
// somebody read "FREQ=WEEKLY;BYDAY=MO,TH".
|
||||
func Describe(rule string) string {
|
||||
if rule == "" {
|
||||
return ""
|
||||
}
|
||||
parts := map[string]string{}
|
||||
for _, kv := range strings.Split(strings.TrimPrefix(rule, "RRULE:"), ";") {
|
||||
if k, v, ok := strings.Cut(kv, "="); ok {
|
||||
parts[strings.ToUpper(k)] = v
|
||||
}
|
||||
}
|
||||
|
||||
interval := 1
|
||||
if n, err := strconv.Atoi(parts["INTERVAL"]); err == nil && n > 0 {
|
||||
interval = n
|
||||
}
|
||||
|
||||
if days := parts["BYDAY"]; days != "" {
|
||||
if days == "MO,TU,WE,TH,FR" {
|
||||
return "hverdage"
|
||||
}
|
||||
if days == "SA,SU" {
|
||||
return "hver weekend"
|
||||
}
|
||||
names := make([]string, 0, 4)
|
||||
for _, code := range strings.Split(days, ",") {
|
||||
names = append(names, danishDay(code))
|
||||
}
|
||||
return every(interval, "uge") + " " + strings.Join(names, " og ")
|
||||
}
|
||||
|
||||
switch parts["FREQ"] {
|
||||
case "DAILY":
|
||||
return every(interval, "dag")
|
||||
case "WEEKLY":
|
||||
return every(interval, "uge")
|
||||
case "MONTHLY":
|
||||
if d := parts["BYMONTHDAY"]; d != "" {
|
||||
return "den " + d + ". hver måned"
|
||||
}
|
||||
return every(interval, "måned")
|
||||
case "YEARLY":
|
||||
return every(interval, "år")
|
||||
}
|
||||
return rule
|
||||
}
|
||||
|
||||
func every(interval int, unit string) string {
|
||||
if interval <= 1 {
|
||||
if unit == "år" {
|
||||
return "hvert år"
|
||||
}
|
||||
return "hver " + unit
|
||||
}
|
||||
if interval == 2 {
|
||||
if unit == "år" {
|
||||
return "hvert andet år"
|
||||
}
|
||||
return "hver anden " + unit
|
||||
}
|
||||
return fmt.Sprintf("hver %d. %s", interval, unit)
|
||||
}
|
||||
|
||||
func danishDay(code string) string {
|
||||
switch code {
|
||||
case "MO":
|
||||
return "mandag"
|
||||
case "TU":
|
||||
return "tirsdag"
|
||||
case "WE":
|
||||
return "onsdag"
|
||||
case "TH":
|
||||
return "torsdag"
|
||||
case "FR":
|
||||
return "fredag"
|
||||
case "SA":
|
||||
return "lørdag"
|
||||
case "SU":
|
||||
return "søndag"
|
||||
}
|
||||
return code
|
||||
}
|
||||
Reference in New Issue
Block a user