Merge pull request #174 from scribd/stephane/fix_runtime_parse

Fix two bugs

Author: Stephane Magne

Sources/WeaverCodeGen/Inspector.swift

@@ -29,11 +29,18 @@ public final class Inspector {
             }
         }
 
+        try validateRuntime()
+    }
+
+    @discardableResult
+    public func validateRuntime() throws -> [TreeNode] {
+        var treeNodes: [TreeNode] = []
         for rootContainer in dependencyGraph.rootContainers {
-            if let treeInspector = RuntimeTreeInspector(rootContainer: rootContainer, dependencyGraph: dependencyGraph) {
-                try treeInspector.validate()
-            }
+            let treeInspector = RuntimeTreeInspector(rootContainer: rootContainer, dependencyGraph: dependencyGraph)
+            try treeInspector.validate()
+            treeNodes.append(treeInspector.rootNode)
         }
+        return treeNodes
     }
 }
 

Sources/WeaverCodeGen/RuntimeTreeInspector.swift

@@ -11,12 +11,11 @@ import Foundation
 
 public final class RuntimeTreeInspector {
 
-    private let rootNode: TreeNode
+    public let rootNode: TreeNode
 
-    init?(rootContainer: DependencyContainer,
-          dependencyGraph: DependencyGraph) {
-        guard let treeNode = TreeNode(rootContainer: rootContainer, dependencyGraph: dependencyGraph) else { return nil }
-        self.rootNode = treeNode
+    init(rootContainer: DependencyContainer,
+         dependencyGraph: DependencyGraph) {
+        self.rootNode = TreeNode(rootContainer: rootContainer, dependencyGraph: dependencyGraph)
     }
 
     public func validate() throws {
@@ -97,8 +96,9 @@ private extension RuntimeTreeInspector {
 
         // dependencyChain
         var stepCount = 1
-        for parentContainer in node.dependencyChain.reversed() {
-            if let earlyReturn = resolveStep(stepCount, parentContainer) {
+        var _parent = node.parent
+        while let parent = _parent {
+            if let earlyReturn = resolveStep(stepCount, parent.inspectingContainer) {
                 switch earlyReturn {
                 case .empty:
                     return nil
@@ -107,49 +107,52 @@ private extension RuntimeTreeInspector {
                 }
             }
 
+            _parent = parent.parent
             stepCount += 1
         }
 
-        if let rootContainer = node.dependencyChain.first {
-            history.append(.dependencyNotFound(dependency, in: rootContainer))
-        }
+        history.append(.dependencyNotFound(dependency, in: rootNode.inspectingContainer))
 
         return history
     }
 }
 
 // MARK: - Full Tree Iterator
 
-final class TreeNode: Sequence, IteratorProtocol {
+public final class TreeNode: Sequence, IteratorProtocol {
 
     let inspectingContainer: DependencyContainer
 
-    let dependencyChain: [DependencyContainer]
+    private(set) var children: [TreeNode] = []
 
-    let dependencyGraph: DependencyGraph
+    weak var parent: TreeNode?
 
-    let dependencyPointer: Dependency
+    // do not encode
+    private(set) var dependencyPointer: Dependency?
 
-    convenience init?(rootContainer: DependencyContainer,
-                      dependencyGraph: DependencyGraph) {
-        guard let firstDependency = rootContainer.dependencies.orderedValues.first else {
-            return nil
-        }
+    private(set) var previousDependencyPointer: Dependency?
+
+    let dependencyGraph: DependencyGraph
 
+    convenience init(rootContainer: DependencyContainer,
+                     dependencyGraph: DependencyGraph) {
         self.init(inspectingContainer: rootContainer,
-                  dependencyChain: [],
                   dependencyGraph: dependencyGraph,
-                  dependencyPointer: firstDependency)
+                  dependencyPointer: rootContainer.dependencies.orderedValues.first,
+                  previousDependencyPointer: nil,
+                  parent: nil)
     }
 
     private init(inspectingContainer: DependencyContainer,
-                dependencyChain: [DependencyContainer],
-                dependencyGraph: DependencyGraph,
-                dependencyPointer: Dependency) {
+                 dependencyGraph: DependencyGraph,
+                 dependencyPointer: Dependency?,
+                 previousDependencyPointer: Dependency?,
+                 parent: TreeNode?) {
         self.inspectingContainer = inspectingContainer
-        self.dependencyChain = dependencyChain
         self.dependencyGraph = dependencyGraph
         self.dependencyPointer = dependencyPointer
+        self.previousDependencyPointer = previousDependencyPointer
+        self.parent = parent
     }
 
     /*
@@ -160,18 +163,26 @@ final class TreeNode: Sequence, IteratorProtocol {
      - If none, then move to the next sibling dependency in the current node
      - If none, then pop up to the parent node
      */
-    func next() -> TreeNode? {
+    public func next() -> TreeNode? {
+
+        guard let dependencyPointer = dependencyPointer else {
+            return nextByPopping()
+        }
 
         guard dependencyPointer.kind.isRegistration,
-              let nextContainer = try? dependencyGraph.dependencyContainer(for: dependencyPointer),
-              let firstNestedDependency = nextContainer.dependencies.orderedValues.first else {
-            return nextByIterating(after: dependencyPointer)
+              let nextContainer = try? dependencyGraph.dependencyContainer(for: dependencyPointer) else {
+                  return nextByIterating(after: dependencyPointer)
         }
 
-        return TreeNode(inspectingContainer: nextContainer,
-                        dependencyChain: dependencyChain + [inspectingContainer],
-                        dependencyGraph: dependencyGraph,
-                        dependencyPointer: firstNestedDependency)
+        let node = TreeNode(inspectingContainer: nextContainer,
+                            dependencyGraph: dependencyGraph,
+                            dependencyPointer: nextContainer.dependencies.orderedValues.first,
+                            previousDependencyPointer: dependencyPointer,
+                            parent: self)
+
+        children.append(node)
+
+        return node
     }
 
     private func nextByIterating(after dependency: Dependency) -> TreeNode? {
@@ -183,34 +194,17 @@ final class TreeNode: Sequence, IteratorProtocol {
         }
 
         let nextIndex = values.index(after: firstIndex)
-        guard nextIndex < values.count else {
-            return nextByPopping()
-        }
-
-        let nextDependency: Dependency = values[nextIndex]
-        return TreeNode(inspectingContainer: inspectingContainer,
-                        dependencyChain: dependencyChain,
-                        dependencyGraph: dependencyGraph,
-                        dependencyPointer: nextDependency).next()
+        dependencyPointer = nextIndex < values.count ? values[nextIndex] : nil
+        return next()
     }
 
     private func nextByPopping() -> TreeNode? {
-        guard let parentContainer: DependencyContainer = dependencyChain.last else {
-            return nil
-        }
-
-        guard let dependencyNames = parentContainer.dependencyNamesByConcreteType[inspectingContainer.type] else {
-            return nil
-        }
 
-        guard let dependencyName = dependencyNames.first(where: { parentContainer.dependencies[$0] != nil }),
-              let parentDependency = parentContainer.dependencies[dependencyName] else {
+        guard let parent = parent,
+              let parentDependency = parent.inspectingContainer.dependencies.orderedValues.first(where: { $0 === previousDependencyPointer }) else {
             return nil
         }
 
-        return TreeNode(inspectingContainer: parentContainer,
-                        dependencyChain: dependencyChain.dropLast(),
-                        dependencyGraph: dependencyGraph,
-                        dependencyPointer: parentDependency).nextByIterating(after: parentDependency)
+        return parent.nextByIterating(after: parentDependency)
     }
 }

Sources/WeaverCommand/Configuration.swift

@@ -240,15 +240,23 @@ extension Configuration {
 
     func inputPaths() throws -> [Path]  {
         var inputPaths = Set<Path>()
-        
+        var fullIgnoredPaths = Set<Path>()
+
         inputPaths.formUnion(inputPathStrings
             .lazy
             .map { self.projectPath + $0 }
             .flatMap { $0.isFile ? [$0] : self.recursivePathsByPattern(fromDirectory: $0) }
             .filter { $0.exists && $0.isFile && $0.extension == "swift" }
             .map { $0.absolute() })
 
-        inputPaths.subtract(try ignoredPathStrings
+        fullIgnoredPaths.formUnion(ignoredPathStrings
+            .lazy
+            .map { self.projectPath + $0 }
+            .flatMap { $0.isFile ? [$0] : self.recursivePathsByPattern(fromDirectory: $0) }
+            .filter { $0.exists && $0.isFile && $0.extension == "swift" }
+            .map { $0.absolute() })
+
+        inputPaths.subtract(try fullIgnoredPaths
             .lazy
             .map { self.projectPath + $0 }
             .flatMap { $0.isFile ? [$0] : try paths(fromDirectory: $0) }

Tests/WeaverCodeGenTests/RuntimeTreeInspectorTests.swift

@@ -108,4 +108,60 @@ final class RuntimeTreeInspectorTests: XCTestCase {
             XCTFail("Unexpected error: \(error).")
         }
     }
+
+    func test_tree_inspector_should_validate_a_dependency_graph_with_the_same_concrete_type_fulfilling_multiple_individual_abstractions() {
+
+        let file = File(contents: """
+            protocol DataConfiguring { }
+
+            protocol DataProviding { }
+
+            final class Coordinator {
+                // weaver: value <= Int
+            }
+
+            final class AppDelegate {
+                // weaver: coordinator = Coordinator
+                // weaver: coordinator.scope = .transient
+
+                // weaver: dataConfiguration = DataManager <- DataConfiguring
+                // weaver: dataConfiguration.scope = .container
+                // weaver: dataConfiguration.builder = { _ in DataManager.shared }
+
+                // weaver: dataProvider = DataManager <- DataProviding
+                // weaver: dataProvider.scope = .container
+                // weaver: dataProvider.builder = { _ in DataManager.shared }
+
+                // weaver: viewController1 = ViewController1
+                // weaver: viewController1.scope = .transient
+            }
+
+            final class DataManager: DataConfiguring, DataProviding {
+                static let shared = DataManager()
+            }
+
+            final class ViewController1: UIViewController {
+                // weaver: coordinator <= Coordinator
+
+                // weaver: viewController2 = ViewController2
+                // weaver: viewController2.scope = .transient
+            }
+
+            final class ViewController2: UIViewController {
+                // weaver: coordinator <- Coordinator
+            }
+            """)
+
+        do {
+            let lexer = Lexer(file, fileName: "test.swift")
+            let tokens = try lexer.tokenize()
+            let parser = Parser(tokens, fileName: "test.swift")
+            let syntaxTree = try parser.parse()
+            let linker = try Linker(syntaxTrees: [syntaxTree])
+            let inspector = Inspector(dependencyGraph: linker.dependencyGraph)
+            try inspector.validate()
+        } catch {
+            XCTFail("Unexpected error: \(error)")
+        }
+    }
 }