coteditor/CotEditor
1
0
Fork 0
mirror of https://github.com/coteditor/CotEditor.git synced 2024-09-11 11:25:57 +03:00
Code Issues Projects Releases Wiki Activity

Deprecate “Append a space to comment delimiter” option

Browse Source
This commit is contained in:
1024jp 2024-03-04 23:30:03 +09:00
parent de73240970
commit 21b6520b4c
9 changed files with 55 additions and 287 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -13,6 +13,7 @@
- Improve the look and feel of the syntax editor.
- Make the encoding priority view undoable.
- Deprecate “Append a space to comment delimiter” option
- [trivial] Enable delete selected separators in the encoding priority view with the Delete key.
- [trivial] Avoid users using reserved syntax names.
- [dev] Migrate the settings window and syntax editor to SwiftUI.

15
CotEditor/CotEditor.help/Contents/Resources/en.lproj/pgs/settings_edit.html
View File

@ -77,21 +77,6 @@
</table>
<table class="settings">
<caption>Comment</caption>
<thead>
<tr><th>Option</th><th>Description</th></tr>
</thead>
<tbody>
<tr>
<th>Append a space to comment delimiter</th>
<td>By commenting out, a single space character is appended between comment delimiters and commented-out strings.</td>
</tr>
</tbody>
</table>
<table class="settings">
<caption>Content parse</caption>
<thead>

15
CotEditor/CotEditor.help/Contents/Resources/ja.lproj/pgs/settings_edit.html
View File

@ -77,21 +77,6 @@
</table>
<table class="settings">
<caption>コメント</caption>
<thead>
<tr><th>オプション</th><th>説明</th></tr>
</thead>
<tbody>
<tr>
<th>コメント記号にスペースを追加</th>
<td>コメントアウトのときに、コメント記号と後続の文字列の間にスペース1つを追加します。</td>
</tr>
</tbody>
</table>
<table class="settings">
<caption>内容解析</caption>
<thead>

1
CotEditor/Sources/DefaultKeys.swift
View File

