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 figuring out about one another? Think about that you’re constructing a dynamic type. Primarily based on some inner circumstances, the fields are going to be composed utilizing the information coming from the enabled modules.

For instance you could have module A, B, C, the place A is offering you Area 1, 2, 3, the B module is taking good care of Area 4, 5 and C is the supplier of Area 6. Now should you flip off B, you must solely have the ability to see subject 1, 2, 3 and 6. If all the things is turned on you must see all of the fields from 1 to six.

We will 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 functinalities by way 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 can we implement one thing related utilizing Swift? 🤔

A hook system implementation

First we begin with a protocol with some extent of invocation. This technique might be referred to as by the module supervisor to invoke the correct hook operate by identify. 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(identify: String, params: [String: Any]) -> Any?
}

extension Module {
    func invoke(identify: 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(identify: String, params: [String: Any]) -> Any? {
        change identify {
        case "example_form":
            return self.exampleFormHook()
        default:
            return nil
        }
    }

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

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

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

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

    personal 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 fitting invocation technique on each single module and it will deal with the returned response in a type-safe method. We’ll implement two invoke technique variations immediately. One for merging the outcome 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>(_ identify: String, kind: T.Kind, params: [String: Any] = [:]) -> [T] {
        let outcome = self.modules.map { module in
            module.invoke(identify: identify, params: params)
        }
        return outcome.compactMap { $0 as? [T] }.flatMap { $0 }
    }

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

You should utilize the the invokeAllHooks technique to merge collectively an array of a generic kind. That is the one which we are able to use to assemble all he type 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 technique you possibly can obtain an identical habits just like the chain of duty design sample. The responder chain works very related similiar, Apple makes use of responders on virtually each platform to deal with UI occasions. Let me present you the way it works by updating module B. 🐝

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

    personal func exampleFormHook() -> [String] {
        ["Field 4", "Field 5"]
    }
    
    personal func exampleResponderHook() -> String {
        "Good day, that is module B."
    }
}

If we set off the brand new example_responder hook with the invokeHook technique on each managers we’ll see that the end result is kind of completely 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 now we have an implementation in one in every 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. Advised ya’, it is like a responder chain. 😜