         let withString = "With"
         var parameters: [String]?
         if hasSuffix(":") {
-            let parameterComponents = componentsSeparatedByString(":")
-            if let withComponents = parameterComponents.first?.componentsSeparatedByString(withString)
-                where !withComponents.isEmpty
+            let parameterComponents = components(separatedBy: ":")
+            if let withComponents = parameterComponents.first?.components(separatedBy: withString), !withComponents.isEmpty
             {
-                let methodBaseName = withComponents.dropLast().joinWithSeparator(withString)
+                let methodBaseName = withComponents.dropLast().joined(separator: withString)
                 let firstParameter = withComponents.last!.lowercasedFirstCharacter
                 parameters = [methodBaseName, firstParameter]
-                parameters?.appendContentsOf(parameterComponents.dropFirst().dropLast())
+                parameters?.append(contentsOf: parameterComponents.dropFirst().dropLast())
             }
         } else {
             parameters = [self]

    }
    
    var isUppercase: Bool {
        return self == uppercaseString
    }
    
    var wordsFromCamelCase: String {
        var wordString = ""
        var previousChar: String? = nil
        for charN in 0 ..< characters.count {
            let thisChar = String(characters[startIndex.advancedBy(charN)])
            let nextChar: String? = charN + 1 < characters.count ? String(characters[startIndex.advancedBy(charN + 1)]) : nil
            if charN > 0
                && previousChar != " "
                && thisChar != " "

extension String {
    
    var uppercasedFirstCharacter: String {
        let index = characters.index(startIndex, offsetBy: 1)
        return substring(to: index).uppercased() + substring(from: index)
    }

    var lowercasedFirstCharacter: String {
        let index = characters.index(startIndex, offsetBy: 1)
        return substring(to: index).lowercased() + substring(from: index)
    }

    var words: [String] {
        return components(separatedBy: CharacterSet.whitespaces).filter { !$0.isEmpty }
    }
    
    var paintcodeCaseFromWords: String {
