How to use RawType class

1import Foundation2import SourceKittenFramework3/// A light wrapper around a SourceKit structure, used for the mocked module and its dependencies.4class RawType {5  let dictionary: StructureDictionary6  let name: String7  /// Fully qualified with respect to the current module (not with respect to other modules)8  let fullyQualifiedName: String9  let containedTypes: [RawType]10  let containingTypeNames: [String]11  let containingScopes: [String] // Including the module name and any containing types.12  let genericTypes: [String] // Ordered generic type parameters.13  let genericTypeContext: [[String]] // Generic type parameters in each containing type.14  let selfConformanceTypeNames: Set<String> // Self conformances defined in generic where clauses.15  let aliasedTypeNames: Set<String> // For typealias definitions only.16  let definedInExtension: Bool // Types can be defined and nested within extensions.17  let kind: SwiftDeclarationKind18  let parsedFile: ParsedFile19  20  var isContainedType: Bool { return !containingTypeNames.isEmpty }21  22  /// Fully qualified with respect to other modules.23  var fullyQualifiedModuleName: String { return parsedFile.moduleName + "." + fullyQualifiedName }24  25  /// Returns a set of qualified and optional/generic type preserving names.26  ///27  /// - Parameters:28  ///   - declaration: The actual string declaration of the `RawType`, containing full type info.29  ///   - context: The containing scope names of where the type was referenced from.30  /// - Returns: Module-qualified and context-qualified names for the type.31  func qualifiedModuleNames(from declaration: String,32                            context: ArraySlice<String>,33                            definingModuleName: String?)34    -> (moduleQualified: String, contextQualified: String) {35      let trimmedDeclaration = declaration.removingParameterAttributes()36      let rawComponents = trimmedDeclaration37        .components(separatedBy: ".", excluding: .allGroups)38        .map({ String($0) })39      let specializedName = rawComponents[(rawComponents.count-1)...]40      41      let qualifiers: [String]42      if let definingModuleName = definingModuleName {43        qualifiers = [definingModuleName] + containingTypeNames + [name]44      } else {45        qualifiers = containingTypeNames + [name]46      }47      48      // Preserve any generic type specialization from the raw declaration components.49      let merge: ([String], [String]) -> String = { (old, new) -> String in50        var components: Array<String>.SubSequence {51          if new.count > old.count {52            return (new[..<(new.count-old.count)] + old[...])53          } else {54            return old[(old.count-new.count)...]55          }56        }57        return components.joined(separator: ".")58      }59      60      // Check if the referencing declaration is in the same scope as the type declaration.61      let lcaScopeIndex = zip(qualifiers, context)62        .map({ ($0, $1) })63        .lastIndex(where: { $0 == $1 }) ?? 064      let endIndex = qualifiers.count - 165      66      // If the LCA is the module then include the module name, else exclude type-scoped qualifiers.67      let startIndex = min(lcaScopeIndex + (lcaScopeIndex > 0 ? 1 : 0), endIndex)68      69      let moduleComponents = (qualifiers[..<endIndex] + specializedName).map({ String($0) })70      let moduleQualified = merge(rawComponents, moduleComponents)71      72      let contextComponents =73        (qualifiers[startIndex..<endIndex] + specializedName).map({ String($0) })74      let contextQualified = merge(rawComponents, contextComponents)75      76      return (moduleQualified: moduleQualified, contextQualified: contextQualified)77  }78  79  init(dictionary: StructureDictionary,80       name: String,81       fullyQualifiedName: String,82       containedTypes: [RawType],83       containingTypeNames: [String],84       genericTypes: [String],85       genericTypeContext: [[String]],86       selfConformanceTypeNames: Set<String>,87       aliasedTypeNames: Set<String>,88       definedInExtension: Bool,89       kind: SwiftDeclarationKind,90       parsedFile: ParsedFile) {91    self.dictionary = dictionary92    self.name = name93    self.fullyQualifiedName = fullyQualifiedName94    self.containedTypes = containedTypes95    self.containingTypeNames = containingTypeNames96    self.containingScopes = [parsedFile.moduleName] + containingTypeNames97    self.genericTypes = genericTypes98    self.genericTypeContext = genericTypeContext99    self.selfConformanceTypeNames = selfConformanceTypeNames100    self.aliasedTypeNames = aliasedTypeNames101    self.definedInExtension = definedInExtension102    self.kind = kind103    self.parsedFile = parsedFile104  }105}106extension RawType: Hashable {107  func hash(into hasher: inout Hasher) {108    hasher.combine(fullyQualifiedModuleName)109  }110  111  static func == (lhs: RawType, rhs: RawType) -> Bool {112    return lhs.fullyQualifiedModuleName == rhs.fullyQualifiedModuleName113  }114}115extension Array where Element == RawType {116  /// Given an array of partial `RawType` objects, return the root declaration (not an extension).117  func findBaseRawType() -> RawType? {118    return first(where: { $0.kind != .extension })119  }120}121/// Stores `RawType` partials indexed by type name indexed by module name. Partials are mainly to122/// support extensions which define parts of a `RawType`. `MockableType` combines all partials into123/// a final unique type definition on initialization.124class RawTypeRepository {125  private(set) var rawTypes = [String: [String: [RawType]]]() // typename => module name => rawtype126  127  /// Used to check if a module name is shadowed by a type name.128  private(set) var moduleTypes = [String: Set<String>]() // module name => set(typename)129  130  /// Get raw type partials for a fully qualified name in a particular module.131  func rawType(named name: String, in moduleName: String) -> [RawType]? {132    return rawTypes[name.removingGenericTyping()]?[moduleName]133  }134  135  /// Get raw type partials for a fully qualified name in all modules.136  func rawTypes(named name: String) -> [String: [RawType]]? {137    return rawTypes[name.removingGenericTyping()]138  }139  140  /// Add a single raw type partial.141  func addRawType(_ rawType: RawType) {142    let name = rawType.fullyQualifiedName.removingGenericTyping()143    let moduleName = rawType.parsedFile.moduleName144    log("Added raw type: \(name.singleQuoted), moduleName: \(moduleName.singleQuoted)")145    rawTypes[name, default: [:]][moduleName, default: []].append(rawType)146    moduleTypes[moduleName, default: []].insert(name)147  }148  149  enum Constants {150    static let optionalsCharacterSet = CharacterSet.createOptionalsSet()151  }152  153  /// Perform type realization based on scope and module.154  ///155  /// Contained types can shadow higher level type names, so inheritance requires some inference.156  /// Type inference starts from the deepest level and works outwards.157  ///     class SecondLevelType {}158  ///     class TopLevelType {159  ///        class SecondLevelType {160  ///          // Inherits from the contained `SecondLevelType`161  ///          class ThirdLevelType: SecondLevelType {}162  ///        }163  ///      }164  func nearestInheritedType(named rawName: String,165                            trimmedName: String? = nil,166                            moduleNames: [String],167                            referencingModuleName: String?, // The module referencing the type.168                            containingTypeNames: ArraySlice<String>) -> [RawType]? {169    let name: String170    if let trimmedName = trimmedName {171      name = trimmedName172    } else {173      name = rawName174        .trimmingCharacters(in: Constants.optionalsCharacterSet)175        .removingParameterAttributes()176        .removingGenericTyping()177    }178    let attributedModuleNames: [String]179    if let referencingModuleName = referencingModuleName {180      attributedModuleNames = [referencingModuleName] + moduleNames181    } else {182      attributedModuleNames = moduleNames183    }184    let getRawType: (String) -> [RawType]? = {185      guard let rawTypes = self.rawTypes(named: $0) else { return nil }186      for moduleName in attributedModuleNames {187        guard let rawType = rawTypes[moduleName],188          rawType.contains(where: { $0.kind != .extension })189          else { continue }190        return rawType191      }192      return nil193    }194    guard !containingTypeNames.isEmpty else { // Base case.195      // Check if this is a potentially fully qualified name (from the module).196      guard let firstComponentIndex = name.firstIndex(of: ".") else { return getRawType(name) }197      if let rawType = getRawType(name) { return rawType }198      199      // Ensure that the first component is actually a module that we've indexed.200      let moduleName = String(name[..<firstComponentIndex])201      guard attributedModuleNames.contains(moduleName) else { return nil }202      let dequalifiedName = name[name.index(after: firstComponentIndex)...]203      204      guard let rawType = self.rawTypes(named: String(dequalifiedName))?[moduleName],205        rawType.contains(where: { $0.kind != .extension })206        else { return nil }207      return rawType208    }209    210    let fullyQualifiedName = (containingTypeNames + [name]).joined(separator: ".")211    if let rawType = getRawType(fullyQualifiedName) { return rawType }212    213    let typeNames = containingTypeNames[0..<(containingTypeNames.count-1)]214    return nearestInheritedType(named: name,215                                trimmedName: name,216                                moduleNames: attributedModuleNames,217                                referencingModuleName: nil,218                                containingTypeNames: typeNames)219  }220  221  /// Returns whether a module name is shadowed by a type definition in any of the given modules.222  /// - Parameter moduleName: A module name to check.223  /// - Parameter moduleNames: An optional list of modules to check for type definitions.224  func isModuleNameShadowed(moduleName: String, moduleNames: [String]? = nil) -> Bool {225    if let moduleNames = moduleNames {...

