func render()

in Sources/MockoloFramework/Templates/MethodTemplate.swift [58:173]
105 lines of code
15 McCabe index (conditional complexity)

        func render() -> String {
            let setter = setterBacking

            let body: String
            if arguments.useTemplateFunc
                && !model.throwing.hasError
                && (handler.type(enclosingType: enclosingType, requiresSendable: context.requiresSendable).cast == nil) {
                let handlerParamValsStr = renderParamValues(includeNewValue: false)

                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 requiresConcurrencySafeAccess {
                    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: String
            if model.isSubscript {
                if let setBody = renderSetterBody(setter) {
                    wrapped = """
                    \(2.tab)get {
                    \(body)
                    \(2.tab)}
                    \(2.tab)set {
                    \(setBody)
                    \(2.tab)}
                    """
                } else {
                    wrapped = """
                    \(2.tab)get {
                    \(body)
                    \(2.tab)}
                    """
                }
            } else {
                wrapped = 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 getter = getterBacking
            let decls: [String?] = [
                renderStateVarDecl(getter),
                renderCallCountVarDecl(getter),
                argsHistoryVarDecl,
                renderHandlerVarDecl(getter),
                setter.flatMap { renderStateVarDecl($0) },
                setter.map { renderCallCountVarDecl($0) },
                setter.map { renderHandlerVarDecl($0) },
                functionDecl,
            ]
            return "\n" + decls.compactMap { $0 }.joined(separator: "\n")
        }