How to use render method of VariableTemplate class

...32        processCombineAliases(entities: entities)33        34        let acl = accessLevel.isEmpty ? "" : accessLevel + " "35        let typealiases = typealiasWhitelist(in: entities)36        let renderedEntities = entities37            .compactMap { (uniqueId: String, model: Model) -> (String, Int64)? in38                if model.modelType == .typeAlias, let _ = typealiases?[model.name] {39                    // this case will be handlded by typealiasWhitelist look up later40                    return nil41                }42                if model.modelType == .variable, model.name == String.hasBlankInit {43                    return nil44                }45                if model.modelType == .method, model.isInitializer, !model.processed {46                    return nil47                }48                if let ret = model.render(with: uniqueId, encloser: name, useTemplateFunc: useTemplateFunc, useMockObservable: useMockObservable, allowSetCallCount: allowSetCallCount, mockFinal: mockFinal, enableFuncArgsHistory: enableFuncArgsHistory) {49                    return (ret, model.offset)50                }51                return nil52        }53        .sorted { (left: (String, Int64), right: (String, Int64)) -> Bool in54            if left.1 == right.1 {55                return left.0 < right.056            }57            return left.1 < right.158        }59        .map {$0.0}60        .joined(separator: "\n")61        62        var typealiasTemplate = ""63        let addAcl = declType == .protocolType ? acl : ""64        if let typealiasWhitelist = typealiases {65            typealiasTemplate = typealiasWhitelist.map { (arg: (key: String, value: [String])) -> String in66                let joinedType = arg.value.sorted().joined(separator: " & ")67                return  "\(1.tab)\(addAcl)\(String.typealias) \(arg.key) = \(joinedType)"68            }.joined(separator: "\n")69        }70        71        var moduleDot = ""72        if let moduleName = metadata?.module, !moduleName.isEmpty {73            moduleDot = moduleName + "."74        }75        76        let extraInits = extraInitsIfNeeded(initParamCandidates: initParamCandidates, declaredInits: declaredInits,  acl: acl, declType: declType, overrides: metadata?.varTypes)77        var body = ""78        if !typealiasTemplate.isEmpty {79            body += "\(typealiasTemplate)\n"80        }81        if !extraInits.isEmpty {82            body += "\(extraInits)\n"83        }84        if !renderedEntities.isEmpty {85            body += "\(renderedEntities)"86        }87        let finalStr = mockFinal ? "\(String.final) " : ""88        let template = """89        \(attribute)90        \(acl)\(finalStr)class \(name): \(moduleDot)\(identifier) {91        \(body)92        }93        """94        95        return template96    }97    98    private func extraInitsIfNeeded(initParamCandidates: [Model],99                                    declaredInits: [MethodModel],100                                    acl: String,101                                    declType: DeclType,102                                    overrides: [String: String]?) -> String {103        104        let declaredInitParamsPerInit = declaredInits.map { $0.params }105        106        var needParamedInit = false107        var needBlankInit = false108        109        if declaredInits.isEmpty, initParamCandidates.isEmpty {110            needBlankInit = true111            needParamedInit = false112        } else {113            if declType == .protocolType {114                needParamedInit = !initParamCandidates.isEmpty115                needBlankInit = true116                let buffer = initParamCandidates.sorted(path: \.fullName, fallback: \.name)117                for paramList in declaredInitParamsPerInit {118                    if paramList.isEmpty {119                        needBlankInit = false120                    } else {121                        let list = paramList.sorted(path: \.fullName, fallback: \.name)122                        if list.count > 0, list.count == buffer.count {123                            let dups = zip(list, buffer).filter {$0.0.fullName == $0.1.fullName}124                            if !dups.isEmpty {125                                needParamedInit = false126                            }127                        }128                    }129                }130            }131        }132        133        var initTemplate = ""134        if needParamedInit {135            var paramsAssign = ""136            let params = initParamCandidates137                .map { (element: Model) -> String in138                    if let val =  element.type.defaultVal(with: overrides, overrideKey: element.name, isInitParam: true) {139                        return "\(element.name): \(element.type.typeName) = \(val)"140                    }141                    var prefix = ""142                    if element.type.hasClosure {143                        if !element.type.isOptional {144                            prefix = String.escaping + " "145                        }146                    }147                    return "\(element.name): \(prefix)\(element.type.typeName)"148            }149            .joined(separator: ", ")150            151            paramsAssign = initParamCandidates.map { p in152                return "\(2.tab)self.\(p.underlyingName) = \(p.name.safeName)"153                154            }.joined(separator: "\n")155            156            initTemplate = """157            \(1.tab)\(acl)init(\(params)) {158            \(paramsAssign)159            \(1.tab)}160            """161        }162        163        let extraInitParamNames = initParamCandidates.map{$0.name}164        let extraVarsToDecl = declaredInitParamsPerInit.flatMap{$0}.compactMap { (p: ParamModel) -> String? in165            if !extraInitParamNames.contains(p.name) {166                return p.asVarDecl167            }168            return nil169        }170        .joined(separator: "\n")171        let declaredInitStr = declaredInits.compactMap { (m: MethodModel) -> String? in172            if case let .initKind(required, override) = m.kind, !m.processed {173                let modifier = required ? "\(String.required) " : (override ? "\(String.override) " : "")174                let mAcl = m.accessLevel.isEmpty ? "" : "\(m.accessLevel) "175                let genericTypeDeclsStr = m.genericTypeParams.compactMap {$0.render(with: "", encloser: "")}.joined(separator: ", ")176                let genericTypesStr = genericTypeDeclsStr.isEmpty ? "" : "<\(genericTypeDeclsStr)>"177                let paramDeclsStr = m.params.compactMap{$0.render(with: "", encloser: "")}.joined(separator: ", ")178                if override {179                    let paramsList = m.params.map { param in180                        return "\(param.name): \(param.name.safeName)"181                    }.joined(separator: ", ")182                    return """183                    \(1.tab)\(modifier)\(mAcl)init\(genericTypesStr)(\(paramDeclsStr)) {184                    \(2.tab)super.init(\(paramsList))185                    \(1.tab)}186                    """187                } else {188                    let paramsAssign = m.params.map { param in189                        let underVars = initParamCandidates.compactMap { return $0.name.safeName == param.name.safeName ? $0.underlyingName : nil}190                        if let underVar = underVars.first {191                            return "\(2.tab)self.\(underVar) = \(param.name.safeName)"...

...15    self.variable = variable16    self.context = context17  }18  19  func render() -> String {20    let (directiveStart, directiveEnd) = compilationDirectiveDeclaration21    return String(lines: [directiveStart,22                          String(lines: [mockedDeclaration, synthesizedDeclarations], spacing: 2),23                          directiveEnd])24  }25  26  var compilationDirectiveDeclaration: (start: String, end: String) {27    guard !variable.compilationDirectives.isEmpty else { return ("", "") }28    let start = String(lines: variable.compilationDirectives.map({ $0.declaration }))29    let end = String(lines: variable.compilationDirectives.map({ _ in "#endif" }))30    return (start, end)31  }32  33  lazy var getterInvocation: String = {34    return ObjectInitializationTemplate(35      name: "Mockingbird.SwiftInvocation",36      arguments: [37        ("selectorName", "\(doubleQuoted: getterName)"),38        ("setterSelectorName", "\(doubleQuoted: setterName)"),39        ("selectorType", "Mockingbird.SelectorType.getter"),40        ("arguments", "[]"),41        ("returnType", "Swift.ObjectIdentifier(\(parenthetical: matchableType).self)"),42      ]).render()43  }()44  45  lazy var mockableSetterInvocation: String = {46    return ObjectInitializationTemplate(47      name: "Mockingbird.SwiftInvocation",48      arguments: [49        ("selectorName", "\(doubleQuoted: setterName)"),50        ("setterSelectorName", "\(doubleQuoted: setterName)"),51        ("selectorType", "Mockingbird.SelectorType.setter"),52        ("arguments", "[Mockingbird.ArgumentMatcher(newValue)]"),53        ("returnType", "Swift.ObjectIdentifier(Void.self)"),54      ]).render()55  }()56  57  lazy var matchableSetterInvocation: String = {58    return ObjectInitializationTemplate(59      name: "Mockingbird.SwiftInvocation",60      arguments: [61        ("selectorName", "\(doubleQuoted: setterName)"),62        ("setterSelectorName", "\(doubleQuoted: setterName)"),63        ("selectorType", "Mockingbird.SelectorType.setter"),64        ("arguments", "[Mockingbird.resolve(newValue)]"),65        ("returnType", "Swift.ObjectIdentifier(Void.self)"),66      ]).render()67  }()68  69  var mockedDeclaration: String {70    let getterDefinition = PropertyDefinitionTemplate(71      type: .getter,72      body: !context.shouldGenerateThunks ? MockableTypeTemplate.Constants.thunkStub :73        ThunkTemplate(mockableType: context.mockableType,74                      invocation: getterInvocation,75                      shortSignature: nil,76                      longSignature: "() -> \(matchableType)",77                      returnType: matchableType,78                      isBridged: true,79                      isThrowing: false,80                      isStatic: variable.kind.typeScope.isStatic,81                      callMember: { scope in82                        return "\(scope).\(backticked: self.variable.name)"83                      },84                      invocationArguments: []).render())85    let setterDefinition = PropertyDefinitionTemplate(86      type: .setter,87      body: !context.shouldGenerateThunks ? MockableTypeTemplate.Constants.thunkStub :88        ThunkTemplate(mockableType: context.mockableType,89                      invocation: mockableSetterInvocation,90                      shortSignature: "() -> Void",91                      longSignature: "\(parenthetical: matchableType) -> Void",92                      returnType: "Void",93                      isBridged: true,94                      isThrowing: false,95                      isStatic: variable.kind.typeScope.isStatic,96                      callMember: { scope in97                        return "\(scope).\(backticked: self.variable.name) = newValue"98                      },99                      invocationArguments: [(nil, "newValue")]).render())100  101    let accessors = !shouldGenerateSetter ? [getterDefinition.render()] : [102      getterDefinition.render(),103      setterDefinition.render(),104    ]105    106    let override = variable.isOverridable ? "override " : ""107    let declaration = "\(override)public \(modifiers)var \(backticked: variable.name): \(mockableType)"108    return String(lines: [109      "// MARK: Mocked \(variable.name)",110      VariableDefinitionTemplate(attributes: variable.attributes.safeDeclarations,111                                 declaration: declaration,112                                 body: String(lines: accessors)).render()113    ])114  }115  116  var synthesizedDeclarations: String {117    let getterGenericTypes = ["\(Declaration.propertyGetterDeclaration)",118                              "() -> \(matchableType)",119                              matchableType]120    let setterGenericTypes = ["\(Declaration.propertySetterDeclaration)",121                              "(\(matchableType)) -> Void",122                              "Void"]123    124    let getterReturnType = "Mockingbird.Mockable<\(separated: getterGenericTypes)>"125    let getterDefinition = FunctionDefinitionTemplate(126      attributes: variable.attributes.safeDeclarations,127      declaration: "public \(modifiers)func get\(capitalizedName)() -> \(getterReturnType)",128      body: !context.shouldGenerateThunks ? MockableTypeTemplate.Constants.thunkStub : """129      return \(ObjectInitializationTemplate(130                name: "Mockingbird.Mockable",131                genericTypes: getterGenericTypes,132                arguments: [("mock", mockObject), ("invocation", getterInvocation)]))133      """)134    135    let setterReturnType = "Mockingbird.Mockable<\(separated: setterGenericTypes)>"136    let setterDefinition = FunctionDefinitionTemplate(137      attributes: variable.attributes.safeDeclarations,138      declaration: "public \(modifiers)func set\(capitalizedName)(_ newValue: @autoclosure () -> \(matchableType)) -> \(setterReturnType)",139      body: !context.shouldGenerateThunks ? MockableTypeTemplate.Constants.thunkStub : """140      return \(ObjectInitializationTemplate(141                name: "Mockingbird.Mockable",142                genericTypes: setterGenericTypes,143                arguments: [("mock", mockObject), ("invocation", matchableSetterInvocation)]))144      """)145    146    let accessors = !shouldGenerateSetter ? [getterDefinition.render()] : [147      getterDefinition.render(),148      setterDefinition.render(),149    ]150    return String(lines: accessors, spacing: 2)151  }152  153  lazy var modifiers: String = {154    return variable.kind.typeScope.isStatic ? "class " : ""155  }()156  157  lazy var mockObject: String = {158    return variable.kind.typeScope.isStatic ? "staticMock" : "self"159  }()160  161  // Keep this in sync with `MockingbirdFramework.Invocation.Constants.getterSuffix`162  lazy var getterName: String = {...

1import Foundation2let template = VariableTemplate()3template.render()4import Foundation5let template = VariableTemplate()6template.render()7import Foundation8let template = VariableTemplate()9template.render()10import Foundation11let template = VariableTemplate()12template.render()13import Foundation14let template = VariableTemplate()15template.render()16import Foundation17let template = VariableTemplate()18template.render()19import Foundation20let template = VariableTemplate()21template.render()22import Foundation23let template = VariableTemplate()24template.render()25import Foundation26let template = VariableTemplate()27template.render()28import Foundation29let template = VariableTemplate()30template.render()31import Foundation32let template = VariableTemplate()33template.render()34import Foundation35let template = VariableTemplate()36template.render()37import Foundation38let template = VariableTemplate()39template.render()40import Foundation41let template = VariableTemplate()42template.render()43import Foundation44let template = VariableTemplate()45template.render()46import Foundation47let template = VariableTemplate()48template.render()49import Foundation50let template = VariableTemplate()51template.render()

1import Foundation2var template = VariableTemplate()3template.render()4import Foundation5var template = VariableTemplate()6template.render()7import Foundation8var template = VariableTemplate()9template.render()10import Foundation11var template = VariableTemplate()12template.render()13import Foundation14var template = VariableTemplate()15template.render()16import Foundation17var template = VariableTemplate()18template.render()19import Foundation20var template = VariableTemplate()21template.render()22import Foundation23var template = VariableTemplate()24template.render()25import Foundation26var template = VariableTemplate()27template.render()28import Foundation29var template = VariableTemplate()30template.render()31import Foundation32var template = VariableTemplate()33template.render()34import Foundation35var template = VariableTemplate()36template.render()37import Foundation38var template = VariableTemplate()39template.render()40import Foundation41var template = VariableTemplate()42template.render()43import Foundation44var template = VariableTemplate()45template.render()46import Foundation47var template = VariableTemplate()48template.render()49import Foundation50var template = VariableTemplate()51template.render()

1import Swift2import Foundation3let template = VariableTemplate()4template.render()5import Swift6import Foundation7let template = VariableTemplate()8template.render()9import Foundation10import Swift11let template = VariableTemplate()12template.render()13import Foundation14import Swift15let template = VariableTemplate()16template.render()

1let template = VariableTemplate(template: "Hello, {{name}}!")2let result = template.render(["name": "World"])3print(result)4let template = VariableTemplate(template: "Hello, {{name}}!")5let result = template.render(["name": "World"])6print(result)7let template = VariableTemplate(template: "Hello, {{name}}!")8let result = template.render(["name": "World"])9print(result)10let template = VariableTemplate(template: "Hello, {{name}}!")11let result = template.render(["name": "World"])12print(result)13let template = VariableTemplate(template: "Hello, {{name}}!")14let result = template.render(["name": "World"])15print(result)16let template = VariableTemplate(template: "Hello, {{name}}!")17let result = template.render(["name": "World"])18print(result)19let template = VariableTemplate(template: "Hello, {{name}}!")20let result = template.render(["name": "World"])21print(result)22let template = VariableTemplate(template: "Hello, {{name}}!")23let result = template.render(["name": "World"])24print(result)25let template = VariableTemplate(template: "Hello, {{name}}!")26let result = template.render(["name": "World"])27print(result)28let template = VariableTemplate(template: "Hello, {{name}}!")29let result = template.render(["name": "World"])30print(result)31let template = VariableTemplate(template: "Hello, {{name}}!")32let result = template.render(["name": "World"])33print(result)

1let template = VariableTemplate(template: "Hello, {{name}}!")2let rendered = template.render(["name": "Swift"])3print(rendered)4let template = VariableTemplate(template: "Hello, {{name}}!")5let rendered = template.render(["name": "Swift"])6print(rendered)7let template = VariableTemplate(template: "Hello, {{name}}!")8let rendered = template.render(["name": "Swift"])9print(rendered)10let template = VariableTemplate(template: "Hello, {{name}}!")11let rendered = template.render(["name": "Swift"])12print(rendered)13let template = VariableTemplate(template: "Hello, {{name}}!")14let rendered = template.render(["name": "Swift"])15print(rendered)16let template = VariableTemplate(template: "Hello, {{name}}!")17let rendered = template.render(["name": "Swift"])18print(rendered)19let template = VariableTemplate(template: "Hello, {{name}}!")20let rendered = template.render(["name": "Swift"])21print(rendered)22let template = VariableTemplate(template: "Hello, {{name}}!")23let rendered = template.render(["name": "Swift"])24print(rendered)25let template = VariableTemplate(template: "Hello, {{name}}!")26let rendered = template.render(["name": "Swift"])27print(rendered)28let template = VariableTemplate(template: "Hello, {{name}}!")29let rendered = template.render(["name": "Swift"])30print(rendered)31let template = VariableTemplate(template: "Hello, {{name}}!")32let rendered = template.render(["name": "Swift"])33print(rendered

1import Foundation2let template = VariableTemplate()3var result = template.render("Hello {{ name }}", context: ["name": "World"])4print(result)5import Foundation6let template = VariableTemplate()7var result = template.render("Hello {{ name }}", context: ["name": "World"])8print(result)9import Foundation10let template = VariableTemplate()11var result = template.render("Hello {{ name }}", context: ["name": "World"])12print(result)13import Foundation14let template = VariableTemplate()15var result = template.render("Hello {{ name }}", context: ["name": "World"])16print(result)17import Foundation18let template = VariableTemplate()19var result = template.render("Hello {{ name }}", context: ["name": "World"])20print(result)21import Foundation22let template = VariableTemplate()23var result = template.render("Hello {{ name }}", context: ["name": "World"])24print(result)25import Foundation26let template = VariableTemplate()27var result = template.render("Hello {{ name }}", context: ["name": "World"])28print(result)29import Foundation30let template = VariableTemplate()31var result = template.render("Hello {{ name }}", context: ["name": "World"])32print(result)33import Foundation34let template = VariableTemplate()35var result = template.render("Hello {{ name }}", context: ["name": "World"])36print(result)37import Foundation38let template = VariableTemplate()39var result = template.render("Hello {{ name }}", context: ["name": "World"])40print(result)41import Foundation

1let template = VariableTemplate()2template.render("Hello, {{name}}", ["name": "World"])3let template = VariableTemplate()4template.render("Hello, {{name}}", ["name": "World"])5let template = VariableTemplate()6template.render("Hello, {{name}}", ["name": "World"])7let template = VariableTemplate()8template.render("Hello, {{name}}", ["name": "World"])9let template = VariableTemplate()10template.render("Hello, {{name}}", ["name": "World"])11let template = VariableTemplate()12template.render("Hello, {{name}}", ["name": "World"])13let template = VariableTemplate()14template.render("Hello, {{name}}", ["name": "World"])15let template = VariableTemplate()16template.render("Hello, {{name}}", ["name": "World"])17let template = VariableTemplate()18template.render("Hello, {{name}}", ["name": "World"])19let template = VariableTemplate()20template.render("Hello, {{name}}", ["name": "World"])21let template = VariableTemplate()22template.render("Hello, {{name}}", ["name": "World"])

1let myTemplate = VariableTemplate()2let myContext = VariableContext()3let myResult = myTemplate.render(myContext)4print(myResult)5let myTemplate = VariableTemplate()6let myContext = VariableContext()7let myResult = myTemplate.render(myContext)8print(myResult)9let myTemplate = VariableTemplate()10let myContext = VariableContext()11let myResult = myTemplate.render(myContext)12print(myResult)13let myTemplate = VariableTemplate()14let myContext = VariableContext()15let myResult = myTemplate.render(myContext)16print(myResult)17let myTemplate = VariableTemplate()18let myContext = VariableContext()19let myResult = myTemplate.render(myContext)20print(myResult)21let myTemplate = VariableTemplate()22let myContext = VariableContext()23let myResult = myTemplate.render(myContext)24print(myResult)25let myTemplate = VariableTemplate()26let myContext = VariableContext()27let myResult = myTemplate.render(myContext)28print(myResult)29let myTemplate = VariableTemplate()30let myContext = VariableContext()31let myResult = myTemplate.render(myContext)32print(myResult)33let myTemplate = VariableTemplate()34let myContext = VariableContext()35let myResult = myTemplate.render(myContext)36print(myResult)