Added support for order of operations with parenthesis

Author: jrosen081

Example/Tests/Tests.swift

@@ -27,6 +27,34 @@ class Tests: XCTestCase {
 		XCTAssertNil(Parser.parse(string: "1 + k"))
 		XCTAssertEqual(Parser.parse(string: "10 * 3 ^ 2")?.evaluate(), 90)
 		XCTAssertEqual(Parser.parse(string: "12 + 4 * 3")?.evaluate(), 24)
+		let value = Parser.parse(string: "23 / 0")
+		XCTAssertNotNil(value)
+		XCTAssertNil(value?.evaluate())
     }
+	
+	func testExponentRelation() {
+		XCTAssertEqual(Parser.parse(string: "2 ^ 3 ^ 2")?.evaluate(), 512)
+		XCTAssertEqual(Parser.parse(string: "2 - 3 ^ 2")?.evaluate(), -7)
+	}
+	
+	func testDifferentOperators() {
+		Operators.addOp = "%"
+		Operators.subOp = "@"
+		Operators.multOp = "#"
+		Operators.powOp = "|"
+		Operators.divOp = "!"
+		XCTAssertNotNil(Parser.parse(string: "2 % 4 | 3"))
+		XCTAssertEqual(Parser.parse(string: "2 % 4 | 3")?.evaluate(), 66)
+	}
+	
+	func testParenthesis() {
+		XCTAssertNotNil(Parser.parse(string: "2 + (2 + 3)"))
+		XCTAssertEqual(Parser.parse(string: "2 + (2 + 3)")?.evaluate(), 7)
+		XCTAssertEqual(Parser.parse(string: "2 * (2 + 4)")?.evaluate(), 12)
+		XCTAssertNil(Parser.parse(string: "2 + (3 * 4"))
+		XCTAssertEqual(Parser.parse(string: "2 + ((4 + 5) * 3)")?.evaluate(), 29)
+		XCTAssertNil(Parser.parse(string: "2 + ((((((((4 * 3) - 4) + 2)"))
+		XCTAssertEqual(Parser.parse(string: "(2 + (3 + (4 * (5)) + 2))")?.evaluate(), 27)
+	}
 
 }

MathParser.podspec

@@ -8,7 +8,7 @@
 
 Pod::Spec.new do |s|
   s.name             = 'MathParser'
-  s.version          = '1.1'
+  s.version          = '1.3'
   s.summary          = 'A simple parser for Mathematical Expressions.'
 
 # This description is used to generate tags and improve search results.

MathParser/Classes/Source/Parser.swift

@@ -14,11 +14,32 @@ public class Parser {
 	/// - parameter string: The string to parse
 	/// - returns: An expression that will result in the value
 	public static func parse(string: String) -> Expression? {
-		let updatedString = Parser.changeMinusIntoOther(change: Operators.subOp, into: string)
+		var updatedString = Parser.changeMinusIntoOther(change: Operators.subOp, into: string)
 		guard updatedString.contains(Operators.divOp) || updatedString.contains(Operators.multOp) || updatedString.contains(Operators.addOp) || updatedString.contains(Operators.subOp) ||  updatedString.contains(Operators.powOp) || Decimal(string) != nil else {
 			return nil
 		}
-		if updatedString.contains(Operators.addOp) || updatedString.contains(Operators.subOp) {
+		if updatedString.contains("(") {
+			let idx = updatedString.firstIndex(of: "(")!
+			var parenCounts = 0
+			var nextIdx = updatedString.index(after: idx)
+			while nextIdx != updatedString.endIndex {
+				if updatedString[nextIdx] == ")"  {
+					parenCounts -= 1
+				} else if updatedString[nextIdx] == "(" {
+					parenCounts += 1
+				}
+				if parenCounts == -1 {
+					updatedString.replaceSubrange(idx..<nextIdx, with: "\(decimal: Parser.parse(string: String(updatedString[updatedString.index(after: idx)..<nextIdx]))?.evaluate())")
+					break
+				}
+				nextIdx = updatedString.index(after: nextIdx)
+			}
+			if updatedString.contains("(") {
+				return nil
+			} else {
+				return Parser.parse(string: updatedString)
+			}
+		} else if updatedString.contains(Operators.addOp) || updatedString.contains(Operators.subOp) {
 			let addAll = updatedString.split(separator: Operators.addOp[Operators.addOp.startIndex]).map(String.init)
 			let subMids = addAll.map({string in string.split(separator: Operators.subOp.first!).map(String.init)})
 			return subMids.reduce(Decimal(0) as Expression, {(result: Expression?, next: [String]) -> Expression? in
@@ -122,3 +143,13 @@ extension Decimal: Expression {
 		}
 	}
 }
+
+extension String.StringInterpolation {
+	mutating func appendInterpolation(decimal: Decimal?) {
+		if let d = decimal {
+			self.appendInterpolation(d)
+		} else {
+			self.appendInterpolation("nil")
+		}
+	}
+}