Replace dictionary-based data to the list-based approach

justtwago · justtwago · commit a0e8b8125fb9 · 2024-02-01T14:48:26.000-07:00
diff --git a/WordPress/Classes/ViewRelated/Me/App Settings/Boolean User Defaults/BooleanUserDefaultsDebugView.swift b/WordPress/Classes/ViewRelated/Me/App Settings/Boolean User Defaults/BooleanUserDefaultsDebugView.swift
@@ -5,17 +5,23 @@ struct BooleanUserDefaultsDebugView: View {
 
     var body: some View {
         List {
-            ForEach(viewModel.userDefaultsSections.keys.sorted(), id: \.self) { sectionKey in
-                let userDefaultsSection = viewModel.userDefaultsSections[sectionKey] ?? BooleanUserDefaultEntries()
-
-                Section(header: Text(sectionKey)
+            ForEach(viewModel.userDefaultsSections, id: \.key) { section in
+                Section(header: Text(section.key)
                     .font(.caption)) {
-                        ForEach(userDefaultsSection.keys.sorted(), id: \.self) { userDefaultKey in
+                        ForEach(section.rows, id: \.key) { row in
                             let isOn = Binding<Bool>(
-                                get: { userDefaultsSection[userDefaultKey]?.value ?? false },
-                                set: { newValue in viewModel.updateUserDefault(newValue, forSection: sectionKey, forUserDefault: userDefaultKey) }
+                                get: {
+                                    row.value
+                                },
+                                set: { newValue in
+                                    viewModel.updateUserDefault(
+                                        newValue,
+                                        forSection: section.key,
+                                        forRow: row.key
+                                    )
+                                }
                             )
-                            Toggle(userDefaultsSection[userDefaultKey]?.title ?? Strings.unrecognizedEntryTitle, isOn: isOn)
+                            Toggle(row.title, isOn: isOn)
                                 .font(.caption)
                                 .toggleStyle(
                                     SwitchToggleStyle(
diff --git a/WordPress/Classes/ViewRelated/Me/App Settings/Boolean User Defaults/BooleanUserDefaultsDebugViewModel.swift b/WordPress/Classes/ViewRelated/Me/App Settings/Boolean User Defaults/BooleanUserDefaultsDebugViewModel.swift
@@ -1,86 +1,126 @@
 import SwiftUI
 
-typealias BooleanUserDefaultsSections = [String: BooleanUserDefaultEntries]
-typealias BooleanUserDefaultEntries = [String: BooleanUserDefault]
-
 final class BooleanUserDefaultsDebugViewModel: ObservableObject {
-    @Published private var allUserDefaultsSections = BooleanUserDefaultsSections()
-    @Published var searchQuery: String = ""
-
-    private var persistentRepository: UserPersistentRepository
-
-    var userDefaultsSections: BooleanUserDefaultsSections {
-        return filterUserDefaults(by: searchQuery)
-    }
-
-    let coreDataStack: CoreDataStack
+    private let persistentRepository: UserPersistentRepository
+    private let coreDataStack: CoreDataStack
 
-    private func filterUserDefaults(by query: String) -> BooleanUserDefaultsSections {
-        guard !query.isEmpty else {
-            return allUserDefaultsSections
+    private var allUserDefaultsSections = Sections() {
+        didSet {
+            self.reloadSections()
         }
+    }
 
-        var filteredSections = BooleanUserDefaultsSections()
-        allUserDefaultsSections.forEach { sectionKey, userDefaults in
-            let filteredUserDefaults = userDefaults.filter { key, userDefault in
-                key.localizedCaseInsensitiveContains(query) || userDefault.title.localizedCaseInsensitiveContains(query)
-            }
-            if sectionKey.localizedCaseInsensitiveContains(query) || !filteredUserDefaults.isEmpty {
-                filteredSections[sectionKey] = filteredUserDefaults.isEmpty ? userDefaults : filteredUserDefaults
-            }
+    @Published var searchQuery: String = "" {
+        didSet {
+            self.reloadSections()
         }
-        return filteredSections
     }
 
+    @Published var userDefaultsSections: Sections = []
+
     init(coreDataStack: CoreDataStack = ContextManager.shared,
          persistentRepository: UserPersistentRepository = UserPersistentStoreFactory.instance()) {
         self.coreDataStack = coreDataStack
         self.persistentRepository = persistentRepository
-        load()
     }
 
     func load() {
         let allUserDefaults = persistentRepository.dictionaryRepresentation()
-        var loadedUserDefaultsSections = BooleanUserDefaultsSections()
-        var otherSection = BooleanUserDefaultEntries()
-
-        for (entryKey, entryValue) in allUserDefaults {
-            if let groupedUserDefaults = entryValue as? [String: Bool], !isFeatureFlagsSection(entryKey) {
-                loadedUserDefaultsSections[entryKey] = processGroupedUserDefaults(groupedUserDefaults)
-            } else if let booleanUserDefault = entryValue as? Bool, !isGutenbergUserDefault(entryKey) {
-                otherSection[entryKey] = BooleanUserDefault(title: entryKey, value: booleanUserDefault)
+        var loadedUserDefaultsSections = Sections()
+        var otherSection = [Row]()
+
+        for (key, value) in allUserDefaults {
+            if let groupedUserDefaults = value as? [String: Bool], !isFeatureFlagsSection(key) {
+                let section = Section(
+                    key: key,
+                    rows: processGroupedUserDefaults(groupedUserDefaults)
+                )
+                loadedUserDefaultsSections.append(section)
+            } else if let booleanUserDefault = value as? Bool, !isGutenbergUserDefault(key) {
+                otherSection.append(.init(key: key, title: key, value: booleanUserDefault))
             }
         }
         if !otherSection.isEmpty {
-            loadedUserDefaultsSections[Strings.otherBooleanUserDefaultsSectionID] = otherSection
+            let rows = otherSection.sorted { $0.title < $1.title }
+            let section = Section(key: Strings.otherBooleanUserDefaultsSectionID, rows: rows)
+            loadedUserDefaultsSections.append(section)
         }
         allUserDefaultsSections = loadedUserDefaultsSections
     }
 
-    private func processGroupedUserDefaults(_ userDefaults: [String: Bool]) -> BooleanUserDefaultEntries {
-        userDefaults.reduce(into: BooleanUserDefaultEntries()) { result, keyValue in
+    private func reloadSections() {
+        self.userDefaultsSections = filterUserDefaults(by: searchQuery)
+    }
+
+    private func filterUserDefaults(by query: String) -> Sections {
+        guard !query.isEmpty else {
+            return allUserDefaultsSections
+        }
+
+        var filteredSections = Sections()
+        allUserDefaultsSections.forEach { section in
+            let filteredUserDefaults = section.rows.filter { entry in
+                section.key.localizedCaseInsensitiveContains(query) || entry.title.localizedCaseInsensitiveContains(query)
+            }
+            if section.key.localizedCaseInsensitiveContains(query) || !filteredUserDefaults.isEmpty {
+                let section = Section(
+                    key: section.key,
+                    rows: filteredUserDefaults.isEmpty ? section.rows : filteredUserDefaults
+                )
+                filteredSections.append(section)
+            }
+        }
+        return filteredSections
+    }
+
+    private func processGroupedUserDefaults(_ userDefaults: [String: Bool]) -> [Row] {
+        var rows = userDefaults.reduce(into: [Row]()) { result, keyValue in
             let (key, value) = keyValue
-            result[key] = processSingleUserDefault(key: key, value: value)
+            result.append(processSingleUserDefault(key: key, value: value))
         }
+        rows = rows.sorted { $0.title < $1.title }
+        return rows
+    }
+
+    private func processSingleUserDefault(key: String, value: Bool) -> Row {
+        let title = findBlog(byID: key)?.url ?? key
+        return Row(key: key, title: title, value: value)
     }
 
-    private func processSingleUserDefault(key: String, value: Bool) -> BooleanUserDefault {
-        if let siteID = Int(key), let blogURL = try? Blog.lookup(withID: siteID, in: coreDataStack.mainContext)?.url {
-            return BooleanUserDefault(title: blogURL, value: value)
+    private func findBlog(byID id: String) -> Blog? {
+        return try? Blog.lookup(withID: Int(id) ?? 0, in: coreDataStack.mainContext)
+    }
+
+    func updateUserDefault(_ newValue: Bool, forSection targetSection: String, forRow targetRow: String) {
+        updateAllUserDefaultsSections(newValue, forSection: targetSection, forRow: targetRow)
+        if targetSection == Strings.otherBooleanUserDefaultsSectionID {
+            persistentRepository.set(newValue, forKey: targetRow)
         } else {
-            return BooleanUserDefault(title: key, value: value)
+            guard let section = allUserDefaultsSections.first(where: { $0.key == targetSection }) else {
+                return
+            }
+            let entries = section.rows.reduce(into: [String: Bool]()) { result, row in
+                result[row.key] = newValue
+            }
+            persistentRepository.set(entries, forKey: targetSection)
         }
     }
 
-    func updateUserDefault(_ value: Bool, forSection sectionID: String, forUserDefault userDefaultID: String) {
-        if sectionID == Strings.otherBooleanUserDefaultsSectionID {
-            persistentRepository.set(value, forKey: userDefaultID)
-        } else if var section = allUserDefaultsSections[sectionID] {
-            section[userDefaultID] = BooleanUserDefault(title: userDefaultID, value: value)
-            let sectionValues = section.mapValues { $0.value }
-            persistentRepository.set(sectionValues, forKey: sectionID)
+    func updateAllUserDefaultsSections(_ newValue: Bool, forSection targetSection: String, forRow targetRow: String) {
+        allUserDefaultsSections = allUserDefaultsSections.map { currentSection in
+            if currentSection.key == targetSection {
+                let updatedRows = currentSection.rows.map { currentRow in
+                    if currentRow.key == targetRow {
+                        return Row(key: currentRow.key, title: currentRow.title, value: newValue)
+                    } else {
+                        return currentRow
+                    }
+                }
+                return Section(key: currentSection.key, rows: updatedRows)
+            } else {
+                return currentSection
+            }
         }
-        load()
     }
 
     private func isGutenbergUserDefault(_ key: String) -> Bool {
@@ -90,13 +130,32 @@ final class BooleanUserDefaultsDebugViewModel: ObservableObject {
     private func isFeatureFlagsSection(_ key: String) -> Bool {
         key.isEqual(to: Strings.featureFlagSectionKey)
     }
-}
 
-struct BooleanUserDefault: Equatable {
-    var title: String
-    var value: Bool
+    // MARK: - Types
+
+    struct Section {
+        let key: String
+        let rows: [Row]
+    }
+
+    final class Row {
+        let key: String
+        let title: String
+        let value: Bool
+
+        init(key: String, title: String, value: Bool) {
+            self.key = key
+            self.title = title
+            self.value = value
+        }
+    }
+
+    typealias Sections = [Section]
+
 }
 
+// MARK: - Constants
+
 private enum Strings {
     static let otherBooleanUserDefaultsSectionID = "Other"
     static let gutenbergUserDefaultPrefix = "com.wordpress.gutenberg-"
diff --git a/WordPress/WordPressTest/Me/App Settings/Boolean User Defaults/BooleanUserDefaultsDebugViewModelTests.swift b/WordPress/WordPressTest/Me/App Settings/Boolean User Defaults/BooleanUserDefaultsDebugViewModelTests.swift
