Merge pull request #871 from naithar/textcheckingresult

swift-ci · web-flow · commit a27996f0d968 · 2017-02-09T12:00:53.000-08:00
diff --git a/Docs/Status.md b/Docs/Status.md
@@ -198,7 +198,7 @@ There is no _Complete_ status for test coverage because there are always additio
     |-----------------------------|-----------------|---------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
     | `RegularExpression`         | Mostly Complete | Substantial   | `NSCoding` remains unimplemented                                                                                                                                 |
     | `Scanner`                   | Mostly Complete | Incomplete    | `scanHex<T: _FloatLike>(_:locale:locationToScanFrom:to:)` and `localizedScannerWithString(_:)` remain unimplemented                                              |
-    | `TextCheckingResult`        | Mostly Complete | Incomplete    | `NSCoding`, `NSCopying`, `resultType`, and `range(at:)` remain unimplemented                                                                                     |
+    | `NSTextCheckingResult`      | Mostly Complete | Incomplete    | `NSCoding`, `NSCopying`, `resultType`, and `range(at:)` remain unimplemented                                                                                     |
     | `NSAttributedString`        | Incomplete      | Incomplete    | `NSCoding`, `NS[Mutable]Copying`, `attributedSubstring(from:)`, `isEqual(to:)`, `init(NSAttributedString:)` remain unimplemented |
     | `NSMutableAttributedString` | Unimplemented   | Incomplete    | Only `addAttribute(_:value:range:)` is implemented                                                                                                               |
     | `NSCharacterSet`            | Mostly Complete | Incomplete    | `NSCoding` remains unimplemented                                                                                                                                 |
