bppr · August 29, 2015 14:23 · Jul 17, 2015 · Jul 17, 2015 · Jun 27, 2015
diff --git a/string-extensions.swift b/string-extensions.swift
@@ -4,24 +4,28 @@ extension String {
     var last: Character { get { return self[self.endIndex.predecessor()] }}
 
     func contains(fragment: String) -> Bool {
+        return self.indexOf(fragment) != nil
+    }
+
+    func indexOf(fragment: String) -> String.Index? {
         guard let startAt = characters.indexOf(fragment.first) else {
-            return false
+            return nil
         }
 
-        var i = distance(self.startIndex, startAt)
+        var i = distance(startIndex, startAt)
 
         while i <= (self.length - fragment.length) {
             let scanStart = advance(startIndex, i)
             let scanEnd   = advance(startIndex, i + fragment.length)
 
             if self[scanStart..<scanEnd] == fragment {
-                return true
+                return scanStart
             }
 
             i++
         }
 
-        return false
+        return nil
     }
 
     func split(character delimiter: Character) -> [String] {
@@ -32,7 +36,7 @@ extension String {
         var chunks: [String] = []
         var currentIndex = startIndex
 
-        var i = 0
+        var i = distance(startIndex, indexOf(delimiter) ?? startIndex)
 
         while i <= (self.length - delimiter.length) {
             let scanStart = advance(startIndex, i)
@@ -79,4 +83,29 @@ extension String {
     func reverse() -> String {
         return String(self.characters.reverse())
     }
+
+    func sub(fragment: String, withString replacement: String, global: Bool = true) -> String {
+        guard let startAt = self.indexOf(fragment) else {
+            return self
+        }
+
+        var i = distance(startIndex, startAt)
+        var newStr = self
+
+        while i <= (newStr.length - fragment.length) && newStr.indexOf(fragment) != nil {
+            let range = Range(
+                start: advance(newStr.startIndex, i),
+                end:   advance(newStr.startIndex, i + fragment.length)
+            )
+
+            if newStr[range] == fragment {
+                newStr.replaceRange(range, with: replacement)
+                if(!global) { return newStr }
+            }
+
+            i++
+        }
+
+        return newStr
+    }
 }
diff --git a/string-extensions.swift b/string-extensions.swift
@@ -1,18 +1,20 @@
 extension String {
-    var length: Int { get { return self.characters.count } }
+    var length: Int { get { return characters.count } }
     var first: Character { get { return self[self.startIndex] }}
+    var last: Character { get { return self[self.endIndex.predecessor()] }}
 
-    func contains(other: String) -> Bool {
-        guard let startAt = self.characters.indexOf(other.first) else {
+    func contains(fragment: String) -> Bool {
+        guard let startAt = characters.indexOf(fragment.first) else {
             return false
         }
 
         var i = distance(self.startIndex, startAt)
 
-        while i <= (self.length - other.length) {
-            let indexOne = advance(self.startIndex, i)
-            let indexTwo = advance(self.startIndex, i + other.length)
-            if self[indexOne..<indexTwo] == other {
+        while i <= (self.length - fragment.length) {
+            let scanStart = advance(startIndex, i)
+            let scanEnd   = advance(startIndex, i + fragment.length)
+
+            if self[scanStart..<scanEnd] == fragment {
                 return true
             }
 
@@ -21,4 +23,60 @@ extension String {
 
         return false
     }
-}
+
+    func split(character delimiter: Character) -> [String] {
+        return Swift.split(characters) { $0 == delimiter }.map(String.init)
+    }
+
+    func split(delimiter: String) -> [String] {
+        var chunks: [String] = []
+        var currentIndex = startIndex
+
+        var i = 0
+
+        while i <= (self.length - delimiter.length) {
+            let scanStart = advance(startIndex, i)
+            let scanEnd   = advance(startIndex, i + delimiter.length)
+
+            if self[scanStart..<scanEnd] == delimiter {
+                chunks.append(self[currentIndex..<scanStart])
+                i += delimiter.length
+                currentIndex = advance(startIndex, i)
+            } else {
+                i++
+            }
+        }
+
+        chunks.append(self[currentIndex..<endIndex])
+
+        return chunks
+    }
+
+    func strip() -> String {
+       return self.lstrip().rstrip()
+    }
+
+    func lstrip() -> String {
+        var newStr = self
+
+        while newStr.first == " " {
+            newStr = newStr[newStr.startIndex.successor()..<newStr.endIndex]
+        }
+
+        return newStr
+    }
+
+    func rstrip() -> String {
+        var newStr = self
+
+        while newStr.last == " " {
+            newStr = newStr[newStr.startIndex..<newStr.endIndex.predecessor()]
+        }
+
+        return newStr
+    }
+
+    func reverse() -> String {
+        return String(self.characters.reverse())
+    }
+}
diff --git a/string-extensions.swift b/string-extensions.swift
@@ -0,0 +1,24 @@
+extension String {
+    var length: Int { get { return self.characters.count } }
+    var first: Character { get { return self[self.startIndex] }}
+
+    func contains(other: String) -> Bool {
+        guard let startAt = self.characters.indexOf(other.first) else {
+            return false
+        }
+
+        var i = distance(self.startIndex, startAt)
+
+        while i <= (self.length - other.length) {
+            let indexOne = advance(self.startIndex, i)
+            let indexTwo = advance(self.startIndex, i + other.length)
+            if self[indexOne..<indexTwo] == other {
+                return true
+            }
+
+            i++
+        }
+
+        return false
+    }
+}