func applyVariableTemplate()

in Sources/MockoloFramework/Templates/VariableTemplate.swift [20:132]
97 lines of code
16 McCabe index (conditional complexity)

    func applyVariableTemplate(name: String,
                               type: SwiftType,
                               encloser: String,
                               isStatic: Bool,
                               customModifiers: [String: Modifier]?,
                               allowSetCallCount: Bool,
                               shouldOverride: Bool,
                               accessLevel: String,
                               context: RenderContext,
                               arguments: GenerationArguments) -> String {
        let underlyingSetCallCount = "\(name)\(String.setCallCountSuffix)"
        let underlyingVarDefaultVal = type.defaultVal()
        var underlyingType = type.typeName
        if underlyingVarDefaultVal == nil {
            underlyingType = type.underlyingType
        }

        let propertyWrapper = propertyWrapper != nil ? "\(propertyWrapper!) " : ""

        let overrideStr = shouldOverride ? "\(String.override) " : ""
        var acl = accessLevel
        if !acl.isEmpty {
            acl = acl + " "
        }

        var assignVal = ""
        if !shouldOverride, let val = underlyingVarDefaultVal {
            assignVal = " = \(val)"
        }

        let privateSetSpace = allowSetCallCount ? "" :  "\(String.privateSet) "

        let modifierTypeStr: String
        if let customModifiers = self.customModifiers,
           let customModifier: Modifier = customModifiers[name] {
            modifierTypeStr = customModifier.rawValue + " "
        } else {
            modifierTypeStr = ""
        }

        let staticSpace = isStatic ? "\(String.static) " : ""

        switch storageKind {
        case .stored(let needSetCount):
            let setCallCountVarDecl = needSetCount ? """
            \(1.tab)\(acl)\(staticSpace)\(privateSetSpace)var \(underlyingSetCallCount) = 0
            """ : ""

            var accessorBlockItems: [String] = []
            if needSetCount {
                let didSetBlock = """
                didSet { \(underlyingSetCallCount) += 1 }
                """
                accessorBlockItems.append(didSetBlock)
            }

            let accessorBlock: String
            switch accessorBlockItems.count {
            case 0: accessorBlock = ""
            case 1: accessorBlock = " { \(accessorBlockItems[0]) }"
            default: accessorBlock = """
                 {
                \(accessorBlockItems.map { "\(2.tab)\($0)" }.joined(separator: "\n"))
                \(1.tab)}
                """
            }

            let template: String
            if underlyingVarDefaultVal == nil {
                template = """
                
                \(setCallCountVarDecl)
                \(1.tab)\(propertyWrapper)\(staticSpace)private var \(underlyingName): \(underlyingType)\(assignVal)\(accessorBlock)
                \(1.tab)\(acl)\(staticSpace)\(overrideStr)\(modifierTypeStr)var \(name): \(type.typeName) {
                \(2.tab)get { return \(underlyingName) }
                \(2.tab)set { \(underlyingName) = newValue }
                \(1.tab)}
                """
            } else {
                template = """
                
                \(setCallCountVarDecl)
                \(1.tab)\(propertyWrapper)\(acl)\(staticSpace)\(overrideStr)\(modifierTypeStr)var \(name): \(type.typeName)\(assignVal)\(accessorBlock)
                """
            }

            return template

        case .computed(let effects):
            let body = (ClosureModel(
                genericTypeParams: [],
                params: [],
                isAsync: effects.isAsync,
                throwing: effects.throwing,
                returnType: type
            ).render(context: .init(
                overloadingResolvedName: name, // var cannot overload. this is ok
                enclosingType: context.enclosingType,
                annotatedTypeKind: context.annotatedTypeKind
            ), arguments: arguments) ?? "")
                .addingIndent(1)

            return """

            \(1.tab)\(acl)\(staticSpace)var \(name)\(String.handlerSuffix): (() \(effects.applyTemplate())-> \(type.typeName))?
            \(1.tab)\(acl)\(staticSpace)\(overrideStr)\(modifierTypeStr)var \(name): \(type.typeName) {
            \(2.tab)get \(effects.applyTemplate()){
            \(body)
            \(2.tab)}
            \(1.tab)}
            """
        }
    }