| @@ -0,0 +1,480 @@ |
| |
1 | import Foundation |
| |
2 | |
| |
3 | // M-q: `org-fill-paragraph` (Org 9.8.7) over Emacs's `fill-region-as-paragraph` (fill.el), for |
| |
4 | // paragraphs, comments and comment blocks, with `sentence-end-double-space` nil, |
| |
5 | // `colon-double-space` nil, `left-margin` 0 and left justification. |
| |
6 | |
| |
7 | extension EmacsBuffer { |
| |
8 | /// `org-element-paragraph-separate`, which org uses as `paragraph-start`. |
| |
9 | var paragraphStartPattern: String { |
| |
10 | let letters = options.listAllowAlphabetical ? "|[A-Za-z]" : "" |
| |
11 | return "(?:\\*+ |\\[fn:[-_\\w]+\\]|%%\\(|[ \\t]*(?:$|\\||\\+(?:-+\\+)+[ \\t]*$|#(?: |$|\\+(?:BEGIN_\\S+|\\S+(?:\\[.*\\])?:[ \\t]*))|:(?: |$|[-_\\w]+:[ \\t]*$)|-{5,}[ \\t]*$|\\\\begin\\{([A-Za-z0-9*]+)\\}|(?:[-+*]|(?:[0-9]+\(letters))[.)])(?:[ \\t]|$)))" |
| |
12 | } |
| |
13 | |
| |
14 | static let adaptiveFillPattern = "[-–!|#%;>*·•‣⁃◦ \\t]*" |
| |
15 | static let sentenceEndPattern = "([.?!…‽][\\]\"'”’)}»›]*($|[\\t \\u00A0])|[。．？！]+)[ \\u00A0\\t\\n]*" |
| |
16 | |
| |
17 | /// An element as `org-element-at-point` sees it, with offsets in the buffer. |
| |
18 | struct Element { |
| |
19 | let kind: SyntaxKind |
| |
20 | let range: Range<Int> |
| |
21 | /// The enclosing element, for paragraphs in items. |
| |
22 | let parentKind: SyntaxKind? |
| |
23 | let parentStart: Int? |
| |
24 | /// For blocks: the word after `#+begin_`, lowercased. |
| |
25 | let blockType: String? |
| |
26 | /// For plain lists: the first item's start. |
| |
27 | let firstItem: Int? |
| |
28 | } |
| |
29 | |
| |
30 | static let elementKinds: Set<SyntaxKind> = [.paragraph, .comment, .block, .table, .tableRow, .item, .plainList, .heading, |
| |
31 | .keyword, .fixedWidth, .drawer, .propertyDrawer, .planning, .dynamicBlock, |
| |
32 | .footnoteDefinition, .horizontalRule, .clock, .nodeProperty] |
| |
33 | |
| |
34 | /// The innermost element (not object) holding `offset`, as `org-element-at-point`. Greater |
| |
35 | /// blocks (quote, center, special) are parsed into their elements. |
| |
36 | func element(at offset: Int) -> Element? { |
| |
37 | element(at: offset, in: string, base: 0) |
| |
38 | } |
| |
39 | |
| |
40 | private func element(at offset: Int, in text: String, base: Int) -> Element? { |
| |
41 | let tree = OrgParser.parse(text, defaults: settings) |
| |
42 | let local = offset - base |
| |
43 | var node = tree.root |
| |
44 | var found: SyntaxNode? |
| |
45 | while true { |
| |
46 | let child = node.child(containing: local) ?? (local == node.range.upperBound ? node.children.last : nil) |
| |
47 | guard let child, Self.elementKinds.contains(child.kind) || child.kind == .section || child.kind == .zerothSection else { break } |
| |
48 | if Self.elementKinds.contains(child.kind) { found = child } |
| |
49 | if [.heading, .paragraph, .comment, .tableRow, .block].contains(child.kind) { break } |
| |
50 | node = child |
| |
51 | } |
| |
52 | guard let found else { return nil } |
| |
53 | let range = (found.range.lowerBound + base)..<(found.range.upperBound + base) |
| |
54 | var blockType: String? |
| |
55 | if found.kind == .block { |
| |
56 | let first = found.text.prefix { $0 != "\n" }.lowercased() |
| |
57 | blockType = first.firstMatch(of: /#\+begin_(\S+)/).map { String($0.1) } |
| |
58 | if let type = blockType, !["src", "example", "export", "comment", "verse"].contains(type) { |
| |
59 | let contentsStart = lineEnd(range.lowerBound) + 1 |
| |
60 | let closing = saveExcursion { () -> Int in |
| |
61 | point = range.upperBound |
| |
62 | skipBackward(Self.whitespace) |
| |
63 | return lineStart(point) |
| |
64 | } |
| |
65 | if offset >= contentsStart, offset < closing, contentsStart < closing { |
| |
66 | return element(at: offset, in: substring(contentsStart, closing), base: contentsStart) |
| |
67 | } |
| |
68 | } |
| |
69 | } |
| |
70 | let parent = found.parent.flatMap { Self.elementKinds.contains($0.kind) ? $0 : nil } |
| |
71 | return Element( |
| |
72 | kind: found.kind, range: range, parentKind: parent?.kind, parentStart: parent.map { $0.range.lowerBound + base }, |
| |
73 | blockType: blockType, firstItem: found.children.first { $0.kind == .item }.map { $0.range.lowerBound + base } |
| |
74 | ) |
| |
75 | } |
| |
76 | |
| |
77 | /// Where an element's contents end: after its last non-blank line. |
| |
78 | func contentsEnd(_ node: Element) -> Int { |
| |
79 | saveExcursion { |
| |
80 | point = node.range.upperBound |
| |
81 | skipBackward(Self.whitespace) |
| |
82 | return min(lineEnd(point) + 1, length) |
| |
83 | } |
| |
84 | } |
| |
85 | |
| |
86 | /// `org-list-item-body-column`. |
| |
87 | func itemBodyColumn(_ item: Int) -> Int { |
| |
88 | saveExcursion { |
| |
89 | point = item |
| |
90 | let match = looking("[ \\t]*(\\S+)", setsMatch: false)! |
| |
91 | point = match[1]!.upperBound |
| |
92 | return currentColumn + 1 |
| |
93 | } |
| |
94 | } |
| |
95 | |
| |
96 | /// `org-adaptive-fill-function` at point's line. |
| |
97 | func orgAdaptiveFillPrefix() -> String? { |
| |
98 | saveExcursion { |
| |
99 | guard !atHeading else { return nil } |
| |
100 | let lineBegin = lineStart(point) |
| |
101 | guard let element = element(at: lineBegin) else { return nil } |
| |
102 | switch element.kind { |
| |
103 | case .comment: |
| |
104 | let indent = substring(lineBegin, lineBegin + (looking("[ \\t]*", setsMatch: false).map { $0[0]!.count } ?? 0)) |
| |
105 | return indent + "# " |
| |
106 | case .item, .plainList: |
| |
107 | let item = element.kind == .item ? element.range.lowerBound : (element.firstItem ?? element.range.lowerBound) |
| |
108 | return String(repeating: " ", count: itemBodyColumn(item)) |
| |
109 | case .block where element.blockType == "comment": |
| |
110 | let begin = lineEnd(element.range.lowerBound) + 1 |
| |
111 | let end = saveExcursion { () -> Int in |
| |
112 | point = element.range.upperBound |
| |
113 | skipBackward(Self.whitespace) |
| |
114 | return lineStart(point) |
| |
115 | } |
| |
116 | guard lineBegin >= begin, lineBegin < end else { return nil } |
| |
117 | point = lineBegin |
| |
118 | return looking("[ \\t]+", setsMatch: false).map { substring($0[0]!.lowerBound, $0[0]!.upperBound) } ?? "" |
| |
119 | case .paragraph: |
| |
120 | point = lineBegin |
| |
121 | if element.parentKind == .item, let parent = element.parentStart { |
| |
122 | return String(repeating: " ", count: itemBodyColumn(parent)) |
| |
123 | } |
| |
124 | if let prefix = contextPrefix(from: postAffiliated(element), to: element.range.upperBound, paragraphOnly: true) { |
| |
125 | return prefix |
| |
126 | } |
| |
127 | return looking("[ \\t]+", setsMatch: false).map { substring($0[0]!.lowerBound, $0[0]!.upperBound) } ?? "" |
| |
128 | default: |
| |
129 | return nil |
| |
130 | } |
| |
131 | } |
| |
132 | } |
| |
133 | |
| |
134 | /// Start of an element after its affiliated keywords. |
| |
135 | func postAffiliated(_ node: Element) -> Int { |
| |
136 | saveExcursion { |
| |
137 | point = node.range.lowerBound |
| |
138 | while looking("[ \\t]*#\\+(?:CAPTION|DATA|HEADERS?|LABEL|NAME|PLOT|RESNAME|RESULTS?|SOURCE|SRCNAME|TBLNAME|ATTR_[-_\\w]+)(?:\\[.*\\])?:", setsMatch: false) != nil { |
| |
139 | if forwardLine(1) != 0 { break } |
| |
140 | } |
| |
141 | return point |
| |
142 | } |
| |
143 | } |
| |
144 | |
| |
145 | /// `fill-match-adaptive-prefix`, with org's function or, in paragraphs, the regexp after |
| |
146 | /// any markup at the line start. |
| |
147 | func matchAdaptivePrefix(paragraphOnly: Bool) -> String? { |
| |
148 | let prefix: String? |
| |
149 | if paragraphOnly { |
| |
150 | let start = point |
| |
151 | prefix = saveExcursion { |
| |
152 | skipLineStartMarkup() |
| |
153 | return looking(Self.adaptiveFillPattern, setsMatch: false).map { substring($0[0]!.lowerBound, $0[0]!.upperBound) } |
| |
154 | } |
| |
155 | point = start |
| |
156 | } else { |
| |
157 | prefix = orgAdaptiveFillPrefix() ?? looking(Self.adaptiveFillPattern, setsMatch: false).map { substring($0[0]!.lowerBound, $0[0]!.upperBound) } |
| |
158 | } |
| |
159 | guard let prefix else { return nil } |
| |
160 | return (prefix as NSString).length >= options.fillColumn ? nil : prefix |
| |
161 | } |
| |
162 | |
| |
163 | /// Moves past the opening markup of an object that starts at point, as |
| |
164 | /// `org-adaptive-fill-paragraph-function` does. |
| |
165 | private func skipLineStartMarkup() { |
| |
166 | let line = substring(point, lineEnd(point)) + "\n" |
| |
167 | let tree = OrgParser.parse(line, defaults: settings) |
| |
168 | var node: SyntaxNode? = tree.root |
| |
169 | while let current = node, let child = current.child(containing: 0), child.range.lowerBound == 0 { |
| |
170 | if [.bold, .italic, .underline, .strikeThrough].contains(child.kind) { |
| |
171 | point += 1 |
| |
172 | return |
| |
173 | } |
| |
174 | if child.kind == .link, let description = child.firstChild(.linkDescription) { |
| |
175 | point += description.range.lowerBound |
| |
176 | return |
| |
177 | } |
| |
178 | node = child |
| |
179 | } |
| |
180 | } |
| |
181 | |
| |
182 | /// `fill-context-prefix`. |
| |
183 | func contextPrefix(from: Int, to: Int, paragraphOnly: Bool = false) -> String? { |
| |
184 | saveExcursion { |
| |
185 | point = from |
| |
186 | if eolp { forwardLine(1) } |
| |
187 | point = lineStart(point) |
| |
188 | var first = matchAdaptivePrefix(paragraphOnly: paragraphOnly) |
| |
189 | forwardLine(1) |
| |
190 | if point < to { |
| |
191 | point = lineStart(point) |
| |
192 | let second: String? = looking(paragraphStartPattern, setsMatch: false) != nil ? nil : matchAdaptivePrefix(paragraphOnly: paragraphOnly) |
| |
193 | if let second { |
| |
194 | if first == nil { first = "" } |
| |
195 | var pattern = "^" |
| |
196 | var rest = Substring(second) |
| |
197 | while let match = rest.firstMatch(of: /^[ \t]*([^ \t]+)/) { |
| |
198 | pattern += ".*" + NSRegularExpression.escapedPattern(for: String(match.1)) |
| |
199 | rest = rest[match.range.upperBound...] |
| |
200 | } |
| |
201 | if first!.range(of: pattern, options: .regularExpression) != nil { return second } |
| |
202 | let common = zip(first!, second).prefix { $0 == $1 }.count |
| |
203 | return common == 0 ? nil : String(first!.prefix(common)) |
| |
204 | } |
| |
205 | } |
| |
206 | guard let firstPrefix = first else { return nil } |
| |
207 | let keep = firstPrefix.allSatisfy({ $0 == " " || $0 == "\t" }) || firstPrefix.range(of: "^\\s*#( |$)", options: .regularExpression) != nil |
| |
208 | let result = keep ? firstPrefix : String(repeating: " ", count: displayWidth(firstPrefix)) |
| |
209 | let probe = result + "a" |
| |
210 | let regex = Self.regex(paragraphStartPattern, caseInsensitive: false) |
| |
211 | if let match = regex.firstMatch(in: probe, options: [.anchored], range: NSRange(location: 0, length: (probe as NSString).length)), match.range.location == 0 { |
| |
212 | return nil |
| |
213 | } |
| |
214 | return result |
| |
215 | } |
| |
216 | } |
| |
217 | |
| |
218 | /// `fill-nobreak-p` with org's predicates. |
| |
219 | func fillNoBreak() -> Bool { |
| |
220 | if bolp { return false } |
| |
221 | let startsParagraph = saveExcursion { () -> Bool in |
| |
222 | skipForward(Self.blanks) |
| |
223 | return !eolp && looking(paragraphStartPattern, setsMatch: false) != nil |
| |
224 | } |
| |
225 | if startsParagraph { return true } |
| |
226 | let lineBreak = saveExcursion { () -> Bool in |
| |
227 | skipBackward(Self.blanks) |
| |
228 | skipBackward([92]) |
| |
229 | return looking("\\\\\\\\($|[^\\\\])", setsMatch: false) != nil |
| |
230 | } |
| |
231 | if lineBreak { return true } |
| |
232 | if looking("[ \\t]*\\{\\{\\{n(?:\\([^\\n)]*\\))?\\}\\}\\}[.)](?:$| )", setsMatch: false) != nil { return true } |
| |
233 | let saved = lastMatch |
| |
234 | defer { lastMatch = saved } |
| |
235 | if atTimestamp() != nil, looking("[\\[<](" + Self.timestampCore + ")[^\\]>\\n]*[\\]>]", setsMatch: false) == nil { return true } |
| |
236 | return false |
| |
237 | } |
| |
238 | |
| |
239 | /// `fill-move-to-break-point` for text without CJK characters. |
| |
240 | func moveToBreakPoint(_ lineBegin: Int) { |
| |
241 | if lineBegin > point { point = lineBegin } |
| |
242 | while true { |
| |
243 | guard let match = searchBackward("[ \\t]", bound: lineBegin, caseInsensitive: false) else { |
| |
244 | point = lineBegin |
| |
245 | break |
| |
246 | } |
| |
247 | point = match[0]!.lowerBound + 1 |
| |
248 | if fillNoBreak() { |
| |
249 | skipBackward(Self.blanks, bound: lineBegin) |
| |
250 | } else { |
| |
251 | break |
| |
252 | } |
| |
253 | } |
| |
254 | skipBackward(Self.blanks) |
| |
255 | if lineBegin >= point { |
| |
256 | let end = lineEnd(point) |
| |
257 | var first = true |
| |
258 | point = lineBegin |
| |
259 | while point < end, first || fillNoBreak() { |
| |
260 | skipForward(Self.blanks) |
| |
261 | while point < length, let c = character(at: point), c != 32, c != 10, c != 9 { point += 1 } |
| |
262 | first = false |
| |
263 | } |
| |
264 | } |
| |
265 | } |
| |
266 | |
| |
267 | /// `skip-chars-backward` stopping at `bound`. |
| |
268 | func skipBackward(_ set: Set<unichar>, bound: Int) { |
| |
269 | while point > bound, let c = character(at: point - 1), set.contains(c) { point -= 1 } |
| |
270 | } |
| |
271 | |
| |
272 | /// `canonically-space-region` with single spaces after sentences. |
| |
273 | func canonicallySpace(_ begin: Int, _ endOffset: Int) { |
| |
274 | saveExcursion { |
| |
275 | let end = marker(endOffset, advances: true) |
| |
276 | defer { release(end) } |
| |
277 | for offset in begin..<end.position where character(at: offset) == 9 { replace(offset..<(offset + 1), with: " ") } |
| |
278 | point = begin |
| |
279 | let pattern = "(" + Self.sentenceEndPattern + ") *| +" |
| |
280 | while point < end.position, let match = searchForward(pattern, bound: end.position, caseInsensitive: false) { |
| |
281 | let matchEnd = match[0]!.upperBound |
| |
282 | let start: Int |
| |
283 | if let sentence = match[1], matchEnd > sentence.upperBound { |
| |
284 | start = sentence.upperBound |
| |
285 | } else if match[1] != nil { |
| |
286 | let lastNonSpace = saveExcursion { () -> Int in point = matchEnd; skipBackward([32]); return point } |
| |
287 | start = min(matchEnd, lastNonSpace + 1) |
| |
288 | } else { |
| |
289 | let before = saveExcursion { () -> unichar? in |
| |
290 | point = match[0]!.lowerBound |
| |
291 | skipBackward(Set(" ]})\"'".utf16)) |
| |
292 | return character(at: point - 1) |
| |
293 | } |
| |
294 | start = match[0]!.lowerBound + (before == 10 ? 0 : 1) |
| |
295 | } |
| |
296 | if start < matchEnd { deleteRegion(start, matchEnd) } |
| |
297 | } |
| |
298 | } |
| |
299 | } |
| |
300 | |
| |
301 | /// `fill-region-as-paragraph` with left justification and adaptive fill. |
| |
302 | func fillRegionAsParagraph(_ fromOffset: Int, _ toOffset: Int, prefix fixedPrefix: String? = nil) { |
| |
303 | point = min(fromOffset, toOffset) |
| |
304 | var to = max(fromOffset, toOffset) |
| |
305 | skipForward(Self.whitespace) |
| |
306 | let fromPlusIndent = point |
| |
307 | point = lineStart(point) |
| |
308 | var from = max(point, fromOffset) |
| |
309 | point = to |
| |
310 | var oneLeft = false |
| |
311 | while point > from, character(at: point - 1) == 10 { |
| |
312 | if oneLeft { |
| |
313 | deleteRegion(point - 1, point) |
| |
314 | } else { |
| |
315 | point -= 1 |
| |
316 | oneLeft = true |
| |
317 | } |
| |
318 | } |
| |
319 | let toMarker = marker(point, advances: true) |
| |
320 | defer { release(toMarker) } |
| |
321 | point = fromPlusIndent |
| |
322 | guard toMarker.position > point else { return } |
| |
323 | var prefix = fixedPrefix |
| |
324 | if prefix == nil || prefix == "" { prefix = contextPrefix(from: from, to: toMarker.position) } |
| |
325 | point = lineStart(from) |
| |
326 | // `fill-delete-prefix`. |
| |
327 | let prefixPattern: String |
| |
328 | if let prefix, !prefix.allSatisfy({ $0 == " " || $0 == "\t" }) { |
| |
329 | prefixPattern = "[ \\t]*(" + NSRegularExpression.escapedPattern(for: prefix).replacingOccurrences(of: "[ \\t]+", with: "[ \\t]*", options: .regularExpression) + ")?[ \\t]*" |
| |
330 | } else { |
| |
331 | prefixPattern = "[ \\t]*" |
| |
332 | } |
| |
333 | point = from |
| |
334 | forwardLine(1) |
| |
335 | while point < toMarker.position { |
| |
336 | if let match = looking(prefixPattern, setsMatch: false) { deleteRegion(point, match[0]!.upperBound) } |
| |
337 | if forwardLine(1) != 0 { break } |
| |
338 | } |
| |
339 | point = from |
| |
340 | if let match = looking(prefixPattern, setsMatch: false) { point = match[0]!.upperBound } |
| |
341 | from = point |
| |
342 | // `fill-delete-newlines`. |
| |
343 | var at = from |
| |
344 | while at < toMarker.position { |
| |
345 | if character(at: at) == 10 { replace(at..<(at + 1), with: " ") } |
| |
346 | at += 1 |
| |
347 | } |
| |
348 | point = from |
| |
349 | skipForward(Self.blanks) |
| |
350 | canonicallySpace(point, toMarker.position) |
| |
351 | point = toMarker.position |
| |
352 | let end = point |
| |
353 | skipBackward(Self.blanks) |
| |
354 | if point < end { deleteRegion(point, end) } |
| |
355 | point = from |
| |
356 | while point < toMarker.position { |
| |
357 | let lineBegin = point |
| |
358 | moveToColumn(options.fillColumn) |
| |
359 | var breaks = false |
| |
360 | if point < toMarker.position, lineBegin < toMarker.position { |
| |
361 | if currentColumn <= options.fillColumn { point += 1 } |
| |
362 | moveToBreakPoint(lineBegin) |
| |
363 | skipForward(Self.blanks) |
| |
364 | breaks = point < toMarker.position |
| |
365 | } |
| |
366 | guard breaks else { |
| |
367 | point = toMarker.position |
| |
368 | break |
| |
369 | } |
| |
370 | // `fill-newline`. |
| |
371 | skipBackward(Self.blanks) |
| |
372 | insert("\n") |
| |
373 | indentLineTo(0) |
| |
374 | if let prefix, !prefix.isEmpty { insertBeforeMarkers(prefix) } |
| |
375 | } |
| |
376 | point = toMarker.position |
| |
377 | if !eobp { point += 1 } |
| |
378 | } |
| |
379 | |
| |
380 | /// `org-fill-paragraph` without a region or justification. |
| |
381 | func fillParagraph() { |
| |
382 | saveExcursion { |
| |
383 | if lookingAt("^[ \\t]*$") != nil || saveExcursion({ beginningOfLine(); return lookingAt("[ \\t]*$") != nil }) { |
| |
384 | skipForward(Self.whitespace) |
| |
385 | } |
| |
386 | let eol = lineEnd(point) |
| |
387 | guard let element = element(at: eol) else { return } |
| |
388 | switch element.kind { |
| |
389 | case .paragraph: |
| |
390 | let begin = paragraphContentsBegin(element) |
| |
391 | var end = contentsEnd(element) |
| |
392 | guard lineEnd(point) >= begin else { return } |
| |
393 | var cuts = [begin] |
| |
394 | saveExcursion { |
| |
395 | point = begin |
| |
396 | while let match = searchForward("\\\\\\\\[ \\t]*\\n", bound: end, caseInsensitive: false) { |
| |
397 | cuts.insert(match[0]!.upperBound, at: 0) |
| |
398 | } |
| |
399 | } |
| |
400 | for cut in cuts where cut != end { |
| |
401 | fillRegionAsParagraph(cut, end) |
| |
402 | end = cut |
| |
403 | } |
| |
404 | case .comment: |
| |
405 | let begin = postAffiliated(element) |
| |
406 | let elementEnd = element.range.upperBound |
| |
407 | guard point >= begin, point <= elementEnd else { return } |
| |
408 | let from = saveExcursion { () -> Int in |
| |
409 | endOfLine() |
| |
410 | if searchBackward("^[ \\t]*#[ \\t]*$", bound: begin, caseInsensitive: false) != nil { |
| |
411 | forwardLine(1) |
| |
412 | return point |
| |
413 | } |
| |
414 | return begin |
| |
415 | } |
| |
416 | let to = saveExcursion { () -> Int in |
| |
417 | endOfLine() |
| |
418 | if searchForward("^[ \\t]*#[ \\t]*$", bound: elementEnd, caseInsensitive: false) != nil { |
| |
419 | return lineStart(point) - 1 |
| |
420 | } |
| |
421 | point = elementEnd |
| |
422 | skipBackward(Self.whitespace) |
| |
423 | return lineEnd(point) |
| |
424 | } |
| |
425 | guard to > from else { return } |
| |
426 | let prefix = saveExcursion { () -> String in |
| |
427 | beginningOfLine() |
| |
428 | let comment = looking("[ \\t]*#", setsMatch: false)! |
| |
429 | point = comment[0]!.upperBound |
| |
430 | let marker = substring(comment[0]!.lowerBound, comment[0]!.upperBound) |
| |
431 | if let rest = looking(Self.adaptiveFillPattern, setsMatch: false) { |
| |
432 | return marker + substring(rest[0]!.lowerBound, rest[0]!.upperBound) |
| |
433 | } |
| |
434 | return marker + " " |
| |
435 | } |
| |
436 | saveExcursion { fillRegionAsParagraph(from, to, prefix: prefix) } |
| |
437 | case .block where element.blockType == "comment": |
| |
438 | let begin = saveExcursion { () -> Int in |
| |
439 | point = element.range.lowerBound |
| |
440 | forwardLine(1) |
| |
441 | return point |
| |
442 | } |
| |
443 | let end = saveExcursion { () -> Int in |
| |
444 | point = element.range.upperBound |
| |
445 | skipBackward(Self.whitespace) |
| |
446 | return lineStart(point) |
| |
447 | } |
| |
448 | guard point >= begin, point <= end else { return } |
| |
449 | let from = saveExcursion { () -> Int in |
| |
450 | endOfLine() |
| |
451 | if searchBackward("^[ \\t]*$", bound: begin, caseInsensitive: false) == nil { point = begin } |
| |
452 | return lineStart(point) |
| |
453 | } |
| |
454 | let to = saveExcursion { () -> Int in |
| |
455 | beginningOfLine() |
| |
456 | if searchForward("^[ \\t]*$", bound: end, caseInsensitive: false) == nil { point = end } |
| |
457 | return lineStart(point) |
| |
458 | } |
| |
459 | fillRegionAsParagraph(from, to) |
| |
460 | default: |
| |
461 | return |
| |
462 | } |
| |
463 | } |
| |
464 | } |
| |
465 | |
| |
466 | /// Where a paragraph's text starts: past affiliated keywords, and for a paragraph that |
| |
467 | /// opens an item, past the bullet. |
| |
468 | func paragraphContentsBegin(_ node: Element) -> Int { |
| |
469 | max(postAffiliated(node), node.range.lowerBound) |
| |
470 | } |
| |
471 | } |
| |
472 | |
| |
473 | /// M-q: `org-fill-paragraph`. |
| |
474 | public struct FillParagraph: OrgCommand { |
| |
475 | public init() {} |
| |
476 | public var id: String { "org.fill-paragraph" } |
| |
477 | public var title: String { "Fill Paragraph" } |
| |
478 | public func applies(in context: EditContext) -> Bool { true } |
| |
479 | public func run(in context: EditContext) -> CommandStep { commitBuffer(context) { $0.fillParagraph() } } |
| |
480 | } |