Simplify Model by extracting a lot of the logic

Author: tomasf

Sources/Cadova/Abstract Layer/Geometry/References/ReferenceState.swift

@@ -75,14 +75,3 @@ extension ReferenceState {
         otherState.usedAnchors.intersection(definedAnchors.keys).count > 0 || otherState.usedTags.intersection(definedTags.keys).count > 0
     }
 }
-
-extension ReferenceState {
-    func printWarningsAtTopLevel() {
-        if !undefinedAnchors.isEmpty {
-            logger.warning("Undefined anchors: \(undefinedAnchors)")
-        }
-        if !undefinedTags.isEmpty {
-            logger.warning("Undefined tags: \(undefinedTags)")
-        }
-    }
-}

Sources/Cadova/Concrete Layer/Build/Build.swift

@@ -0,0 +1,46 @@
+import Foundation
+
+extension [BuildDirective] {
+    func build(
+        with options: ModelOptions,
+        in environment: EnvironmentValues,
+        context: EvaluationContext
+    ) async throws -> (OutputDataProvider, [BuildWarning]) {
+        let geometries3D = compactMap(\.geometry3D)
+        let geometries2D = compactMap(\.geometry2D)
+
+        if geometries3D.count > 0 {
+            let promotedFrom2D = geometries2D.map { $0.promotedTo3D() }
+            let result = try await context.buildModelResult(for: Union(geometries3D + promotedFrom2D), in: environment)
+            return (options.dataProvider(for: result), result.buildWarnings)
+
+        } else if geometries2D.count > 0 {
+            let result = try await context.buildModelResult(for: Union(geometries2D), in: environment)
+            return (options.dataProvider(for: result), result.buildWarnings)
+
+        } else {
+            throw BuildError.noGeometry
+        }
+    }
+}
+
+enum BuildError: Error {
+    case noGeometry
+}
+
+fileprivate extension Geometry2D {
+    func promotedTo3D() -> any Geometry3D {
+        extruded(height: 0.001)
+    }
+}
+
+internal extension EnvironmentValues {
+    func adding(directives: [BuildDirective], modelOptions: ModelOptions) -> Self {
+        var mutatingEnvironment = self
+        for builder in directives.compactMap(\.environment) {
+            builder(&mutatingEnvironment)
+        }
+        mutatingEnvironment.modelOptions = modelOptions
+        return mutatingEnvironment
+    }
+}

Sources/Cadova/Concrete Layer/Build/BuildWarning.swift

@@ -0,0 +1,38 @@
+import Foundation
+
+public enum BuildWarning {
+    case onlyModifier
+    case undefinedAnchors (Set<Anchor>)
+    case undefinedTags (Set<Tag>)
+
+    public var description: String {
+        switch self {
+        case .onlyModifier:
+            return "Model uses only() modifier; saving a partial geometry tree"
+
+        case .undefinedAnchors (let anchors):
+            return "Undefined anchors: \(anchors)"
+
+        case .undefinedTags (let tags):
+            return "Undefined tags: \(tags)"
+        }
+    }
+}
+
+extension BuildResult {
+    var buildWarnings: [BuildWarning] {
+        var warnings: [BuildWarning] = []
+        let referenceState = elements[ReferenceState.self]
+
+        if !referenceState.undefinedTags.isEmpty {
+            warnings.append(.undefinedTags(referenceState.undefinedTags))
+        }
+        if !referenceState.undefinedAnchors.isEmpty {
+            warnings.append(.undefinedAnchors(referenceState.undefinedAnchors))
+        }
+        if hasOnly {
+            warnings.append(.onlyModifier)
+        }
+        return warnings
+    }
+}

Sources/Cadova/Concrete Layer/Build/Model/Model.swift

