Sources/OrgCore/Capture/Datetree.swift

  1import Foundation
  2
  3// Date trees (org-datetree.el, Org 9.8.7): `org-datetree-find-create-entry` with the groupings
  4// capture uses, and `org-datetree-add-timestamp` nil. Each level is found or created inside
  5// the one above it, as org does while narrowed to it.
  6enum Datetree {
  7    static let weekdays = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
  8    static let months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]
  9
 10    /// Each level's heading title, and the pattern whose first group orders siblings.
 11    static func levels(_ tree: CaptureTemplate.TreeType, date: DateComponents) -> [(title: String, pattern: String)] {
 12        var gregorian = Calendar(identifier: .gregorian)
 13        gregorian.timeZone = TimeZone(identifier: "UTC")!
 14        let day = gregorian.date(from: DateComponents(year: date.year, month: date.month, day: date.day))!
 15        let weekday = weekdays[gregorian.component(.weekday, from: day) - 1]
 16        var iso = Calendar(identifier: .iso8601)
 17        iso.timeZone = gregorian.timeZone
 18        let isoYear = iso.component(.yearForWeekOfYear, from: day)
 19        let week = iso.component(.weekOfYear, from: day)
 20        let year = (title: String(date.year!), pattern: "([12][0-9]{3})")
 21        let dayLevel = (title: String(format: "%04d-%02d-%02d ", date.year!, date.month!, date.day!) + weekday,
 22                        pattern: "([12][0-9]{3}-[01][0-9]-[0123][0-9]) \\w+")
 23        switch tree {
 24        case .day, .month:
 25            let month = (title: String(format: "%04d-%02d ", date.year!, date.month!) + months[date.month! - 1],
 26                         pattern: "([12][0-9]{3}-[01][0-9]) \\w+")
 27            return tree == .day ? [year, month, dayLevel] : [year, month]
 28        case .week:
 29            return [(String(isoYear), year.pattern), (String(format: "%04d-W%02d", isoYear, week), "([12][0-9]{3}-W[0-5][0-9])"), dayLevel]
 30        }
 31    }
 32
 33    /// Point at the date's entry, created where missing, under the heading at `parent` or at
 34    /// the top of the file. Returns the entry's start.
 35    static func findCreate(_ buffer: EmacsBuffer, under parent: Int?, tree: CaptureTemplate.TreeType, date: DateComponents) -> Int {
 36        let low = buffer.marker(parent ?? 0)
 37        let high = buffer.marker(parent.map { narrowEnd(buffer, $0, limit: buffer.length) } ?? buffer.length, advances: true)
 38        defer {
 39            buffer.release(low)
 40            buffer.release(high)
 41        }
 42        var level = parent.map { Capture.headingLevel(buffer, at: $0) + 1 } ?? 1
 43        for (title, pattern) in levels(tree, date: date) {
 44            subheading(buffer, title: title, pattern: pattern, level: level, low: low, high: high)
 45            level += 1
 46        }
 47        return low.position
 48    }
 49
 50    /// `org-datetree--find-create-subheading`: leaves the region narrowed to the subheading.
 51    static func subheading(_ buffer: EmacsBuffer, title: String, pattern: String, level: Int, low: EmacsBuffer.Marker, high: EmacsBuffer.Marker) {
 52        func compare(_ sibling: String) -> Int? {
 53            guard let a = firstGroup(pattern, sibling), let b = firstGroup(pattern, title) else { return nil }
 54            return a < b ? -1 : a > b ? 1 : 0
 55        }
 56        var sibling: (start: Int, order: Int)?
 57        buffer.point = low.position
 58        while let match = buffer.searchForward("^(\\*+) ", bound: high.position, caseInsensitive: false) {
 59            let start = match[0]!.lowerBound
 60            buffer.point = buffer.lineEnd(start)
 61            guard match[1]!.count == level else { continue }
 62            if let order = compare(rawTitle(buffer, start)), order >= 0 {
 63                sibling = (start, order)
 64                break
 65            }
 66        }
 67        if let sibling {
 68            buffer.point = sibling.start
 69        } else {
 70            buffer.point = high.position
 71            if !buffer.bolp { buffer.insert("\n") }
 72        }
 73        if let sibling, sibling.order == 0 {
 74            narrow(buffer, to: sibling.start, low: low, high: high)
 75            return
 76        }
 77        let end = buffer.point
 78        while buffer.point > low.position, let c = buffer.character(at: buffer.point - 1), c == 32 || c == 9 || c == 10 { buffer.point -= 1 }
 79        buffer.deleteRegion(buffer.point, end)
 80        if blankBeforeHeading(buffer, low: low.position, high: high.position) { buffer.insert("\n") }
 81        buffer.insert("\n" + String(repeating: "*", count: level) + " " + title + "\n")
 82        buffer.forwardLine(-1)
 83        narrow(buffer, to: buffer.point, low: low, high: high)
 84    }
 85
 86    static func firstGroup(_ pattern: String, _ s: String) -> String? {
 87        let regex = try! NSRegularExpression(pattern: pattern)
 88        let ns = s as NSString
 89        guard let m = regex.firstMatch(in: s, range: NSRange(location: 0, length: ns.length)) else { return nil }
 90        return ns.substring(with: m.range(at: 1))
 91    }
 92
 93    /// A heading's `:raw-value`: its title without keyword, priority or tags.
 94    static func rawTitle(_ buffer: EmacsBuffer, _ start: Int) -> String {
 95        buffer.saveExcursion {
 96            buffer.point = start
 97            guard let match = buffer.lookingAt(buffer.complexHeadingPattern), let title = match[4] else { return "" }
 98            return buffer.substring(title.lowerBound, title.upperBound)
 99        }
100    }
101
102    /// `org-narrow-to-subtree` inside the current region.
103    static func narrow(_ buffer: EmacsBuffer, to heading: Int, low: EmacsBuffer.Marker, high: EmacsBuffer.Marker) {
104        low.position = heading
105        high.position = narrowEnd(buffer, heading, limit: high.position)
106        buffer.point = heading
107    }
108
109    /// The subtree's end, before the newline that precedes the next heading, within `limit`.
110    static func narrowEnd(_ buffer: EmacsBuffer, _ heading: Int, limit: Int) -> Int {
111        let end = buffer.saveExcursion { () -> Int in
112            Capture.endOfSubtree(buffer, heading: heading)
113            return buffer.point
114        }
115        return min(limit, end == buffer.length ? end : end - 1)
116    }
117
118    /// `org--blank-before-heading-p` with `org-blank-before-new-entry` `(heading . auto)`,
119    /// in the region `low..<high`.
120    static func blankBeforeHeading(_ buffer: EmacsBuffer, low: Int, high: Int) -> Bool {
121        buffer.saveExcursion {
122            func headingStart(before limit: Int) -> Int? {
123                buffer.saveExcursion {
124                    buffer.point = buffer.lineEnd(limit)
125                    return buffer.searchBackward("^\\*+ ", bound: low, caseInsensitive: false)?[0]?.lowerBound
126                }
127            }
128            /// `outline-next-heading` bounded by `high`.
129            func nextHeading() -> Bool {
130                if let match = buffer.searchForward("\\n\\*+ ", bound: high, caseInsensitive: false) {
131                    buffer.point = match[0]!.lowerBound + 1
132                    return true
133                }
134                buffer.point = high
135                return false
136            }
137            func previousLineEmpty() -> Bool {
138                guard buffer.point > low else { return false }
139                let start = buffer.lineStart(buffer.point)
140                guard start > low else { return false }
141                let previous = max(low, buffer.lineStart(start - 1))
142                return buffer.substring(previous, start - 1).allSatisfy { $0 == " " || $0 == "\t" }
143            }
144            if headingStart(before: buffer.point) == nil {
145                guard nextHeading() else { return false }
146            }
147            guard let heading = headingStart(before: buffer.point) else { return false }
148            buffer.point = heading
149            if buffer.point != low { return previousLineEmpty() }
150            if nextHeading() { return previousLineEmpty() }
151            while buffer.point > low, let c = buffer.character(at: buffer.point - 1), c == 32 || c == 9 { buffer.point -= 1 }
152            return buffer.bolp ? previousLineEmpty() : false
153        }
154    }
155}