diff --git a/Foundation/NSRegularExpression.swift b/Foundation/NSRegularExpression.swift
@@ -113,8 +113,8 @@ public struct NSMatchingFlags : OptionSet {
 
 internal class _NSRegularExpressionMatcher {
     var regex: NSRegularExpression
-    var block: (TextCheckingResult?, NSMatchingFlags, UnsafeMutablePointer<ObjCBool>) -> Void
-    init(regex: NSRegularExpression, block: @escaping (TextCheckingResult?, NSMatchingFlags, UnsafeMutablePointer<ObjCBool>) -> Void) {
+    var block: (NSTextCheckingResult?, NSMatchingFlags, UnsafeMutablePointer<ObjCBool>) -> Void
+    init(regex: NSRegularExpression, block: @escaping (NSTextCheckingResult?, NSMatchingFlags, UnsafeMutablePointer<ObjCBool>) -> Void) {
         self.regex = regex
         self.block = block
     }
@@ -133,7 +133,7 @@ internal func _NSRegularExpressionMatch(_ context: UnsafeMutableRawPointer?, ran
         })
     } else {
         let result = ranges!.withMemoryRebound(to: NSRange.self, capacity: count) { rangePtr in
-            TextCheckingResult.regularExpressionCheckingResultWithRanges(rangePtr, count: count, regularExpression: matcher.regex)
+            NSTextCheckingResult.regularExpressionCheckingResultWithRanges(rangePtr, count: count, regularExpression: matcher.regex)
         }
 #if os(OSX) || os(iOS)
         let flags = NSMatchingFlags(rawValue: options.rawValue)
@@ -151,7 +151,7 @@ extension NSRegularExpression {
     /* The fundamental matching method on NSRegularExpression is a block iterator.  There are several additional convenience methods, for returning all matches at once, the number of matches, the first match, or the range of the first match.  Each match is specified by an instance of NSTextCheckingResult (of type NSTextCheckingTypeRegularExpression) in which the overall match range is given by the range property (equivalent to range at:0) and any capture group ranges are given by range at: for indexes from 1 to numberOfCaptureGroups.  {NSNotFound, 0} is used if a particular capture group does not participate in the match.
     */
     
-    public func enumerateMatches(in string: String, options: NSMatchingOptions, range: NSRange, using block: @escaping (TextCheckingResult?, NSMatchingFlags, UnsafeMutablePointer<ObjCBool>) -> Swift.Void) {
+    public func enumerateMatches(in string: String, options: NSMatchingOptions, range: NSRange, using block: @escaping (NSTextCheckingResult?, NSMatchingFlags, UnsafeMutablePointer<ObjCBool>) -> Swift.Void) {
         let matcher = _NSRegularExpressionMatcher(regex: self, block: block)
         withExtendedLifetime(matcher) { (m: _NSRegularExpressionMatcher) -> Void in
 #if os(OSX) || os(iOS)
@@ -163,9 +163,9 @@ extension NSRegularExpression {
         }
     }
     
-    public func matches(in string: String, options: NSMatchingOptions, range: NSRange) -> [TextCheckingResult] {
-        var matches = [TextCheckingResult]()
-        enumerateMatches(in: string, options: options.subtracting(.reportProgress).subtracting(.reportCompletion), range: range) { (result: TextCheckingResult?, flags: NSMatchingFlags, stop: UnsafeMutablePointer<ObjCBool>) in
+    public func matches(in string: String, options: NSMatchingOptions, range: NSRange) -> [NSTextCheckingResult] {
+        var matches = [NSTextCheckingResult]()
+        enumerateMatches(in: string, options: options.subtracting(.reportProgress).subtracting(.reportCompletion), range: range) { (result: NSTextCheckingResult?, flags: NSMatchingFlags, stop: UnsafeMutablePointer<ObjCBool>) in
             if let match = result {
                 matches.append(match)
             }
@@ -182,9 +182,9 @@ extension NSRegularExpression {
         return count
     }
     
-    public func firstMatch(in string: String, options: NSMatchingOptions, range: NSRange) -> TextCheckingResult? {
-        var first: TextCheckingResult?
-        enumerateMatches(in: string, options: options.subtracting(.reportProgress).subtracting(.reportCompletion), range: range) { (result: TextCheckingResult?, flags: NSMatchingFlags, stop: UnsafeMutablePointer<ObjCBool>) in
+    public func firstMatch(in string: String, options: NSMatchingOptions, range: NSRange) -> NSTextCheckingResult? {
+        var first: NSTextCheckingResult?
+        enumerateMatches(in: string, options: options.subtracting(.reportProgress).subtracting(.reportCompletion), range: range) { (result: NSTextCheckingResult?, flags: NSMatchingFlags, stop: UnsafeMutablePointer<ObjCBool>) in
             first = result
             stop.pointee = true
         }
@@ -193,7 +193,7 @@ extension NSRegularExpression {
     
     public func rangeOfFirstMatch(in string: String, options: NSMatchingOptions, range: NSRange) -> NSRange {
         var firstRange = NSMakeRange(NSNotFound, 0)
-        enumerateMatches(in: string, options: options.subtracting(.reportProgress).subtracting(.reportCompletion), range: range) { (result: TextCheckingResult?, flags: NSMatchingFlags, stop: UnsafeMutablePointer<ObjCBool>) in
+        enumerateMatches(in: string, options: options.subtracting(.reportProgress).subtracting(.reportCompletion), range: range) { (result: NSTextCheckingResult?, flags: NSMatchingFlags, stop: UnsafeMutablePointer<ObjCBool>) in
             if let match = result {
                 firstRange = match.range
             } else {
@@ -264,7 +264,7 @@ extension NSRegularExpression {
     
     /* For clients implementing their own replace functionality, this is a method to perform the template substitution for a single result, given the string from which the result was matched, an offset to be added to the location of the result in the string (for example, in case modifications to the string moved the result since it was matched), and a replacement template.
     */
-    public func replacementString(for result: TextCheckingResult, in string: String, offset: Int, template templ: String) -> String {
+    public func replacementString(for result: NSTextCheckingResult, in string: String, offset: Int, template templ: String) -> String {
         // ??? need to consider what happens if offset takes range out of bounds due to replacement
         struct once {
             static let characterSet = CharacterSet(charactersIn: "\\$")
diff --git a/Foundation/NSTextCheckingResult.swift b/Foundation/NSTextCheckingResult.swift
@@ -10,7 +10,7 @@
 import CoreFoundation
 
 /* NSTextCheckingType in this project is limited to regular expressions. */
-extension TextCheckingResult {
+extension NSTextCheckingResult {
     public struct CheckingType : OptionSet {
         public let rawValue: UInt64
         public init(rawValue: UInt64) { self.rawValue = rawValue }
@@ -19,44 +19,49 @@ extension TextCheckingResult {
     }
 }
 
-open class TextCheckingResult: NSObject, NSCopying, NSCoding {
+open class NSTextCheckingResult: NSObject, NSCopying, NSCoding {
     
     public override init() {
-        super.init()
+        if type(of: self) == NSTextCheckingResult.self {
+            NSRequiresConcreteImplementation()
+        }
     }
     
-    open class func regularExpressionCheckingResultWithRanges(_ ranges: NSRangePointer, count: Int, regularExpression: NSRegularExpression) -> TextCheckingResult {
-        return _NSRegularExpressionTextCheckingResultResult(ranges: ranges, count: count, regularExpression: regularExpression)
+    open class func regularExpressionCheckingResultWithRanges(_ ranges: NSRangePointer, count: Int, regularExpression: NSRegularExpression) -> NSTextCheckingResult {
+        return _NSRegularExpressionNSTextCheckingResultResult(ranges: ranges, count: count, regularExpression: regularExpression)
     }
 
     public required init?(coder aDecoder: NSCoder) {
-        NSUnimplemented()
+        if type(of: self) == NSTextCheckingResult.self {
+            NSRequiresConcreteImplementation()
+        }
     }
     
     open func encode(with aCoder: NSCoder) {
-        NSUnimplemented()
+        NSRequiresConcreteImplementation()
     }
     
     open override func copy() -> Any {
         return copy(with: nil)
     }
     
     open func copy(with zone: NSZone? = nil) -> Any {
-        NSUnimplemented()
+        return self
     }
     
     /* Mandatory properties, used with all types of results. */
-    open var resultType: CheckingType { NSUnimplemented() }
+    open var resultType: CheckingType { NSRequiresConcreteImplementation() }
     open var range: NSRange { return range(at: 0) }
     /* A result must have at least one range, but may optionally have more (for example, to represent regular expression capture groups).  The range at index 0 always matches the range property.  Additional ranges, if any, will have indexes from 1 to numberOfRanges-1. */
-    open func range(at idx: Int) -> NSRange { NSUnimplemented() }
+    open func range(at idx: Int) -> NSRange { NSRequiresConcreteImplementation() }
     open var regularExpression: NSRegularExpression? { return nil }
     open var numberOfRanges: Int { return 1 }
 }
 
-internal class _NSRegularExpressionTextCheckingResultResult : TextCheckingResult {
+internal class _NSRegularExpressionNSTextCheckingResultResult : NSTextCheckingResult {
     var _ranges = [NSRange]()
     let _regularExpression: NSRegularExpression
+    
     init(ranges: NSRangePointer, count: Int, regularExpression: NSRegularExpression) {
         _regularExpression = regularExpression
         super.init()
@@ -67,7 +72,11 @@ internal class _NSRegularExpressionTextCheckingResultResult : TextCheckingResult
     }
 
     internal required init?(coder aDecoder: NSCoder) {
-        fatalError("init(coder:) has not been implemented")
+        NSUnimplemented()
+    }
+    
+    internal override func encode(with aCoder: NSCoder) {
+        NSUnimplemented()
     }
     
     override var resultType: CheckingType { return .RegularExpression }
@@ -76,9 +85,9 @@ internal class _NSRegularExpressionTextCheckingResultResult : TextCheckingResult
     override var regularExpression: NSRegularExpression? { return _regularExpression }
 }
 
-extension TextCheckingResult {
+extension NSTextCheckingResult {
     
-    public func resultByAdjustingRangesWithOffset(_ offset: Int) -> TextCheckingResult {
+    public func resultByAdjustingRangesWithOffset(_ offset: Int) -> NSTextCheckingResult {
         let count = self.numberOfRanges
         var newRanges = [NSRange]()
         for idx in 0..<count {
@@ -91,7 +100,7 @@ extension TextCheckingResult {
               newRanges.append(NSRange(location: currentRange.location + offset,length: currentRange.length))
            }
         }
-        let result = TextCheckingResult.regularExpressionCheckingResultWithRanges(&newRanges, count: count, regularExpression: self.regularExpression!)
+        let result = NSTextCheckingResult.regularExpressionCheckingResultWithRanges(&newRanges, count: count, regularExpression: self.regularExpression!)
         return result
     }
 }
diff --git a/TestFoundation/TestNSTextCheckingResult.swift b/TestFoundation/TestNSTextCheckingResult.swift
@@ -32,7 +32,7 @@ class TestNSTextCheckingResult: XCTestCase {
            let searchString = "1x030cy"
            let searchOptions: NSMatchingOptions = []
            let searchRange = NSMakeRange(0,7)
-           let match: TextCheckingResult =  regex.firstMatch(in: searchString, options: searchOptions, range: searchRange)!
+           let match: NSTextCheckingResult =  regex.firstMatch(in: searchString, options: searchOptions, range: searchRange)!
            //Positive offset
            var result = match.resultByAdjustingRangesWithOffset(1)
            XCTAssertEqual(result.range(at: 0).location, 6)