...23        self.values = values24        super.init(values.isEmpty ? TypeArray([""]) : values.first!)25        26        if solidityType != nil {27            self.rawType = ABIRawType(rawValue: solidityType!) ?? .DynamicArray(.DynamicString)28            guard let components = solidityType?.components(separatedBy: CharacterSet(charactersIn: "[]")) else { return }29            self.subRawType = ABIRawType(rawValue: String(describing: components[0])) ?? .DynamicString30            if components.count > 3 {31                let sub = solidityType?[solidityType!.startIndex..<solidityType!.lastIndex(of: "[")!]32                self.subRawType = ABIRawType(rawValue: String(describing: String(sub!))) ?? .DynamicString33            }34        } else if let val = values.first {35            self.rawType = .DynamicArray(type(of: val).rawType)36        }37        self.value = self38    }39    40    public init(_ values: [ABIType], _ rawType: ABIRawType) {41        self.values = values42        super.init(values.isEmpty ? TypeArray([""]) : values.first!)43        44        self.rawType = rawType45        self.subRawType = rawType.subType ?? .DynamicString46        47        self.value = self48    }49    50    public var subRawType: ABIRawType = .DynamicString51    var subParser: ParserFunction = String.parser52    53    public static var rawType: ABIRawType {54        .DynamicArray(.DynamicString)55    }56    57    public static var parser: ParserFunction {58        String.parser59    }60    61    public var parser: ParserFunction {62        return self.subParser63    }64}65public class DynamicArray: TypeArray {66    public override init(_ values: [ABIType], _ rawType: ABIRawType) {67        super.init(values, rawType)68    }69    70    public override init(_ values: [ABIType], _ solidityType: String? = nil) {71        if solidityType == nil {72            if let val = (values.first as? Type) {73                super.init(values, ABIRawType.DynamicArray(val.rawType).rawValue)74            } else {75                super.init(values, ABIRawType.DynamicArray(type(of: values.first!).rawType).rawValue)76            }77        } else {78            super.init(values, solidityType)79        }80    }81}82public class StaticArray: TypeArray {83    public override init(_ values: [ABIType], _ rawType: ABIRawType) {84        super.init(values, rawType)85    }86    87    public override init(_ values: [ABIType], _ solidityType: String? = nil) {88        if solidityType == nil {89            super.init(values, ABIRawType.FixedArray(type(of: values.first!).rawType, values.count).rawValue)90        } else {91            super.init(values, solidityType)92        }93    }94}95public class StaticArray1: StaticArray {96    public init(_ values: [ABIType]) {97        super.init(values)98        self.rawType = .FixedArray(type(of: values.first!).rawType, self.size)99    }100}101public class StaticArray2: StaticArray {102    public init(_ values: [ABIType]) {103        super.init(values)...

1//2// Project «Synopsis»3// Created by Jeorge Taflanidi4//5import Foundation6import SourceKittenFramework7class TypeParser {8    9    func parse(rawDescription: [String: AnyObject]) -> TypeDescription {10        let typename:    String = rawDescription.typename11        let declaration: String = rawDescription.parsedDeclaration12        13        switch typename {14            // TODO: incorporate all possible rawDescription.typename values15            case "Bool": return TypeDescription.boolean16            case "Int": return TypeDescription.integer17            case "Float": return TypeDescription.floatingPoint18            case "Double": return TypeDescription.doublePrecision19            case "String": return TypeDescription.string20            case "Void": return TypeDescription.void21            22            default: return deduceType(fromDeclaration: declaration)23        }24    }25    26    func parse(functionTypename: String, declarationString: String) -> TypeDescription? {27        let returnTypename: String =28            String(functionTypename.split(separator: " ").last!)29        30        switch returnTypename {31            case "()", "Void": return TypeDescription.void32            33            case "Bool": return TypeDescription.boolean34            case "Int": return TypeDescription.integer35            case "Float": return TypeDescription.floatingPoint36            case "Double": return TypeDescription.doublePrecision37            case "String": return TypeDescription.string38            39            default:40                if functionTypename != "<<error type>>" {41                    return parse(rawType: returnTypename)42                }43                44                // FIXME: Make a LexemeString, exclude comments45                46                if !declarationString.contains("->") {47                    return nil48                }49                50                if let rawReturnType: String = declarationString.components(separatedBy: "->").last?.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines) {51                    return parse(rawType: rawReturnType)52                }53                54                return nil55        }56    }57    58    func deduceType(fromDeclaration declaration: String) -> TypeDescription {59        if let type: TypeDescription = parseExplicitType(fromDeclaration: declaration) {60            return type61        }62        63        return deduceType(fromDefaultValue: declaration)64    }65}66private extension TypeParser {67    68    func parseExplicitType(fromDeclaration declaration: String) -> TypeDescription? {69        guard declaration.contains(":")70        else { return nil }71        72        let declarationWithoutDefultValue: String =73            declaration74                .truncateAfter(word: "=", deleteWord: true)75                .trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)76        77        let typename: String =78            declarationWithoutDefultValue79                .truncateUntilExist(word: ":")80                .trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)81        82        return parse(rawType: typename)83    }84    85    func deduceType(fromDefaultValue declaration: String) -> TypeDescription {86        guard declaration.contains("=")87        else { return TypeDescription.object(name: "") }88        89        let defaultValue: String =90            declaration91                .truncateUntilExist(word: "=")92                .trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)93        94        return guessType(ofVariableValue: defaultValue)95    }96    97    /**98     Parse raw type line without any other garbage.99     100     ```MyType<[Entity]>```101     */102    func parse(rawType: String) -> TypeDescription {103        // check type ends with ?104        if rawType.hasSuffix("?") {105            return TypeDescription.optional(106                wrapped: parse(rawType: String(rawType.dropLast()))107            )108        }109        110        if rawType.contains("<") && rawType.contains(">") {111            let name: String = rawType.truncateAfter(word: "<", deleteWord: true).trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)112            let itemName: String = String(rawType.truncateUntilExist(word: "<").truncateAfter(word: ">", deleteWord: true))113            let itemType: TypeDescription = self.parse(rawType: itemName)114            return TypeDescription.generic(name: name, constraints: [itemType])115        }116        117        if rawType.contains("[") && rawType.contains("]") {118            let collecitonItemTypeName: String =119                rawType120                    .truncateUntilExist(word: "[")121                    .truncateAfter(word: "]", deleteWord: true)122                    .trimmingCharacters(in: CharacterSet.whitespaces)123            return self.parseCollectionItemType(collecitonItemTypeName)124        }125        126        if rawType == "Bool" {127            return TypeDescription.boolean128        }129        130        if rawType.contains("Int") {131            return TypeDescription.integer132        }133        134        if rawType == "Float" {135            return TypeDescription.floatingPoint136        }137        138        if rawType == "Double" {139            return TypeDescription.doublePrecision140        }141        142        if rawType == "Date" {143            return TypeDescription.date144        }145        146        if rawType == "Data" {147            return TypeDescription.data148        }149        150        if rawType == "String" {151            return TypeDescription.string152        }153        154        if rawType == "Void" {155            return TypeDescription.void156        }157        158        var objectTypeName: String = String(rawType.firstWord())159        if objectTypeName.last == "?" {160            objectTypeName = String(objectTypeName.dropLast())161        }162        163        return TypeDescription.object(name: objectTypeName)164    }165    func guessType(ofVariableValue value: String) -> TypeDescription {166        // collections are not supported yet167        if value.contains("[") {168            return TypeDescription.object(name: "")169        }170        171        // check value is text in quotes:172        // let abc = "abcd"173        if let _ = value.range(of: "^\"(.*)\"$", options: .regularExpression) {174            return TypeDescription.string175        }176        177        // check value is double:178        // let abc = 123.45179        if let _ = value.range(of: "^(\\d+)\\.(\\d+)$", options: .regularExpression) {180            return TypeDescription.doublePrecision181        }182        183        // check value is int:184        // let abc = 123185        if let _ = value.range(of: "^(\\d+)$", options: .regularExpression) {186            return TypeDescription.integer187        }188        189        // check value is bool190        // let abc = true191        if value.contains("true") || value.contains("false") {192            return TypeDescription.boolean193        }194        195        // check value contains object init statement:196        // let abc = Object(some: 123)197        if let _ = value.range(of: "^(\\w+)\\((.*)\\)$", options: .regularExpression) {198            let rawValueTypeName: String = String(value.truncateAfter(word: "(", deleteWord: true))199            return parse(rawType: rawValueTypeName)200        }201        202        return TypeDescription.object(name: "")203    }204    205    func parseCollectionItemType(_ collecitonItemTypeName: String) -> TypeDescription {206        if collecitonItemTypeName.contains(":") {207            let keyTypeName:   String = String(collecitonItemTypeName.truncateAfter(word: ":", deleteWord: true))208            let valueTypeName: String = String(collecitonItemTypeName.truncateUntilExist(word: ":"))209            210            return TypeDescription.map(key: self.parse(rawType: keyTypeName), value: self.parse(rawType: valueTypeName))211        } else {212            return TypeDescription.array(element: self.parse(rawType: collecitonItemTypeName))213        }214    }215    216}...

1import Mockingbird2class MockRawType: RawType, Mock {3  required init(description: String, debugDescription: String) {4    self.__handler = Mockingbird.MockHandlerImpl()5  }6  convenience init() {7    self.init(description: "", debugDescription: "")8  }9  struct __RawTypeStubbingProxy {10    init(description: String, debugDescription: String, __handler: Mockingbird.MockHandler) {11    }12  }13  struct __RawTypeVerificationProxy {14    init(description: String, debugDescription: String, __handler: Mockingbird.MockHandler) {15    }16  }17}18import Mockingbird19class MockRawType: RawType, Mock {20  required init(description: String, debugDescription: String) {21    self.__handler = Mockingbird.MockHandlerImpl()22  }23  convenience init() {24    self.init(description: "", debugDescription: "")25  }26  struct __RawTypeStubbingProxy {27    init(description: String, debugDescription: String, __handler: Mockingbird.MockHandler) {

1import MockingbirdFramework2import MockingbirdFramework3import MockingbirdFramework4import MockingbirdFramework5import MockingbirdFramework6import MockingbirdFramework7import MockingbirdFramework8import MockingbirdFramework9import MockingbirdFramework10import MockingbirdFramework11import MockingbirdFramework12import MockingbirdFramework13import MockingbirdFramework14import MockingbirdFramework15import MockingbirdFramework16import MockingbirdFramework17import MockingbirdFramework18import MockingbirdFramework19import MockingbirdFramework20import MockingbirdFramework21import MockingbirdFramework22import MockingbirdFramework23import Mock

1import Mockingbird2let rawType = RawType()3rawType.method1()4rawType.method2()5rawType.method3()6rawType.method4()7rawType.method5()8rawType.method6()9rawType.method7()10rawType.method8()11rawType.method9()12rawType.method10()13rawType.method11()14rawType.method12()15rawType.method13()16rawType.method14()17rawType.method15()18rawType.method16()19rawType.method17()20rawType.method18()21rawType.method19()22rawType.method20()23rawType.method21()24rawType.method22()25rawType.method23()26rawType.method24()27rawType.method25()28rawType.method26()29rawType.method27()30rawType.method28()31rawType.method29()32rawType.method30()33rawType.method31()34rawType.method32()35rawType.method33()36rawType.method34()37rawType.method35()38rawType.method36()39rawType.method37()40rawType.method38()41rawType.method39()42rawType.method40()43rawType.method41()44rawType.method42()45rawType.method43()46rawType.method44()47rawType.method45()48rawType.method46()49rawType.method47()50rawType.method48()51rawType.method49()52rawType.method50()53rawType.method51()54rawType.method52()55rawType.method53()56rawType.method54()57rawType.method55()58rawType.method56()59rawType.method57()60rawType.method58()61rawType.method59()62rawType.method60()63rawType.method61()64rawType.method62()65rawType.method63()66rawType.method64()67rawType.method65()68rawType.method66()69rawType.method67()70rawType.method68()71rawType.method69()72rawType.method70()73rawType.method71()74rawType.method72()75rawType.method73()76rawType.method74()77rawType.method75()78rawType.method76()79rawType.method77()80rawType.method78()81rawType.method79()82rawType.method80()83rawType.method81()84rawType.method82()85rawType.method83()86rawType.method84()87rawType.method85()88rawType.method86()89rawType.method87()90rawType.method88()91rawType.method89()92rawType.method90()93rawType.method91()94rawType.method92()95rawType.method93()96rawType.method94()97rawType.method95()98rawType.method96()99rawType.method97()

1import Mockingbird2import Foundation3struct RawType: RawRepresentable, Equatable {4    init(rawValue: String) {5    }6}7class RawTypeMocks {8    static let `default` = RawTypeMocks()9    lazy var string: RawType = RawType(rawValue: "string")10    lazy var int: RawType = RawType(rawValue: "int")11    lazy var float: RawType = RawType(rawValue: "float")12    lazy var double: RawType = RawType(rawValue: "double")13    lazy var bool: RawType = RawType(rawValue: "bool")14    lazy var date: RawType = RawType(rawValue: "date")15    lazy var data: RawType = RawType(rawValue: "data")16    lazy var url: RawType = RawType(rawValue: "url")17}18class RawTypeMock: RawType, Mock {19    init() {20        self.handler = MockHandlerImpl(for: RawTypeMock.self, mode: .record)21    }22    init(handler: MockHandler) {23    }24    required init(rawValue: String) {25        self.handler = MockHandlerImpl(for: RawTypeMock.self, mode: .record)26        super.init(rawValue: rawValue)27    }28    required init(handler: MockHandler, rawValue: String) {29        super.init(rawValue: rawValue)30    }31    required init(mock: RawTypeMock) {32        super.init(rawValue: mock.rawValue)33    }34    static var string: RawType {35        get { return RawTypeMocks.default.string }36        set { RawTypeMocks.default.string = newValue }37    }38    static var int: RawType {39        get { return RawTypeMocks.default.int }40        set { RawTypeMocks.default.int = newValue }41    }42    static var float: RawType {43        get { return RawTypeMocks.default.float }44        set { RawTypeMocks.default.float = newValue }45    }46    static var double: RawType {47        get { return RawTypeMocks.default.double }48        set { RawTypeMocks.default.double = newValue }49    }50    static var bool: RawType {51        get { return RawTypeMocks.default.bool }

1import Mockingbird2let rawType = RawType()3let rawTypeMock = mock(RawType.self)4let rawTypeStub = stub(RawType.self)5import Mockingbird6let rawType = RawType()7let rawTypeMock = mock(RawType.self)8let rawTypeStub = stub(RawType.self)9import Mockingbird10let rawType = RawType()11let rawTypeMock = mock(RawType.self)12let rawTypeStub = stub(RawType.self)13import Mockingbird14let rawType = RawType()15let rawTypeMock = mock(RawType.self)16let rawTypeStub = stub(RawType.self)17import Mockingbird18let rawType = RawType()19let rawTypeMock = mock(RawType.self)20let rawTypeStub = stub(RawType.self)21import Mockingbird22let rawType = RawType()23let rawTypeMock = mock(RawType.self)24let rawTypeStub = stub(RawType.self)25import Mockingbird26let rawType = RawType()27let rawTypeMock = mock(RawType.self)28let rawTypeStub = stub(RawType.self)29import Mockingbird30let rawType = RawType()31let rawTypeMock = mock(RawType.self)32let rawTypeStub = stub(RawType.self)33import Mockingbird34let rawType = RawType()35let rawTypeMock = mock(RawType.self)36let rawTypeStub = stub(RawType.self)37import Mockingbird38let rawType = RawType()39let rawTypeMock = mock(RawType

1import Foundation2import Mockingbird3import MockingbirdFramework4class Path {5    init(rawType: RawType) {6    }7}8import Foundation9import Mockingbird10import MockingbirdFramework11class Path {12    init(rawType: RawType) {13    }14}15import Foundation16import Mockingbird17import MockingbirdFramework18class Path {19    init(rawType: RawType) {20    }21}22import Foundation23import Mockingbird24import MockingbirdFramework25class Path {26    init(rawType: RawType) {27    }28}29import Foundation30import Mockingbird31import MockingbirdFramework32class Path {33    init(rawType: RawType) {34    }35}36import Foundation37import Mockingbird38import MockingbirdFramework39class Path {40    init(rawType: RawType) {41    }42}43import Foundation44import Mockingbird45import MockingbirdFramework46class Path {47    init(rawType: RawType) {48    }49}50import Foundation51import Mockingbird52import MockingbirdFramework53class Path {54    init(rawType: RawType) {55    }56}57import Foundation58import Mockingbird59import MockingbirdFramework60class Path {

1class RawType {2    init(name: String) {3    }4}5import Mockingbird6import Mockingbird7import Mockingbird8import Mockingbird9import Mockingbird10import Mockingbird11import Mockingbird12import Mockingbird13import Mockingbird14import Mockingbird15import Mockingbird16import Mockingbird17import Mockingbird18import Mockingbird19import Mockingbird20import Mockingbird21import Mockingbird22import Mockingbird23import Mockingbird24import Mockingbird25import Mockingbird26import Mockingbird27import Mockingbird

1import Foundation2import Mockingbird3enum RawType: String {4}5let rawTypeJson = try Mockingbird.generateJSON(from: rawType)6print(rawTypeJson)7import Foundation8import Mockingbird9enum RawType: String {10}11let rawTypeJson = try Mockingbird.generateJSON(from: rawType)12print(rawTypeJson)13import Foundation14import Mockingbird15enum RawType: String {16}17let rawTypeJson = try Mockingbird.generateJSON(from: rawType)18print(rawTypeJson)19import Foundation20import Mockingbird21enum RawType: String {22}23let rawTypeJson = try Mockingbird.generateJSON(from: rawType)24print(rawTypeJson)25import Foundation26import Mockingbird27enum RawType: String {28}29let rawTypeJson = try Mockingbird.generateJSON(from: rawType)30print(rawTypeJson)31import Foundation32import Mockingbird33enum RawType: String {

1import Mockingbird2import UIKit3import Foundation4extension RawType {5    public static func mock(_ value: Any) -> RawType {6        return RawType(value)7    }8}9import Mockingbird10import UIKit11import Foundation12extension RawType {13    public static func mock(_ value: Any) -> RawType {14        return RawType(value)15    }16}17import Mockingbird18import UIKit19import Foundation20extension RawType {21    public static func mock(_ value: Any) -> RawType {22        return RawType(value)23    }24}25import Mockingbird26import UIKit27import Foundation28extension RawType {29    public static func mock(_ value: Any) -> RawType {30        return RawType(value)31    }32}33import Mockingbird34import UIKit35import Foundation36extension RawType {37    public static func mock(_ value: Any) -> RawType {38        return RawType(value)39    }40}41import Mockingbird42import UIKit43import Foundation44extension RawType {45    public static func mock(_ value: Any) -> RawType {46        return RawType(value)47    }48}49import Mockingbird50import UIKit51import Foundation52extension RawType {53    public static func mock(_ value: Any) -> RawType {54        return RawType(value)55    }56}57import Mockingbird58import UIKit59import Foundation60extension RawType {61    public static func mock(_ value: Any) -> RawType {62        return RawType(value)63    }64}65import Mockingbird66import UIKit67import Foundation68extension RawType {69    public static func mock(_ value: Any) -> RawType {70        return RawType(value)71    }72}