Support elseif/else directive (#328)

* Create `ImportContent` which can recursively collect imports.

* Change `ImportMap` type to make it more structured.

* Add Clause type to IfMacroModel.

* Parse IfConfigDeclSyntax recursively and extract imports inside them as structured Import type.

* Render all entities of IfMacroModel.

* Update import rendering logic to consider both top-level imports and conditional imports.

* Update tests around IfMacro

* Add public access modifier to fix build error.

* Add testcases for IfMacro.

* Add testcases for nested macro and duplicatedImports in macro.

* Delete `ParsedImports` type, and use `[ImportContent]`

* Remove public acl from SourceParser and related types.

* Remove unnecessary changes

* Change from function-focused to structure-focused modeling

* Combine duplicate processes

* Fix redundant logic

* The `prefix` `suffix` became unnecessary with the introduction of ConditionalImportBlock.

* remove unused propertry

* Integrate separated logic between topLevel and nested

* Add test and handle @testable in nested import

* Remove unused property

* stop using legacy style coding

* Fix waning

* Remove unnecessary changes

* Rename ambiguous name

---------

Co-authored-by: Iceman <okamura@qoncept.co.jp>

Author: fummicc1

Sources/Mockolo/Executor.swift

@@ -192,7 +192,6 @@ struct Executor: ParsableCommand {
         do {
             try generate(sourceDirs: srcDirs,
                          sourceFiles: srcs,
-                         parser: SourceParser(),
                          exclusionSuffixes: exclusionSuffixes,
                          mockFilePaths: mockFilePaths,
                          annotation: annotation,

Sources/MockoloFramework/Models/ConditionalImportBlock.swift

@@ -0,0 +1,38 @@
+//
+//  Copyright (c) 2018. Uber Technologies
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+/// Represents import content: either a simple import statement or a nested conditional block
+indirect enum ImportContent {
+    case simple(Import)
+    case conditional(ConditionalImportBlock)
+}
+
+/// Represents a conditional import block (#if/#elseif/#else/#endif)
+struct ConditionalImportBlock {
+    /// Represents a single clause in a conditional import block
+    struct Clause {
+        var type: IfClauseType
+        var contents: [ImportContent]
+    }
+
+    let clauses: [Clause]
+    let offset: Int64
+
+    init(clauses: [Clause], offset: Int64) {
+        self.clauses = clauses
+        self.offset = offset
+    }
+}

Sources/MockoloFramework/Models/IfMacroModel.swift

@@ -14,36 +14,65 @@
 //  limitations under the License.
 //
 
+/// Represents the type of a clause in an #if/#elseif/#else block
+enum IfClauseType {
+    case `if`(_ condition: String)
+    case elseif(_ condition: String)
+    case `else`
+
+    var condition: String? {
+        switch self {
+        case .if(let condition), .elseif(let condition):
+            return condition
+        case .else:
+            return nil
+        }
+    }
+}
+
 final class IfMacroModel: Model {
-    let name: String
+    /// Represents a single clause in a conditional compilation block
+    struct Clause {
+        var type: IfClauseType
+        var entities: [(String, Model)]
+    }
+
+    let clauses: [Clause]
     let offset: Int64
-    let entities: [(String, Model)]
 
     var modelType: ModelType {
-        return .macro
+        .macro
+    }
+    
+    var name: String {
+        clauses.first?.type.condition ?? ""
     }
 
     var fullName: String {
-        return entities.map {$0.0}.joined(separator: "_")
+        clauses.flatMap(\.entities).map { $0.0 }.joined(separator: "_")
     }
-    
-    init(name: String,
-         offset: Int64,
-         entities: [(String, Model)]) {
-        self.name = name
-        self.entities = entities
+
+    /// Creates an IfMacroModel with multiple clauses
+    init(clauses: [Clause], offset: Int64) {
+        self.clauses = clauses
         self.offset = offset
     }
-    
+
+    /// Initializer for simple #if blocks
+    convenience init(name: String,
+                     offset: Int64,
+                     entities: [(String, Model)]) {
+        let clause = Clause(type: .if(name), entities: entities)
+        self.init(clauses: [clause], offset: offset)
+    }
+
     func render(
         context: RenderContext,
         arguments: GenerationArguments
     ) -> String? {
-        return applyMacroTemplate(
-            name: name,
+        applyMacroTemplate(
             context: context,
-            arguments: arguments,
-            entities: entities
+            arguments: arguments
         )
     }
 }

Sources/MockoloFramework/Models/Import.swift

@@ -61,36 +61,25 @@ struct Import: CustomStringConvertible {
 
     /// Name of the module
     var moduleName: String
+
 
     /// A modifier preceding the "import" keyword (e.g. public, internal, @testable)
     var modifier: Modifier?
-    
-    /// An opaque string preceding the entire import statement (typically `#if FOO\n` for nested macro support)
-    var prefix: String?
-    
-    /// An opaque string following the entire import statement (typically `\n#endif` for nested macro support)
-    var suffix: String?
-    
+
     var description: String {
-        let line: String
         if let modifier {
-            line = "\(modifier.rawValue) import \(moduleName)"
+            return "\(modifier.rawValue) import \(moduleName)"
         } else {
-            line = "import \(moduleName)"
+            return "import \(moduleName)"
         }
-        return [prefix, line, suffix].compactMap { $0 }.joined()
     }
 
     init(
         moduleName: String,
-        modifier: Modifier? = nil,
-        prefix: String? = nil,
-        suffix: String? = nil
+        modifier: Modifier? = nil
     ) {
         self.moduleName = moduleName
         self.modifier = modifier
-        self.prefix = prefix
-        self.suffix = suffix
     }
 }
 
@@ -104,7 +93,6 @@ extension Import {
     }
 
     /// Creates an `Import` by parsing a `String` provided by `Generator`.
-    /// It is typically a single line, but can be wrapped by `#if FOO\n...\n#endif` when it's a nested macro.
     init?(line: String) {
         guard let importSpaceRange = line.range(of: String.importSpace) else { return nil }
 
@@ -121,9 +109,6 @@ extension Import {
             let modifierEndIndex = line.index(before: importSpaceRange.lowerBound)
             modifier = Modifier(rawValue: String(line[startIndex..<modifierEndIndex]))
         }
-        
-        `prefix` = firstNewlineIndex.map { String(line[...$0]) }
-        suffix = lastNewlineIndex.map { String(line[$0...]) }
     }
 }
 
@@ -136,9 +121,7 @@ extension Array where Element == Import {
     /// - sorts by module name
     func resolved() -> [Import] {
         var modifierByModuleName = [String: Import.Modifier]()
-        var prefixByModuleName = [String: String]()
-        var suffixByModuleName = [String: String]()
-        
+
         for imp in self {
             switch (imp.modifier, modifierByModuleName[imp.moduleName]) {
             case let (.acl(acl), .acl(existingACL)):
@@ -152,21 +135,12 @@ extension Array where Element == Import {
             default:
                 break
             }
-            
-            if let prefix = imp.prefix {
-                prefixByModuleName[imp.moduleName] = prefix
-            }
-            if let suffix = imp.suffix {
-                suffixByModuleName[imp.moduleName] = suffix
-            }
         }
 
         return Set(map(\.moduleName)).sorted().map {
             Import(
                 moduleName: $0,
-                modifier: modifierByModuleName[$0],
-                prefix: prefixByModuleName[$0],
-                suffix: suffixByModuleName[$0]
+                modifier: modifierByModuleName[$0]
             )
         }
     }

Sources/MockoloFramework/Models/ParsedEntity.swift

@@ -150,7 +150,7 @@ struct GenerationArguments {
     )
 }
 
-public typealias ImportMap = [String: [String: [String]]]
+typealias ImportMap = [String: [ImportContent]]
 
 /// Metadata for a type being mocked
 public final class Entity {

Sources/MockoloFramework/Operations/Generator.swift

@@ -25,7 +25,6 @@ enum InputError: Error {
 @discardableResult
 public func generate(sourceDirs: [String],
                      sourceFiles: [String],
-                     parser: SourceParser,
                      exclusionSuffixes: [String],
                      mockFilePaths: [String]?,
                      annotation: String,
@@ -47,7 +46,8 @@ public func generate(sourceDirs: [String],
         log("Source files or directories do not exist", level: .error)
         throw InputError.sourceFilesError
     }
-    
+
+    let parser = SourceParser()
     scanConcurrencyLimit = concurrencyLimit
     minLogLevel = loggingLevel
     var candidates = [(String, Int64)]()