Modules and hooks in Swift

How do modules (plugins) work?

Would not be cool should you may create objects that would work collectively with out understanding about one another? Think about that you’re constructing a dynamic kind. Based mostly on some inner situations, the fields are going to be composed utilizing the info coming from the enabled modules.

For instance you’ve module A, B, C, the place A is offering you Discipline 1, 2, 3, the B module is caring for Discipline 4, 5 and C is the supplier of Discipline 6. Now should you flip off B, you need to solely have the ability to see subject 1, 2, 3 and 6. If all the pieces is turned on you need to see all of the fields from 1 to six.

We are able to apply this very same sample to many issues. Simply take into consideration one of many largest plugin ecosystem. WordPress is utilizing hooks to increase the core functionalities by means of them. It is all based mostly on the idea I simply talked about above. That is a part of the event-driven structure design sample. Now the query is how will we implement one thing related utilizing Swift? 🤔

A hook system implementation

First we begin with a protocol with a degree of invocation. This methodology might be known as by the module supervisor to invoke the correct hook perform by title. We’ll go round a dictionary of parameters, so our hooks can have arguments. We’re utilizing the Any kind right here as a worth, so you possibly can ship something as a parameter beneath a given key.

protocol Module {
    func invoke(title: String, params: [String: Any]) -> Any?
}

extension Module {
    func invoke(title: String, params: [String: Any]) -> Any? { nil }
}

Now let’s implement our modules utilizing a simplified model based mostly on the shape instance. 🤓

class A: Module {

    func invoke(title: String, params: [String: Any]) -> Any? {
        swap title {
        case "example_form":
            return self.exampleFormHook()
        default:
            return nil
        }
    }

    non-public func exampleFormHook() -> [String] {
        ["Field 1", "Field 2", "Field 3"]
    }
}

class B: Module {
    func invoke(title: String, params: [String: Any]) -> Any? {
        swap title {
        case "example_form":
            return self.exampleFormHook()
        default:
            return nil
        }
    }

    non-public func exampleFormHook() -> [String] {
        ["Field 4", "Field 5"]
    }
}

class C: Module {
    func invoke(title: String, params: [String: Any]) -> Any? {
        swap title {
        case "example_form":
            return self.exampleFormHook()
        default:
            return nil
        }
    }

    non-public func exampleFormHook() -> [String] {
        ["Field 6"]
    }
}

Subsequent we’d like a module supervisor that may be initialized with an array of modules. This supervisor might be liable for calling the suitable invocation methodology on each single module and it will deal with the returned response in a type-safe method. We’ll implement two invoke methodology variations immediately. One for merging the consequence and the opposite to return the primary results of a hook.

You’ll be able to attempt to implement a model that may merge Bool values utilizing the && operator

Right here is our module supervisor implementation with the 2 generic strategies:

struct ModuleManager {

    let  modules: [Module]
    
    func invokeAllHooks<T>(_ title: String, kind: T.Kind, params: [String: Any] = [:]) -> [T] {
        let consequence = self.modules.map { module in
            module.invoke(title: title, params: params)
        }
        return consequence.compactMap { $0 as? [T] }.flatMap { $0 }
    }

    func invokeHook<T>(_ title: String, kind: T.Kind, params: [String: Any] = [:]) -> T? {
        for module in self.modules {
            let consequence = module.invoke(title: title, params: params)
            if consequence != nil {
                return consequence as? T
            }
        }
        return nil
    }
}

You should use the the invokeAllHooks methodology to merge collectively an array of a generic kind. That is the one which we are able to use to assemble all he kind fields utilizing the underlying hook strategies.

let manager1 = ModuleManager(modules: [A(), B(), C()])
let form1 = manager1.invokeAllHooks("example_form", kind: String.self)
print(form1) 

let manager2 = ModuleManager(modules: [A(), C()])
let form2 = manager2.invokeAllHooks("example_form", kind: String.self)
print(form2) 

Utilizing the invokeHook methodology you possibly can obtain an identical habits just like the chain of accountability design sample. The responder chain works very related related, Apple makes use of responders on nearly each platform to deal with UI occasions. Let me present you the way it works by updating module B. 🐝

class B: Module {
    func invoke(title: String, params: [String: Any]) -> Any? {
        swap title {
        case "example_form":
            return self.exampleFormHook()
        case "example_responder":
            return self.exampleResponderHook()
        default:
            return nil
        }
    }

    non-public func exampleFormHook() -> [String] {
        ["Field 4", "Field 5"]
    }
    
    non-public func exampleResponderHook() -> String {
        "Whats up, that is module B."
    }
}

If we set off the brand new example_responder hook with the invokeHook methodology on each managers we’ll see that the result is kind of totally different.

if let worth = manager1.invokeHook("example_responder", kind: String.self) {
    print(worth) 
}

if let worth = manager2.invokeHook("example_responder", kind: String.self) {
    print(worth) 
}

Within the first case, since we’ve got an implementation in considered one of our modules for this hook, the return worth might be current, so we are able to print it. Within the second case there isn’t a module to deal with the occasion, so the block contained in the situation will not be executed. Instructed ya’, it is like a responder chain. 😜

Conclusion

Utilizing modules or plugins is a robust strategy to decouple some elements of the code. I actually love hook features since they’ll present extension factors for nearly something within the utility.

Combine this with a dynamic module loader and you’ve got a fully-extensible next-gen backend resolution on high of Vapor. You’ll be able to have a compiled core system independently from the modules and in a while you possibly can improve just a few elements of the complete stuff with out touching the others. Whops… I simply made that occur and I believe (identical to Swift) it completely rulez. 🤘🏻

I am working exhausting each on my upcoming Sensible server aspect Swift ebook and the open-source weblog engine that is powering this web site for fairly some time now. I used this modular structure loads throughout the creation of my engine. Cannot wait to launch all the pieces and present it to you. 😉