func applyClassTemplate()

in Sources/MockoloFramework/Templates/ClassTemplate.swift [20:102]
74 lines of code
14 McCabe index (conditional complexity)

    func applyClassTemplate(name: String,
                            identifier: String,
                            accessLevel: String,
                            attribute: String,
                            declType: DeclType,
                            metadata: AnnotationMetadata?,
                            useTemplateFunc: Bool,
                            useMockObservable: Bool,
                            allowSetCallCount: Bool,
                            mockFinal: Bool,
                            enableFuncArgsHistory: Bool,
                            disableCombineDefaultValues: Bool,
                            initParamCandidates: [VariableModel],
                            declaredInits: [MethodModel],
                            entities: [(String, Model)]) -> String {

        processCombineAliases(entities: entities)
        
        let acl = accessLevel.isEmpty ? "" : accessLevel + " "
        let typealiases = typealiasWhitelist(in: entities)
        let renderedEntities = entities
            .compactMap { (uniqueId: String, model: Model) -> (String, Int64)? in
                if model.modelType == .typeAlias, let _ = typealiases?[model.name] {
                    // this case will be handlded by typealiasWhitelist look up later
                    return nil
                }
                if model.modelType == .variable, model.name == String.hasBlankInit {
                    return nil
                }
                if model.modelType == .method, model.isInitializer, !model.processed {
                    return nil
                }
                if let ret = model.render(with: uniqueId, encloser: name, useTemplateFunc: useTemplateFunc, useMockObservable: useMockObservable, allowSetCallCount: allowSetCallCount, mockFinal: mockFinal, enableFuncArgsHistory: enableFuncArgsHistory, disableCombineDefaultValues: disableCombineDefaultValues) {
                    return (ret, model.offset)
                }
                return nil
        }
        .sorted { (left: (String, Int64), right: (String, Int64)) -> Bool in
            if left.1 == right.1 {
                return left.0 < right.0
            }
            return left.1 < right.1
        }
        .map {$0.0}
        .joined(separator: "\n")
        
        var typealiasTemplate = ""
        let addAcl = declType == .protocolType ? acl : ""
        if let typealiasWhitelist = typealiases {
            typealiasTemplate = typealiasWhitelist.map { (arg: (key: String, value: [String])) -> String in
                let joinedType = arg.value.sorted().joined(separator: " & ")
                return  "\(1.tab)\(addAcl)\(String.typealias) \(arg.key) = \(joinedType)"
            }.joined(separator: "\n")
        }
        
        var moduleDot = ""
        if let moduleName = metadata?.module, !moduleName.isEmpty {
            moduleDot = moduleName + "."
        }
        
        let extraInits = extraInitsIfNeeded(initParamCandidates: initParamCandidates, declaredInits: declaredInits,  acl: acl, declType: declType, overrides: metadata?.varTypes)

        var body = ""
        if !typealiasTemplate.isEmpty {
            body += "\(typealiasTemplate)\n"
        }
        if !extraInits.isEmpty {
            body += "\(extraInits)\n"
        }
        if !renderedEntities.isEmpty {
            body += "\(renderedEntities)"
        }

        let finalStr = mockFinal ? "\(String.final) " : ""
        let template = """
        \(attribute)
        \(acl)\(finalStr)class \(name): \(moduleDot)\(identifier) {
        \(body)
        }
        """
        
        return template
    }