Merge pull request #6 from jasl/octwu/refactor_api

refactor router api

Author: jasl

Demo.playground/Contents.swift

@@ -2,7 +2,6 @@
 
 import Foundation
 import RouterX
-
 //: Here I define some pattern
 
 let pattern1 = "/articles(/page/:page(/per_page/:per_page))(/sort/:sort)(.:format)"
@@ -13,34 +12,37 @@ let pattern4 = "/:article_id"
 //: Initialize the router, I can give a default closure to handle while given a URI path but match no one.
 
 // This is the handler that would be performed after no pattern match
-let defaultUnmatchHandler = { (url: URL, context: AnyObject?) -> Void in
-  // Do something here, e.g: give some tips or show a default UI
-  print("\(url) is unmatched.")
-
-  // context can be provided on matching patterns
-  if let context = context as? String {
-    print("Context is \"\(context)\"")
-  }
+let defaultUnmatchHandler: Router<Any>.UnmatchHandler = { url, context in
+    // Do something here, e.g: give some tips or show a default UI
+    print("Default unmatch handler")
+    print("\(url) is unmatched")
+
+    // context can be provided on matching patterns
+    if let context = context as? String {
+        print("Context is \"\(context)\"")
+    }
+    print("\n")
 }
 
 // Initialize a router instance, consider it's global and singleton
-let router = Router(defaultUnmatchHandler: defaultUnmatchHandler)
+// Router.T is used for specifying context type
+let router = Router<Any>(defaultUnmatchHandler: defaultUnmatchHandler)
 
 //: Register patterns, the closure is the handle when matched the pattern.
 
 // Set a route pattern, the closure is a handler that would be performed after match the pattern
-router.register(pattern: pattern1) { (url, parameters, context) in
-  // Do something here, e.g: show a UI
-  var string = "URL is \(url), parameter is \(parameters)"
-  if let context = context as? String {
-    string += " Context is \"\(context)\""
-  }
-  print(string)
+router.register(pattern: pattern1) { result in
+    // Now, registered pattern has been matched
+    // Do anything you want, e.g: show a UI
+    print(result)
+    print("\n")
+
 }
 
-router.register(pattern: pattern2) { _, _, _  in
-  // Do something here, e.g: show a UI
-  print("call new article")
+router.register(pattern: pattern2) { _ in
+    // Now, registered pattern has been matched
+    // Do anything you want, e.g: show a UI
+    print("call new article")
 }
 
 //: Let match some URI Path.
@@ -49,24 +51,25 @@ router.register(pattern: pattern2) { _, _, _  in
 let path1 = "/articles/page/2/sort/recent.json?foo=bar&baz"
 
 // It's will be matched, and perform the handler that we have set up.
-router.match(urlPath: path1)
+router.match(path1)
 // It can pass the context for handler
-router.match(urlPath: path1, context: "fooo" as AnyObject?)
+router.match(path1, context: "fooo")
 
 // A case that shouldn't be matched
 let path2 = "/articles/2/edit"
 
-let customUnmatchHandler: UnmatchRouteHandler = { (url, context) in
-  var string = "\(url) is no match..."
-  // context can be provided on matching patterns
-  if let context = context as? String {
-    string += "Context is \"\(context)\""
-  }
+let customUnmatchHandler: Router<Any>.UnmatchHandler = { (url, context) in
+    print("This is custom unmatch handler")
+    var string = "\(url) is no match..."
+    // context can be provided on matching patterns
+    if let context = context as? String {
+        string += "\nContext is \"\(context)\""
+    }
 
-  print(string)
+    print(string)
 }
 // It's will not be matched, and perform the default unmatch handler that we have set up
-router.match(urlPath: path2)
+router.match(path2)
 
 // It can provide a custome unmatch handler to override the default, also can pass the context
-router.match(urlPath: path2, context: "bar" as AnyObject?, unmatchHandler: customUnmatchHandler)
+router.match(path2, context: "bar", unmatchHandler: customUnmatchHandler)

RouterX.xcodeproj/project.pbxproj

@@ -21,6 +21,7 @@
 /* End PBXAggregateTarget section */
 
 /* Begin PBXBuildFile section */
+		48E62CA721A695000005838B /* MatchResult.swift in Sources */ = {isa = PBXBuildFile; fileRef = 48E62CA621A695000005838B /* MatchResult.swift */; };
 		OBJ_35 /* Router.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_9 /* Router.swift */; };
 		OBJ_36 /* RouterXCore.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_10 /* RouterXCore.swift */; };
 		OBJ_37 /* RoutingGraph.swift in Sources */ = {isa = PBXBuildFile; fileRef = OBJ_11 /* RoutingGraph.swift */; };
@@ -57,6 +58,7 @@
 /* End PBXContainerItemProxy section */
 
 /* Begin PBXFileReference section */
+		48E62CA621A695000005838B /* MatchResult.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MatchResult.swift; sourceTree = "<group>"; };
 		OBJ_10 /* RouterXCore.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RouterXCore.swift; sourceTree = "<group>"; };
 		OBJ_11 /* RoutingGraph.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RoutingGraph.swift; sourceTree = "<group>"; };
 		OBJ_12 /* RoutingPatternParser.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RoutingPatternParser.swift; sourceTree = "<group>"; };
@@ -156,6 +158,7 @@
 			isa = PBXGroup;
 			children = (
 				OBJ_9 /* Router.swift */,
+				48E62CA621A695000005838B /* MatchResult.swift */,
 				OBJ_10 /* RouterXCore.swift */,
 				OBJ_11 /* RoutingGraph.swift */,
 				OBJ_12 /* RoutingPatternParser.swift */,
@@ -252,6 +255,7 @@
 			buildActionMask = 0;
 			files = (
 				OBJ_35 /* Router.swift in Sources */,
+				48E62CA721A695000005838B /* MatchResult.swift in Sources */,
 				OBJ_36 /* RouterXCore.swift in Sources */,
 				OBJ_37 /* RoutingGraph.swift in Sources */,
 				OBJ_38 /* RoutingPatternParser.swift in Sources */,

Sources/RouterX/MatchResult.swift

@@ -0,0 +1,21 @@
+import Foundation
+
+public struct MatchResult<Context>: CustomDebugStringConvertible, CustomStringConvertible {
+    public let url: URL
+    public let parameters: [String: String]
+    public let context: Context?
+
+    public var description: String {
+        return """
+        MatchResult<\(Context.self)> {
+        url: \(url)
+        parameters: \(parameters)
+        context: \(String(describing: context))
+        }
+        """
+    }
+
+    public var debugDescription: String {
+        return description
+    }
+}

Sources/RouterX/Router.swift

@@ -1,44 +1,46 @@
 import Foundation
 
-public typealias MatchRouteHandler = ((URL, _ parameters: [String: String], _ context: AnyObject?) -> Void)
-public typealias UnmatchRouteHandler = ((URL, _ context: AnyObject?) -> Void)
+open class Router<Context> {
+
+    public typealias MatchedHandler = (MatchResult<Context>) -> Void
+    public typealias UnmatchHandler = ((URL, _ context: Context?) -> Void)
 
-open class Router {
     private let core: RouterXCore = RouterXCore()
-    private let defaultUnmatchHandler: UnmatchRouteHandler?
+    private let defaultUnmatchHandler: UnmatchHandler?
 
-    private var handlerMappings: [PatternIdentifier: MatchRouteHandler] = [:]
+    private var handlerMappings: [PatternIdentifier: MatchedHandler] = [:]
 
-    public init(defaultUnmatchHandler: UnmatchRouteHandler? = nil) {
+    public init(defaultUnmatchHandler: UnmatchHandler? = nil) {
         self.defaultUnmatchHandler = defaultUnmatchHandler
     }
 
-    open func register(pattern: String, handler: @escaping MatchRouteHandler) -> Bool {
-        let patternIdentifier = pattern.hashValue
-        if self.core.registerRoutingPattern(pattern, patternIdentifier: patternIdentifier) {
-            self.handlerMappings[patternIdentifier] = handler
-
+    open func register(pattern: String, handler: @escaping MatchedHandler) -> Bool {
+        if self.core.registerRoutingPattern(pattern) {
+            self.handlerMappings[pattern] = handler
             return true
         } else {
             return false
         }
     }
 
-    open func match(url: URL, context: AnyObject? = nil, unmatchHandler: UnmatchRouteHandler? = nil) -> Bool {
+    @discardableResult
+    open func match(_ url: URL, context: Context? = nil, unmatchHandler: UnmatchHandler? = nil) -> Bool {
         guard let matchedRoute = core.matchURL(url),
-        let matchHandler = handlerMappings[matchedRoute.patternIdentifier] else {
-            let expectUnmatchHandler = unmatchHandler ?? defaultUnmatchHandler
-            expectUnmatchHandler?(url, context)
-            return false
+            let matchHandler = handlerMappings[matchedRoute.patternIdentifier] else {
+                let expectUnmatchHandler = unmatchHandler ?? defaultUnmatchHandler
+                expectUnmatchHandler?(url, context)
+                return false
         }
 
-        matchHandler(url, matchedRoute.parametars, context)
+        let result = MatchResult<Context>(url: url, parameters: matchedRoute.parametars, context: context)
+        matchHandler(result)
         return true
     }
 
-    open func match(urlPath: String, context: AnyObject? = nil, unmatchHandler: UnmatchRouteHandler? = nil) -> Bool {
-        guard let url = URL(string: urlPath) else { return false }
+    @discardableResult
+    open func match(_ path: String, context: Context? = nil, unmatchHandler: UnmatchHandler? = nil) -> Bool {
+        guard let url = URL(string: path) else { return false }
 
-        return match(url: url, context: context, unmatchHandler: unmatchHandler)
+        return match(url, context: context, unmatchHandler: unmatchHandler)
     }
 }

Sources/RouterX/RouterXCore.swift

@@ -12,25 +12,25 @@ public struct MatchedRoute {
     }
 }
 
-open class RouterXCore {
+public class RouterXCore {
     private let rootRoute: RouteVertex
 
     public init() {
         self.rootRoute = RouteVertex()
     }
 
-    open func registerRoutingPattern(_ pattern: String, patternIdentifier: PatternIdentifier) -> Bool {
+    public func registerRoutingPattern(_ pattern: String) -> Bool {
         let tokens = RoutingPatternScanner.tokenize(pattern)
 
         do {
-            try RoutingPatternParser.parseAndAppendTo(self.rootRoute, routingPatternTokens: tokens, patternIdentifier: patternIdentifier)
+            try RoutingPatternParser.parseAndAppendTo(self.rootRoute, routingPatternTokens: tokens, patternIdentifier: pattern)
             return true
         } catch {
             return false
         }
     }
 
-    open func matchURL(_ url: URL) -> MatchedRoute? {
+    public func matchURL(_ url: URL) -> MatchedRoute? {
         let path = url.path
 
         let tokens = URLPathScanner.tokenize(path)
@@ -52,13 +52,13 @@ open class RouterXCore {
                 return nil
             }
         }
-        
+
         guard let pathPatternIdentifier = targetRoute.patternIdentifier else { return nil }
 
         return MatchedRoute(url: url, parameters: parameters, patternIdentifier: pathPatternIdentifier)
     }
 
-    open func matchURLPath(_ urlPath: String) -> MatchedRoute? {
+    public func matchURLPath(_ urlPath: String) -> MatchedRoute? {
         guard let url = URL(string: urlPath) else { return nil }
         return matchURL(url)
     }

Sources/RouterX/RoutingGraph.swift

@@ -1,15 +1,15 @@
 import Foundation
 
-public typealias PatternIdentifier = Int
+public typealias PatternIdentifier = String
 
-public enum RouteEdge {
+internal enum RouteEdge {
     case dot
     case slash
     case literal(String)
 }
 
 extension RouteEdge: Hashable, CustomDebugStringConvertible, CustomStringConvertible {
-    public var description: String {
+    var description: String {
         switch self {
         case .literal(let value):
             return value
@@ -20,29 +20,29 @@ extension RouteEdge: Hashable, CustomDebugStringConvertible, CustomStringConvert
         }
     }
 
-    public var debugDescription: String {
+    var debugDescription: String {
         return self.description
     }
 
-    public func hash(into hasher: inout Hasher) {
+    func hash(into hasher: inout Hasher) {
         hasher.combine(description)
     }
 }
 
-open class RouteVertex {
-    open var nextRoutes: [RouteEdge: RouteVertex] = [:]
-    open var epsilonRoute: (String, RouteVertex)?
-    open var patternIdentifier: PatternIdentifier?
+internal class RouteVertex {
+    var nextRoutes: [RouteEdge: RouteVertex] = [:]
+    var epsilonRoute: (String, RouteVertex)?
+    var patternIdentifier: PatternIdentifier?
 
-    public init(patternIdentifier: PatternIdentifier? = nil) {
+    init(patternIdentifier: PatternIdentifier? = nil) {
         self.patternIdentifier = patternIdentifier
     }
 
-    open var isTerminal: Bool {
+    var isTerminal: Bool {
         return self.patternIdentifier != nil
     }
 
-    open var isFinale: Bool {
+    var isFinale: Bool {
         return self.nextRoutes.isEmpty && self.epsilonRoute == nil
     }
 }