Sources/OrgCore/Commands/ElectricPair.swift

  1import Foundation
  2
  3// `electric-pair-mode` (Emacs 31.1 elec-pair.el) in an Org buffer, with its defaults:
  4// `electric-pair-preserve-balance`, skipping whitespace before a closer, deleting adjacent
  5// pairs and opening a line between them. Delimiters are what `org-mode-syntax-table` makes
  6// them: () [] {} <> and "; inside a string, `prog-mode-syntax-table`'s.
  7
  8/// A syntax table's view of a character, as far as pairing goes.
  9private enum SyntaxClass: Equatable {
 10    case open(unichar), close(unichar), string, escape, other
 11}
 12
 13private enum SyntaxTable {
 14    case org, text
 15
 16    func classify(_ c: unichar) -> SyntaxClass {
 17        switch c {
 18        case 40: return .open(41)
 19        case 91: return .open(93)
 20        case 123: return .open(125)
 21        case 41: return .close(40)
 22        case 93: return .close(91)
 23        case 125: return .close(123)
 24        case 34: return .string
 25        case 60: return self == .org ? .open(62) : .other
 26        case 62: return self == .org ? .close(60) : .other
 27        // Org makes the backslash a symbol constituent; the standard table escapes with it.
 28        case 92: return self == .org ? .other : .escape
 29        default: return .other
 30        }
 31    }
 32
 33    /// `matching-paren`.
 34    func matching(_ c: unichar) -> unichar? {
 35        switch classify(c) {
 36        case .open(let m), .close(let m): return m
 37        default: return nil
 38        }
 39    }
 40}
 41
 42/// The text being typed into, with point, as the hook functions see the buffer.
 43private final class PairBuffer {
 44    let s: NSMutableString
 45    var point: Int
 46
 47    init(_ text: String, point: Int) {
 48        s = NSMutableString(string: text)
 49        self.point = point
 50    }
 51
 52    var length: Int { s.length }
 53    func char(_ i: Int) -> unichar? { i >= 0 && i < s.length ? s.character(at: i) : nil }
 54    var charAfter: unichar? { char(point) }
 55    var charBefore: unichar? { char(point - 1) }
 56
 57    func insert(_ text: String, at i: Int) {
 58        s.insert(text, at: i)
 59        if point >= i { point += (text as NSString).length }
 60    }
 61
 62    func delete(_ range: Range<Int>) {
 63        s.deleteCharacters(in: NSRange(location: range.lowerBound, length: range.count))
 64        if point > range.upperBound { point -= range.count } else if point > range.lowerBound { point = range.lowerBound }
 65    }
 66
 67    // MARK: Parsing, as `parse-partial-sexp` and `scan-sexps`
 68
 69    struct State {
 70        var depth = 0
 71        /// Positions of the open parens enclosing the end, innermost last (nth 9).
 72        var opens: [Int] = []
 73        /// The string's delimiter while inside one (nth 3).
 74        var stringChar: unichar?
 75        /// Where that string starts (nth 8).
 76        var stringStart: Int?
 77    }
 78
 79    func parse(from: Int, to: Int, table: SyntaxTable) -> State {
 80        var state = State()
 81        var i = from
 82        while i < to, let c = char(i) {
 83            let cls = table.classify(c)
 84            if let delimiter = state.stringChar {
 85                if cls == .escape { i += 2; continue }
 86                if c == delimiter { state.stringChar = nil; state.stringStart = nil }
 87            } else {
 88                switch cls {
 89                case .open: state.depth += 1; state.opens.append(i)
 90                case .close: state.depth -= 1; if !state.opens.isEmpty { state.opens.removeLast() }
 91                case .string: state.stringChar = c; state.stringStart = i
 92                case .escape: i += 2; continue
 93                case .other: break
 94                }
 95            }
 96            i += 1
 97        }
 98        return state
 99    }
100
101    /// `syntax-ppss`: the buffer's table, from the start.
102    func ppss(_ pos: Int) -> State { parse(from: 0, to: pos, table: .org) }
103
104    /// `electric-pair--syntax-ppss` with WHERE `(string comment)`: inside a string, its text
105    /// parsed with the text table.
106    func pairPpss(_ pos: Int) -> State {
107        let quick = ppss(pos)
108        if quick.stringChar != nil, let start = quick.stringStart {
109            return parse(from: start + 1, to: pos, table: .text)
110        }
111        return quick
112    }
113
114    enum ScanResult {
115        case done
116        /// "Containing expression ends prematurely", and where it stopped.
117        case premature(Int)
118        case unbalanced
119    }
120
121    /// `scan-sexps` from `from` over as many sexps as there are, forward or back.
122    func scan(from: Int, forward: Bool, table: SyntaxTable) -> ScanResult {
123        var depth = 0
124        if forward {
125            var i = from
126            while let c = char(i) {
127                switch table.classify(c) {
128                case .open: depth += 1
129                case .close:
130                    depth -= 1
131                    if depth < 0 { return .premature(i + 1) }
132                case .string:
133                    var j = i + 1
134                    while let d = char(j), d != c { j += table.classify(d) == .escape ? 2 : 1 }
135                    if j >= length { return .unbalanced }
136                    i = j
137                case .escape: i += 1
138                case .other: break
139                }
140                i += 1
141            }
142        } else {
143            var i = from - 1
144            while i >= 0, let c = char(i) {
145                if quoted(i, table) { i -= 1; continue }
146                switch table.classify(c) {
147                case .close: depth += 1
148                case .open:
149                    depth -= 1
150                    if depth < 0 { return .premature(i) }
151                case .string:
152                    var j = i - 1
153                    while j >= 0, !(char(j) == c && !quoted(j, table)) { j -= 1 }
154                    if j < 0 { return .unbalanced }
155                    i = j
156                default: break
157                }
158                i -= 1
159            }
160        }
161        return depth > 0 ? .unbalanced : .done
162    }
163
164    /// `char-quoted`: an odd number of escapes before `i`.
165    private func quoted(_ i: Int, _ table: SyntaxTable) -> Bool {
166        var n = 0
167        var j = i - 1
168        while j >= 0, let c = char(j), table.classify(c) == .escape { n += 1; j -= 1 }
169        return n % 2 == 1
170    }
171
172    /// `scan-sexps` forward by one from the open paren at `from`: past its closer, or nil on an
173    /// error.
174    func scanOne(from: Int, table: SyntaxTable) -> Int? {
175        var depth = 0
176        var i = from
177        while let c = char(i) {
178            switch table.classify(c) {
179            case .open: depth += 1
180            case .close:
181                depth -= 1
182                if depth < 0 { return nil }
183                if depth == 0 { return i + 1 }
184            case .string:
185                var j = i + 1
186                while let d = char(j), d != c { j += table.classify(d) == .escape ? 2 : 1 }
187                if j >= length { return nil }
188                i = j
189                if depth == 0 { return i + 1 }
190            case .escape: i += 1
191            case .other: break
192            }
193            i += 1
194        }
195        return nil
196    }
197
198    // MARK: elec-pair.el
199
200    struct Info {
201        enum Syntax { case open, close, string }
202        let syntax: Syntax
203        let pair: unichar
204        let unconditional: Bool
205        /// Where the string point is in starts.
206        let stringStart: Int?
207    }
208
209    /// `electric-quote-chars` pairs, from `electric-pair-pairs` (and the text pairs, the same).
210    static let fallback: [(unichar, unichar)] = [(34, 34), (0x2018, 0x2019), (0x201C, 0x201D)]
211
212    /// `electric-pair-syntax-info`.
213    func info(_ c: unichar) -> Info? {
214        let pre = point == 0 || ppss(point - 1).stringStart != nil
215        let post = ppss(point).stringStart
216        let stringStart = pre ? post : nil
217        let table: SyntaxTable = stringStart == nil ? .org : .text
218        switch table.classify(c) {
219        case .open(let m): return Info(syntax: .open, pair: m, unconditional: false, stringStart: stringStart)
220        case .close(let m): return Info(syntax: .close, pair: m, unconditional: false, stringStart: stringStart)
221        case .string: return Info(syntax: .string, pair: c, unconditional: false, stringStart: stringStart)
222        default: break
223        }
224        if let direct = Self.fallback.first(where: { $0.0 == c }) {
225            return direct.0 == direct.1
226                ? Info(syntax: .string, pair: c, unconditional: true, stringStart: stringStart)
227                : Info(syntax: .open, pair: direct.1, unconditional: true, stringStart: stringStart)
228        }
229        if let reverse = Self.fallback.first(where: { $0.1 == c }) {
230            return Info(syntax: .close, pair: reverse.0, unconditional: true, stringStart: stringStart)
231        }
232        return nil
233    }
234
235    struct Side {
236        var matched: Bool
237        var pair: unichar?
238    }
239
240    /// `electric-pair--balance-info`: the innermost and outermost lists around point.
241    func balance(forward: Bool, stringStart: Int?) -> (innermost: Side, outermost: Side) {
242        let table: SyntaxTable = stringStart == nil ? .org : .text
243        var innermost: Side?
244        var outermost: Side?
245        let saved = point
246        defer { point = saved }
247        while outermost == nil {
248            switch scan(from: point, forward: forward, table: table) {
249            case .done, .unbalanced:
250                outermost = Side(matched: true)
251                if innermost == nil { innermost = Side(matched: true) }
252            case .premature(let pos):
253                if stringStart != nil, ppss(point).stringStart == nil {
254                    outermost = Side(matched: true)
255                    if innermost == nil { innermost = Side(matched: true) }
256                    break
257                }
258                point = pos
259                let matched: Bool
260                if forward {
261                    let state = pairPpss(point - 1)
262                    if let start = state.opens.last, let opener = char(start) {
263                        matched = charBefore == (table.matching(opener) ?? opener)
264                    } else {
265                        matched = false
266                    }
267                } else if let end = scanOne(from: point, table: table), let closer = char(end - 1) {
268                    matched = charAfter == table.matching(closer)
269                } else {
270                    matched = false
271                }
272                let actual = forward ? charBefore : charAfter
273                if innermost == nil { innermost = Side(matched: matched, pair: actual) }
274                if !matched { outermost = Side(matched: matched, pair: actual) }
275            }
276        }
277        return (innermost!, outermost!)
278    }
279
280    /// `electric-pair-inhibit-if-helps-balance`, with the typed character before point.
281    func inhibit(_ c: unichar) -> Bool {
282        guard let info = info(c) else { return false }
283        let at = point - 1
284        delete(at..<point)
285        defer { insert(String(utf16CodeUnits: [c], count: 1), at: at) }
286        switch info.syntax {
287        case .open:
288            let outermost = balance(forward: true, stringStart: info.stringStart).outermost
289            return outermost.matched ? false : outermost.pair == info.pair
290        case .string:
291            return ppss(length).stringChar == c
292        case .close:
293            return false
294        }
295    }
296
297    /// `electric-pair-skip-if-helps-balance`, with the typed character before point.
298    func skip(_ c: unichar) -> Bool {
299        guard let info = info(c) else { return false }
300        let at = point - 1
301        delete(at..<point)
302        defer { insert(String(utf16CodeUnits: [c], count: 1), at: at) }
303        switch info.syntax {
304        case .close:
305            let (innermost, outermost) = balance(forward: false, stringStart: info.stringStart)
306            if outermost.matched { return innermost.matched }
307            return innermost.matched && outermost.pair != info.pair
308        case .string:
309            return ppss(point).stringChar == c
310        case .open:
311            return false
312        }
313    }
314
315    /// `electric-pair--skip-whitespace`, unless that leaves or enters a string.
316    func skipWhitespace() {
317        let saved = point
318        let before = ppss(point).stringStart
319        while let c = charAfter, c == 9 || c == 32 || c == 10 { point += 1 }
320        if ppss(point).stringStart != before { point = saved }
321    }
322}
323
324public enum ElectricPair {
325    /// Typing `c` into `text` with `selection` (point at its upper end, mark at its lower):
326    /// the text and point that `self-insert-command` and `electric-pair-post-self-insert-function`
327    /// leave.
328    public static func type(_ c: unichar, text: String, selection: Range<Int>) -> (text: String, point: Int) {
329        let b = PairBuffer(text, point: selection.upperBound)
330        let typed = String(utf16CodeUnits: [c], count: 1)
331        b.insert(typed, at: b.point)
332        let pos = b.point
333        guard let info = b.info(c) else { return (b.s as String, b.point) }
334        if !selection.isEmpty {
335            // `use-region-p`: the region is wrapped.
336            let mark = selection.lowerBound
337            let pair = String(utf16CodeUnits: [info.pair], count: 1)
338            if info.syntax == .string || info.syntax == .close {
339                b.insert(pair, at: mark)
340            } else {
341                b.delete(pos - 1..<pos)
342                b.insert(pair, at: b.point)
343                b.point = mark
344                b.insert(typed, at: b.point)
345            }
346            return (b.s as String, b.point)
347        }
348        if info.syntax == .close || info.syntax == .string {
349            let skipsSelf = info.unconditional || b.skip(c)
350            if skipsSelf {
351                let skipsSpace = !(info.unconditional && info.syntax == .string)
352                let saved = b.point
353                if skipsSpace { b.skipWhitespace() }
354                let lands = b.charAfter == c
355                b.point = saved
356                if lands {
357                    if skipsSpace { b.skipWhitespace() }
358                    b.delete(pos - 1..<pos)
359                    b.point += 1
360                    return (b.s as String, b.point)
361                }
362            }
363        }
364        if info.syntax == .open || info.syntax == .string, info.unconditional || !b.inhibit(c) {
365            b.insert(String(utf16CodeUnits: [info.pair], count: 1), at: b.point)
366            b.point = pos
367        }
368        return (b.s as String, b.point)
369    }
370
371    /// DEL at `caret` between an opening delimiter and its pair: both go
372    /// (`electric-pair-delete-pair`). Nil leaves DEL as it is.
373    public static func deletePair(text: String, caret: Int) -> Range<Int>? {
374        let b = PairBuffer(text, point: caret)
375        guard let prev = b.charBefore, let next = b.charAfter, let info = b.info(prev),
376              info.syntax != .close, info.pair == next else { return nil }
377        return caret - 1..<caret + 1
378    }
379
380    /// RET at `caret` between an open paren and its closer: a second newline after point
381    /// (`electric-pair-open-newline-between-pairs`).
382    public static func opensLine(text: String, caret: Int) -> Bool {
383        let b = PairBuffer(text, point: caret)
384        guard caret > 0, caret < b.length, let prev = b.charBefore, let next = b.charAfter else { return false }
385        return SyntaxTable.org.matching(next) == prev
386    }
387}
388
389/// A key typed with `electric-pair-mode` on: a pairing character, DEL or RET. It doesn't
390/// apply where the key types as it would without the mode.
391public struct ElectricPairKey: OrgCommand {
392    public let key: String
393    public init(key: String) { self.key = key }
394    public var id: String { "internal.electric-pair" }
395    public var title: String { "Electric Pair" }
396
397    /// The characters `electric-pair-syntax-info` knows in an Org buffer.
398    public static let characters: Set<String> = ["(", ")", "[", "]", "{", "}", "<", ">", "\"", "\u{2018}", "\u{2019}", "\u{201C}", "\u{201D}"]
399
400    public func applies(in context: EditContext) -> Bool { result(context) != nil }
401
402    public func run(in context: EditContext) -> CommandStep {
403        guard let result = result(context) else { return .failed("") }
404        return .commit(result)
405    }
406
407    private func result(_ context: EditContext) -> EditResult? {
408        guard context.options.electricPair else { return nil }
409        let selection = context.selection.first ?? context.caret..<context.caret
410        let ns = context.text as NSString
411        switch key {
412        case "DEL":
413            guard selection.isEmpty, let range = ElectricPair.deletePair(text: context.text, caret: selection.lowerBound) else { return nil }
414            return EditResult(baseRevision: context.revision, edits: [TextEdit(range: range, replacement: "")], selection: [range.lowerBound..<range.lowerBound])
415        case "RET":
416            guard selection.isEmpty, ElectricPair.opensLine(text: context.text, caret: selection.lowerBound) else { return nil }
417            let at = selection.lowerBound
418            return EditResult(baseRevision: context.revision, edits: [TextEdit(range: at..<at, replacement: "\n\n")], selection: [at + 1..<at + 1])
419        default:
420            guard Self.characters.contains(key), let unit = key.utf16.first else { return nil }
421            let typed = ElectricPair.type(unit, text: context.text, selection: selection)
422            let plain = ns.replacingCharacters(in: NSRange(location: selection.lowerBound, length: selection.count), with: key)
423            if typed.text == plain, typed.point == selection.lowerBound + 1 { return nil }
424            // One replacement: what lies between the common start and end.
425            let new = typed.text as NSString
426            var start = 0
427            while start < ns.length, start < new.length, ns.character(at: start) == new.character(at: start) { start += 1 }
428            var end = 0
429            while end < ns.length - start, end < new.length - start,
430                  ns.character(at: ns.length - 1 - end) == new.character(at: new.length - 1 - end) { end += 1 }
431            let replacement = new.substring(with: NSRange(location: start, length: new.length - start - end))
432            return EditResult(baseRevision: context.revision, edits: [TextEdit(range: start..<ns.length - end, replacement: replacement)],
433                              selection: [typed.point..<typed.point])
434        }
435    }
436}