@@ -95,19 +95,8 @@ public struct Model: Sendable {
         let directives = inheritedEnvironment.whileCurrent {
             self.directives()
         }
-        let localOptions: ModelOptions = [
-            .init(ModelName(name: name)),
-            inheritedOptions ?? [],
-            options,
-            .init(directives.compactMap(\.options))
-        ]
-
-        var mutatingEnvironment = inheritedEnvironment
-        for builder in directives.compactMap(\.environment) {
-            builder(&mutatingEnvironment)
-        }
-        mutatingEnvironment.modelOptions = localOptions
-        let environment = mutatingEnvironment
+        let options = self.options.adding(modelName: name, defaults: inheritedOptions, directives: directives)
+        let environment = inheritedEnvironment.adding(directives: directives, modelOptions: options)
 
         let baseURL: URL
         if let parent = directory {
@@ -116,31 +105,24 @@ public struct Model: Sendable {
             baseURL = URL(expandingFilePath: name)
         }
 
-        let geometries3D = directives.compactMap(\.geometry3D)
-        let geometries2D = directives.compactMap(\.geometry2D)
         let provider: OutputDataProvider
 
         do {
-            if geometries3D.count > 0 {
-                let promotedFrom2D = geometries2D.map { $0.promotedTo3D() }
-                let result = try await generateResult(for: Union(geometries3D + promotedFrom2D), in: environment, context: context)
-
-                switch localOptions[ModelOptions.FileFormat3D.self] {
-                case .threeMF: provider = ThreeMFDataProvider(result: result, options: localOptions)
-                case .stl: provider = BinarySTLDataProvider(result: result, options: localOptions)
-                }
-
-            } else if geometries2D.count > 0 {
-                let result = try await generateResult(for: Union(geometries2D), in: environment, context: context)
-
-                switch localOptions[ModelOptions.FileFormat2D.self] {
-                case .threeMF: provider = ThreeMFDataProvider(result: result.promotedTo3D(), options: localOptions)
-                case .svg: provider = SVGDataProvider(result: result, options: localOptions)
-                }
-            } else {
-                logger.warning("No geometry for model \"\(name)\"")
-                return nil
+            let warnings: [BuildWarning]
+            (provider, warnings) = try await ContinuousClock().measure {
+                try await directives.build(with: options, in: environment, context: context)
+            } results: { duration, _ in
+                logger.debug("Built geometry node tree in \(duration)")
+            }
+
+            for warning in warnings {
+                logger.warning("⚠️ \(warning.description)")
             }
+
+        } catch BuildError.noGeometry {
+            logger.error("No geometry for model \"\(name)\"")
+            return nil
+
         } catch {
             logger.error("Cadova caught an error while evaluating model \"\(name)\":\n🛑 \(error)\n")
             return nil
@@ -158,21 +140,6 @@ public struct Model: Sendable {
 
         return fileExisted ? nil : url
     }
-
-    private func generateResult<D: Dimensionality>(
-        for geometry: D.Geometry,
-        in environment: EnvironmentValues,
-        context: EvaluationContext
-    ) async throws -> BuildResult<D> {
-        let result = try await ContinuousClock().measure {
-            try await context.buildModelResult(for: geometry, in: environment)
-        } results: { duration, _ in
-            logger.debug("Built geometry node tree in \(duration)")
-        }
-
-        result.printWarnings(modelName: name)
-        return result
-    }
 }
 
 extension Error {
@@ -184,18 +151,3 @@ extension Error {
         }
     }
 }
-
-fileprivate extension Geometry2D {
-    func promotedTo3D() -> any Geometry3D {
-        extruded(height: 0.001)
-    }
-}
-
-fileprivate extension BuildResult {
-    func printWarnings(modelName: String) {
-        if hasOnly {
-            logger.warning("⚠️ Model \"\(modelName)\" uses only() modifier; saving a partial geometry tree")
-        }
-        elements[ReferenceState.self].printWarningsAtTopLevel()
-    }
-}

Sources/Cadova/Concrete Layer/Build/Options/FileFormats.swift

@@ -37,3 +37,19 @@ public extension ModelOptions {
         internal func combined(with other: Self) -> Self { other }
     }
 }
+
+extension ModelOptions {
+    func dataProvider(for result: BuildResult<D3>) -> OutputDataProvider {
+        switch self[FileFormat3D.self] {
+        case .threeMF: return ThreeMFDataProvider(result: result, options: self)
+        case .stl: return BinarySTLDataProvider(result: result, options: self)
+        }
+    }
+
+    func dataProvider(for result: BuildResult<D2>) -> OutputDataProvider {
+        switch self[FileFormat2D.self] {
+        case .threeMF: return ThreeMFDataProvider(result: result.promotedTo3D(), options: self)
+        case .svg: return SVGDataProvider(result: result, options: self)
+        }
+    }
+}

Sources/Cadova/Concrete Layer/Build/Options/ModelOptions.swift

@@ -21,6 +21,17 @@ public struct ModelOptions: Sendable, ExpressibleByArrayLiteral {
     }
 }
 
+internal extension ModelOptions {
+    func adding(modelName: String? = nil, defaults: ModelOptions? = nil, directives: [BuildDirective] = []) -> Self {
+        [
+            .init(ModelName(name: modelName)),
+            defaults ?? [],
+            self,
+            .init(directives.compactMap(\.options))
+        ]
+    }
+}
+
 internal protocol ModelOptionItem: Sendable {
     static var defaultValue: Self { get }
     func combined(with other: Self) -> Self