diff --git a/Foundation/NSCFString.swift b/Foundation/NSCFString.swift index 4fb5640b81..f6e494404d 100644 --- a/Foundation/NSCFString.swift +++ b/Foundation/NSCFString.swift @@ -44,11 +44,11 @@ internal class _NSCFString : NSMutableString { return CFStringGetLength(unsafeBitCast(self, to: CFString.self)) } - override func characterAtIndex(_ index: Int) -> unichar { + override func character(at index: Int) -> unichar { return CFStringGetCharacterAtIndex(unsafeBitCast(self, to: CFString.self), index) } - override func replaceCharactersInRange(_ range: NSRange, withString aString: String) { + override func replaceCharacters(in range: NSRange, with aString: String) { CFStringReplace(unsafeBitCast(self, to: CFMutableString.self), CFRangeMake(range.location, range.length), aString._cfObject) } @@ -100,11 +100,11 @@ internal final class _NSCFConstantString : _NSCFString { return Int(_length) } - override func characterAtIndex(_ index: Int) -> unichar { + override func character(at index: Int) -> unichar { return unichar(_ptr[index]) } - override func replaceCharactersInRange(_ range: NSRange, withString aString: String) { + override func replaceCharacters(in range: NSRange, with aString: String) { fatalError() } @@ -118,7 +118,7 @@ internal func _CFSwiftStringGetLength(_ string: AnyObject) -> CFIndex { } internal func _CFSwiftStringGetCharacterAtIndex(_ str: AnyObject, index: CFIndex) -> UniChar { - return (str as! NSString).characterAtIndex(index) + return (str as! NSString).character(at: index) } internal func _CFSwiftStringGetCharacters(_ str: AnyObject, range: CFRange, buffer: UnsafeMutablePointer) { @@ -164,7 +164,7 @@ internal func _CFSwiftStringGetBytes(_ str: AnyObject, encoding: CFStringEncodin } internal func _CFSwiftStringCreateWithSubstring(_ str: AnyObject, range: CFRange) -> Unmanaged { - return Unmanaged.passRetained((str as! NSString).substringWithRange(NSMakeRange(range.location, range.length))._nsObject) + return Unmanaged.passRetained((str as! NSString).substring(with: NSMakeRange(range.location, range.length))._nsObject) } @@ -193,15 +193,15 @@ internal func _CFSwiftStringIsUnicode(_ str: AnyObject) -> Bool { } internal func _CFSwiftStringInsert(_ str: AnyObject, index: CFIndex, inserted: AnyObject) { - (str as! NSMutableString).insertString((inserted as! NSString)._swiftObject, atIndex: index) + (str as! NSMutableString).insert((inserted as! NSString)._swiftObject, at: index) } internal func _CFSwiftStringDelete(_ str: AnyObject, range: CFRange) { - (str as! NSMutableString).deleteCharactersInRange(NSMakeRange(range.location, range.length)) + (str as! NSMutableString).deleteCharacters(in: NSMakeRange(range.location, range.length)) } internal func _CFSwiftStringReplace(_ str: AnyObject, range: CFRange, replacement: AnyObject) { - (str as! NSMutableString).replaceCharactersInRange(NSMakeRange(range.location, range.length), withString: (replacement as! NSString)._swiftObject) + (str as! NSMutableString).replaceCharacters(in: NSMakeRange(range.location, range.length), with: (replacement as! NSString)._swiftObject) } internal func _CFSwiftStringReplaceAll(_ str: AnyObject, replacement: AnyObject) { @@ -209,7 +209,7 @@ internal func _CFSwiftStringReplaceAll(_ str: AnyObject, replacement: AnyObject) } internal func _CFSwiftStringAppend(_ str: AnyObject, appended: AnyObject) { - (str as! NSMutableString).appendString((appended as! NSString)._swiftObject) + (str as! NSMutableString).append((appended as! NSString)._swiftObject) } internal func _CFSwiftStringAppendCharacters(_ str: AnyObject, chars: UnsafePointer, length: CFIndex) { diff --git a/Foundation/NSConcreteValue.swift b/Foundation/NSConcreteValue.swift index 9385a2db60..abf820c444 100644 --- a/Foundation/NSConcreteValue.swift +++ b/Foundation/NSConcreteValue.swift @@ -105,7 +105,7 @@ internal class NSConcreteValue : NSValue { } override var objCType : UnsafePointer { - return NSString(self._typeInfo.name).UTF8String! // XXX leaky + return NSString(self._typeInfo.name).utf8String! // XXX leaky } override var classForCoder: AnyClass { diff --git a/Foundation/NSFileManager.swift b/Foundation/NSFileManager.swift index a97c9d5d02..638790294c 100644 --- a/Foundation/NSFileManager.swift +++ b/Foundation/NSFileManager.swift @@ -884,7 +884,7 @@ internal class NSPathDirectoryEnumerator: NSDirectoryEnumerator { guard let url = o as? NSURL else { return nil } - let path = url.path!.stringByReplacingOccurrencesOfString(baseURL.path!+"/", withString: "") + let path = url.path!.replacingOccurrences(of: baseURL.path!+"/", with: "") return NSString(string: path) } diff --git a/Foundation/NSJSONSerialization.swift b/Foundation/NSJSONSerialization.swift index d3422dcc48..e86cb33bc1 100644 --- a/Foundation/NSJSONSerialization.swift +++ b/Foundation/NSJSONSerialization.swift @@ -109,7 +109,7 @@ public class NSJSONSerialization : NSObject { pretty: opt.contains(.PrettyPrinted), writer: { (str: String?) in if let str = str { - result.append(str.bridge().cStringUsingEncoding(NSUTF8StringEncoding)!, length: str.lengthOfBytesUsingEncoding(NSUTF8StringEncoding)) + result.append(str.bridge().cString(using: NSUTF8StringEncoding)!, length: str.lengthOfBytes(using: NSUTF8StringEncoding)) } } ) diff --git a/Foundation/NSKeyedUnarchiver.swift b/Foundation/NSKeyedUnarchiver.swift index 351bfca593..7b25bb9bb3 100644 --- a/Foundation/NSKeyedUnarchiver.swift +++ b/Foundation/NSKeyedUnarchiver.swift @@ -828,7 +828,7 @@ public class NSKeyedUnarchiver : NSCoder { break case .CharPtr: if let ns = decodeObject() as? NSString { - let string = ns.UTF8String! // XXX leaky + let string = ns.utf8String! // XXX leaky unsafeBitCast(addr, to: UnsafeMutablePointer>.self).pointee = string } break diff --git a/Foundation/NSObjCRuntime.swift b/Foundation/NSObjCRuntime.swift index 8bf47bc38a..87dc4c0397 100644 --- a/Foundation/NSObjCRuntime.swift +++ b/Foundation/NSObjCRuntime.swift @@ -249,7 +249,7 @@ private let _SwiftFoundationModuleName = "Foundation" */ public func NSStringFromClass(_ aClass: AnyClass) -> String { let aClassName = String(reflecting: aClass).bridge() - let components = aClassName.componentsSeparatedByString(".") + let components = aClassName.components(separatedBy: ".") guard components.count == 2 else { fatalError("NSStringFromClass: \(String(reflecting: aClass)) is not a top-level class") @@ -272,7 +272,7 @@ public func NSStringFromClass(_ aClass: AnyClass) -> String { */ public func NSClassFromString(_ aClassName: String) -> AnyClass? { let aClassNameWithPrefix : String - let components = aClassName.bridge().componentsSeparatedByString(".") + let components = aClassName.bridge().components(separatedBy: ".") switch components.count { case 1: diff --git a/Foundation/NSPathUtilities.swift b/Foundation/NSPathUtilities.swift index e197e1acf3..9b6e8f8eb2 100644 --- a/Foundation/NSPathUtilities.swift +++ b/Foundation/NSPathUtilities.swift @@ -497,7 +497,7 @@ public extension NSString { if caseSensetive { return { $0 != nil && $0!.hasPrefix(thePrefix) } } else { - return { $0 != nil && $0!.bridge().rangeOfString(thePrefix, options: .CaseInsensitiveSearch).location == 0 } + return { $0 != nil && $0!.bridge().range(of: thePrefix, options: .caseInsensitiveSearch).location == 0 } } } diff --git a/Foundation/NSRegularExpression.swift b/Foundation/NSRegularExpression.swift index dca8f1b62e..72338c4184 100644 --- a/Foundation/NSRegularExpression.swift +++ b/Foundation/NSRegularExpression.swift @@ -247,7 +247,7 @@ extension NSRegularExpression { let replacement = replacementString(for: result, in: string._swiftObject, offset: offset, template: templ) currentRnage.location += offset - string.replaceCharactersInRange(currentRnage, withString: replacement) + string.replaceCharacters(in: currentRnage, with: replacement) offset += replacement.length - currentRnage.length count += 1 } @@ -262,7 +262,7 @@ extension NSRegularExpression { static let characterSet = NSCharacterSet(charactersInString: "\\$") } let template = templ._nsObject - var range = template.rangeOfCharacterFromSet(once.characterSet) + var range = template.rangeOfCharacter(from: once.characterSet) if range.length > 0 { var numberOfDigits = 1 var orderOfMagnitude = 10 @@ -274,16 +274,16 @@ extension NSRegularExpression { orderOfMagnitude *= 10 } while range.length > 0 { - var c = str.characterAtIndex(range.location) + var c = str.character(at: range.location) if c == unichar(unicodeScalarLiteral: "\\") { - str.deleteCharactersInRange(range) + str.deleteCharacters(in: range) length -= range.length range.length = 1 } else if c == unichar(unicodeScalarLiteral: "$") { var groupNumber: Int = NSNotFound var idx = NSMaxRange(range) while idx < length && idx < NSMaxRange(range) + numberOfDigits { - c = str.characterAtIndex(idx) + c = str.character(at: idx) if c < unichar(unicodeScalarLiteral: "0") || c > unichar(unicodeScalarLiteral: "9") { break } @@ -311,7 +311,7 @@ extension NSRegularExpression { let max = start.advanced(by: substringRange.location + substringRange.length) substring = String(string.utf16[min.. length { break } - range = str.rangeOfCharacterFromSet(once.characterSet, options: [], range: NSMakeRange(NSMaxRange(range), length - NSMaxRange(range))) + range = str.rangeOfCharacter(from: once.characterSet, options: [], range: NSMakeRange(NSMaxRange(range), length - NSMaxRange(range))) } return str._swiftObject } diff --git a/Foundation/NSScanner.swift b/Foundation/NSScanner.swift index ba0ac0388d..159b861abc 100644 --- a/Foundation/NSScanner.swift +++ b/Foundation/NSScanner.swift @@ -497,7 +497,7 @@ extension NSScanner { var stringLoc = scanLocation let stringLen = string.length if let invSet = invertedSkipSet { - let range = string._nsObject.rangeOfCharacterFromSet(invSet, options: [], range: NSMakeRange(stringLoc, stringLen - stringLoc)) + let range = string._nsObject.rangeOfCharacter(from: invSet, options: [], range: NSMakeRange(stringLoc, stringLen - stringLoc)) stringLoc = range.length > 0 ? range.location : stringLen } return stringLoc == stringLen @@ -627,17 +627,17 @@ extension NSScanner { let str = self.string._bridgeToObject() var stringLoc = scanLocation let stringLen = str.length - let options: NSStringCompareOptions = [caseSensitive ? [] : NSStringCompareOptions.CaseInsensitiveSearch, NSStringCompareOptions.AnchoredSearch] + let options: NSStringCompareOptions = [caseSensitive ? [] : NSStringCompareOptions.caseInsensitiveSearch, NSStringCompareOptions.anchoredSearch] if let invSkipSet = charactersToBeSkipped?.invertedSet { - let range = str.rangeOfCharacterFromSet(invSkipSet, options: [], range: NSMakeRange(stringLoc, stringLen - stringLoc)) + let range = str.rangeOfCharacter(from: invSkipSet, options: [], range: NSMakeRange(stringLoc, stringLen - stringLoc)) stringLoc = range.length > 0 ? range.location : stringLen } - let range = str.rangeOfString(searchString, options: options, range: NSMakeRange(stringLoc, stringLen - stringLoc)) + let range = str.range(of: searchString, options: options, range: NSMakeRange(stringLoc, stringLen - stringLoc)) if range.length > 0 { /* ??? Is the range below simply range? 99.9% of the time, and perhaps even 100% of the time... Hmm... */ - let res = str.substringWithRange(NSMakeRange(stringLoc, range.location + range.length - stringLoc)) + let res = str.substring(with: NSMakeRange(stringLoc, range.location + range.length - stringLoc)) scanLocation = range.location + range.length return res } @@ -648,17 +648,17 @@ extension NSScanner { let str = self.string._bridgeToObject() var stringLoc = scanLocation let stringLen = str.length - let options: NSStringCompareOptions = caseSensitive ? [] : NSStringCompareOptions.CaseInsensitiveSearch + let options: NSStringCompareOptions = caseSensitive ? [] : NSStringCompareOptions.caseInsensitiveSearch if let invSkipSet = charactersToBeSkipped?.invertedSet { - let range = str.rangeOfCharacterFromSet(invSkipSet, options: [], range: NSMakeRange(stringLoc, stringLen - stringLoc)) + let range = str.rangeOfCharacter(from: invSkipSet, options: [], range: NSMakeRange(stringLoc, stringLen - stringLoc)) stringLoc = range.length > 0 ? range.location : stringLen } - var range = str.rangeOfCharacterFromSet(set.invertedSet, options: options, range: NSMakeRange(stringLoc, stringLen - stringLoc)) + var range = str.rangeOfCharacter(from: set.invertedSet, options: options, range: NSMakeRange(stringLoc, stringLen - stringLoc)) if range.length == 0 { range.location = stringLen } if stringLoc != range.location { - let res = str.substringWithRange(NSMakeRange(stringLoc, range.location - stringLoc)) + let res = str.substring(with: NSMakeRange(stringLoc, range.location - stringLoc)) scanLocation = range.location return res } @@ -669,17 +669,17 @@ extension NSScanner { let str = self.string._bridgeToObject() var stringLoc = scanLocation let stringLen = str.length - let options: NSStringCompareOptions = caseSensitive ? [] : NSStringCompareOptions.CaseInsensitiveSearch + let options: NSStringCompareOptions = caseSensitive ? [] : NSStringCompareOptions.caseInsensitiveSearch if let invSkipSet = charactersToBeSkipped?.invertedSet { - let range = str.rangeOfCharacterFromSet(invSkipSet, options: [], range: NSMakeRange(stringLoc, stringLen - stringLoc)) + let range = str.rangeOfCharacter(from: invSkipSet, options: [], range: NSMakeRange(stringLoc, stringLen - stringLoc)) stringLoc = range.length > 0 ? range.location : stringLen } - var range = str.rangeOfString(string, options: options, range: NSMakeRange(stringLoc, stringLen - stringLoc)) + var range = str.range(of: string, options: options, range: NSMakeRange(stringLoc, stringLen - stringLoc)) if range.length == 0 { range.location = stringLen } if stringLoc != range.location { - let res = str.substringWithRange(NSMakeRange(stringLoc, range.location - stringLoc)) + let res = str.substring(with: NSMakeRange(stringLoc, range.location - stringLoc)) scanLocation = range.location return res } @@ -690,17 +690,17 @@ extension NSScanner { let str = self.string._bridgeToObject() var stringLoc = scanLocation let stringLen = str.length - let options: NSStringCompareOptions = caseSensitive ? [] : NSStringCompareOptions.CaseInsensitiveSearch + let options: NSStringCompareOptions = caseSensitive ? [] : NSStringCompareOptions.caseInsensitiveSearch if let invSkipSet = charactersToBeSkipped?.invertedSet { - let range = str.rangeOfCharacterFromSet(invSkipSet, options: [], range: NSMakeRange(stringLoc, stringLen - stringLoc)) + let range = str.rangeOfCharacter(from: invSkipSet, options: [], range: NSMakeRange(stringLoc, stringLen - stringLoc)) stringLoc = range.length > 0 ? range.location : stringLen } - var range = str.rangeOfCharacterFromSet(set, options: options, range: NSMakeRange(stringLoc, stringLen - stringLoc)) + var range = str.rangeOfCharacter(from: set, options: options, range: NSMakeRange(stringLoc, stringLen - stringLoc)) if range.length == 0 { range.location = stringLen } if stringLoc != range.location { - let res = str.substringWithRange(NSMakeRange(stringLoc, range.location - stringLoc)) + let res = str.substring(with: NSMakeRange(stringLoc, range.location - stringLoc)) scanLocation = range.location return res } diff --git a/Foundation/NSSpecialValue.swift b/Foundation/NSSpecialValue.swift index b8833c9301..1c17c00adc 100644 --- a/Foundation/NSSpecialValue.swift +++ b/Foundation/NSSpecialValue.swift @@ -121,7 +121,7 @@ internal class NSSpecialValue : NSValue { override var objCType : UnsafePointer { let typeName = NSSpecialValue._objCTypeFromType(_value.dynamicType) - return typeName!.bridge().UTF8String! // leaky + return typeName!.bridge().utf8String! // leaky } override var classForCoder: AnyClass { diff --git a/Foundation/NSString.swift b/Foundation/NSString.swift index e70969293d..74002c3766 100644 --- a/Foundation/NSString.swift +++ b/Foundation/NSString.swift @@ -52,8 +52,8 @@ public struct NSStringEncodingConversionOptions : OptionSet { public let rawValue : UInt public init(rawValue: UInt) { self.rawValue = rawValue } - public static let AllowLossy = NSStringEncodingConversionOptions(rawValue: 1) - public static let ExternalRepresentation = NSStringEncodingConversionOptions(rawValue: 2) + public static let allowLossy = NSStringEncodingConversionOptions(rawValue: 1) + public static let externalRepresentation = NSStringEncodingConversionOptions(rawValue: 2) internal static let FailOnPartialEncodingConversion = NSStringEncodingConversionOptions(rawValue: 1 << 20) } @@ -61,14 +61,14 @@ public struct NSStringEnumerationOptions : OptionSet { public let rawValue : UInt public init(rawValue: UInt) { self.rawValue = rawValue } - public static let ByLines = NSStringEnumerationOptions(rawValue: 0) - public static let ByParagraphs = NSStringEnumerationOptions(rawValue: 1) - public static let ByComposedCharacterSequences = NSStringEnumerationOptions(rawValue: 2) - public static let ByWords = NSStringEnumerationOptions(rawValue: 3) - public static let BySentences = NSStringEnumerationOptions(rawValue: 4) - public static let Reverse = NSStringEnumerationOptions(rawValue: 1 << 8) - public static let SubstringNotRequired = NSStringEnumerationOptions(rawValue: 1 << 9) - public static let Localized = NSStringEnumerationOptions(rawValue: 1 << 10) + public static let byLines = NSStringEnumerationOptions(rawValue: 0) + public static let byParagraphs = NSStringEnumerationOptions(rawValue: 1) + public static let byComposedCharacterSequences = NSStringEnumerationOptions(rawValue: 2) + public static let byWords = NSStringEnumerationOptions(rawValue: 3) + public static let bySentences = NSStringEnumerationOptions(rawValue: 4) + public static let reverse = NSStringEnumerationOptions(rawValue: 1 << 8) + public static let substringNotRequired = NSStringEnumerationOptions(rawValue: 1 << 9) + public static let localized = NSStringEnumerationOptions(rawValue: 1 << 10) internal static let ForceFullTokens = NSStringEnumerationOptions(rawValue: 1 << 20) } @@ -120,21 +120,21 @@ public struct NSStringCompareOptions : OptionSet { public let rawValue : UInt public init(rawValue: UInt) { self.rawValue = rawValue } - public static let CaseInsensitiveSearch = NSStringCompareOptions(rawValue: 1) - public static let LiteralSearch = NSStringCompareOptions(rawValue: 2) - public static let BackwardsSearch = NSStringCompareOptions(rawValue: 4) - public static let AnchoredSearch = NSStringCompareOptions(rawValue: 8) - public static let NumericSearch = NSStringCompareOptions(rawValue: 64) - public static let DiacriticInsensitiveSearch = NSStringCompareOptions(rawValue: 128) - public static let WidthInsensitiveSearch = NSStringCompareOptions(rawValue: 256) - public static let ForcedOrderingSearch = NSStringCompareOptions(rawValue: 512) - public static let RegularExpressionSearch = NSStringCompareOptions(rawValue: 1024) + public static let caseInsensitiveSearch = NSStringCompareOptions(rawValue: 1) + public static let literalSearch = NSStringCompareOptions(rawValue: 2) + public static let backwardsSearch = NSStringCompareOptions(rawValue: 4) + public static let anchoredSearch = NSStringCompareOptions(rawValue: 8) + public static let numericSearch = NSStringCompareOptions(rawValue: 64) + public static let diacriticInsensitiveSearch = NSStringCompareOptions(rawValue: 128) + public static let widthInsensitiveSearch = NSStringCompareOptions(rawValue: 256) + public static let forcedOrderingSearch = NSStringCompareOptions(rawValue: 512) + public static let regularExpressionSearch = NSStringCompareOptions(rawValue: 1024) internal func _cfValue(_ fixLiteral: Bool = false) -> CFStringCompareFlags { #if os(OSX) || os(iOS) - return contains(.LiteralSearch) || !fixLiteral ? CFStringCompareFlags(rawValue: rawValue) : CFStringCompareFlags(rawValue: rawValue).union(.compareNonliteral) + return contains(.literalSearch) || !fixLiteral ? CFStringCompareFlags(rawValue: rawValue) : CFStringCompareFlags(rawValue: rawValue).union(.compareNonliteral) #else - return contains(.LiteralSearch) || !fixLiteral ? CFStringCompareFlags(rawValue) : CFStringCompareFlags(rawValue) | UInt(kCFCompareNonliteral) + return contains(.literalSearch) || !fixLiteral ? CFStringCompareFlags(rawValue) : CFStringCompareFlags(rawValue) | UInt(kCFCompareNonliteral) #endif } } @@ -169,12 +169,12 @@ internal func _bytesInEncoding(_ str: NSString, _ encoding: NSStringEncoding, _ var used = 0 var options: NSStringEncodingConversionOptions = [] if externalRep { - options.unionInPlace(.ExternalRepresentation) + options.unionInPlace(.externalRepresentation) } if lossy { - options.unionInPlace(.AllowLossy) + options.unionInPlace(.allowLossy) } - if !str.getBytes(nil, maxLength: Int.max - 1, usedLength: &cLength, encoding: encoding, options: options, range: theRange, remainingRange: nil) { + if !str.getBytes(nil, maxLength: Int.max - 1, usedLength: &cLength, encoding: encoding, options: options, range: theRange, remaining: nil) { if fatalOnError { fatalError("Conversion on encoding failed") } @@ -182,7 +182,7 @@ internal func _bytesInEncoding(_ str: NSString, _ encoding: NSStringEncoding, _ } let buffer = malloc(cLength + 1) - if !str.getBytes(buffer, maxLength: cLength, usedLength: &used, encoding: encoding, options: options, range: theRange, remainingRange: nil) { + if !str.getBytes(buffer, maxLength: cLength, usedLength: &used, encoding: encoding, options: options, range: theRange, remaining: nil) { fatalError("Internal inconsistency; previously claimed getBytes returned success but failed with similar invocation") } @@ -217,7 +217,7 @@ public class NSString : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, N } } - public func characterAtIndex(_ index: Int) -> unichar { + public func character(at index: Int) -> unichar { if self.dynamicType === NSString.self || self.dynamicType === NSMutableString.self { let start = _storage.utf16.startIndex return _storage.utf16[start.advanced(by: index)] @@ -347,7 +347,7 @@ public class NSString : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, N public override func isEqual(_ object: AnyObject?) -> Bool { guard let string = (object as? NSString)?._swiftObject else { return false } - return self.isEqualToString(string) + return self.isEqual(to: string) } public override var description: String { @@ -362,28 +362,28 @@ public class NSString : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, N extension NSString { public func getCharacters(_ buffer: UnsafeMutablePointer, range: NSRange) { for idx in 0.. String { + public func substring(from: Int) -> String { if self.dynamicType == NSString.self || self.dynamicType == NSMutableString.self { return String(_storage.utf16.suffix(from: _storage.utf16.startIndex.advanced(by: from))) } else { - return substringWithRange(NSMakeRange(from, length - from)) + return substring(with: NSMakeRange(from, length - from)) } } - public func substringToIndex(_ to: Int) -> String { + public func substring(to: Int) -> String { if self.dynamicType == NSString.self || self.dynamicType == NSMutableString.self { return String(_storage.utf16.prefix(upTo: _storage.utf16.startIndex .advanced(by: to))) } else { - return substringWithRange(NSMakeRange(0, to)) + return substring(with: NSMakeRange(0, to)) } } - public func substringWithRange(_ range: NSRange) -> String { + public func substring(with range: NSRange) -> String { if self.dynamicType == NSString.self || self.dynamicType == NSMutableString.self { let start = _storage.utf16.startIndex let min = start.advanced(by: range.location) @@ -422,7 +422,7 @@ extension NSString { } public func caseInsensitiveCompare(_ string: String) -> NSComparisonResult { - return compare(string, options: .CaseInsensitiveSearch, range: NSMakeRange(0, length)) + return compare(string, options: .caseInsensitiveSearch, range: NSMakeRange(0, length)) } public func localizedCompare(_ string: String) -> NSComparisonResult { @@ -430,32 +430,32 @@ extension NSString { } public func localizedCaseInsensitiveCompare(_ string: String) -> NSComparisonResult { - return compare(string, options: .CaseInsensitiveSearch, range: NSMakeRange(0, length), locale: NSLocale.currentLocale()) + return compare(string, options: .caseInsensitiveSearch, range: NSMakeRange(0, length), locale: NSLocale.currentLocale()) } public func localizedStandardCompare(_ string: String) -> NSComparisonResult { - return compare(string, options: [.CaseInsensitiveSearch, .NumericSearch, .WidthInsensitiveSearch, .ForcedOrderingSearch], range: NSMakeRange(0, length), locale: NSLocale.currentLocale()) + return compare(string, options: [.caseInsensitiveSearch, .numericSearch, .widthInsensitiveSearch, .forcedOrderingSearch], range: NSMakeRange(0, length), locale: NSLocale.currentLocale()) } - public func isEqualToString(_ aString: String) -> Bool { + public func isEqual(to aString: String) -> Bool { if self.dynamicType == NSString.self || self.dynamicType == NSMutableString.self { return _storage == aString } else { - return length == aString.length && compare(aString, options: .LiteralSearch, range: NSMakeRange(0, length)) == .OrderedSame + return length == aString.length && compare(aString, options: .literalSearch, range: NSMakeRange(0, length)) == .OrderedSame } } public func hasPrefix(_ str: String) -> Bool { - return rangeOfString(str, options: .AnchoredSearch, range: NSMakeRange(0, length)).location != NSNotFound + return range(of: str, options: .anchoredSearch, range: NSMakeRange(0, length)).location != NSNotFound } public func hasSuffix(_ str: String) -> Bool { - return rangeOfString(str, options: [.AnchoredSearch, .BackwardsSearch], range: NSMakeRange(0, length)).location != NSNotFound + return range(of: str, options: [.anchoredSearch, .backwardsSearch], range: NSMakeRange(0, length)).location != NSNotFound } - public func commonPrefixWithString(_ str: String, options mask: NSStringCompareOptions) -> String { + public func commonPrefix(with str: String, options mask: NSStringCompareOptions = []) -> String { var currentSubstring: CFMutableString? - let isLiteral = mask.contains(.LiteralSearch) + let isLiteral = mask.contains(.literalSearch) var lastMatch = NSRange() let selfLen = length let otherLen = str.length @@ -474,7 +474,7 @@ extension NSString { return arrayBuffer.withUnsafeMutablePointerOrAllocation(selfLen, fastpath: UnsafeMutablePointer(_fastContents)) { (selfChars: UnsafeMutablePointer) -> String in // Now do the binary search. Note that the probe value determines the length of the substring to check. while true { - let range = NSMakeRange(0, isLiteral ? probe + 1 : NSMaxRange(rangeOfComposedCharacterSequenceAtIndex(probe))) // Extend the end of the composed char sequence + let range = NSMakeRange(0, isLiteral ? probe + 1 : NSMaxRange(rangeOfComposedCharacterSequence(at: probe))) // Extend the end of the composed char sequence if range.length > numCharsBuffered { // Buffer more characters if needed getCharacters(selfChars, range: NSMakeRange(numCharsBuffered, range.length - numCharsBuffered)) numCharsBuffered = range.length @@ -484,7 +484,7 @@ extension NSString { } else { CFStringSetExternalCharactersNoCopy(currentSubstring, selfChars, range.length, range.length) } - if other.rangeOfString(currentSubstring!._swiftObject, options: mask.union(.AnchoredSearch), range: NSMakeRange(0, otherLen)).length != 0 { // Match + if other.range(of: currentSubstring!._swiftObject, options: mask.union(.anchoredSearch), range: NSMakeRange(0, otherLen)).length != 0 { // Match lastMatch = range low = probe + 1 } else { @@ -495,55 +495,55 @@ extension NSString { } probe = (low + high) / 2 } - return lastMatch.length != 0 ? substringWithRange(lastMatch) : "" + return lastMatch.length != 0 ? substring(with: lastMatch) : "" } } - public func containsString(_ str: String) -> Bool { - return rangeOfString(str, options: [], range: NSMakeRange(0, length), locale: nil).location != NSNotFound + public func contains(_ str: String) -> Bool { + return range(of: str, options: [], range: NSMakeRange(0, length), locale: nil).location != NSNotFound } - public func localizedCaseInsensitiveContainsString(_ str: String) -> Bool { - return rangeOfString(str, options: .CaseInsensitiveSearch, range: NSMakeRange(0, length), locale: NSLocale.currentLocale()).location != NSNotFound + public func localizedCaseInsensitiveContains(_ str: String) -> Bool { + return range(of: str, options: .caseInsensitiveSearch, range: NSMakeRange(0, length), locale: NSLocale.currentLocale()).location != NSNotFound } - public func localizedStandardContainsString(_ str: String) -> Bool { - return rangeOfString(str, options: [.CaseInsensitiveSearch, .DiacriticInsensitiveSearch], range: NSMakeRange(0, length), locale: NSLocale.currentLocale()).location != NSNotFound + public func localizedStandardContains(_ str: String) -> Bool { + return range(of: str, options: [.caseInsensitiveSearch, .diacriticInsensitiveSearch], range: NSMakeRange(0, length), locale: NSLocale.currentLocale()).location != NSNotFound } - public func localizedStandardRangeOfString(_ str: String) -> NSRange { - return rangeOfString(str, options: [.CaseInsensitiveSearch, .DiacriticInsensitiveSearch], range: NSMakeRange(0, length), locale: NSLocale.currentLocale()) + public func localizedStandardRange(of str: String) -> NSRange { + return range(of: str, options: [.caseInsensitiveSearch, .diacriticInsensitiveSearch], range: NSMakeRange(0, length), locale: NSLocale.currentLocale()) } - public func rangeOfString(_ searchString: String) -> NSRange { - return rangeOfString(searchString, options: [], range: NSMakeRange(0, length), locale: nil) + public func range(of searchString: String) -> NSRange { + return range(of: searchString, options: [], range: NSMakeRange(0, length), locale: nil) } - public func rangeOfString(_ searchString: String, options mask: NSStringCompareOptions) -> NSRange { - return rangeOfString(searchString, options: mask, range: NSMakeRange(0, length), locale: nil) + public func range(of searchString: String, options mask: NSStringCompareOptions = []) -> NSRange { + return range(of: searchString, options: mask, range: NSMakeRange(0, length), locale: nil) } - public func rangeOfString(_ searchString: String, options mask: NSStringCompareOptions, range searchRange: NSRange) -> NSRange { - return rangeOfString(searchString, options: mask, range: searchRange, locale: nil) + public func range(of searchString: String, options mask: NSStringCompareOptions = [], range searchRange: NSRange) -> NSRange { + return range(of: searchString, options: mask, range: searchRange, locale: nil) } internal func _rangeOfRegularExpressionPattern(regex pattern: String, options mask: NSStringCompareOptions, range searchRange: NSRange, locale: NSLocale?) -> NSRange { var matchedRange = NSMakeRange(NSNotFound, 0) - let regexOptions: NSRegularExpressionOptions = mask.contains(.CaseInsensitiveSearch) ? .caseInsensitive : [] - let matchingOptions: NSMatchingOptions = mask.contains(.AnchoredSearch) ? .anchored : [] + let regexOptions: NSRegularExpressionOptions = mask.contains(.caseInsensitiveSearch) ? .caseInsensitive : [] + let matchingOptions: NSMatchingOptions = mask.contains(.anchoredSearch) ? .anchored : [] if let regex = _createRegexForPattern(pattern, regexOptions) { matchedRange = regex.rangeOfFirstMatch(in: _swiftObject, options: matchingOptions, range: searchRange) } return matchedRange } - public func rangeOfString(_ searchString: String, options mask: NSStringCompareOptions, range searchRange: NSRange, locale: NSLocale?) -> NSRange { + public func range(of searchString: String, options mask: NSStringCompareOptions = [], range searchRange: NSRange, locale: NSLocale?) -> NSRange { let findStrLen = searchString.length let len = length precondition(searchRange.length <= len && searchRange.location <= len - searchRange.length, "Bounds Range {\(searchRange.location), \(searchRange.length)} out of bounds; string length \(len)") - if mask.contains(.RegularExpressionSearch) { + if mask.contains(.regularExpressionSearch) { return _rangeOfRegularExpressionPattern(regex: searchString, options: mask, range:searchRange, locale: locale) } @@ -566,15 +566,15 @@ extension NSString { } } - public func rangeOfCharacterFromSet(_ searchSet: NSCharacterSet) -> NSRange { - return rangeOfCharacterFromSet(searchSet, options: [], range: NSMakeRange(0, length)) + public func rangeOfCharacter(from searchSet: NSCharacterSet) -> NSRange { + return rangeOfCharacter(from: searchSet, options: [], range: NSMakeRange(0, length)) } - public func rangeOfCharacterFromSet(_ searchSet: NSCharacterSet, options mask: NSStringCompareOptions) -> NSRange { - return rangeOfCharacterFromSet(searchSet, options: mask, range: NSMakeRange(0, length)) + public func rangeOfCharacter(from searchSet: NSCharacterSet, options mask: NSStringCompareOptions = []) -> NSRange { + return rangeOfCharacter(from: searchSet, options: mask, range: NSMakeRange(0, length)) } - public func rangeOfCharacterFromSet(_ searchSet: NSCharacterSet, options mask: NSStringCompareOptions, range searchRange: NSRange) -> NSRange { + public func rangeOfCharacter(from searchSet: NSCharacterSet, options mask: NSStringCompareOptions = [], range searchRange: NSRange) -> NSRange { let len = length precondition(searchRange.length <= len && searchRange.location <= len - searchRange.length, "Bounds Range {\(searchRange.location), \(searchRange.length)} out of bounds; string length \(len)") @@ -590,19 +590,19 @@ extension NSString { } } - public func rangeOfComposedCharacterSequenceAtIndex(_ index: Int) -> NSRange { + public func rangeOfComposedCharacterSequence(at index: Int) -> NSRange { let range = CFStringGetRangeOfCharacterClusterAtIndex(_cfObject, index, kCFStringComposedCharacterCluster) return NSMakeRange(range.location, range.length) } - public func rangeOfComposedCharacterSequencesForRange(_ range: NSRange) -> NSRange { + public func rangeOfComposedCharacterSequences(for range: NSRange) -> NSRange { let length = self.length var start: Int var end: Int if range.location == length { start = length } else { - start = rangeOfComposedCharacterSequenceAtIndex(range.location).location + start = rangeOfComposedCharacterSequence(at: range.location).location } var endOfRange = NSMaxRange(range) if endOfRange == length { @@ -611,12 +611,12 @@ extension NSString { if range.length > 0 { endOfRange = endOfRange - 1 // We want 0-length range to be treated same as 1-length range. } - end = NSMaxRange(rangeOfComposedCharacterSequenceAtIndex(endOfRange)) + end = NSMaxRange(rangeOfComposedCharacterSequence(at: endOfRange)) } return NSMakeRange(start, end - start) } - public func stringByAppendingString(_ aString: String) -> String { + public func appending(_ aString: String) -> String { return _swiftObject + aString } @@ -666,43 +666,43 @@ extension NSString { return scanner.scanCharactersFromSet(NSCharacterSet(charactersInString: "tTyY123456789")) != nil } - public var uppercaseString: String { - return uppercaseStringWithLocale(nil) + public var uppercased: String { + return uppercased(with: nil) } - public var lowercaseString: String { - return lowercaseStringWithLocale(nil) + public var lowercased: String { + return lowercased(with: nil) } - public var capitalizedString: String { - return capitalizedStringWithLocale(nil) + public var capitalized: String { + return capitalized(with: nil) } - public var localizedUppercaseString: String { - return uppercaseStringWithLocale(NSLocale.currentLocale()) + public var localizedUppercase: String { + return uppercased(with: NSLocale.currentLocale()) } - public var localizedLowercaseString: String { - return lowercaseStringWithLocale(NSLocale.currentLocale()) + public var localizedLowercase: String { + return lowercased(with: NSLocale.currentLocale()) } - public var localizedCapitalizedString: String { - return capitalizedStringWithLocale(NSLocale.currentLocale()) + public var localizedCapitalized: String { + return capitalized(with: NSLocale.currentLocale()) } - public func uppercaseStringWithLocale(_ locale: NSLocale?) -> String { + public func uppercased(with locale: NSLocale?) -> String { let mutableCopy = CFStringCreateMutableCopy(kCFAllocatorSystemDefault, 0, self._cfObject) CFStringUppercase(mutableCopy, locale?._cfObject ?? nil) return mutableCopy._swiftObject } - public func lowercaseStringWithLocale(_ locale: NSLocale?) -> String { + public func lowercased(with locale: NSLocale?) -> String { let mutableCopy = CFStringCreateMutableCopy(kCFAllocatorSystemDefault, 0, self._cfObject) CFStringLowercase(mutableCopy, locale?._cfObject ?? nil) return mutableCopy._swiftObject } - public func capitalizedStringWithLocale(_ locale: NSLocale?) -> String { + public func capitalized(with locale: NSLocale?) -> String { let mutableCopy = CFStringCreateMutableCopy(kCFAllocatorSystemDefault, 0, self._cfObject) CFStringCapitalize(mutableCopy, locale?._cfObject ?? nil) return mutableCopy._swiftObject @@ -786,39 +786,39 @@ extension NSString { } } - public func getLineStart(_ startPtr: UnsafeMutablePointer?, end lineEndPtr: UnsafeMutablePointer?, contentsEnd contentsEndPtr: UnsafeMutablePointer?, forRange range: NSRange) { + public func getLineStart(_ startPtr: UnsafeMutablePointer?, end lineEndPtr: UnsafeMutablePointer?, contentsEnd contentsEndPtr: UnsafeMutablePointer?, for range: NSRange) { _getBlockStart(startPtr, end: lineEndPtr, contentsEnd: contentsEndPtr, forRange: range, stopAtLineSeparators: true) } - public func lineRangeForRange(_ range: NSRange) -> NSRange { + public func lineRange(for range: NSRange) -> NSRange { var start = 0 var lineEnd = 0 - getLineStart(&start, end: &lineEnd, contentsEnd: nil, forRange: range) + getLineStart(&start, end: &lineEnd, contentsEnd: nil, for: range) return NSMakeRange(start, lineEnd - start) } - public func getParagraphStart(_ startPtr: UnsafeMutablePointer?, end parEndPtr: UnsafeMutablePointer?, contentsEnd contentsEndPtr: UnsafeMutablePointer?, forRange range: NSRange) { + public func getParagraphStart(_ startPtr: UnsafeMutablePointer?, end parEndPtr: UnsafeMutablePointer?, contentsEnd contentsEndPtr: UnsafeMutablePointer?, for range: NSRange) { _getBlockStart(startPtr, end: parEndPtr, contentsEnd: contentsEndPtr, forRange: range, stopAtLineSeparators: false) } - public func paragraphRangeForRange(_ range: NSRange) -> NSRange { + public func paragraphRange(for range: NSRange) -> NSRange { var start = 0 var parEnd = 0 - getParagraphStart(&start, end: &parEnd, contentsEnd: nil, forRange: range) + getParagraphStart(&start, end: &parEnd, contentsEnd: nil, for: range) return NSMakeRange(start, parEnd - start) } - public func enumerateSubstringsInRange(_ range: NSRange, options opts: NSStringEnumerationOptions, usingBlock block: (String?, NSRange, NSRange, UnsafeMutablePointer) -> Void) { + public func enumerateSubstrings(in range: NSRange, options opts: NSStringEnumerationOptions = [], using block: (String?, NSRange, NSRange, UnsafeMutablePointer) -> Void) { NSUnimplemented() } - public func enumerateLinesUsingBlock(_ block: (String, UnsafeMutablePointer) -> Void) { - enumerateSubstringsInRange(NSMakeRange(0, length), options:.ByLines) { substr, substrRange, enclosingRange, stop in + public func enumerateLines(_ block: (String, UnsafeMutablePointer) -> Void) { + enumerateSubstrings(in: NSMakeRange(0, length), options:.byLines) { substr, substrRange, enclosingRange, stop in block(substr!, stop) } } - public var UTF8String: UnsafePointer? { + public var utf8String: UnsafePointer? { return _bytesInEncoding(self, NSUTF8StringEncoding, false, false, false) } @@ -827,13 +827,13 @@ extension NSString { } public var smallestEncoding: UInt { - if canBeConvertedToEncoding(NSASCIIStringEncoding) { + if canBeConverted(to: NSASCIIStringEncoding) { return NSASCIIStringEncoding } return NSUnicodeStringEncoding } - public func dataUsingEncoding(_ encoding: UInt, allowLossyConversion lossy: Bool) -> NSData? { + public func data(using encoding: UInt, allowLossyConversion lossy: Bool) -> NSData? { let len = length var reqSize = 0 @@ -860,18 +860,18 @@ extension NSString { return nil } - public func dataUsingEncoding(_ encoding: UInt) -> NSData? { - return dataUsingEncoding(encoding, allowLossyConversion: false) + public func data(using encoding: UInt) -> NSData? { + return data(using: encoding, allowLossyConversion: false) } - public func canBeConvertedToEncoding(_ encoding: UInt) -> Bool { + public func canBeConverted(to encoding: UInt) -> Bool { if encoding == NSUnicodeStringEncoding || encoding == NSNonLossyASCIIStringEncoding || encoding == NSUTF8StringEncoding { return true } return __CFStringEncodeByteStream(_cfObject, 0, length, false, CFStringConvertNSStringEncodingToEncoding(encoding), 0, nil, 0, nil) == length } - - public func cStringUsingEncoding(_ encoding: UInt) -> UnsafePointer? { + + public func cString(using encoding: UInt) -> UnsafePointer? { return _bytesInEncoding(self, encoding, false, false, false) } @@ -886,22 +886,22 @@ extension NSString { return true } } - if getBytes(UnsafeMutablePointer(buffer), maxLength: maxBufferCount, usedLength: &used, encoding: encoding, options: [], range: NSMakeRange(0, self.length), remainingRange: nil) { + if getBytes(UnsafeMutablePointer(buffer), maxLength: maxBufferCount, usedLength: &used, encoding: encoding, options: [], range: NSMakeRange(0, self.length), remaining: nil) { buffer.advanced(by: used).initialize(with: 0) return true } return false } - public func getBytes(_ buffer: UnsafeMutablePointer?, maxLength maxBufferCount: Int, usedLength usedBufferCount: UnsafeMutablePointer?, encoding: UInt, options: NSStringEncodingConversionOptions, range: NSRange, remainingRange leftover: NSRangePointer?) -> Bool { + public func getBytes(_ buffer: UnsafeMutablePointer?, maxLength maxBufferCount: Int, usedLength usedBufferCount: UnsafeMutablePointer?, encoding: UInt, options: NSStringEncodingConversionOptions = [], range: NSRange, remaining leftover: NSRangePointer?) -> Bool { var totalBytesWritten = 0 var numCharsProcessed = 0 let cfStringEncoding = CFStringConvertNSStringEncodingToEncoding(encoding) var result = true if length > 0 { if CFStringIsEncodingAvailable(cfStringEncoding) { - let lossyOk = options.contains(.AllowLossy) - let externalRep = options.contains(.ExternalRepresentation) + let lossyOk = options.contains(.allowLossy) + let externalRep = options.contains(.externalRepresentation) let failOnPartial = options.contains(.FailOnPartialEncodingConversion) numCharsProcessed = __CFStringEncodeByteStream(_cfObject, range.location, range.length, externalRep, cfStringEncoding, lossyOk ? (encoding == NSASCIIStringEncoding ? 0xFF : 0x3F) : 0, UnsafeMutablePointer(buffer), buffer != nil ? maxBufferCount : 0, &totalBytesWritten) if (failOnPartial && numCharsProcessed < range.length) || numCharsProcessed == 0 { @@ -916,13 +916,13 @@ extension NSString { return result } - public func maximumLengthOfBytesUsingEncoding(_ enc: UInt) -> Int { + public func maximumLengthOfBytes(using enc: UInt) -> Int { let cfEnc = CFStringConvertNSStringEncodingToEncoding(enc) let result = CFStringGetMaximumSizeForEncoding(length, cfEnc) return result == kCFNotFound ? 0 : result } - public func lengthOfBytesUsingEncoding(_ enc: UInt) -> Int { + public func lengthOfBytes(using enc: UInt) -> Int { let len = length var numBytes: CFIndex = 0 let cfEnc = CFStringConvertNSStringEncodingToEncoding(enc) @@ -957,7 +957,7 @@ extension NSString { return once.encodings } - public class func localizedNameOfStringEncoding(_ encoding: UInt) -> String { + public class func localizedName(of encoding: UInt) -> String { if let theString = CFStringGetNameOfEncoding(CFStringConvertNSStringEncodingToEncoding(encoding)) { // TODO: read the localized version from the Foundation "bundle" return theString._swiftObject @@ -998,32 +998,32 @@ extension NSString { return string._swiftObject } - public func componentsSeparatedByString(_ separator: String) -> [String] { + public func components(separatedBy separator: String) -> [String] { let len = length - var range = rangeOfString(separator, options: [], range: NSMakeRange(0, len)) - if range.length == 0 { + var lrange = range(of: separator, options: [], range: NSMakeRange(0, len)) + if lrange.length == 0 { return [_swiftObject] } else { var array = [String]() var srange = NSMakeRange(0, len) while true { - let trange = NSMakeRange(srange.location, range.location - srange.location) - array.append(substringWithRange(trange)) - srange.location = range.location + range.length + let trange = NSMakeRange(srange.location, lrange.location - srange.location) + array.append(substring(with: trange)) + srange.location = lrange.location + lrange.length srange.length = len - srange.location - range = rangeOfString(separator, options: [], range: srange) - if range.length == 0 { + lrange = range(of: separator, options: [], range: srange) + if lrange.length == 0 { break } } - array.append(substringWithRange(srange)) + array.append(substring(with: srange)) return array } } - public func componentsSeparatedByCharactersInSet(_ separator: NSCharacterSet) -> [String] { + public func components(separatedBy separator: NSCharacterSet) -> [String] { let len = length - var range = rangeOfCharacterFromSet(separator, options: [], range: NSMakeRange(0, len)) + var range = rangeOfCharacter(from: separator, options: [], range: NSMakeRange(0, len)) if range.length == 0 { return [_swiftObject] } else { @@ -1031,20 +1031,20 @@ extension NSString { var srange = NSMakeRange(0, len) while true { let trange = NSMakeRange(srange.location, range.location - srange.location) - array.append(substringWithRange(trange)) + array.append(substring(with: trange)) srange.location = range.location + range.length srange.length = len - srange.location - range = rangeOfCharacterFromSet(separator, options: [], range: srange) + range = rangeOfCharacter(from: separator, options: [], range: srange) if range.length == 0 { break } } - array.append(substringWithRange(srange)) + array.append(substring(with: srange)) return array } } - public func stringByTrimmingCharactersInSet(_ set: NSCharacterSet) -> String { + public func trimmingCharacters(in set: NSCharacterSet) -> String { let len = length var buf = _NSStringBuffer(string: self, start: 0, end: len) while !buf.isAtEnd && set.characterIsMember(buf.currentCharacter) { @@ -1061,16 +1061,16 @@ extension NSString { buf.rewind() } let endOfNonTrimmedRange = buf.location - return substringWithRange(NSMakeRange(startOfNonTrimmedRange, endOfNonTrimmedRange + 1 - startOfNonTrimmedRange)) + return substring(with: NSMakeRange(startOfNonTrimmedRange, endOfNonTrimmedRange + 1 - startOfNonTrimmedRange)) } else { - return substringWithRange(NSMakeRange(startOfNonTrimmedRange, 1)) + return substring(with: NSMakeRange(startOfNonTrimmedRange, 1)) } } - public func stringByPaddingToLength(_ newLength: Int, withString padString: String, startingAtIndex padIndex: Int) -> String { + public func padding(toLength newLength: Int, withPad padString: String, startingAt padIndex: Int) -> String { let len = length if newLength <= len { // The simple cases (truncation) - return newLength == len ? _swiftObject : substringWithRange(NSMakeRange(0, newLength)) + return newLength == len ? _swiftObject : substring(with: NSMakeRange(0, newLength)) } let padLen = padString.length if padLen < 1 { @@ -1085,7 +1085,7 @@ extension NSString { return mStr._swiftObject } - public func stringByFoldingWithOptions(_ options: NSStringCompareOptions, locale: NSLocale?) -> String { + public func folding(_ options: NSStringCompareOptions = [], locale: NSLocale?) -> String { let string = CFStringCreateMutable(kCFAllocatorSystemDefault, 0) CFStringReplaceAll(string, self._cfObject) CFStringFold(string, options._cfValue(), locale?._cfObject) @@ -1093,37 +1093,37 @@ extension NSString { } internal func _stringByReplacingOccurrencesOfRegularExpressionPattern(_ pattern: String, withTemplate replacement: String, options: NSStringCompareOptions, range: NSRange) -> String { - let regexOptions: NSRegularExpressionOptions = options.contains(.CaseInsensitiveSearch) ? .caseInsensitive : [] - let matchingOptions: NSMatchingOptions = options.contains(.AnchoredSearch) ? .anchored : [] + let regexOptions: NSRegularExpressionOptions = options.contains(.caseInsensitiveSearch) ? .caseInsensitive : [] + let matchingOptions: NSMatchingOptions = options.contains(.anchoredSearch) ? .anchored : [] if let regex = _createRegexForPattern(pattern, regexOptions) { return regex.stringByReplacingMatches(in: _swiftObject, options: matchingOptions, range: range, withTemplate: replacement) } return "" } - public func stringByReplacingOccurrencesOfString(_ target: String, withString replacement: String, options: NSStringCompareOptions, range searchRange: NSRange) -> String { - if options.contains(.RegularExpressionSearch) { + public func replacingOccurrences(of target: String, with replacement: String, options: NSStringCompareOptions = [], range searchRange: NSRange) -> String { + if options.contains(.regularExpressionSearch) { return _stringByReplacingOccurrencesOfRegularExpressionPattern(target, withTemplate: replacement, options: options, range: searchRange) } let str = mutableCopyWithZone(nil) as! NSMutableString - if str.replaceOccurrencesOfString(target, withString: replacement, options: options, range: searchRange) == 0 { + if str.replaceOccurrences(of: target, with: replacement, options: options, range: searchRange) == 0 { return _swiftObject } else { return str._swiftObject } } - public func stringByReplacingOccurrencesOfString(_ target: String, withString replacement: String) -> String { - return stringByReplacingOccurrencesOfString(target, withString: replacement, options: [], range: NSMakeRange(0, length)) + public func replacingOccurrences(of target: String, with replacement: String) -> String { + return replacingOccurrences(of: target, with: replacement, options: [], range: NSMakeRange(0, length)) } - public func stringByReplacingCharactersInRange(_ range: NSRange, withString replacement: String) -> String { + public func replacingCharacters(in range: NSRange, with replacement: String) -> String { let str = mutableCopyWithZone(nil) as! NSMutableString - str.replaceCharactersInRange(range, withString: replacement) + str.replaceCharacters(in: range, with: replacement) return str._swiftObject } - public func stringByApplyingTransform(_ transform: String, reverse: Bool) -> String? { + public func applyingTransform(_ transform: String, reverse: Bool) -> String? { let string = CFStringCreateMutable(kCFAllocatorSystemDefault, 0) CFStringReplaceAll(string, _cfObject) if (CFStringTransform(string, nil, transform._cfObject, reverse)) { @@ -1137,7 +1137,7 @@ extension NSString { let length = self.length var numBytes = 0 let theRange = NSMakeRange(0, length) - if !getBytes(nil, maxLength: Int.max - 1, usedLength: &numBytes, encoding: enc, options: [], range: theRange, remainingRange: nil) { + if !getBytes(nil, maxLength: Int.max - 1, usedLength: &numBytes, encoding: enc, options: [], range: theRange, remaining: nil) { throw NSError(domain: NSCocoaErrorDomain, code: NSCocoaError.FileWriteInapplicableStringEncodingError.rawValue, userInfo: [ NSURLErrorKey: dest, ]) @@ -1145,7 +1145,7 @@ extension NSString { let mData = NSMutableData(length: numBytes)! // The getBytes:... call should hopefully not fail, given it succeeded above, but check anyway (mutable string changing behind our back?) var used = 0 - if !getBytes(mData.mutableBytes, maxLength: numBytes, usedLength: &used, encoding: enc, options: [], range: theRange, remainingRange: nil) { + if !getBytes(mData.mutableBytes, maxLength: numBytes, usedLength: &used, encoding: enc, options: [], range: theRange, remaining: nil) { throw NSError(domain: NSCocoaErrorDomain, code: NSCocoaError.FileWriteUnknownError.rawValue, userInfo: [ NSURLErrorKey: dest, ]) @@ -1170,11 +1170,11 @@ extension NSString { } } - public func writeToURL(_ url: NSURL, atomically useAuxiliaryFile: Bool, encoding enc: UInt) throws { + public func write(to url: NSURL, atomically useAuxiliaryFile: Bool, encoding enc: UInt) throws { try _writeTo(url, useAuxiliaryFile, enc) } - public func writeToFile(_ path: String, atomically useAuxiliaryFile: Bool, encoding enc: UInt) throws { + public func write(toFile path: String, atomically useAuxiliaryFile: Bool, encoding enc: UInt) throws { try _writeTo(NSURL(fileURLWithPath: path), useAuxiliaryFile, enc) } @@ -1290,7 +1290,7 @@ extension NSString { extension NSString : StringLiteralConvertible { } public class NSMutableString : NSString { - public func replaceCharactersInRange(_ range: NSRange, withString aString: String) { + public func replaceCharacters(in range: NSRange, with aString: String) { if self.dynamicType === NSString.self || self.dynamicType === NSMutableString.self { // this is incorrectly calculated for grapheme clusters that have a size greater than a single unichar let start = _storage.startIndex @@ -1343,7 +1343,7 @@ public class NSMutableString : NSString { if self.dynamicType == NSMutableString.self { _storage.append(String._fromWellFormedCodeUnitSequence(UTF16.self, input: UnsafeBufferPointer(start: characters, count: length))) } else { - replaceCharactersInRange(NSMakeRange(self.length, 0), withString: String._fromWellFormedCodeUnitSequence(UTF16.self, input: UnsafeBufferPointer(start: characters, count: length))) + replaceCharacters(in: NSMakeRange(self.length, 0), with: String._fromWellFormedCodeUnitSequence(UTF16.self, input: UnsafeBufferPointer(start: characters, count: length))) } } @@ -1355,38 +1355,38 @@ public class NSMutableString : NSString { } extension NSMutableString { - public func insertString(_ aString: String, atIndex loc: Int) { - replaceCharactersInRange(NSMakeRange(loc, 0), withString: aString) + public func insert(_ aString: String, at loc: Int) { + replaceCharacters(in: NSMakeRange(loc, 0), with: aString) } - public func deleteCharactersInRange(_ range: NSRange) { - replaceCharactersInRange(range, withString: "") + public func deleteCharacters(in range: NSRange) { + replaceCharacters(in: range, with: "") } - public func appendString(_ aString: String) { - replaceCharactersInRange(NSMakeRange(length, 0), withString: aString) + public func append(_ aString: String) { + replaceCharacters(in: NSMakeRange(length, 0), with: aString) } public func setString(_ aString: String) { - replaceCharactersInRange(NSMakeRange(0, length), withString: aString) + replaceCharacters(in: NSMakeRange(0, length), with: aString) } internal func _replaceOccurrencesOfRegularExpressionPattern(_ pattern: String, withTemplate replacement: String, options: NSStringCompareOptions, range searchRange: NSRange) -> Int { - let regexOptions: NSRegularExpressionOptions = options.contains(.CaseInsensitiveSearch) ? .caseInsensitive : [] - let matchingOptions: NSMatchingOptions = options.contains(.AnchoredSearch) ? .anchored : [] + let regexOptions: NSRegularExpressionOptions = options.contains(.caseInsensitiveSearch) ? .caseInsensitive : [] + let matchingOptions: NSMatchingOptions = options.contains(.anchoredSearch) ? .anchored : [] if let regex = _createRegexForPattern(pattern, regexOptions) { return regex.replaceMatches(in: self, options: matchingOptions, range: searchRange, withTemplate: replacement) } return 0 } - public func replaceOccurrencesOfString(_ target: String, withString replacement: String, options: NSStringCompareOptions, range searchRange: NSRange) -> Int { - let backwards = options.contains(.BackwardsSearch) + public func replaceOccurrences(of target: String, with replacement: String, options: NSStringCompareOptions = [], range searchRange: NSRange) -> Int { + let backwards = options.contains(.backwardsSearch) let len = length precondition(searchRange.length <= len && searchRange.location <= len - searchRange.length, "Search range is out of bounds") - if options.contains(.RegularExpressionSearch) { + if options.contains(.regularExpressionSearch) { return _replaceOccurrencesOfRegularExpressionPattern(target, withTemplate:replacement, options:options, range: searchRange) } @@ -1395,7 +1395,7 @@ extension NSMutableString { let numOccurrences = CFArrayGetCount(findResults) for cnt in 0..(CFArrayGetValueAtIndex(findResults, backwards ? cnt : numOccurrences - cnt - 1)!) - replaceCharactersInRange(NSRange(range.pointee), withString: replacement) + replaceCharacters(in: NSRange(range.pointee), with: replacement) } return numOccurrences } else { diff --git a/Foundation/NSURLResponse.swift b/Foundation/NSURLResponse.swift index 0855ddd036..3389039f91 100644 --- a/Foundation/NSURLResponse.swift +++ b/Foundation/NSURLResponse.swift @@ -327,12 +327,12 @@ private extension String { if type == nil { type = string } else { - if let r = string.rangeOfString("=") { - let name = string[string.startIndex.. String { - return NSString.localizedNameOfStringEncoding(encoding) + return NSString.localizedName(of: encoding) } // + (instancetype)localizedStringWithFormat:(NSString *)format, ... @@ -255,24 +255,24 @@ extension String { /// `String` can be converted to a given encoding without loss of /// information. @warn_unused_result - public func canBeConvertedToEncoding(_ encoding: NSStringEncoding) -> Bool { - return _ns.canBeConvertedToEncoding(encoding) + public func canBeConverted(to encoding: NSStringEncoding) -> Bool { + return _ns.canBeConverted(to: encoding) } // @property NSString* capitalizedString /// Produce a string with the first character from each word changed /// to the corresponding uppercase value. - public var capitalizedString: String { - return _ns.capitalizedString as String + public var capitalized: String { + return _ns.capitalized as String } // @property (readonly, copy) NSString *localizedCapitalizedString NS_AVAILABLE(10_11, 9_0); /// A capitalized representation of the `String` that is produced /// using the current locale. - public var localizedCapitalizedString: String { - return _ns.localizedCapitalizedString + public var localizedCapitalized: String { + return _ns.localizedCapitalized } // - (NSString *)capitalizedStringWithLocale:(NSLocale *)locale @@ -280,8 +280,8 @@ extension String { /// Returns a capitalized representation of the `String` /// using the specified locale. @warn_unused_result - public func capitalizedStringWithLocale(_ locale: NSLocale?) -> String { - return _ns.capitalizedStringWithLocale(locale) as String + public func capitalized(with locale: NSLocale?) -> String { + return _ns.capitalized(with: locale) as String } // - (NSComparisonResult)caseInsensitiveCompare:(NSString *)aString @@ -307,9 +307,9 @@ extension String { /// given string have in common, starting from the beginning of each /// up to the first characters that aren’t equivalent. @warn_unused_result - public func commonPrefixWithString( - _ aString: String, options: NSStringCompareOptions) -> String { - return _ns.commonPrefixWithString(aString, options: options) + public func commonPrefix( + with aString: String, options: NSStringCompareOptions) -> String { + return _ns.commonPrefix(with: aString, options: options) } // - (NSComparisonResult) @@ -402,10 +402,10 @@ extension String { /// Returns an array containing substrings from the `String` /// that have been divided by characters in a given set. @warn_unused_result - public func componentsSeparatedByCharactersInSet( - _ separator: NSCharacterSet + public func components( + separatedBy separator: NSCharacterSet ) -> [String] { - return _ns.componentsSeparatedByCharactersInSet(separator) + return _ns.components(separatedBy: separator) } @@ -413,8 +413,8 @@ extension String { /// Returns an array containing substrings from the `String` /// that have been divided by a given separator. - public func componentsSeparatedByString(_ separator: String) -> [String] { - return _ns.componentsSeparatedByString(separator) + public func components(separatedBy separator: String) -> [String] { + return _ns.components(separatedBy: separator) } // - (const char *)cStringUsingEncoding:(NSStringEncoding)encoding @@ -422,10 +422,10 @@ extension String { /// Returns a representation of the `String` as a C string /// using a given encoding. @warn_unused_result - public func cStringUsingEncoding(_ encoding: NSStringEncoding) -> [CChar]? { + public func cString(using encoding: NSStringEncoding) -> [CChar]? { return withExtendedLifetime(_ns) { (s: NSString) -> [CChar]? in - _persistCString(s.cStringUsingEncoding(encoding)) + _persistCString(s.cString(using: encoding)) } } @@ -438,12 +438,12 @@ extension String { /// Returns an `NSData` object containing a representation of /// the `String` encoded using a given encoding. @warn_unused_result - public func dataUsingEncoding( - _ encoding: NSStringEncoding, + public func data( + using encoding: NSStringEncoding, allowLossyConversion: Bool = false ) -> NSData? { - return _ns.dataUsingEncoding( - encoding, allowLossyConversion: allowLossyConversion) + return _ns.data( + using: encoding, allowLossyConversion: allowLossyConversion) } // @property NSString* decomposedStringWithCanonicalMapping; @@ -476,7 +476,7 @@ extension String { /// Enumerates all the lines in a string. public func enumerateLines(_ body: (line: String, stop: inout Bool) -> ()) { - _ns.enumerateLinesUsingBlock { + _ns.enumerateLines { (line: String, stop: UnsafeMutablePointer) in var stop_ = false @@ -500,15 +500,15 @@ extension String { /// Enumerates the substrings of the specified type in the /// specified range of the string. - public func enumerateSubstringsInRange( - _ range: Range, + public func enumerateSubstrings( + in range: Range, options opts:NSStringEnumerationOptions, _ body: ( substring: String?, substringRange: Range, enclosingRange: Range, inout Bool ) -> () ) { - _ns.enumerateSubstringsInRange(_toNSRange(range), options: opts) { + _ns.enumerateSubstrings(in: _toNSRange(range), options: opts) { var stop_ = false body(substring: $0, @@ -585,7 +585,7 @@ extension String { encoding: NSStringEncoding, options: NSStringEncodingConversionOptions, range: Range, - remainingRange leftover: UnsafeMutablePointer> + remaining leftover: UnsafeMutablePointer> ) -> Bool { return _withOptionalOutParameter(leftover) { self._ns.getBytes( @@ -595,7 +595,7 @@ extension String { encoding: encoding, options: options, range: _toNSRange(range), - remainingRange: $0) + remaining: $0) } } @@ -640,7 +640,7 @@ extension String { _ start: UnsafeMutablePointer, end: UnsafeMutablePointer, contentsEnd: UnsafeMutablePointer, - forRange: Range + for range: Range ) { _withOptionalOutParameter(start) { start in self._withOptionalOutParameter(end) { @@ -648,7 +648,7 @@ extension String { contentsEnd in self._ns.getLineStart( start, end: end, contentsEnd: contentsEnd, - forRange: _toNSRange(forRange)) + for: _toNSRange(range)) } } } @@ -666,7 +666,7 @@ extension String { _ start: UnsafeMutablePointer, end: UnsafeMutablePointer, contentsEnd: UnsafeMutablePointer, - forRange: Range + for range: Range ) { _withOptionalOutParameter(start) { start in self._withOptionalOutParameter(end) { @@ -674,7 +674,7 @@ extension String { contentsEnd in self._ns.getParagraphStart( start, end: end, contentsEnd: contentsEnd, - forRange: _toNSRange(forRange)) + for: _toNSRange(range)) } } } @@ -949,8 +949,8 @@ extension String { /// Returns the number of bytes required to store the /// `String` in a given encoding. @warn_unused_result - public func lengthOfBytesUsingEncoding(_ encoding: NSStringEncoding) -> Int { - return _ns.lengthOfBytesUsingEncoding(encoding) + public func lengthOfBytes(using encoding: NSStringEncoding) -> Int { + return _ns.lengthOfBytes(using: encoding) } // - (NSRange)lineRangeForRange:(NSRange)aRange @@ -958,8 +958,8 @@ extension String { /// Returns the range of characters representing the line or lines /// containing a given range. @warn_unused_result - public func lineRangeForRange(_ aRange: Range) -> Range { - return _range(_ns.lineRangeForRange(_toNSRange(aRange))) + public func lineRange(for aRange: Range) -> Range { + return _range(_ns.lineRange(for: _toNSRange(aRange))) } // - (NSComparisonResult)localizedCaseInsensitiveCompare:(NSString *)aString @@ -994,8 +994,8 @@ extension String { /// A lowercase version of the string that is produced using the current /// locale. - public var localizedLowercaseString: String { - return _ns.localizedLowercaseString + public var localizedLowercase: String { + return _ns.localizedLowercase } // - (NSString *)lowercaseStringWithLocale:(NSLocale *)locale @@ -1004,8 +1004,8 @@ extension String { /// converted to lowercase, taking into account the specified /// locale. @warn_unused_result - public func lowercaseStringWithLocale(_ locale: NSLocale?) -> String { - return _ns.lowercaseStringWithLocale(locale) + public func lowercased(with locale: NSLocale?) -> String { + return _ns.lowercased(with: locale) } // - (NSUInteger)maximumLengthOfBytesUsingEncoding:(NSStringEncoding)enc @@ -1014,8 +1014,8 @@ extension String { /// `String` in a given encoding. @warn_unused_result public - func maximumLengthOfBytesUsingEncoding(_ encoding: NSStringEncoding) -> Int { - return _ns.maximumLengthOfBytesUsingEncoding(encoding) + func maximumLengthOfBytes(using encoding: NSStringEncoding) -> Int { + return _ns.maximumLengthOfBytes(using: encoding) } // - (NSRange)paragraphRangeForRange:(NSRange)aRange @@ -1023,8 +1023,8 @@ extension String { /// Returns the range of characters representing the /// paragraph or paragraphs containing a given range. @warn_unused_result - public func paragraphRangeForRange(_ aRange: Range) -> Range { - return _range(_ns.paragraphRangeForRange(_toNSRange(aRange))) + public func paragraphRange(for aRange: Range) -> Range { + return _range(_ns.paragraphRange(for: _toNSRange(aRange))) } // @property NSArray* pathComponents @@ -1095,14 +1095,14 @@ extension String { /// character from a given character set found in a given range with /// given options. @warn_unused_result - public func rangeOfCharacterFromSet( - _ aSet: NSCharacterSet, + public func rangeOfCharacter( + from aSet: NSCharacterSet, options mask:NSStringCompareOptions = [], range aRange: Range? = nil ) -> Range? { return _optionalRange( - _ns.rangeOfCharacterFromSet( - aSet, options: mask, + _ns.rangeOfCharacter( + from: aSet, options: mask, range: _toNSRange(aRange ?? self.characters.indices))) } @@ -1112,9 +1112,9 @@ extension String { /// character sequence located at a given index. @warn_unused_result public - func rangeOfComposedCharacterSequenceAtIndex(_ anIndex: Index) -> Range { + func rangeOfComposedCharacterSequence(at anIndex: Index) -> Range { return _range( - _ns.rangeOfComposedCharacterSequenceAtIndex(anIndex._utf16Index)) + _ns.rangeOfComposedCharacterSequence(at: anIndex._utf16Index)) } // - (NSRange)rangeOfComposedCharacterSequencesForRange:(NSRange)range @@ -1122,14 +1122,14 @@ extension String { /// Returns the range in the string of the composed character /// sequences for a given range. @warn_unused_result - public func rangeOfComposedCharacterSequencesForRange( - _ range: Range + public func rangeOfComposedCharacterSequences( + for range: Range ) -> Range { // Theoretically, this will be the identity function. In practice // I think users will be able to observe differences in the input // and output ranges due (if nothing else) to locale changes return _range( - _ns.rangeOfComposedCharacterSequencesForRange(_toNSRange(range))) + _ns.rangeOfComposedCharacterSequences(for: _toNSRange(range))) } // - (NSRange)rangeOfString:(NSString *)aString @@ -1152,23 +1152,23 @@ extension String { /// given string within a given range of the `String`, subject to /// given options, using the specified locale, if any. @warn_unused_result - public func rangeOfString( - _ aString: String, + public func range( + of aString: String, options mask: NSStringCompareOptions = [], range searchRange: Range? = nil, locale: NSLocale? = nil ) -> Range? { return _optionalRange( - locale != nil ? _ns.rangeOfString( - aString, options: mask, + locale != nil ? _ns.range( + of: aString, options: mask, range: _toNSRange(searchRange ?? self.characters.indices), locale: locale ) - : searchRange != nil ? _ns.rangeOfString( - aString, options: mask, range: _toNSRange(searchRange!) + : searchRange != nil ? _ns.range( + of: aString, options: mask, range: _toNSRange(searchRange!) ) - : !mask.isEmpty ? _ns.rangeOfString(aString, options: mask) - : _ns.rangeOfString(aString) + : !mask.isEmpty ? _ns.range(of: aString, options: mask) + : _ns.range(of: aString) ) } @@ -1182,8 +1182,8 @@ extension String { /// locale-aware, case and diacritic insensitive. The exact list of search /// options applied may change over time. @warn_unused_result - public func localizedStandardContainsString(_ string: String) -> Bool { - return _ns.localizedStandardContainsString(string) + public func localizedStandardContains(_ string: String) -> Bool { + return _ns.localizedStandardContains(string) } // - (NSRange)localizedStandardRangeOfString:(NSString *)str NS_AVAILABLE(10_11, 9_0); @@ -1197,8 +1197,8 @@ extension String { /// locale-aware, case and diacritic insensitive. The exact list of search /// options applied may change over time. @warn_unused_result - public func localizedStandardRangeOfString(_ string: String) -> Range? { - return _optionalRange(_ns.localizedStandardRangeOfString(string)) + public func localizedStandardRange(of string: String) -> Range? { + return _optionalRange(_ns.localizedStandardRange(of: string)) } // @property NSStringEncoding smallestEncoding; @@ -1263,10 +1263,10 @@ extension String { /// string constructed from a given format string and the following /// arguments. @warn_unused_result - public func stringByAppendingFormat( + public func appending( _ format: String, _ arguments: CVarArg... ) -> String { - return _ns.stringByAppendingString( + return _ns.appending( String(format: format, arguments: arguments)) } @@ -1296,8 +1296,8 @@ extension String { /// Returns a new string made by appending a given string to /// the `String`. @warn_unused_result - public func stringByAppendingString(_ aString: String) -> String { - return _ns.stringByAppendingString(aString) + public func appending(_ aString: String) -> String { + return _ns.appending(aString) } // @property NSString* stringByDeletingLastPathComponent; @@ -1332,10 +1332,10 @@ extension String { /// Returns a string with the given character folding options /// applied. @warn_unused_result - public func stringByFoldingWithOptions( + public func folding( _ options: NSStringCompareOptions, locale: NSLocale? ) -> String { - return _ns.stringByFoldingWithOptions(options, locale: locale) + return _ns.folding(options, locale: locale) } // - (NSString *)stringByPaddingToLength:(NSUInteger)newLength @@ -1346,11 +1346,11 @@ extension String { /// removing characters from the end, or by appending as many /// occurrences as necessary of a given pad string. @warn_unused_result - public func stringByPaddingToLength( - _ newLength: Int, withString padString: String, startingAtIndex padIndex: Int + public func padding( + toLength newLength: Int, withPad padString: String, startingAt padIndex: Int ) -> String { - return _ns.stringByPaddingToLength( - newLength, withString: padString, startingAtIndex: padIndex) + return _ns.padding( + toLength: newLength, withPad: padString, startingAt: padIndex) } // @property NSString* stringByRemovingPercentEncoding; @@ -1369,11 +1369,11 @@ extension String { /// Returns a new string in which the characters in a /// specified range of the `String` are replaced by a given string. @warn_unused_result - public func stringByReplacingCharactersInRange( - _ range: Range, withString replacement: String + public func replacingCharacters( + in range: Range, with replacement: String ) -> String { - return _ns.stringByReplacingCharactersInRange( - _toNSRange(range), withString: replacement) + return _ns.replacingCharacters( + in: _toNSRange(range), with: replacement) } // - (NSString *) @@ -1390,19 +1390,19 @@ extension String { /// string in a specified range of the `String` are replaced by /// another given string. @warn_unused_result - public func stringByReplacingOccurrencesOfString( - _ target: String, - withString replacement: String, + public func replacingOccurrences( + of target: String, + with replacement: String, options: NSStringCompareOptions = [], range searchRange: Range? = nil ) -> String { return (searchRange != nil) || (!options.isEmpty) - ? _ns.stringByReplacingOccurrencesOfString( - target, - withString: replacement, options: options, + ? _ns.replacingOccurrences( + of: target, + with: replacement, options: options, range: _toNSRange(searchRange ?? self.characters.indices) ) - : _ns.stringByReplacingOccurrencesOfString(target, withString: replacement) + : _ns.replacingOccurrences(of: target, with: replacement) } // - (NSString *) @@ -1439,8 +1439,8 @@ extension String { /// Returns a new string made by removing from both ends of /// the `String` characters contained in a given character set. @warn_unused_result - public func stringByTrimmingCharactersInSet(_ set: NSCharacterSet) -> String { - return _ns.stringByTrimmingCharactersInSet(set) + public func trimmingCharacters(in set: NSCharacterSet) -> String { + return _ns.trimmingCharacters(in: set) } // - (NSArray *)stringsByAppendingPaths:(NSArray *)paths @@ -1456,8 +1456,8 @@ extension String { /// Returns a new string containing the characters of the /// `String` from the one at a given index to the end. @warn_unused_result - public func substringFromIndex(_ index: Index) -> String { - return _ns.substringFromIndex(index._utf16Index) + public func substring(from index: Index) -> String { + return _ns.substring(from: index._utf16Index) } // - (NSString *)substringToIndex:(NSUInteger)anIndex @@ -1465,8 +1465,8 @@ extension String { /// Returns a new string containing the characters of the /// `String` up to, but not including, the one at a given index. @warn_unused_result - public func substringToIndex(_ index: Index) -> String { - return _ns.substringToIndex(index._utf16Index) + public func substring(to index: Index) -> String { + return _ns.substring(to: index._utf16Index) } // - (NSString *)substringWithRange:(NSRange)aRange @@ -1474,16 +1474,16 @@ extension String { /// Returns a string object containing the characters of the /// `String` that lie within a given range. @warn_unused_result - public func substringWithRange(_ aRange: Range) -> String { - return _ns.substringWithRange(_toNSRange(aRange)) + public func substring(with aRange: Range) -> String { + return _ns.substring(with: _toNSRange(aRange)) } // @property (readonly, copy) NSString *localizedUppercaseString NS_AVAILABLE(10_11, 9_0); /// An uppercase version of the string that is produced using the current /// locale. - public var localizedUppercaseString: String { - return _ns.localizedUppercaseString as String + public var localizedUppercase: String { + return _ns.localizedUppercase as String } // - (NSString *)uppercaseStringWithLocale:(NSLocale *)locale @@ -1492,8 +1492,8 @@ extension String { /// converted to uppercase, taking into account the specified /// locale. @warn_unused_result - public func uppercaseStringWithLocale(_ locale: NSLocale?) -> String { - return _ns.uppercaseStringWithLocale(locale) + public func uppercased(with locale: NSLocale?) -> String { + return _ns.uppercased(with: locale) } //===--- Omitted due to redundancy with "utf8" property -----------------===// @@ -1507,12 +1507,12 @@ extension String { /// Writes the contents of the `String` to a file at a given /// path using a given encoding. - public func writeToFile( - _ path: String, atomically useAuxiliaryFile:Bool, + public func write( + toFile path: String, atomically useAuxiliaryFile:Bool, encoding enc: NSStringEncoding ) throws { - try self._ns.writeToFile( - path, atomically: useAuxiliaryFile, encoding: enc) + try self._ns.write( + toFile: path, atomically: useAuxiliaryFile, encoding: enc) } // - (BOOL) @@ -1523,22 +1523,22 @@ extension String { /// Writes the contents of the `String` to the URL specified /// by url using the specified encoding. - public func writeToURL( - _ url: NSURL, atomically useAuxiliaryFile: Bool, + public func write( + to url: NSURL, atomically useAuxiliaryFile: Bool, encoding enc: NSStringEncoding ) throws { - try self._ns.writeToURL( - url, atomically: useAuxiliaryFile, encoding: enc) + try self._ns.write( + to: url, atomically: useAuxiliaryFile, encoding: enc) } // - (nullable NSString *)stringByApplyingTransform:(NSString *)transform reverse:(BOOL)reverse NS_AVAILABLE(10_11, 9_0); /// Perform string transliteration. @warn_unused_result - public func stringByApplyingTransform( + public func applyingTransform( _ transform: String, reverse: Bool ) -> String? { - return _ns.stringByApplyingTransform(transform, reverse: reverse) + return _ns.applyingTransform(transform, reverse: reverse) } //===--- From the 10.10 release notes; not in public documentation ------===// @@ -1550,8 +1550,8 @@ extension String { /// /// Equivalent to `self.rangeOfString(other) != nil` @warn_unused_result - public func containsString(_ other: String) -> Bool { - let r = self.rangeOfString(other) != nil + public func contains(_ other: String) -> Bool { + let r = self.range(of: other) != nil return r } @@ -1569,9 +1569,9 @@ extension String { /// other, options: .CaseInsensitiveSearch, /// locale: NSLocale.currentLocale()) != nil @warn_unused_result - public func localizedCaseInsensitiveContainsString(_ other: String) -> Bool { - let r = self.rangeOfString( - other, options: .CaseInsensitiveSearch, locale: NSLocale.currentLocale() + public func localizedCaseInsensitiveContains(_ other: String) -> Bool { + let r = self.range( + of: other, options: .caseInsensitiveSearch, locale: NSLocale.currentLocale() ) != nil return r } diff --git a/TestFoundation/TestNSCharacterSet.swift b/TestFoundation/TestNSCharacterSet.swift index 459f1dc894..4d80b8004b 100644 --- a/TestFoundation/TestNSCharacterSet.swift +++ b/TestFoundation/TestNSCharacterSet.swift @@ -107,13 +107,13 @@ class TestNSCharacterSet : XCTestCase { mcset1.addCharactersInRange(attachmentCharacterRange) XCTAssertTrue(mcset1.characterIsMember(attachmentCharacterUnichar), "attachmentCharacter should be member of mcset1 after being added") - XCTAssertNotNil(string.rangeOfCharacterFromSet(mcset1), "Range of character from mcset1 set should not be nil") + XCTAssertNotNil(string.rangeOfCharacter(from: mcset1), "Range of character from mcset1 set should not be nil") let mcset2 = NSMutableCharacterSet(range: initialSetRange) mcset2.addCharactersInString(string) XCTAssertTrue(mcset2.characterIsMember(attachmentCharacterUnichar), "attachmentCharacter should be member of mcset2 after being added") - XCTAssertNotNil(string.rangeOfCharacterFromSet(mcset2), "Range of character from mcset2 should not be nil") + XCTAssertNotNil(string.rangeOfCharacter(from: mcset2), "Range of character from mcset2 should not be nil") } func test_AnnexPlanes() { diff --git a/TestFoundation/TestNSData.swift b/TestFoundation/TestNSData.swift index cbf786264a..bba0c914e5 100644 --- a/TestFoundation/TestNSData.swift +++ b/TestFoundation/TestNSData.swift @@ -125,7 +125,7 @@ class TestNSData: XCTestCase { func test_initializeWithBase64EncodedDataGetsDecodedData() { let plainText = "ARMA virumque cano, Troiae qui primus ab oris\nItaliam, fato profugus, Laviniaque venit" let encodedText = "QVJNQSB2aXJ1bXF1ZSBjYW5vLCBUcm9pYWUgcXVpIHByaW11cyBhYiBvcmlzCkl0YWxpYW0sIGZhdG8gcHJvZnVndXMsIExhdmluaWFxdWUgdmVuaXQ=" - guard let encodedData = encodedText.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let encodedData = encodedText.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Could not get UTF-8 data") return } @@ -139,11 +139,11 @@ class TestNSData: XCTestCase { } XCTAssertEqual(decodedText, plainText) - XCTAssertTrue(decodedData.isEqual(to: plainText.bridge().dataUsingEncoding(NSUTF8StringEncoding)!)) } + XCTAssertTrue(decodedData.isEqual(to: plainText.bridge().data(using: NSUTF8StringEncoding)!)) } func test_initializeWithBase64EncodedDataWithNonBase64CharacterIsNil() { let encodedText = "QVJNQSB2aXJ1bXF1ZSBjYW5vLCBUcm9pYWUgcXVpIHBya$W11cyBhYiBvcmlzCkl0YWxpYW0sIGZhdG8gcHJvZnVndXMsIExhdmluaWFxdWUgdmVuaXQ=" - guard let encodedData = encodedText.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let encodedData = encodedText.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Could not get UTF-8 data") return } @@ -154,7 +154,7 @@ class TestNSData: XCTestCase { func test_initializeWithBase64EncodedDataWithNonBase64CharacterWithOptionToAllowItSkipsCharacter() { let plainText = "ARMA virumque cano, Troiae qui primus ab oris\nItaliam, fato profugus, Laviniaque venit" let encodedText = "QVJNQSB2aXJ1bXF1ZSBjYW5vLCBUcm9pYWUgcXVpIHBya$W11cyBhYiBvcmlzCkl0YWxpYW0sIGZhdG8gcHJvZnVndXMsIExhdmluaWFxdWUgdmVuaXQ=" - guard let encodedData = encodedText.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let encodedData = encodedText.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Could not get UTF-8 data") return } @@ -168,7 +168,7 @@ class TestNSData: XCTestCase { } XCTAssertEqual(decodedText, plainText) - XCTAssertTrue(decodedData.isEqual(to: plainText.bridge().dataUsingEncoding(NSUTF8StringEncoding)!)) + XCTAssertTrue(decodedData.isEqual(to: plainText.bridge().data(using: NSUTF8StringEncoding)!)) } func test_initializeWithBase64EncodedStringGetsDecodedData() { @@ -189,7 +189,7 @@ class TestNSData: XCTestCase { func test_base64EncodedDataGetsEncodedText() { let plainText = "Constitit, et lacrimans, `Quis iam locus’ inquit `Achate,\nquae regio in terris nostri non plena laboris?`" let encodedText = "Q29uc3RpdGl0LCBldCBsYWNyaW1hbnMsIGBRdWlzIGlhbSBsb2N1c+KAmSBpbnF1aXQgYEFjaGF0ZSwKcXVhZSByZWdpbyBpbiB0ZXJyaXMgbm9zdHJpIG5vbiBwbGVuYSBsYWJvcmlzP2A=" - guard let data = plainText.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = plainText.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Could not encode UTF-8 string") return } @@ -204,7 +204,7 @@ class TestNSData: XCTestCase { func test_base64EncodedDataWithOptionToInsertLineFeedsContainsLineFeed() { let plainText = "Constitit, et lacrimans, `Quis iam locus’ inquit `Achate,\nquae regio in terris nostri non plena laboris?`" let encodedText = "Q29uc3RpdGl0LCBldCBsYWNyaW1hbnMsIGBRdWlzIGlhbSBsb2N1c+KAmSBpbnF1\naXQgYEFjaGF0ZSwKcXVhZSByZWdpbyBpbiB0ZXJyaXMgbm9zdHJpIG5vbiBwbGVu\nYSBsYWJvcmlzP2A=" - guard let data = plainText.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = plainText.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Could not encode UTF-8 string") return } @@ -219,7 +219,7 @@ class TestNSData: XCTestCase { func test_base64EncodedDataWithOptionToInsertCarriageReturnContainsCarriageReturn() { let plainText = "Constitit, et lacrimans, `Quis iam locus’ inquit `Achate,\nquae regio in terris nostri non plena laboris?`" let encodedText = "Q29uc3RpdGl0LCBldCBsYWNyaW1hbnMsIGBRdWlzIGlhbSBsb2N1c+KAmSBpbnF1aXQgYEFjaGF0\rZSwKcXVhZSByZWdpbyBpbiB0ZXJyaXMgbm9zdHJpIG5vbiBwbGVuYSBsYWJvcmlzP2A=" - guard let data = plainText.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = plainText.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Could not encode UTF-8 string") return } @@ -234,7 +234,7 @@ class TestNSData: XCTestCase { func test_base64EncodedDataWithOptionToInsertCarriageReturnAndLineFeedContainsBoth() { let plainText = "Revocate animos, maestumque timorem mittite: forsan et haec olim meminisse iuvabit." let encodedText = "UmV2b2NhdGUgYW5pbW9zLCBtYWVzdHVtcXVlIHRpbW9yZW0gbWl0dGl0ZTogZm9yc2FuIGV0IGhh\r\nZWMgb2xpbSBtZW1pbmlzc2UgaXV2YWJpdC4=" - guard let data = plainText.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = plainText.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Could not encode UTF-8 string") return } @@ -249,7 +249,7 @@ class TestNSData: XCTestCase { func test_base64EncodedStringGetsEncodedText() { let plainText = "Revocate animos, maestumque timorem mittite: forsan et haec olim meminisse iuvabit." let encodedText = "UmV2b2NhdGUgYW5pbW9zLCBtYWVzdHVtcXVlIHRpbW9yZW0gbWl0dGl0ZTogZm9yc2FuIGV0IGhhZWMgb2xpbSBtZW1pbmlzc2UgaXV2YWJpdC4=" - guard let data = plainText.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = plainText.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Could not encode UTF-8 string") return } diff --git a/TestFoundation/TestNSJSONSerialization.swift b/TestFoundation/TestNSJSONSerialization.swift index 83e87f155c..f0f648275a 100644 --- a/TestFoundation/TestNSJSONSerialization.swift +++ b/TestFoundation/TestNSJSONSerialization.swift @@ -120,7 +120,7 @@ extension TestNSJSONSerialization { func test_deserialize_emptyObject() { let subject = "{}" do { - guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = subject.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Unable to convert string to data") return } @@ -136,7 +136,7 @@ extension TestNSJSONSerialization { let subject = "{ \"hello\": \"world\", \"swift\": \"rocks\" }" do { for encoding in [NSUTF8StringEncoding, NSUTF16BigEndianStringEncoding] { - guard let data = subject.bridge().dataUsingEncoding(encoding) else { + guard let data = subject.bridge().data(using: encoding) else { XCTFail("Unable to convert string to data") return } @@ -154,7 +154,7 @@ extension TestNSJSONSerialization { let subject = "[]" do { - guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = subject.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Unable to convert string to data") return } @@ -170,7 +170,7 @@ extension TestNSJSONSerialization { do { for encoding in [NSUTF8StringEncoding, NSUTF16BigEndianStringEncoding] { - guard let data = subject.bridge().dataUsingEncoding(encoding) else { + guard let data = subject.bridge().data(using: encoding) else { XCTFail("Unable to convert string to data") return } @@ -189,7 +189,7 @@ extension TestNSJSONSerialization { do { for encoding in [NSUTF16LittleEndianStringEncoding, NSUTF16BigEndianStringEncoding, NSUTF32LittleEndianStringEncoding, NSUTF32BigEndianStringEncoding] { - guard let data = subject.bridge().dataUsingEncoding(encoding) else { + guard let data = subject.bridge().data(using: encoding) else { XCTFail("Unable to convert string to data") return } @@ -209,7 +209,7 @@ extension TestNSJSONSerialization { do { for encoding in supportedEncodings { - guard let data = subject.bridge().dataUsingEncoding(encoding) else { + guard let data = subject.bridge().data(using: encoding) else { XCTFail("Unable to convert string to data") return } @@ -232,7 +232,7 @@ extension TestNSJSONSerialization { do { for encoding in supportedEncodings { - guard let data = subject.bridge().dataUsingEncoding(encoding) else { + guard let data = subject.bridge().data(using: encoding) else { XCTFail("Unable to convert string to data") return } @@ -253,7 +253,7 @@ extension TestNSJSONSerialization { func test_deserialize_simpleEscapeSequences() { let subject = "[\"\\\"\", \"\\\\\", \"\\/\", \"\\b\", \"\\f\", \"\\n\", \"\\r\", \"\\t\"]" do { - guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = subject.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Unable to convert string to data") return } @@ -275,7 +275,7 @@ extension TestNSJSONSerialization { func test_deserialize_unicodeEscapeSequence() { let subject = "[\"\\u2728\"]" do { - guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = subject.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Unable to convert string to data") return } @@ -289,7 +289,7 @@ extension TestNSJSONSerialization { func test_deserialize_unicodeSurrogatePairEscapeSequence() { let subject = "[\"\\uD834\\udd1E\"]" do { - guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = subject.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Unable to convert string to data") return } @@ -305,7 +305,7 @@ extension TestNSJSONSerialization { do { for encoding in supportedEncodings { - guard let data = subject.bridge().dataUsingEncoding(encoding) else { + guard let data = subject.bridge().data(using: encoding) else { XCTFail("Unable to convert string to data") return } @@ -322,7 +322,7 @@ extension TestNSJSONSerialization { let subject = "{\"}" do { - guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = subject.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Unable to convert string to data") return } @@ -337,7 +337,7 @@ extension TestNSJSONSerialization { let subject = "{3}" do { - guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = subject.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Unable to convert string to data") return } @@ -352,7 +352,7 @@ extension TestNSJSONSerialization { let subject = "{" do { - guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = subject.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Unable to convert string to data") return } @@ -367,7 +367,7 @@ extension TestNSJSONSerialization { let subject = "{\"error\":}" do { - guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = subject.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Unable to convert string to data") return } @@ -382,7 +382,7 @@ extension TestNSJSONSerialization { let subject = "{\"missing\";}" do { - guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = subject.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Unable to convert string to data") return } @@ -397,7 +397,7 @@ extension TestNSJSONSerialization { let subject = "[," do { - guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = subject.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Unable to convert string to data") return } @@ -412,7 +412,7 @@ extension TestNSJSONSerialization { let subject = "[2b4]" do { - guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = subject.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Unable to convert string to data") return } @@ -427,7 +427,7 @@ extension TestNSJSONSerialization { let subject = "[\"\\e\"]" do { - guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = subject.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Unable to convert string to data") return } @@ -441,7 +441,7 @@ extension TestNSJSONSerialization { func test_deserialize_unicodeMissingTrailingSurrogate() { let subject = "[\"\\uD834\"]" do { - guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else { + guard let data = subject.bridge().data(using: NSUTF8StringEncoding) else { XCTFail("Unable to convert string to data") return } diff --git a/TestFoundation/TestNSPipe.swift b/TestFoundation/TestNSPipe.swift index 660ae97c87..9cc755222c 100644 --- a/TestFoundation/TestNSPipe.swift +++ b/TestFoundation/TestNSPipe.swift @@ -31,7 +31,7 @@ class TestNSPipe : XCTestCase { let text = "test-pipe" // First write some data into the pipe - let stringAsData = text.bridge().dataUsingEncoding(NSUTF8StringEncoding) + let stringAsData = text.bridge().data(using: NSUTF8StringEncoding) XCTAssertNotNil(stringAsData) aPipe.fileHandleForWriting.writeData(stringAsData!) diff --git a/TestFoundation/TestNSProcessInfo.swift b/TestFoundation/TestNSProcessInfo.swift index 1664745cba..e99d732cd2 100644 --- a/TestFoundation/TestNSProcessInfo.swift +++ b/TestFoundation/TestNSProcessInfo.swift @@ -57,7 +57,7 @@ class TestNSProcessInfo : XCTestCase { func test_globallyUniqueString() { let uuid = NSProcessInfo.processInfo().globallyUniqueString - let parts = uuid.bridge().componentsSeparatedByString("-") + let parts = uuid.bridge().components(separatedBy: "-") XCTAssertEqual(parts.count, 5) XCTAssertEqual(parts[0].bridge().length, 8) XCTAssertEqual(parts[1].bridge().length, 4) diff --git a/TestFoundation/TestNSRegularExpression.swift b/TestFoundation/TestNSRegularExpression.swift index 6a062cb095..cc0644cd6e 100644 --- a/TestFoundation/TestNSRegularExpression.swift +++ b/TestFoundation/TestNSRegularExpression.swift @@ -43,8 +43,8 @@ class TestNSRegularExpression : XCTestCase { XCTAssertTrue((matchResult && match) || (!matchResult && !match), "Case 0 simple regex \(patternString) in \(searchString) match \(matchResult) should be \(match)", file: file, line: line) } do { - let lookingRange = str.rangeOfString(patternString, options: [.RegularExpressionSearch, .AnchoredSearch], range: range, locale: nil) - let matchRange = str.rangeOfString(patternString, options: .RegularExpressionSearch, range: range, locale: nil) + let lookingRange = str.range(of: patternString, options: [.regularExpressionSearch, .anchoredSearch], range: range, locale: nil) + let matchRange = str.range(of: patternString, options: .regularExpressionSearch, range: range, locale: nil) let lookingResult = lookingRange.location == range.location let matchResult = NSEqualRanges(matchRange, range) @@ -56,8 +56,8 @@ class TestNSRegularExpression : XCTestCase { let suffixString = " becomes necessary" let searchString2 = "\(prefixString)\(searchString)\(suffixString)".bridge() range.location = prefixString.utf16.count - let lookingRange = searchString2.rangeOfString(patternString, options: [.RegularExpressionSearch, .AnchoredSearch], range: range, locale: nil) - let matchRange = searchString2.rangeOfString(patternString, options: [.RegularExpressionSearch], range: range, locale: nil) + let lookingRange = searchString2.range(of: patternString, options: [.regularExpressionSearch, .anchoredSearch], range: range, locale: nil) + let matchRange = searchString2.range(of: patternString, options: [.regularExpressionSearch], range: range, locale: nil) let lookingResult = lookingRange.location == range.location let matchResult = NSEqualRanges(matchRange, range) @@ -70,8 +70,8 @@ class TestNSRegularExpression : XCTestCase { let suffixString = " becomes necessary becomes necessary becomes necessary becomes necessary becomes necessary becomes necessary becomes necessary becomes necessary becomes necessary becomes necessary becomes necessary becomes necessary becomes necessary becomes necessary becomes necessary" let searchString2 = "\(prefixString)\(searchString)\(suffixString)".bridge() range.location = prefixString.utf16.count - let lookingRange = searchString2.rangeOfString(patternString, options: [.RegularExpressionSearch, .AnchoredSearch], range: NSMakeRange(range.location, range.length + suffixString.utf16.count), locale: nil) - let matchRange = searchString2.rangeOfString(patternString, options: .RegularExpressionSearch, range: NSMakeRange(range.location, range.length + suffixString.utf16.count), locale: nil) + let lookingRange = searchString2.range(of: patternString, options: [.regularExpressionSearch, .anchoredSearch], range: NSMakeRange(range.location, range.length + suffixString.utf16.count), locale: nil) + let matchRange = searchString2.range(of: patternString, options: .regularExpressionSearch, range: NSMakeRange(range.location, range.length + suffixString.utf16.count), locale: nil) let lookingResult = lookingRange.location == range.location let matchResult = lookingResult && (matchRange.length >= range.length) @@ -84,8 +84,8 @@ class TestNSRegularExpression : XCTestCase { let suffixString = " becomes necessary’" let searchString2 = "\(prefixString)\(searchString)\(suffixString)".bridge() range.location = prefixString.utf16.count - let lookingRange = searchString2.rangeOfString(patternString, options: [.RegularExpressionSearch, .AnchoredSearch], range: range, locale: nil) - let matchRange = searchString2.rangeOfString(patternString, options: [.RegularExpressionSearch], range: range, locale: nil) + let lookingRange = searchString2.range(of: patternString, options: [.regularExpressionSearch, .anchoredSearch], range: range, locale: nil) + let matchRange = searchString2.range(of: patternString, options: [.regularExpressionSearch], range: range, locale: nil) let lookingResult = lookingRange.location == range.location let matchResult = NSEqualRanges(matchRange, range) diff --git a/TestFoundation/TestNSString.swift b/TestFoundation/TestNSString.swift index 4a33fbecc2..8c8b5ef2a9 100644 --- a/TestFoundation/TestNSString.swift +++ b/TestFoundation/TestNSString.swift @@ -110,7 +110,7 @@ class TestNSString : XCTestCase { XCTAssertTrue(nonLiteralConversion.length > 4) let nonLiteral2: NSString = String(4).bridge() - let t = nonLiteral2.characterAtIndex(0) + let t = nonLiteral2.character(at: 0) XCTAssertTrue(t == 52) let externalString: NSString = String.localizedNameOfStringEncoding(String.defaultCStringEncoding()).bridge() @@ -187,7 +187,7 @@ class TestNSString : XCTestCase { func test_isEqualToStringWithSwiftString() { let string: NSString = "literal" let swiftString = "literal" - XCTAssertTrue(string.isEqualToString(swiftString)) + XCTAssertTrue(string.isEqual(to: swiftString)) } func test_isEqualToObjectWithNSString() { @@ -212,14 +212,14 @@ class TestNSString : XCTestCase { let bytes = mockASCIIStringBytes let string = NSString(bytes: bytes, length: bytes.count, encoding: NSASCIIStringEncoding) XCTAssertNotNil(string) - XCTAssertTrue(string?.isEqualToString(mockASCIIString) ?? false) + XCTAssertTrue(string?.isEqual(to: mockASCIIString) ?? false) } func test_FromUTF8Data() { let bytes = mockUTF8StringBytes let string = NSString(bytes: bytes, length: bytes.count, encoding: NSUTF8StringEncoding) XCTAssertNotNil(string) - XCTAssertTrue(string?.isEqualToString(mockUTF8String) ?? false) + XCTAssertTrue(string?.isEqual(to: mockUTF8String) ?? false) } func test_FromMalformedUTF8Data() { @@ -233,7 +233,7 @@ class TestNSString : XCTestCase { let data = NSData(bytes: bytes, length: bytes.count) let string = NSString(data: data, encoding: NSASCIIStringEncoding) XCTAssertNotNil(string) - XCTAssertTrue(string?.isEqualToString(mockASCIIString) ?? false) + XCTAssertTrue(string?.isEqual(to: mockASCIIString) ?? false) } func test_FromUTF8NSData() { @@ -241,7 +241,7 @@ class TestNSString : XCTestCase { let data = NSData(bytes: bytes, length: bytes.count) let string = NSString(data: data, encoding: NSUTF8StringEncoding) XCTAssertNotNil(string) - XCTAssertTrue(string?.isEqualToString(mockUTF8String) ?? false) + XCTAssertTrue(string?.isEqual(to: mockUTF8String) ?? false) } func test_FromMalformedUTF8NSData() { @@ -255,14 +255,14 @@ class TestNSString : XCTestCase { let bytes = mockASCIIStringBytes + [0x00] let string = NSString(CString: bytes.map { Int8(bitPattern: $0) }, encoding: NSASCIIStringEncoding) XCTAssertNotNil(string) - XCTAssertTrue(string?.isEqualToString(mockASCIIString) ?? false) + XCTAssertTrue(string?.isEqual(to: mockASCIIString) ?? false) } func test_FromNullTerminatedCStringInUTF8() { let bytes = mockUTF8StringBytes + [0x00] let string = NSString(CString: bytes.map { Int8(bitPattern: $0) }, encoding: NSUTF8StringEncoding) XCTAssertNotNil(string) - XCTAssertTrue(string?.isEqualToString(mockUTF8String) ?? false) + XCTAssertTrue(string?.isEqual(to: mockUTF8String) ?? false) } func test_FromMalformedNullTerminatedCStringInUTF8() { @@ -304,37 +304,37 @@ class TestNSString : XCTestCase { } func test_uppercaseString() { - XCTAssertEqual(NSString(stringLiteral: "abcd").uppercaseString, "ABCD") - XCTAssertEqual(NSString(stringLiteral: "ａｂｃｄ").uppercaseString, "ＡＢＣＤ") // full-width - XCTAssertEqual(NSString(stringLiteral: "абВГ").uppercaseString, "АБВГ") - XCTAssertEqual(NSString(stringLiteral: "たちつてと").uppercaseString, "たちつてと") + XCTAssertEqual(NSString(stringLiteral: "abcd").uppercased, "ABCD") + XCTAssertEqual(NSString(stringLiteral: "ａｂｃｄ").uppercased, "ＡＢＣＤ") // full-width + XCTAssertEqual(NSString(stringLiteral: "абВГ").uppercased, "АБВГ") + XCTAssertEqual(NSString(stringLiteral: "たちつてと").uppercased, "たちつてと") // Special casing (see swift/validation-tests/stdlib/NSStringAPI.swift) - XCTAssertEqual(NSString(stringLiteral: "\u{0069}").uppercaseStringWithLocale(NSLocale(localeIdentifier: "en")), "\u{0049}") + XCTAssertEqual(NSString(stringLiteral: "\u{0069}").uppercased(with: NSLocale(localeIdentifier: "en")), "\u{0049}") // Currently fails; likely there are locale loading issues that are preventing this from functioning correctly - // XCTAssertEqual(NSString(stringLiteral: "\u{0069}").uppercaseStringWithLocale(NSLocale(localeIdentifier: "tr")), "\u{0130}") - XCTAssertEqual(NSString(stringLiteral: "\u{00df}").uppercaseString, "\u{0053}\u{0053}") - XCTAssertEqual(NSString(stringLiteral: "\u{fb01}").uppercaseString, "\u{0046}\u{0049}") + // XCTAssertEqual(NSString(stringLiteral: "\u{0069}").uppercased(with: NSLocale(localeIdentifier: "tr")), "\u{0130}") + XCTAssertEqual(NSString(stringLiteral: "\u{00df}").uppercased, "\u{0053}\u{0053}") + XCTAssertEqual(NSString(stringLiteral: "\u{fb01}").uppercased, "\u{0046}\u{0049}") } func test_lowercaseString() { - XCTAssertEqual(NSString(stringLiteral: "abCD").lowercaseString, "abcd") - XCTAssertEqual(NSString(stringLiteral: "ＡＢＣＤ").lowercaseString, "ａｂｃｄ") // full-width - XCTAssertEqual(NSString(stringLiteral: "aБВГ").lowercaseString, "aбвг") - XCTAssertEqual(NSString(stringLiteral: "たちつてと").lowercaseString, "たちつてと") + XCTAssertEqual(NSString(stringLiteral: "abCD").lowercased, "abcd") + XCTAssertEqual(NSString(stringLiteral: "ＡＢＣＤ").lowercased, "ａｂｃｄ") // full-width + XCTAssertEqual(NSString(stringLiteral: "aБВГ").lowercased, "aбвг") + XCTAssertEqual(NSString(stringLiteral: "たちつてと").lowercased, "たちつてと") // Special casing (see swift/validation-tests/stdlib/NSStringAPI.swift) - XCTAssertEqual(NSString(stringLiteral: "\u{0130}").lowercaseStringWithLocale(NSLocale(localeIdentifier: "en")), "\u{0069}\u{0307}") + XCTAssertEqual(NSString(stringLiteral: "\u{0130}").lowercased(with: NSLocale(localeIdentifier: "en")), "\u{0069}\u{0307}") // Currently fails; likely there are locale loading issues that are preventing this from functioning correctly - // XCTAssertEqual(NSString(stringLiteral: "\u{0130}").lowercaseStringWithLocale(NSLocale(localeIdentifier: "tr")), "\u{0069}") - XCTAssertEqual(NSString(stringLiteral: "\u{0049}\u{0307}").lowercaseStringWithLocale(NSLocale(localeIdentifier: "en")), "\u{0069}\u{0307}") + // XCTAssertEqual(NSString(stringLiteral: "\u{0130}").lowercased(with: NSLocale(localeIdentifier: "tr")), "\u{0069}") + XCTAssertEqual(NSString(stringLiteral: "\u{0049}\u{0307}").lowercased(with: NSLocale(localeIdentifier: "en")), "\u{0069}\u{0307}") // Currently fails; likely there are locale loading issues that are preventing this from functioning correctly // XCTAssertEqual(NSString(stringLiteral: "\u{0049}\u{0307}").lowercaseStringWithLocale(NSLocale(localeIdentifier: "tr")), "\u{0069}") } func test_capitalizedString() { - XCTAssertEqual(NSString(stringLiteral: "foo Foo fOO FOO").capitalizedString, "Foo Foo Foo Foo") - XCTAssertEqual(NSString(stringLiteral: "жжж").capitalizedString, "Жжж") + XCTAssertEqual(NSString(stringLiteral: "foo Foo fOO FOO").capitalized, "Foo Foo Foo Foo") + XCTAssertEqual(NSString(stringLiteral: "жжж").capitalized, "Жжж") } func test_longLongValue() { @@ -373,10 +373,10 @@ class TestNSString : XCTestCase { let string: NSString = "0Az" let letters = NSCharacterSet.letterCharacterSet() let decimalDigits = NSCharacterSet.decimalDigitCharacterSet() - XCTAssertEqual(string.rangeOfCharacterFromSet(letters).location, 1) - XCTAssertEqual(string.rangeOfCharacterFromSet(decimalDigits).location, 0) - XCTAssertEqual(string.rangeOfCharacterFromSet(letters, options: [.BackwardsSearch]).location, 2) - XCTAssertEqual(string.rangeOfCharacterFromSet(letters, options: [], range: NSMakeRange(2, 1)).location, 2) + XCTAssertEqual(string.rangeOfCharacter(from: letters).location, 1) + XCTAssertEqual(string.rangeOfCharacter(from: decimalDigits).location, 0) + XCTAssertEqual(string.rangeOfCharacter(from: letters, options: [.backwardsSearch]).location, 2) + XCTAssertEqual(string.rangeOfCharacter(from: letters, options: [], range: NSMakeRange(2, 1)).location, 2) } func test_CFStringCreateMutableCopy() { @@ -409,7 +409,7 @@ class TestNSString : XCTestCase { let newCFString = CFStringCreateWithBytes(nil, buf, usedLen, CFStringEncoding(kCFStringEncodingUTF16), false) let newString = unsafeBitCast(newCFString, to: NSString.self) - XCTAssertTrue(newString.isEqualToString(testString)) + XCTAssertTrue(newString.isEqual(to: testString)) } func test_completePathIntoString() { @@ -594,13 +594,13 @@ class TestNSString : XCTestCase { } private func stringsAreCaseInsensitivelyEqual(_ lhs: NSString, _ rhs: NSString) -> Bool { - return lhs.compare(rhs.bridge(), options: .CaseInsensitiveSearch) == .OrderedSame + return lhs.compare(rhs.bridge(), options: .caseInsensitiveSearch) == .OrderedSame } func test_stringByTrimmingCharactersInSet() { let characterSet = NSCharacterSet.whitespaceCharacterSet() let string: NSString = " abc " - XCTAssertEqual(string.stringByTrimmingCharactersInSet(characterSet), "abc") + XCTAssertEqual(string.trimmingCharacters(in: characterSet), "abc") } func test_initializeWithFormat() { diff --git a/TestFoundation/TestNSXMLDocument.swift b/TestFoundation/TestNSXMLDocument.swift index d7ab49b783..f02c63fcdb 100644 --- a/TestFoundation/TestNSXMLDocument.swift +++ b/TestFoundation/TestNSXMLDocument.swift @@ -317,7 +317,7 @@ class TestNSXMLDocument : XCTestCase { } catch let nsError as NSError { XCTAssert(nsError.code == NSXMLParserError.InternalError.rawValue) XCTAssert(nsError.domain == NSXMLParserErrorDomain) - XCTAssert((nsError.userInfo[NSLocalizedDescriptionKey] as! NSString).containsString("Element img was declared EMPTY this one has content")) + XCTAssert((nsError.userInfo[NSLocalizedDescriptionKey] as! NSString).contains("Element img was declared EMPTY this one has content")) } let plistDocString = " MyKeyHello!MyBooleanThingfoobar" @@ -326,7 +326,7 @@ class TestNSXMLDocument : XCTestCase { try plistDoc.validate() XCTFail("Should have thrown!") } catch let error as NSError { - XCTAssert((error.userInfo[NSLocalizedDescriptionKey] as! NSString).containsString("Element true was declared EMPTY this one has content")) + XCTAssert((error.userInfo[NSLocalizedDescriptionKey] as! NSString).contains("Element true was declared EMPTY this one has content")) } }