Support ImageClassPicker with a view model

Author: leptos-null

HeaderViewer/ContentView.swift

@@ -86,7 +86,6 @@ struct ContentRootView: View {
             .navigationDestination(for: NamedNode.self) { namedNode in
                 if namedNode.isLeaf {
                     ImageClassPicker(namedNode: namedNode, selection: $selectedObject)
-                        .environmentObject(listings)
                 } else {
                     NamedNodeView(node: namedNode)
                         .environmentObject(listings)

HeaderViewer/ImageClassPicker.swift

@@ -8,77 +8,141 @@
 import SwiftUI
 import ClassDump
 
-struct ImageClassPicker: View {
+private enum ImageLoadState {
+    case notLoaded
+    case loading
+    case loaded
+    case loadError(Error)
+}
+
+private class ImageClassPickerModel: ObservableObject {
     let namedNode: NamedNode
-    @Binding private var selection: RuntimeObjectType?
-    @State private var searchString: String = ""
-    @State private var loadError: Error?
 
-    @EnvironmentObject private var listings: RuntimeListings
+    let imagePath: String
+    let imageName: String
 
-    private var classNames: [String] {
-        CDUtilities.classNamesIn(image: namedNode.path)
-    }
+    let runtimeListings: RuntimeListings = .shared
 
-    init(namedNode: NamedNode, selection: Binding<RuntimeObjectType?>) {
-        self.namedNode = namedNode
-        _selection = selection
-    }
+    @Published var searchString: String
+    
+    @Published private(set) var classNames: [String] // not filtered
+    @Published private(set) var runtimeObjects: [RuntimeObjectType] // filtered based on search
+    @Published private(set) var loadState: ImageLoadState
 
-    private var runtimeObjects: [RuntimeObjectType] {
+    private static func runtimeObjectsFor(classNames: [String], searchString: String) -> [RuntimeObjectType] {
         let ret: [RuntimeObjectType] = classNames.map { .class(named: $0) }
         if searchString.isEmpty { return ret }
         return ret.filter { $0.name.localizedCaseInsensitiveContains(searchString) }
     }
 
+    init(namedNode: NamedNode) {
+        self.namedNode = namedNode
+        
+        let imagePath = namedNode.path
+        self.imagePath = imagePath
+        self.imageName = namedNode.name
+        
+        let classNames = CDUtilities.classNamesIn(image: imagePath)
+        self.classNames = classNames
+        
+        let searchString = ""
+        self.searchString = searchString
+        
+        self.runtimeObjects = Self.runtimeObjectsFor(classNames: classNames, searchString: searchString)
+        
+        self.loadState = runtimeListings.isImageLoaded(path: imagePath) ? .loaded : .notLoaded
+        
+        runtimeListings.$classList
+            .map { _ in
+                CDUtilities.classNamesIn(image: imagePath)
+            }
+            .assign(to: &$classNames)
+        
+        let debouncedSearch = $searchString
+            .debounce(for: 0.08, scheduler: RunLoop.main)
+        
+        $classNames.combineLatest(debouncedSearch) { classNames, searchString in
+            Self.runtimeObjectsFor(classNames: classNames, searchString: searchString)
+        }
+        .assign(to: &$runtimeObjects)
+        
+        runtimeListings.$imageList
+            .map { imageList in
+                imageList.contains(CDUtilities.patchImagePathForDyld(imagePath))
+            }
+            .filter { $0 } // only allow isLoaded to pass through; we don't want to erase an existing state
+            .map { _ in
+                ImageLoadState.loaded
+            }
+            .assign(to: &$loadState)
+    }
+    
+    func tryLoadImage() {
+        do {
+            loadState = .loading
+            try CDUtilities.loadImage(at: imagePath)
+            // we could set .loaded here, but there are already pipelines that will update the state
+        } catch {
+            loadState = .loadError(error)
+        }
+    }
+}
+
+struct ImageClassPicker: View {
+    @StateObject private var viewModel: ImageClassPickerModel
+    @Binding private var selection: RuntimeObjectType?
+    
+    init(namedNode: NamedNode, selection: Binding<RuntimeObjectType?>) {
+        _viewModel = StateObject(wrappedValue: ImageClassPickerModel(namedNode: namedNode))
+        _selection = selection
+    }
+    
     var body: some View {
         Group {
-            if let loadError {
-                if let dlOpenError = loadError as? DlOpenError,
-                   let errorMessage = dlOpenError.message {
-                    StatusView {
-                        Text(errorMessage)
-                            .font(.callout.monospaced())
-                            .padding(.top)
-                    }
-                } else {
-                    StatusView {
-                        Text("An unknown error occured trying to load '\(namedNode.path)'")
-                            .padding(.top)
+            switch viewModel.loadState {
+            case .notLoaded:
+                StatusView {
+                    Text("\(viewModel.imageName) is not yet loaded")
+                        .padding(.top)
+                    Button {
+                        viewModel.tryLoadImage()
+                    } label: {
+                        Text("Load now")
                     }
+                    .buttonStyle(.bordered)
                 }
-            } else if listings.isImageLoaded(path: namedNode.path) {
-                let runtimeObjects = self.runtimeObjects
-                if runtimeObjects.isEmpty {
+            case .loading:
+                ProgressView()
+                    .scenePadding()
+            case .loaded:
+                if viewModel.classNames.isEmpty {
                     StatusView {
-                        Text("\(namedNode.name) is loaded however does not appear to contain any classes")
+                        Text("\(viewModel.imageName) is loaded however does not appear to contain any classes")
                             .padding(.top)
                     }
                 } else {
+                    let runtimeObjects = viewModel.runtimeObjects
                     ListView(runtimeObjects, selection: $selection) { runtimeObject in
                         RuntimeObjectRow(type: runtimeObject)
                     }
                     .id(runtimeObjects) // don't try to diff the List
-                    .searchable(text: $searchString)
+                    .searchable(text: $viewModel.searchString)
                 }
-            } else {
+            case .loadError(let error):
                 StatusView {
-                    Text("\(namedNode.name) is not yet loaded")
-                        .padding(.top)
-                    Button {
-                        do {
-                            try CDUtilities.loadImage(at: namedNode.path)
-                        } catch {
-                            loadError = error
-                        }
-                    } label: {
-                        Text("Load now")
+                    if let dlOpenError = error as? DlOpenError,
+                       let errorMessage = dlOpenError.message {
+                        Text(errorMessage)
+                            .font(.callout.monospaced())
+                            .padding(.top)
+                    } else {
+                        Text("An unknown error occured trying to load '\(viewModel.imagePath)'")
+                            .padding(.top)
                     }
-                    .buttonStyle(.bordered)
                 }
             }
         }
-        .navigationTitle(namedNode.name)
+        .navigationTitle(viewModel.imageName)
     }
 }