func render()

in Sources/MockoloFramework/Templates/MethodTemplate.swift [52:151]
90 lines of code
15 McCabe index (conditional complexity)

        func render() -> String {
            let body: String
            if arguments.useTemplateFunc
                && !model.throwing.hasError
                && (handler.type(enclosingType: enclosingType, requiresSendable: context.requiresSendable).cast == nil) {
                let handlerParamValsStr = model.params.map { (arg) -> String in
                    if arg.type.typeName.hasPrefix(String.autoclosure) {
                        return arg.name.safeName + "()"
                    }
                    return arg.name.safeName
                }.joined(separator: ", ")

                let defaultVal = model.returnType?.defaultVal()

                var mockReturn = ".error"
                if model.returnType?.isVoid ?? true {
                    mockReturn = ".void"
                } else if let val = defaultVal {
                    mockReturn = ".val(\(val))"
                }

                body = """
                \(2.tab)mockFunc(&\(callCountVarName))(\"\(model.name)\", \(handlerVarName)?(\(handlerParamValsStr)), \(mockReturn))
                """
            } else {
                let handlerReturn = handler.render(context: context, arguments: arguments)

                if context.requiresSendable {
                    let paramNamesStr: String?
                    if let argsHistory = model.argsHistory, argsHistory.enable(force: arguments.enableFuncArgsHistory) {
                        paramNamesStr = argsHistory.capturableParamLabels.joined(separator: ", ")
                    } else {
                        paramNamesStr = nil
                    }
                    body = [
                        paramNamesStr.map { "\(2.tab)warnIfNotSendable(\($0))" },
                        "\(2.tab)let \(handlerVarName) = \(stateVarName).withLock { state in",
                        "\(3.tab)state.callCount += 1",
                        paramNamesStr.map { "\(3.tab)state.argValues.append(.init((\($0))))" },
                        "\(3.tab)return state.handler",
                        "\(2.tab)}",
                        handlerReturn,
                    ].compactMap { $0 }.joined(separator: "\n")
                } else {
                    let argsHistoryCaptureCall: String?
                    if let argsHistory = model.argsHistory, argsHistory.enable(force: arguments.enableFuncArgsHistory) {
                        let argsHistoryCapture = argsHistory.render(context: context, arguments: arguments) ?? ""
                        argsHistoryCaptureCall = argsHistoryCapture
                    } else {
                        argsHistoryCaptureCall = nil
                    }

                    body = [
                        "\(2.tab)\(callCountVarName) += 1",
                        argsHistoryCaptureCall.map { "\(2.tab)\($0)" },
                        handlerReturn,
                    ].compactMap { $0 }.joined(separator: "\n")
                }
            }

            let wrapped = model.isSubscript ? """
            \(2.tab)get {
            \(body)
            \(2.tab)}
            \(2.tab)set { }
            """ : body

            let overrideStr = isOverride ? String.override.withSpace : ""
            let modifierTypeStr: String
            if let customModifier: Modifier = model.customModifiers[model.name] {
                modifierTypeStr = customModifier.rawValue + " "
            } else {
                modifierTypeStr = ""
            }

            let keyword = model.isSubscript ? "" : "func "
            let genericTypeDeclsStr = model.genericTypeParams.render(context: context, arguments: arguments)
            let genericTypesStr = genericTypeDeclsStr.isEmpty ? "" : "<\(genericTypeDeclsStr)>"
            let paramDeclsStr = model.params.render(context: context, arguments: arguments)
            let suffixStr = applyFunctionSuffixTemplate(
                isAsync: model.isAsync,
                throwing: model.throwing
            )
            let genericWhereStr = model.genericWhereClause.map { "\($0) " } ?? ""

            let functionDecl = """
            \(1.tab)\(declModifiers)\(overrideStr)\(modifierTypeStr)\(keyword)\(model.name)\(genericTypesStr)(\(paramDeclsStr)) \(suffixStr)\(returnClause)\(genericWhereStr){
            \(wrapped)
            \(1.tab)}
            """

            let decls: [String?] = [
                stateVarDecl,
                callCountVarDecl,
                argsHistoryVarDecl,
                handlerVarDecl,
                functionDecl,
            ]
            return "\n" + decls.compactMap { $0 }.joined(separator: "\n")
        }