@ -84,7 +84,6 @@ extension DefaultKeys {
static let detectsIndentStyle = DefaultKey<Bool>("detectsIndentStyle")
static let autoExpandTab = DefaultKey<Bool>("autoExpandTab")
static let indentWithTabKey = DefaultKey<Bool>("indentWithTabKey")
static let appendsCommentSpacer = DefaultKey<Bool>("appendsCommentSpacer")
static let autoLinkDetection = DefaultKey<Bool>("autoLinkDetectionKey")
static let checkSpellingAsType = DefaultKey<Bool>("checkSpellingAsType")
static let highlightBraces = DefaultKey<Bool>("highlightBraces")

1
CotEditor/Sources/DefaultSettings.swift
View File

@ -80,7 +80,6 @@ struct DefaultSettings {
.detectsIndentStyle: true,
.autoIndent: true,
.indentWithTabKey: false,
.appendsCommentSpacer: false,
.autoLinkDetection: false,
.checkSpellingAsType: false,
.highlightBraces: true,

11
CotEditor/Sources/EditSettingsView.swift
View File

@ -36,8 +36,6 @@ struct EditSettingsView: View {
@AppStorage(.autoTrimsTrailingWhitespace) private var autoTrimsTrailingWhitespace
@AppStorage(.trimsWhitespaceOnlyLines) private var trimsWhitespaceOnlyLines
@AppStorage(.appendsCommentSpacer) private var appendsCommentSpacer
@AppStorage(.autoLinkDetection) private var autoLinkDetection
@AppStorage(.highlightBraces) private var highlightBraces
@AppStorage(.highlightLtGt) private var highlightLtGt
@ -81,15 +79,6 @@ struct EditSettingsView: View {
}
}
GridRow {
Text("Comment:", tableName: "EditSettings")
.gridColumnAlignment(.trailing)
VStack(alignment: .leading, spacing: 6) {
Toggle(String(localized: "Append a space to comment delimiter", table: "EditSettings"), isOn: $appendsCommentSpacer)
}
}
GridRow {
Text("Content parse:", tableName: "EditSettings")
.gridColumnAlignment(.trailing)

78
CotEditor/Sources/EditorTextView+Commenting.swift
View File

@ -27,15 +27,6 @@ import AppKit
extension EditorTextView: Commenting {
// MARK: Commenting Protocol
var appendsCommentSpacer: Bool {
UserDefaults.standard[.appendsCommentSpacer]
}
// MARK: Action Messages
/// Toggles the comment state of the selections.
@ -96,8 +87,6 @@ protocol Commenting: NSTextView {
var inlineCommentDelimiter: String? { get }
var blockCommentDelimiters: Pair<String>? { get }
var appendsCommentSpacer: Bool { get }
}
@ -118,16 +107,15 @@ extension Commenting {
else { return }
let items: [NSRange.InsertionItem] = {
let spacer = self.appendsCommentSpacer ? " " : ""
let targetRanges = selectedRanges
.map { fromLineHead ? self.string.lineContentsRange(for: $0) : $0 }
.unique
if types.contains(.inline), let delimiter = self.inlineCommentDelimiter {
return self.string.inlineCommentOut(delimiter: delimiter, spacer: spacer, ranges: targetRanges)
return self.string.inlineCommentOut(delimiter: delimiter, ranges: targetRanges)
}
if types.contains(.block), let delimiters = self.blockCommentDelimiters {
return self.string.blockCommentOut(delimiters: delimiters, spacer: spacer, ranges: targetRanges)
return self.string.blockCommentOut(delimiters: delimiters, ranges: targetRanges)
}
return []
}()
@ -152,17 +140,15 @@ extension Commenting {
else { return }
let deletionRanges: [NSRange] = {
let spacer = self.appendsCommentSpacer ? " " : ""
if let delimiters = self.blockCommentDelimiters {
let targetRanges = selectedRanges.map { $0.isEmpty ? self.string.lineContentsRange(for: $0) : $0 }.unique
if let ranges = self.string.rangesOfBlockDelimiters(delimiters, spacer: spacer, ranges: targetRanges) {
if let ranges = self.string.rangesOfBlockDelimiters(delimiters, ranges: targetRanges) {
return ranges
}
}
if let delimiter = self.inlineCommentDelimiter {
let targetRanges = selectedRanges.map { self.string.lineContentsRange(for: $0) }.unique
if let ranges = self.string.rangesOfInlineDelimiter(delimiter, spacer: spacer, ranges: targetRanges) {
if let ranges = self.string.rangesOfInlineDelimiter(delimiter, ranges: targetRanges) {
return ranges
}
}
@ -195,17 +181,17 @@ extension Commenting {
!targetRanges.isEmpty
else { return false }
if let delimiters = self.blockCommentDelimiters {
if let ranges = self.string.rangesOfBlockDelimiters(delimiters, spacer: "", ranges: targetRanges) {
return partly ? true : (ranges.count == (2 * targetRanges.count))
}
if let delimiters = self.blockCommentDelimiters,
let ranges = self.string.rangesOfBlockDelimiters(delimiters, ranges: targetRanges)
{
return partly ? true : (ranges.count == (2 * targetRanges.count))
}
if let delimiter = self.inlineCommentDelimiter {
if let ranges = self.string.rangesOfInlineDelimiter(delimiter, spacer: "", ranges: targetRanges) {
let lineRanges = targetRanges.flatMap { self.string.lineContentsRanges(for: $0) }.unique
return partly ? true : (ranges.count == lineRanges.count)
}
if let delimiter = self.inlineCommentDelimiter,
let ranges = self.string.rangesOfInlineDelimiter(delimiter, ranges: targetRanges)
{
let lineRanges = targetRanges.flatMap { self.string.lineContentsRanges(for: $0) }.unique
return partly ? true : (ranges.count == lineRanges.count)
}
return false
@ -216,58 +202,52 @@ extension Commenting {
extension String {
/// Returns the editing information to comment out the given `ranges` by appending inline-style comment delimiters
/// and spacers after delimiters.
/// Returns the editing information to comment out the given `ranges` by appending inline-style comment delimiters.
///
/// - Parameters:
/// - delimiter: The inline comment delimiter to insert.
/// - spacer: The spacer between delimiter and string.
/// - ranges: The ranges where to comment out.
/// - Returns: Items that contain editing information to insert comment delimiters.
func inlineCommentOut(delimiter: String, spacer: String, ranges: [NSRange]) -> [NSRange.InsertionItem] {
func inlineCommentOut(delimiter: String, ranges: [NSRange]) -> [NSRange.InsertionItem] {
let regex = try! NSRegularExpression(pattern: "^", options: [.anchorsMatchLines])
return ranges.flatMap { regex.matches(in: self, range: $0) }
.map(\.range.location)
.unique
.map { NSRange.InsertionItem(string: delimiter + spacer, location: $0, forward: true) }
.map { NSRange.InsertionItem(string: delimiter, location: $0, forward: true) }
}
/// Returns the editing information to comment out the given `ranges` by appending block-style comment delimiters
/// and spacers between string and delimiters.
/// Returns the editing information to comment out the given `ranges` by appending block-style comment delimiters.
///
/// - Parameters:
/// - delimiters: The pair of block comment delimiters to insert.
/// - spacer: The spacer between delimiter and string.
/// - ranges: The ranges where to comment out.
/// - Returns: Items that contain editing information to insert comment delimiters.
func blockCommentOut(delimiters: Pair<String>, spacer: String, ranges: [NSRange]) -> [NSRange.InsertionItem] {
func blockCommentOut(delimiters: Pair<String>, ranges: [NSRange]) -> [NSRange.InsertionItem] {
ranges.flatMap {
[NSRange.InsertionItem(string: delimiters.begin + spacer, location: $0.lowerBound, forward: true),
NSRange.InsertionItem(string: spacer + delimiters.end, location: $0.upperBound, forward: false)]
[NSRange.InsertionItem(string: delimiters.begin, location: $0.lowerBound, forward: true),
NSRange.InsertionItem(string: delimiters.end, location: $0.upperBound, forward: false)]
}
}
/// Finds inline-style delimiters in `ranges` as well as spacers between the content and a delimiter if any.
/// Finds inline-style delimiters in `ranges`.
///
/// - Parameters:
/// - delimiter: The inline delimiter to find.
/// - spacer: The spacer between delimiter and string.
/// - ranges: The ranges where to find.
/// - Returns: Ranges where delimiters and spacers are, or `nil` when no delimiters was found.
func rangesOfInlineDelimiter(_ delimiter: String, spacer: String, ranges: [NSRange]) -> [NSRange]? {
/// - Returns: Ranges where delimiters are, or `nil` when no delimiters was found.
func rangesOfInlineDelimiter(_ delimiter: String, ranges: [NSRange]) -> [NSRange]? {
let ranges = ranges.filter { !$0.isEmpty }
guard !ranges.isEmpty, !self.isEmpty else { return [] }
let delimiterPattern = NSRegularExpression.escapedPattern(for: delimiter)
let spacerPattern = spacer.isEmpty ? "" : "(?:\(spacer))?"
let pattern = "^[ \t]*(\(delimiterPattern + spacerPattern))"
let pattern = "^[ \t]*(\(delimiterPattern))"
let regex = try! NSRegularExpression(pattern: pattern, options: [.anchorsMatchLines])
let delimiterRanges = ranges
@ -279,16 +259,15 @@ extension String {
}
/// Finds block-style delimiters in `ranges` as well as spacers between the content and a delimiter if any.
/// Finds block-style delimiters in `ranges`.
///
/// - Note: This method matches a block only when one of the given `ranges` fits exactly.
///
/// - Parameters:
/// - delimiters: The pair of block delimiters to find.
/// - spacer: The spacer between delimiter and string.
/// - ranges: The ranges where to find.
/// - Returns: Ranges where delimiters and spacers are, or `nil` when no delimiters was found.
func rangesOfBlockDelimiters(_ delimiters: Pair<String>, spacer: String, ranges: [NSRange]) -> [NSRange]? {
/// - Returns: Ranges where delimiters are, or `nil` when no delimiters was found.
func rangesOfBlockDelimiters(_ delimiters: Pair<String>, ranges: [NSRange]) -> [NSRange]? {
let ranges = ranges.filter { !$0.isEmpty }
@ -296,8 +275,7 @@ extension String {
let beginPattern = NSRegularExpression.escapedPattern(for: delimiters.begin)
let endPattern = NSRegularExpression.escapedPattern(for: delimiters.end)
let spacerPattern = spacer.isEmpty ? "" : "(?:\(spacer))?"
let pattern = "\\A[ \t]*(\(beginPattern + spacerPattern)).*?(\(spacerPattern + endPattern))[ \t]*\\Z"
let pattern = "\\A[ \t]*(\(beginPattern)).*?(\(endPattern))[ \t]*\\Z"
let regex = try! NSRegularExpression(pattern: pattern, options: [.dotMatchesLineSeparators])
let delimiterRanges = ranges

146
CotEditor/mul.lproj/EditSettings.xcstrings
View File

@ -1,82 +1,6 @@
{
"sourceLanguage" : "en",
"strings" : {
"Append a space to comment delimiter" : {
"localizations" : {
"cs" : {
"stringUnit" : {
"state" : "translated",
"value" : "Přidat mezery do oddělovačů komentáře"
}
},
"de" : {
"stringUnit" : {
"state" : "translated",
"value" : "Leerzeichen zu Kommentartrennzeichen hinzufügen"
}
},
"en" : {
"stringUnit" : {
"state" : "new",
"value" : "Append a space to comment delimiter"
}
},
"en-GB" : {
"stringUnit" : {
"state" : "translated",
"value" : "Append a space to comment delimiter"
}
},
"es" : {
"stringUnit" : {
"state" : "translated",
"value" : "Añadir un espacio en el delimitador de comentario"
}
},
"fr" : {
"stringUnit" : {
"state" : "translated",
"value" : "Ajouter un espace après le symbole de commentaire"
}
},
"it" : {
"stringUnit" : {
"state" : "translated",
"value" : "Aggiungi uno spazio al delimitatore del commento"
}
},
"ja" : {
"stringUnit" : {
"state" : "translated",
"value" : "コメント記号にスペースを追加"
}
},
"pt" : {
"stringUnit" : {
"state" : "translated",
"value" : "Anexar espaço ao delimitador de comentários"
}
},
"tr" : {
"stringUnit" : {
"state" : "translated",
"value" : "Yorum sınırlayıcısına bir boşluk iliştir"
}
},
"zh-Hans" : {
"stringUnit" : {
"state" : "translated",
"value" : "在注释符号后追加空格"
}
},
"zh-Hant" : {
"stringUnit" : {
"state" : "translated",
"value" : "在註釋符號後追加空格"
}
}
}
},
"Automatically indent while typing" : {
"localizations" : {
"cs" : {
@ -375,76 +299,6 @@
}
}
},
"Comment:" : {
"localizations" : {
"cs" : {
"stringUnit" : {
"state" : "translated",
"value" : "Komentář:"
}
},
"de" : {
"stringUnit" : {
"state" : "translated",
"value" : "Kommentar:"
}
},
"en-GB" : {
"stringUnit" : {
"state" : "translated",
"value" : "Comment:"
}
},
"es" : {
"stringUnit" : {
"state" : "translated",
"value" : "Comentario:"
}
},
"fr" : {
"stringUnit" : {
"state" : "translated",
"value" : "Commentaires :"
}
},
"it" : {
"stringUnit" : {
"state" : "translated",
"value" : "Commento:"
}
},
"ja" : {
"stringUnit" : {
"state" : "translated",
"value" : "コメント:"
}
},
"pt" : {
"stringUnit" : {
"state" : "translated",
"value" : "Comentário:"
}
},
"tr" : {
"stringUnit" : {
"state" : "translated",
"value" : "Yorum:"
}
},
"zh-Hans" : {
"stringUnit" : {
"state" : "translated",
"value" : "注释："
}
},
"zh-Hant" : {
"stringUnit" : {
"state" : "translated",
"value" : "註釋："
}
}
}
},
"Completion list includes:" : {
"localizations" : {
"cs" : {

74
Tests/StringCommentingTests.swift
View File

@ -9,7 +9,7 @@
//
// ---------------------------------------------------------------------------
//
// © 2019-2023 1024jp
// © 2019-2024 1024jp
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@ -33,70 +33,49 @@ final class StringCommentingTests: XCTestCase {
func testInlineCommentOut() {
XCTAssertEqual("foo".inlineCommentOut(delimiter: "//", spacer: "", ranges: []), [])
XCTAssertEqual("foo".inlineCommentOut(delimiter: "//", ranges: []), [])
XCTAssertEqual("foo".inlineCommentOut(delimiter: "//", spacer: "", ranges: [NSRange(0..<0)]),
XCTAssertEqual("foo".inlineCommentOut(delimiter: "//", ranges: [NSRange(0..<0)]),
[.init(string: "//", location: 0, forward: true)])
XCTAssertEqual("foo".inlineCommentOut(delimiter: "//", spacer: " ", ranges: [NSRange(0..<0)]),
[.init(string: "// ", location: 0, forward: true)])
XCTAssertEqual("foo".inlineCommentOut(delimiter: "//", spacer: "", ranges: [NSRange(1..<2)]),
XCTAssertEqual("foo".inlineCommentOut(delimiter: "//", ranges: [NSRange(1..<2)]),
[.init(string: "//", location: 1, forward: true)])
}
func testBlockCommentOut() {
XCTAssertEqual("foo".blockCommentOut(delimiters: Pair("<-", "->"), spacer: "", ranges: []), [])
XCTAssertEqual("foo".blockCommentOut(delimiters: Pair("<-", "->"), ranges: []), [])
XCTAssertEqual("foo".blockCommentOut(delimiters: Pair("<-", "->"), spacer: "", ranges: [NSRange(0..<0)]),
XCTAssertEqual("foo".blockCommentOut(delimiters: Pair("<-", "->"), ranges: [NSRange(0..<0)]),
[.init(string: "<-", location: 0, forward: true), .init(string: "->", location: 0, forward: false)])
XCTAssertEqual("foo".blockCommentOut(delimiters: Pair("<-", "->"), spacer: " ", ranges: [NSRange(0..<3)]),
[.init(string: "<- ", location: 0, forward: true), .init(string: " ->", location: 3, forward: false)])
XCTAssertEqual("foo".blockCommentOut(delimiters: Pair("<-", "->"), spacer: " ", ranges: [NSRange(1..<2)]),
[.init(string: "<- ", location: 1, forward: true), .init(string: " ->", location: 2, forward: false)])
}
func testInlineUncomment() {
XCTAssertEqual("foo".rangesOfInlineDelimiter("//", spacer: "", ranges: []), [])
XCTAssertEqual("foo".rangesOfInlineDelimiter("//", spacer: "", ranges: [NSRange(0..<0)]), [])
XCTAssertEqual("foo".rangesOfInlineDelimiter("//", ranges: []), [])
XCTAssertEqual("foo".rangesOfInlineDelimiter("//", ranges: [NSRange(0..<0)]), [])
XCTAssertEqual("//foo".rangesOfInlineDelimiter("//", spacer: "", ranges: [NSRange(0..<5)]), [NSRange(0..<2)])
XCTAssertEqual("//foo".rangesOfInlineDelimiter("//", spacer: " ", ranges: [NSRange(0..<5)]), [NSRange(0..<2)])
XCTAssertEqual("// foo".rangesOfInlineDelimiter("//", spacer: "", ranges: [NSRange(0..<5)]), [NSRange(0..<2)])
XCTAssertEqual("// foo".rangesOfInlineDelimiter("//", spacer: " ", ranges: [NSRange(0..<5)]), [NSRange(0..<3)])
XCTAssertEqual("//foo".rangesOfInlineDelimiter("//", ranges: [NSRange(0..<5)]), [NSRange(0..<2)])
XCTAssertEqual("// foo".rangesOfInlineDelimiter("//", ranges: [NSRange(0..<5)]), [NSRange(0..<2)])
XCTAssertEqual(" //foo".rangesOfInlineDelimiter("//", spacer: "", ranges: [NSRange(0..<7)]), [NSRange(2..<4)])
XCTAssertNil("// foo".rangesOfInlineDelimiter("//", spacer: " ", ranges: [NSRange(0..<1)]))
XCTAssertNil("// foo".rangesOfInlineDelimiter("//", spacer: " ", ranges: [NSRange(1..<3)]))
XCTAssertEqual("// foo".rangesOfInlineDelimiter("//", spacer: " ", ranges: [NSRange(0..<2)]), [NSRange(0..<2)])
XCTAssertEqual("// foo\n//bar".rangesOfInlineDelimiter("//", spacer: " ", ranges: [NSRange(0..<12)]), [NSRange(0..<3), NSRange(7..<9)])
XCTAssertEqual(" //foo\n//bar".rangesOfInlineDelimiter("//", spacer: " ", ranges: [NSRange(0..<12)]), [NSRange(1..<3), NSRange(7..<9)])
XCTAssertEqual(" //foo\n//bar".rangesOfInlineDelimiter("//", spacer: " ", ranges: [NSRange(0..<3), NSRange(0..<6)]), [NSRange(1..<3)])
XCTAssertEqual("// foo\n//bar".rangesOfInlineDelimiter("//", spacer: " ", ranges: [NSRange(0..<5), NSRange(7..<12)]), [NSRange(0..<3), NSRange(7..<9)])
XCTAssertEqual(" //foo".rangesOfInlineDelimiter("//", ranges: [NSRange(0..<7)]), [NSRange(2..<4)])
}
func testBlockUncomment() {
XCTAssertEqual("foo".rangesOfBlockDelimiters(Pair("<-", "->"), spacer: "", ranges: []), [])
XCTAssertEqual("foo".rangesOfBlockDelimiters(Pair("<-", "->"), spacer: "", ranges: [NSRange(0..<0)]), [])
XCTAssertEqual("foo".rangesOfBlockDelimiters(Pair("<-", "->"), ranges: []), [])
XCTAssertEqual("foo".rangesOfBlockDelimiters(Pair("<-", "->"), ranges: [NSRange(0..<0)]), [])
XCTAssertEqual("<-foo->".rangesOfBlockDelimiters(Pair("<-", "->"), spacer: "", ranges: [NSRange(0..<7)]), [NSRange(0..<2), NSRange(5..<7)])
XCTAssertEqual("<-foo->".rangesOfBlockDelimiters(Pair("<-", "->"), spacer: " ", ranges: [NSRange(0..<7)]), [NSRange(0..<2), NSRange(5..<7)])
XCTAssertEqual("<- foo ->".rangesOfBlockDelimiters(Pair("<-", "->"), spacer: "", ranges: [NSRange(0..<9)]), [NSRange(0..<2), NSRange(7..<9)])
XCTAssertEqual("<- foo ->".rangesOfBlockDelimiters(Pair("<-", "->"), spacer: " ", ranges: [NSRange(0..<9)]), [NSRange(0..<3), NSRange(6..<9)])
XCTAssertEqual("<-foo->".rangesOfBlockDelimiters(Pair("<-", "->"), ranges: [NSRange(0..<7)]), [NSRange(0..<2), NSRange(5..<7)])
XCTAssertEqual("<- foo ->".rangesOfBlockDelimiters(Pair("<-", "->"), ranges: [NSRange(0..<9)]), [NSRange(0..<2), NSRange(7..<9)])
XCTAssertEqual(" <-foo-> ".rangesOfBlockDelimiters(Pair("<-", "->"), spacer: "", ranges: [NSRange(0..<9)]), [NSRange(1..<3), NSRange(6..<8)])
XCTAssertNil(" <-foo-> ".rangesOfBlockDelimiters(Pair("<-", "->"), spacer: "", ranges: [NSRange(1..<7)]))
XCTAssertEqual(" <-foo-> ".rangesOfBlockDelimiters(Pair("<-", "->"), ranges: [NSRange(0..<9)]), [NSRange(1..<3), NSRange(6..<8)])
XCTAssertNil(" <-foo-> ".rangesOfBlockDelimiters(Pair("<-", "->"), ranges: [NSRange(1..<7)]))
// ok, this is currently in spec, but not a good one...
XCTAssertEqual("<-foo-><-bar->".rangesOfBlockDelimiters(Pair("<-", "->"), spacer: "", ranges: [NSRange(0..<14)]), [NSRange(0..<2), NSRange(12..<14)])
XCTAssertNil("<- foo ->".rangesOfBlockDelimiters(Pair("<-", "->"), spacer: " ", ranges: [NSRange(0..<3), NSRange(6..<9)]))
XCTAssertEqual("<-foo-><-bar->".rangesOfBlockDelimiters(Pair("<-", "->"), ranges: [NSRange(0..<14)]), [NSRange(0..<2), NSRange(12..<14)])
}
@ -110,8 +89,8 @@ final class StringCommentingTests: XCTestCase {
textView.string = "foo\nbar"
textView.selectedRanges = [NSRange(0..<3), NSRange(4..<7)] as [NSValue]
textView.commentOut(types: .inline, fromLineHead: true)
XCTAssertEqual(textView.string, "// foo\n// bar")
XCTAssertEqual(textView.selectedRanges, [NSRange(0..<6), NSRange(7..<13)] as [NSValue])
XCTAssertEqual(textView.string, "//foo\n//bar")
XCTAssertEqual(textView.selectedRanges, [NSRange(0..<5), NSRange(6..<11)] as [NSValue])
XCTAssertTrue(textView.canUncomment(partly: false))
textView.uncomment()
XCTAssertEqual(textView.string, "foo\nbar")
@ -120,8 +99,8 @@ final class StringCommentingTests: XCTestCase {
textView.selectedRanges = [NSRange(1..<1)] as [NSValue]
textView.insertionLocations = [5]
textView.commentOut(types: .inline, fromLineHead: true)
XCTAssertEqual(textView.string, "// foo\n// bar")
XCTAssertEqual(textView.rangesForUserTextChange, [NSRange(4..<4), NSRange(11..<11)] as [NSValue])
XCTAssertEqual(textView.string, "//foo\n//bar")
XCTAssertEqual(textView.rangesForUserTextChange, [NSRange(3..<3), NSRange(9..<9)] as [NSValue])
XCTAssertTrue(textView.canUncomment(partly: false))
textView.uncomment()
XCTAssertEqual(textView.string, "foo\nbar")
@ -136,8 +115,8 @@ final class StringCommentingTests: XCTestCase {
textView.string = "foo\nbar"
textView.selectedRanges = [NSRange(0..<3), NSRange(4..<7)] as [NSValue]
textView.commentOut(types: .block, fromLineHead: true)
XCTAssertEqual(textView.string, "<- foo ->\n<- bar ->")
XCTAssertEqual(textView.selectedRanges, [NSRange(0..<9), NSRange(10..<19)] as [NSValue])
XCTAssertEqual(textView.string, "<-foo->\n<-bar->")
XCTAssertEqual(textView.selectedRanges, [NSRange(0..<7), NSRange(8..<15)] as [NSValue])
XCTAssertTrue(textView.canUncomment(partly: false))
textView.uncomment()
XCTAssertEqual(textView.string, "foo\nbar")
@ -146,8 +125,8 @@ final class StringCommentingTests: XCTestCase {
textView.selectedRanges = [NSRange(1..<1)] as [NSValue]
textView.insertionLocations = [5]
textView.commentOut(types: .block, fromLineHead: true)
XCTAssertEqual(textView.string, "<- foo ->\n<- bar ->")
XCTAssertEqual(textView.rangesForUserTextChange, [NSRange(4..<4), NSRange(14..<14)] as [NSValue])
XCTAssertEqual(textView.string, "<-foo->\n<-bar->")
XCTAssertEqual(textView.rangesForUserTextChange, [NSRange(3..<3), NSRange(11..<11)] as [NSValue])
XCTAssertTrue(textView.canUncomment(partly: false))
textView.uncomment()
XCTAssertEqual(textView.string, "foo\nbar")
@ -186,7 +165,6 @@ private final class CommentingTextView: NSTextView, Commenting, MultiCursorEditi
// Commenting
var inlineCommentDelimiter: String? = "//"
var blockCommentDelimiters: Pair<String>? = Pair("<-", "->")
var appendsCommentSpacer: Bool = true
// MultiCursorEditing
var insertionLocations: [Int] = []