Sources/OrgCore/Commands/TimestampCommands.swift
235 lines · 12850 bytes
1import Foundation
2
3extension EmacsBuffer {
4 /// Reads a date prompt answer the way `org-read-date` does: an empty answer takes the
5 /// default date.
6 func readDate(_ answer: String, default defaultDate: Date?) -> ReadDate.Answer {
7 ReadDate.read(answer, default: defaultDate, now: now, calendar: calendar)
8 }
9
10 /// The date an Org time string stands for, as a prompt default.
11 func dateDefault(_ stamp: String?) -> Date? { stamp.flatMap(Self.parseTimeString).map(date) }
12
13 func date(_ components: DateComponents) -> Date { calendar.date(from: components)! }
14
15 /// `org-timestamp`: replaces the timestamp at point, keeping its repeater, or inserts one.
16 func timestampCommand(_ answer: String, inactive: Bool) {
17 let stamp = timestampForUpdate()
18 let defaultDate = stamp.flatMap(Self.parseTimeString).map(date)
19 let repeater = stamp.flatMap { $0.firstMatch(of: try! Regex("([.+-]+[0-9]+[hdwmy] ?)+")).map { String($0.output[0].substring!) } }
20 let result = readDate(answer, default: defaultDate)
21 let components = result.components(calendar)
22 // Between a range's dashes, the end is replaced.
23 var existing = atTimestamp()
24 if stamp != nil, existing == nil {
25 skipForward([45])
26 existing = atTimestamp()
27 }
28 if let existing {
29 replace(existing.match[0]!, with: "")
30 insertTimestamp(components, withTime: result.timeGiven, inactive: inactive, endTime: result.endTime)
31 if let repeater {
32 point -= 1
33 insert(" " + repeater)
34 }
35 } else {
36 insertTimestamp(components, withTime: result.timeGiven, inactive: inactive, endTime: result.endTime)
37 }
38 }
39
40 /// The first timestamp after `kind` in the entry, as the date prompt's default.
41 func planningDefault(_ kind: PlanningKind) -> String? {
42 saveExcursion {
43 guard (try? backToHeading()) != nil else { return nil }
44 let end = saveExcursion { () -> Int in outlineNextHeading(); return point }
45 return searchForward(kind.pattern, bound: end, caseInsensitive: false).map { substring($0[1]!.lowerBound, $0[1]!.upperBound) }
46 }
47 }
48
49 /// `org--deadline-or-schedule` without a prefix argument.
50 func schedule(_ kind: PlanningKind, answer: String, answers: [String: String] = [:]) throws {
51 let old = planningValue(kind)
52 let repeatPattern = "([.+-]+[0-9]+[hdwmy](?:[/ ][-+]?[0-9]+[hdwmy])?)"
53 let repeater = old.flatMap { $0.firstMatch(of: try! Regex(repeatPattern)).map { String($0.output[1].substring!) } }
54 let defaultDate = planningDefault(kind).flatMap(Self.parseTimeString).map(date)
55 let result = readDate(answer, default: defaultDate)
56 try addPlanningInfo(kind, time: result.components(calendar), withTime: result.timeGiven, endTime: result.endTime, remove: [.closed])
57 if let repeater, let inserted = lastInsertedTimestamp {
58 try saveExcursion {
59 try backToHeading()
60 let bound = saveExcursion { () -> Int in forwardLine(2); return lineEnd(point) }
61 if let match = searchForward(NSRegularExpression.escapedPattern(for: kind.keyword + " " + inserted), bound: bound, caseInsensitive: false) {
62 point = match[0]!.upperBound - 1
63 insert(" " + repeater)
64 }
65 }
66 }
67 if let old, let inserted = lastInsertedTimestamp {
68 try logPlanningChange(kind, old: "<" + old + ">", new: inserted, answers: answers)
69 }
70 }
71
72 /// `org--deadline-or-schedule` with C-u: removes the planning timestamp.
73 func removePlanning(_ kind: PlanningKind) {
74 guard planningValue(kind) != nil else { return }
75 saveExcursion {
76 guard let begin = try? backToHeading() else { return }
77 outlineNextHeading()
78 let pattern = "\\b" + NSRegularExpression.escapedPattern(for: kind.keyword) + " +<[^>\\n]+>[ \\t]*"
79 while let match = searchBackward(pattern, bound: begin, caseInsensitive: false) {
80 replace(match[0]!, with: "")
81 let before = substring(lineStart(point), point)
82 if before.contains(where: { !$0.isWhitespace }), character(at: point - 1) == 32 {
83 deleteRegion(point - 1, point)
84 } else if substring(lineStart(point), lineEnd(point)).allSatisfy({ $0 == " " || $0 == "\t" }) {
85 deleteRegion(lineStart(point), min(length, lineEnd(point) + 1))
86 }
87 }
88 }
89 }
90}
91
92private func timestampCommand(_ context: EditContext, _ body: (EmacsBuffer) throws -> Void) -> CommandStep {
93 commitBuffer(context, body)
94}
95
96private func atTimestamp(_ context: EditContext) -> Bool {
97 EmacsBuffer(context.text, point: context.caret).atTimestamp() != nil
98}
99
100/// The prompt's starting text: the time of the timestamp at the caret, as org pre-fills it.
101private func timeOfDayAtCaret(_ context: EditContext) -> String {
102 let buffer = EmacsBuffer(context.text, point: context.caret)
103 guard let stamp = buffer.timestampForUpdate() else { return "" }
104 return EmacsBuffer.compactTimeOfDay(stamp) ?? ""
105}
106
107/// C-c . and C-c !: `org-timestamp`.
108public struct InsertTimestamp: OrgCommand {
109 let inactive: Bool
110 public init(inactive: Bool = false) { self.inactive = inactive }
111 public var id: String { inactive ? "org.timestamp.inactive" : "org.timestamp.active" }
112 public var title: String { inactive ? "Insert Inactive Timestamp" : "Insert Timestamp" }
113 public func applies(in context: EditContext) -> Bool { true }
114 public func run(in context: EditContext) -> CommandStep {
115 guard let answer = context.answers["date"] else {
116 let buffer = EmacsBuffer(context.text, point: context.caret)
117 buffer.calendar = context.calendar
118 return .prompt(Prompt(key: "date", message: "Date+time:", initial: timeOfDayAtCaret(context),
119 date: .init(defaultDate: buffer.dateDefault(buffer.timestampForUpdate()), inactive: inactive)))
120 }
121 // Twice in a row on a timestamp: a range to a second one.
122 let repeated = context.lastCommand == "org.timestamp.active" || context.lastCommand == "org.timestamp.inactive"
123 if repeated, EmacsBuffer(context.text, point: context.caret).timestampForUpdate() != nil {
124 return timestampCommand(context) { buffer in
125 let result = buffer.readDate(answer, default: buffer.dateDefault(buffer.timestampForUpdate()))
126 buffer.insert("--")
127 buffer.insertTimestamp(result.components(buffer.calendar), withTime: result.timeGiven, inactive: inactive)
128 }
129 }
130 return timestampCommand(context) { $0.timestampCommand(answer, inactive: inactive) }
131 }
132}
133
134/// C-c C-s and C-c C-d: `org-schedule` and `org-deadline`.
135public struct SetPlanning: OrgCommand {
136 let deadline: Bool
137 public init(deadline: Bool) { self.deadline = deadline }
138 public var id: String { deadline ? "org.deadline" : "org.schedule" }
139 public var title: String { deadline ? "Set Deadline" : "Schedule" }
140 public func applies(in context: EditContext) -> Bool { entryHeading(at: context.caret, in: context.tree) != nil }
141 public func run(in context: EditContext) -> CommandStep {
142 guard entryHeading(at: context.caret, in: context.tree) != nil else { return .failed("Before first headline") }
143 let kind: EmacsBuffer.PlanningKind = deadline ? .deadline : .scheduled
144 guard let answer = context.answers["date"] else {
145 let buffer = EmacsBuffer(context.text, point: context.caret)
146 buffer.calendar = context.calendar
147 let initial = buffer.planningDefault(kind).flatMap(EmacsBuffer.compactTimeOfDay) ?? ""
148 return .prompt(Prompt(key: "date", message: deadline ? "DEADLINE:" : "SCHEDULED:", initial: initial,
149 date: .init(defaultDate: buffer.dateDefault(buffer.planningDefault(kind)))))
150 }
151 return timestampCommand(context) { try $0.schedule(kind, answer: answer, answers: context.answers) }
152 }
153}
154
155/// C-u C-c C-s and C-u C-c C-d.
156public struct RemovePlanning: OrgCommand {
157 let deadline: Bool
158 public init(deadline: Bool) { self.deadline = deadline }
159 public var id: String { deadline ? "org.deadline.remove" : "org.schedule.remove" }
160 public var title: String { deadline ? "Remove Deadline" : "Remove Schedule" }
161 public func applies(in context: EditContext) -> Bool { entryHeading(at: context.caret, in: context.tree) != nil }
162 public func run(in context: EditContext) -> CommandStep {
163 timestampCommand(context) { buffer in
164 let kind: EmacsBuffer.PlanningKind = deadline ? .deadline : .scheduled
165 let old = buffer.planningValue(kind)
166 if let old { try buffer.logPlanningChange(kind, old: "<" + old + ">", new: nil, answers: context.answers) }
167 buffer.removePlanning(kind)
168 }
169 }
170}
171
172/// S-up and S-down on a timestamp: `org-timestamp-up` and `org-timestamp-down`.
173public struct ShiftTimestamp: OrgCommand {
174 let up: Bool
175 public init(up: Bool) { self.up = up }
176 public var id: String { up ? "org.timestamp.up" : "org.timestamp.down" }
177 public var title: String { up ? "Increase Timestamp Part" : "Decrease Timestamp Part" }
178 public func applies(in context: EditContext) -> Bool { atTimestamp(context) }
179 public func run(in context: EditContext) -> CommandStep {
180 timestampCommand(context) { try $0.changeTimestamp(up ? 1 : -1, updown: true) }
181 }
182}
183
184/// S-right and S-left on a timestamp: `org-timestamp-up-day` and `org-timestamp-down-day`.
185public struct ShiftTimestampDay: OrgCommand {
186 let later: Bool
187 public init(later: Bool) { self.later = later }
188 public var id: String { later ? "org.timestamp.day-later" : "org.timestamp.day-earlier" }
189 public var title: String { later ? "Timestamp One Day Later" : "Timestamp One Day Earlier" }
190 public func applies(in context: EditContext) -> Bool { atTimestamp(context) }
191 public func run(in context: EditContext) -> CommandStep {
192 timestampCommand(context) { try $0.changeTimestamp(later ? 1 : -1, what: .day, updown: true) }
193 }
194}
195
196/// C-c C-y: `org-evaluate-time-range`. On a clock line, updates it; otherwise says how long the
197/// range at the caret, or the first on its line, lasts.
198public struct EvaluateTimeRange: OrgCommand {
199 public init() {}
200 public var id: String { "org.timestamp.evaluate-range" }
201 public var title: String { "Evaluate Time Range" }
202 public func applies(in context: EditContext) -> Bool { true }
203 public func run(in context: EditContext) -> CommandStep {
204 let buffer = EmacsBuffer(context.text, point: context.caret)
205 buffer.calendar = context.calendar
206 if buffer.lookingAtLine("^[ \\t]*CLOCK:") { return CtrlCCtrlC().run(in: context) }
207 let ns = context.text as NSString
208 let line = ns.lineRange(for: NSRange(location: min(context.caret, ns.length), length: 0))
209 let regex = try! NSRegularExpression(pattern: "[\\[<]([0-9]{4}-[0-9]{2}-[0-9]{2}[^\\]>\\n]*?)[\\]>]--?-?[\\[<]([0-9]{4}-[0-9]{2}-[0-9]{2}[^\\]>\\n]*?)[\\]>]")
210 let matches = regex.matches(in: context.text, range: line)
211 guard let m = matches.first(where: { $0.range.location <= context.caret && context.caret <= NSMaxRange($0.range) }) ?? matches.first else {
212 return .failed("Not at a timestamp range, and none found in current line")
213 }
214 let ts1 = ns.substring(with: m.range(at: 1))
215 let ts2 = ns.substring(with: m.range(at: 2))
216 let haveTime = ts1.count > 15 || ts2.count > 15
217 let t1 = TagsMatcher.seconds(ts1, now: context.now, calendar: context.calendar)
218 let t2 = TagsMatcher.seconds(ts2, now: context.now, calendar: context.calendar)
219 var diff = abs(t2 - t1)
220 var d = 0, h = 0, minutes = 0
221 if haveTime {
222 d = Int(floor(diff / 86400)); diff = diff.truncatingRemainder(dividingBy: 86400)
223 h = Int(floor(diff / 3600)); diff = diff.truncatingRemainder(dividingBy: 3600)
224 minutes = Int(floor(diff / 60))
225 } else {
226 d = Int((diff / 86400).rounded())
227 }
228 var parts: [String] = []
229 if d > 0 { parts.append("\(d) day" + (d > 1 ? "s" : "")) }
230 if h > 0 { parts.append("\(h) hour" + (h > 1 ? "s" : "")) }
231 if minutes > 0 { parts.append("\(minutes) minute" + (minutes > 1 ? "s" : "")) }
232 let text = parts.isEmpty ? "" : parts.joined(separator: " ") + " "
233 return .commit(EditResult(baseRevision: context.revision, edits: [], effects: [.message(text)]))
234 }
235}