update

optional multitons

Author: saadshams

Sources/PureMVC/core/Controller.swift

@@ -105,13 +105,13 @@ open class Controller: IController {
     - parameter factory: reference that returns `IController`
     - returns: the Multiton instance
     */
-    open class func getInstance(_ key:String, factory: (String) -> IController) -> IController {
+    open class func getInstance(_ key:String, factory: (String) -> IController) -> IController? {
         instanceQueue.sync(flags: .barrier) {
             if instanceMap[key] == nil {
                 instanceMap[key] = factory(key)
             }
         }
-        return instanceMap[key]!
+        return instanceMap[key]
     }
 
     /**

Sources/PureMVC/core/Model.swift

@@ -88,13 +88,13 @@ open class Model: IModel {
     - parameter factory: reference that returns `IModel`
     - returns: the instance returned by the passed closure
     */
-    open class func getInstance(_ key: String, factory: (String) -> IModel) -> IModel {
+    open class func getInstance(_ key: String, factory: (String) -> IModel) -> IModel? {
         instanceQueue.sync(flags: .barrier) {
             if instanceMap[key] == nil {
                 instanceMap[key] = factory(key)
             }
         }
-        return instanceMap[key]!
+        return instanceMap[key]
     }
 
     /**

Sources/PureMVC/core/View.swift

@@ -93,13 +93,13 @@ open class View: IView {
     - parameter factory: reference that returns `IView`
     - returns: the Multiton instance returned by executing the passed closure
     */
-    open class func getInstance(_ key: String, factory: (String) -> IView) -> IView {
+    open class func getInstance(_ key: String, factory: (String) -> IView) -> IView? {
         instanceQueue.sync(flags: .barrier) {
             if instanceMap[key] == nil {
                 instanceMap[key] = factory(key)
             }
         }
-        return instanceMap[key]!
+        return instanceMap[key]
     }
 
     /**

Sources/PureMVC/patterns/command/MacroCommand.swift

@@ -62,7 +62,7 @@ open class MacroCommand: Notifier, ICommand {
         public func addSubCommand(closure: () -> ICommand) {
             addSubCommand( { FirstCommand() } );
             addSubCommand( { SecondCommand() } );
-            addSubCommand( ) { ThirdCommand() }; //or by using a trailing closure
+            addSubCommand { ThirdCommand() }; // or by using a trailing closure
         }
 
     Note that *SubCommands* may be any closure returning `ICommand`

Sources/PureMVC/patterns/facade/Facade.swift

@@ -80,13 +80,13 @@ open class Facade: IFacade {
     - parameter factory: reference that returns `IFacade`
     - returns: the Multiton instance of the `IFacade`
     */
-    open class func getInstance(_ key: String, factory: (String) -> IFacade) -> IFacade {
+    open class func getInstance(_ key: String, factory: (String) -> IFacade) -> IFacade? {
         instanceMapQueue.sync(flags: .barrier) {
             if instanceMap[key] == nil {
                 instanceMap[key] = factory(key)
             }
         }
-        return instanceMap[key]!
+        return instanceMap[key]
     }
 
     /**

Sources/PureMVC/patterns/mediator/Mediator.swift

@@ -34,7 +34,7 @@ open class Mediator: Notifier, IMediator {
     - parameter name: the mediator name
     - parameter viewComponent: viewComponent instance
     */
-    public init(name: String?=nil, viewComponent: AnyObject?=nil) {
+    public init(name: String? = nil, viewComponent: AnyObject? = nil) {
         self.name = name ?? Mediator.NAME
         self.viewComponent = viewComponent
     }

Sources/PureMVC/patterns/observer/Notifier.swift

@@ -51,7 +51,7 @@ open class Notifier : INotifier {
     internal var multitonKey: String?
 
     /// Reference to the Facade Multiton
-    open lazy var facade:IFacade = {
+    open lazy var facade: IFacade? = {
         assert(multitonKey != nil, Notifier.MULTITON_MSG)
 
         // returns instance mapped to multitonKey if it exists otherwise defaults to Facade
@@ -74,7 +74,7 @@ open class Notifier : INotifier {
     - parameter type: the type of the notification (optional)
     */
     open func sendNotification(_ notificationName: String, body: Any, type: String) {
-        facade.sendNotification(notificationName, body: body, type: type)
+        facade?.sendNotification(notificationName, body: body, type: type)
     }
 
     /**
@@ -87,7 +87,7 @@ open class Notifier : INotifier {
     - parameter body: the body of the notification (optional)
     */
     open func sendNotification(_ notificationName: String, body: Any) {
-        facade.sendNotification(notificationName, body: body)
+        facade?.sendNotification(notificationName, body: body)
     }
 
     /**
@@ -99,7 +99,7 @@ open class Notifier : INotifier {
     - parameter notificationName: the name of the notification to send
     */
     open func sendNotification(_ notificationName: String) {
-        facade.sendNotification(notificationName)
+        facade?.sendNotification(notificationName)
     }
 
     /**

Sources/PureMVC/patterns/proxy/Proxy.swift

@@ -36,7 +36,7 @@ open class Proxy: Notifier, IProxy {
     public var data: Any?
 
     /// Constructor
-    public init(name: String?=nil, data: Any?=nil) {
+    public init(name: String? = nil, data: Any? = nil) {
         self.name = name ?? Proxy.NAME
         self.data = data
     }

Tests/PureMVCTests/core/ControllerExtend.swift

@@ -16,7 +16,7 @@ public class ControllerExtend: Controller {
         view = View.getInstance(multitonKey) { key in ViewExtend(key: key) }
     }
 
-    public class func getInstance(key: String) -> IController {
+    public class func getInstance(key: String) -> IController? {
         return Controller.getInstance(key) { key in ControllerExtend(key: key) }
     }
 

Tests/PureMVCTests/core/ControllerTest.swift

@@ -33,7 +33,7 @@ class ControllerTest: XCTestCase {
     */
     func testGetInstance() {
         // Test Factory Method
-        let controller: IController = Controller.getInstance("ControllerTestKey1") { key in Controller(key: key) }
+        let controller: IController? = Controller.getInstance("ControllerTestKey1") { key in Controller(key: key) }
 
         // test assertions
         XCTAssertNotNil(controller as? Controller, "Expecting instance not nil")
@@ -54,8 +54,8 @@ class ControllerTest: XCTestCase {
     */
     func testRegisterAndExecuteCommand() {
         // Create the controller, register the ControllerTestCommand to handle 'ControllerTest' notes
-        let controller: IController = Controller.getInstance("ControllerTestKey1") { key in Controller(key: key) }
-        controller.registerCommand("ControllerTest", factory: {ControllerTestCommand()})
+        let controller: IController? = Controller.getInstance("ControllerTestKey1") { key in Controller(key: key) }
+        controller?.registerCommand("ControllerTest", factory: {ControllerTestCommand()})
 
         // Create a 'ControllerTest' note
         let vo: ControllerTestVO = ControllerTestVO(input: 12)
@@ -64,7 +64,7 @@ class ControllerTest: XCTestCase {
         // Tell the controller to execute the Command associated with the note
         // the ControllerTestCommand invoked will multiply the vo.input value
         // by 2 and set the result on vo.result
-        controller.executeCommand(note)
+        controller?.executeCommand(note)
 
         // test assertions
         XCTAssertTrue(vo.result == 24, "Expecting vo.result == 24")
@@ -79,8 +79,8 @@ class ControllerTest: XCTestCase {
     */
     func testRegisterAndRemoveCommand() {
         // Create the controller, register the ControllerTestCommand to handle 'ControllerTest' notes
-        let controller: IController = Controller.getInstance("ControllerTestKey3") { key in Controller(key: key) }
-        controller.registerCommand("ControllerRemoveTest", factory: {ControllerTestCommand()})
+        let controller: IController? = Controller.getInstance("ControllerTestKey3") { key in Controller(key: key) }
+        controller?.registerCommand("ControllerRemoveTest", factory: {ControllerTestCommand()})
 
         // Create a 'ControllerTest' note
         let vo = ControllerTestVO(input: 12)
@@ -89,7 +89,7 @@ class ControllerTest: XCTestCase {
         // Tell the controller to execute the Command associated with the note
         // the ControllerTestCommand invoked will multiply the vo.input value
         // by 2 and set the result on vo.result
-        controller.executeCommand(note)
+        controller?.executeCommand(note)
 
         // test assertions
         XCTAssertTrue(vo.result == 24, "Expecting vo.result == 24")
@@ -98,12 +98,12 @@ class ControllerTest: XCTestCase {
         vo.result = 0
 
         // Remove the Command from the Controller
-        controller.removeCommand("ControllerRemoveTest")
+        controller?.removeCommand("ControllerRemoveTest")
 
         // Tell the controller to execute the Command associated with the
         // note. This time, it should not be registered, and our vo result
         // will not change
-        controller.executeCommand(note)
+        controller?.executeCommand(note)
 
         // test assertions
         XCTAssertTrue(vo.result == 0, "Expecting vo.result == 0")
@@ -115,16 +115,16 @@ class ControllerTest: XCTestCase {
     func testHasCommand() {
         // register the ControllerTestCommand to handle 'hasCommandTest' notes
         let controller = Controller.getInstance("ControllerTestKey4") { key in Controller(key: key) }
-        controller.registerCommand("hasCommandTest", factory: {ControllerTestCommand()})
+        controller?.registerCommand("hasCommandTest", factory: {ControllerTestCommand()})
 
         // test that hasCommand returns true for hasCommandTest notifications
-        XCTAssertTrue(controller.hasCommand("hasCommandTest"), "Expecting controller.hasCommand('hasCommandTest') == true")
+        XCTAssertTrue(controller?.hasCommand("hasCommandTest") == true, "Expecting controller.hasCommand('hasCommandTest') == true")
 
         // Remove the Command from the Controller
-        controller.removeCommand("hasCommandTest")
+        controller?.removeCommand("hasCommandTest")
 
         // test that hasCommand returns false for hasCommandTest notifications
-        XCTAssertTrue(controller.hasCommand("hasCommandTest") == false, "Expecting controller.hasCommand('hasCommandTest') == false")
+        XCTAssertTrue(controller?.hasCommand("hasCommandTest") == false, "Expecting controller.hasCommand('hasCommandTest') == false")
     }
 
     /**
@@ -141,13 +141,13 @@ class ControllerTest: XCTestCase {
     func testReregisterAndExecuteCommand() {
         // Fetch the controller, register the ControllerTestCommand2 to handle 'ControllerTest2' notes
         let controller = Controller.getInstance("ControllerTestKey5") { key in Controller(key: key) }
-        controller.registerCommand("ControllerTest2", factory: {ControllerTestCommand2()})
+        controller?.registerCommand("ControllerTest2", factory: {ControllerTestCommand2()})
 
         // Remove the Command from the Controller
-        controller.removeCommand("ControllerTest2")
+        controller?.removeCommand("ControllerTest2")
 
         // Re-register the Command with the Controller
-        controller.registerCommand("ControllerTest2", factory: {ControllerTestCommand2()})
+        controller?.registerCommand("ControllerTest2", factory: {ControllerTestCommand2()})
 
         // Create a 'ControllerTest2' note
         let vo = ControllerTestVO(input: 12)
@@ -157,14 +157,14 @@ class ControllerTest: XCTestCase {
         let view = View.getInstance("ControllerTestKey5") { key in View(key: key) }
 
         // send the Notification
-        view.notifyObservers(note)
+        view?.notifyObservers(note)
 
         // test assertions
         // if the command is executed once the value will be 24
         XCTAssertTrue(vo.result == 24, "Expecting vo.result == 24")
 
         // Prove that accumulation works in the VO by sending the notification again
-        view.notifyObservers(note)
+        view?.notifyObservers(note)
 
         // if the command is executed twice the value will be 48
         XCTAssertTrue(vo.result == 48, "Expecting vo.result == 48")

Tests/PureMVCTests/core/ModelExtend.swift

@@ -12,7 +12,7 @@ public class ModelExtend: Model {
 
     public var resource: Resource?
 
-    public class func getInstance(key: String) -> IModel {
+    public class func getInstance(key: String) -> IModel? {
         return Model.getInstance(key) { key in ModelExtend(key: key) }
     }
 

Tests/PureMVCTests/core/ModelTest.swift

@@ -26,7 +26,7 @@ class ModelTest: XCTestCase {
 
     func testGetInstance() {
         // Test Factory Method
-        let model: IModel = Model.getInstance("ModelTestKey4") { key in Model(key: key) }
+        let model: IModel? = Model.getInstance("ModelTestKey4") { key in Model(key: key) }
 
         // test assertions
         XCTAssertNotNil(model as? Model, "Expecting instance not null")
@@ -42,9 +42,9 @@ class ModelTest: XCTestCase {
     */
     func testRegisterAndRetrieveProxy() {
         // register a proxy and retrieve it.
-        let model: IModel = Model.getInstance("ModelTestKey2") { key in Model(key: key) }
-        model.registerProxy(Proxy(name: "colors", data: ["red", "green", "blue"]))
-        let proxy: Proxy = model.retrieveProxy("colors") as! Proxy
+        let model: IModel? = Model.getInstance("ModelTestKey2") { key in Model(key: key) }
+        model?.registerProxy(Proxy(name: "colors", data: ["red", "green", "blue"]))
+        let proxy: Proxy = model?.retrieveProxy("colors") as! Proxy
         let data: Array<String> = proxy.data as! Array<String>
 
         // test assertions
@@ -57,10 +57,10 @@ class ModelTest: XCTestCase {
 
     //Test with tuple
     func testRegisterAndRetrieveProxy2() {
-        let model: IModel = Model.getInstance("ModelTestKey2") { key in Model(key: key) }
-        model.registerProxy(Proxy(name: "tuple", data: (1, "abc", false)))
+        let model: IModel? = Model.getInstance("ModelTestKey2") { key in Model(key: key) }
+        model?.registerProxy(Proxy(name: "tuple", data: (1, "abc", false)))
 
-        let proxy: Proxy = model.retrieveProxy("tuple") as! Proxy
+        let proxy: Proxy = model?.retrieveProxy("tuple") as! Proxy
         let data: (Int, String, Bool)  = proxy.data as! (Int, String, Bool)
 
         XCTAssertTrue(data.0 == 1, "Expecting data.0 == 1")
@@ -73,18 +73,18 @@ class ModelTest: XCTestCase {
     */
     func testRegisterAndRemoveProxy() {
         // register a proxy, remove it, then try to retrieve it
-        let model: IModel = Model.getInstance("ModelTestKey3") { key in Model(key: key) }
+        let model: IModel? = Model.getInstance("ModelTestKey3") { key in Model(key: key) }
         let proxy: IProxy = Proxy(name: "sizes", data: ["7", "13", "21"])
-        model.registerProxy(proxy)
+        model?.registerProxy(proxy)
 
         // remove the proxy
-        let removedProxy = model.removeProxy("sizes")
+        let removedProxy = model?.removeProxy("sizes")
 
         // assert that we removed the appropriate proxy
         XCTAssertTrue(removedProxy!.name == "sizes", "Expecting removedProxy.getProxyName() == 'sizes'")
 
         // ensure that the proxy is no longer retrievable from the model
-        let nilProxy = model.retrieveProxy("sizes")
+        let nilProxy = model?.retrieveProxy("sizes")
 
         // test assertions
         XCTAssertTrue(nilProxy == nil, "Expecting proxy is nil")
@@ -95,38 +95,38 @@ class ModelTest: XCTestCase {
     */
     func testHasProxy() {
         // register a proxy
-        let model: IModel = Model.getInstance("ModelTestKey4") { key in Model(key: key) }
+        let model: IModel? = Model.getInstance("ModelTestKey4") { key in Model(key: key) }
         let proxy: IProxy = Proxy(name: "aces", data: ["clubs", "spades", "hearts", "diamonds"])
-        model.registerProxy(proxy)
+        model?.registerProxy(proxy)
 
         // assert that the model.hasProxy method returns true
         // for that proxy name
-        XCTAssertTrue(model.hasProxy("aces"), "Expecting model.hasProxy('aces') == true")
+        XCTAssertTrue(model?.hasProxy("aces") == true, "Expecting model.hasProxy('aces') == true")
 
         // remove the proxy
-        _ = model.removeProxy("aces")
+        _ = model?.removeProxy("aces")
 
         // assert that the model.hasProxy method returns false
         // for that proxy name
-        XCTAssertTrue(model.hasProxy("aces") == false, "Expecting model.hasProxy('aces') == false")
+        XCTAssertTrue(model?.hasProxy("aces") == false, "Expecting model.hasProxy('aces') == false")
     }
 
     /**
     Tests that the Model calls the onRegister and onRemove methods
     */
     func testOnRegisterAndOnRemove() {
         // Get a Multiton View instance
-        let model: IModel = Model.getInstance("ModelTestKey4") { key in Model(key: key) }
+        let model: IModel? = Model.getInstance("ModelTestKey4") { key in Model(key: key) }
 
         // Create and register the test mediator
         let proxy: IProxy = ModelTestProxy()
-        model.registerProxy(proxy)
+        model?.registerProxy(proxy)
 
         // assert that onRegsiter was called, and the proxy responded by setting its data accordingly
         XCTAssertTrue((proxy.data as! String) == ModelTestProxy.ON_REGISTER_CALLED, "Expecting proxy.data == ModelTestProxy.ON_REGISTER_CALLED")
 
         // Remove the component
-        _ = model.removeProxy(ModelTestProxy.NAME)
+        _ = model?.removeProxy(ModelTestProxy.NAME)
 
         // assert that onRemove was called, and the proxy responded by setting its data accordingly
         XCTAssertTrue((proxy.data as! String) == ModelTestProxy.ON_REMOVE_CALLED, "Expecting proxy.data == ModelTestProxy.ON_REMOVE_CALLED \(String(describing: proxy.data))")

Tests/PureMVCTests/core/ViewExtend.swift

@@ -12,7 +12,7 @@ public class ViewExtend: View {
 
     public var resource: Resource?
 
-    public class func getInstance(key: String) -> IView {
+    public class func getInstance(key: String) -> IView? {
         return View.getInstance(key) { key in ViewExtend(key: key) }
     }