func applyNominalTemplate()

in Sources/MockoloFramework/Templates/NominalTemplate.swift [20:106]
78 lines of code
13 McCabe index (conditional complexity)

    func applyNominalTemplate(name: String,
                              accessLevel: String,
                              attribute: String,
                              arguments: GenerationArguments,
                              initParamCandidates: [VariableModel],
                              declaredInits: [MethodModel],
                              entities: [(String, Model)]) -> String {

        processCombineAliases(entities: entities)
        
        let acl = accessLevel.isEmpty ? "" : accessLevel + " "

        let (aliasItems,
             typeparameters,
             whereClauses,
             renderedModelNames) = processAssociatedTypes(in: entities, acl: acl)
        let renderedEntities = entities
            .compactMap { (uniqueId: String, model: Model) -> String? in
                if model is TypealiasRenderableModel && renderedModelNames.contains(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, let model = model as? MethodModel, model.isInitializer, !model.processed {
                    return nil
                }

                return model.render(
                    context: .init(
                        overloadingResolvedName: uniqueId,
                        enclosingType: type,
                        annotatedTypeKind: declKindOfMockAnnotatedBaseType,
                        requiresSendable: requiresSendable
                    ),
                    arguments: arguments
                )
            }
            .joined(separator: "\n")

        let extraInits = extraInitsIfNeeded(
            initParamCandidates: initParamCandidates,
            declaredInits: declaredInits,
            acl: acl,
            declKindOfMockAnnotatedBaseType: declKindOfMockAnnotatedBaseType,
            context: .init(
                enclosingType: type,
                annotatedTypeKind: declKindOfMockAnnotatedBaseType,
                requiresSendable: requiresSendable
            ),
            arguments: arguments
        )

        var body = ""
        if !extraInits.isEmpty {
            body += "\(extraInits)\n"
        }
        if !aliasItems.isEmpty {
            body += "\(aliasItems)\n"
        }
        if !renderedEntities.isEmpty {
            body += "\(renderedEntities)"
        }
        var uncheckedSendableStr = ""
        if requiresSendable {
            uncheckedSendableStr = ", @unchecked Sendable"
        }

        let finalStr = arguments.mockFinal || requiresSendable ? String.final.withSpace : ""
        let template = """
        \(attribute)
        \(acl)\(finalStr)\(declKind.rawValue) \(name)\(typeparameters): \(inheritedTypeName)\(uncheckedSendableStr) \(whereClauses){
        \(body)
        }
        """

        if namespaces.isEmpty {
            return template
        } else {
            return """
            extension \(namespaces.joined(separator: ".")) {
            \(template.addingIndent(1))
            }
            """
        }
    }