Project configuration improvements

- Support `completed` field for objects in project config. In object tree, displays red for incomplete, green for complete.
- Add support for one-sided diffs. A project can include objects without an associated source file for viewing.
- Add versioning to AppConfig, supporting upgrades without losing user configuration.

Author: encounter

Cargo.lock

@@ -42,6 +42,7 @@ png = "0.17.9"
 ppc750cl = { git = "https://github.com/terorie/ppc750cl", rev = "9ae36eef34aa6d74e00972c7671f547a2acfd0aa" }
 rabbitizer = "1.7.4"
 rfd = { version = "0.11.4" } #, default-features = false, features = ['xdg-portal']
+ron = "0.8.0"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1.0.104"
 serde_yaml = "0.9.25"

Cargo.toml

@@ -14,13 +14,14 @@ use notify::{RecursiveMode, Watcher};
 use time::UtcOffset;
 
 use crate::{
+    app_config::{deserialize_config, AppConfigVersion},
     config::{
         build_globset, load_project_config, ProjectObject, ProjectObjectNode, CONFIG_FILENAMES,
     },
     jobs::{objdiff::start_build, Job, JobQueue, JobResult, JobStatus},
     views::{
         appearance::{appearance_window, Appearance},
-        config::{config_ui, project_window, ConfigViewState},
+        config::{config_ui, project_window, ConfigViewState, DEFAULT_WATCH_PATTERNS},
         data_diff::data_diff_ui,
         demangle::{demangle_window, DemangleViewState},
         function_diff::function_diff_ui,
@@ -44,16 +45,21 @@ pub struct ViewState {
 #[derive(Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
 pub struct ObjectConfig {
     pub name: String,
-    pub target_path: PathBuf,
-    pub base_path: PathBuf,
+    pub target_path: Option<PathBuf>,
+    pub base_path: Option<PathBuf>,
     pub reverse_fn_order: Option<bool>,
+    pub complete: Option<bool>,
 }
 
 #[inline]
 fn bool_true() -> bool { true }
 
-#[derive(Default, Clone, serde::Deserialize, serde::Serialize)]
+#[derive(Clone, serde::Deserialize, serde::Serialize)]
 pub struct AppConfig {
+    // TODO: https://github.com/ron-rs/ron/pull/455
+    // #[serde(flatten)]
+    // pub version: AppConfigVersion,
+    pub version: u32,
     pub custom_make: Option<String>,
     pub selected_wsl_distro: Option<String>,
     pub project_dir: Option<PathBuf>,
@@ -82,6 +88,31 @@ pub struct AppConfig {
     pub project_config_loaded: bool,
 }
 
+impl Default for AppConfig {
+    fn default() -> Self {
+        Self {
+            version: AppConfigVersion::default().version,
+            custom_make: None,
+            selected_wsl_distro: None,
+            project_dir: None,
+            target_obj_dir: None,
+            base_obj_dir: None,
+            selected_obj: None,
+            build_target: false,
+            rebuild_on_changes: true,
+            auto_update_check: true,
+            watch_patterns: DEFAULT_WATCH_PATTERNS.iter().map(|s| Glob::new(s).unwrap()).collect(),
+            objects: vec![],
+            object_nodes: vec![],
+            watcher_change: false,
+            config_change: false,
+            obj_change: false,
+            queue_build: false,
+            project_config_loaded: false,
+        }
+    }
+}
+
 impl AppConfig {
     pub fn set_project_dir(&mut self, path: PathBuf) {
         self.project_dir = Some(path);
@@ -133,8 +164,8 @@ pub struct App {
     should_relaunch: bool,
 }
 
-const APPEARANCE_KEY: &str = "appearance";
-const CONFIG_KEY: &str = "app_config";
+pub const APPEARANCE_KEY: &str = "appearance";
+pub const CONFIG_KEY: &str = "app_config";
 
 impl App {
     /// Called once before the first frame.
@@ -153,7 +184,7 @@ impl App {
             if let Some(appearance) = eframe::get_value::<Appearance>(storage, APPEARANCE_KEY) {
                 app.appearance = appearance;
             }
-            if let Some(mut config) = eframe::get_value::<AppConfig>(storage, CONFIG_KEY) {
+            if let Some(mut config) = deserialize_config(storage) {
                 if config.project_dir.is_some() {
                     config.config_change = true;
                     config.watcher_change = true;

src/app.rs

@@ -0,0 +1,96 @@
+use std::path::PathBuf;
+
+use eframe::Storage;
+use globset::Glob;
+
+use crate::app::{AppConfig, ObjectConfig, CONFIG_KEY};
+
+#[derive(Clone, serde::Deserialize, serde::Serialize)]
+pub struct AppConfigVersion {
+    pub version: u32,
+}
+
+impl Default for AppConfigVersion {
+    fn default() -> Self { Self { version: 1 } }
+}
+
+/// Deserialize the AppConfig from storage, handling upgrades from older versions.
+pub fn deserialize_config(storage: &dyn Storage) -> Option<AppConfig> {
+    let str = storage.get_string(CONFIG_KEY)?;
+    match ron::from_str::<AppConfigVersion>(&str) {
+        Ok(version) => match version.version {
+            1 => from_str::<AppConfig>(&str),
+            _ => {
+                log::warn!("Unknown config version: {}", version.version);
+                None
+            }
+        },
+        Err(e) => {
+            log::warn!("Failed to decode config version: {e}");
+            // Try to decode as v0
+            from_str::<AppConfigV0>(&str).map(|c| c.into_config())
+        }
+    }
+}
+
+fn from_str<T>(str: &str) -> Option<T>
+where T: serde::de::DeserializeOwned {
+    match ron::from_str(str) {
+        Ok(config) => Some(config),
+        Err(err) => {
+            log::warn!("Failed to decode config: {err}");
+            None
+        }
+    }
+}
+
+#[derive(serde::Deserialize, serde::Serialize)]
+pub struct ObjectConfigV0 {
+    pub name: String,
+    pub target_path: PathBuf,
+    pub base_path: PathBuf,
+    pub reverse_fn_order: Option<bool>,
+}
+
+impl ObjectConfigV0 {
+    fn into_config(self) -> ObjectConfig {
+        ObjectConfig {
+            name: self.name,
+            target_path: Some(self.target_path),
+            base_path: Some(self.base_path),
+            reverse_fn_order: self.reverse_fn_order,
+            complete: None,
+        }
+    }
+}
+
+#[derive(serde::Deserialize, serde::Serialize)]
+pub struct AppConfigV0 {
+    pub custom_make: Option<String>,
+    pub selected_wsl_distro: Option<String>,
+    pub project_dir: Option<PathBuf>,
+    pub target_obj_dir: Option<PathBuf>,
+    pub base_obj_dir: Option<PathBuf>,
+    pub selected_obj: Option<ObjectConfigV0>,
+    pub build_target: bool,
+    pub auto_update_check: bool,
+    pub watch_patterns: Vec<Glob>,
+}
+
+impl AppConfigV0 {
+    fn into_config(self) -> AppConfig {
+        log::info!("Upgrading configuration from v0");
+        AppConfig {
+            custom_make: self.custom_make,
+            selected_wsl_distro: self.selected_wsl_distro,
+            project_dir: self.project_dir,
+            target_obj_dir: self.target_obj_dir,
+            base_obj_dir: self.base_obj_dir,
+            selected_obj: self.selected_obj.map(|obj| obj.into_config()),
+            build_target: self.build_target,
+            auto_update_check: self.auto_update_check,
+            watch_patterns: self.watch_patterns,
+            ..Default::default()
+        }
+    }
+}

src/app_config.rs

@@ -27,6 +27,7 @@ pub struct ProjectObject {
     pub target_path: Option<PathBuf>,
     pub base_path: Option<PathBuf>,
     pub reverse_fn_order: Option<bool>,
+    pub complete: Option<bool>,
 }
 
 impl ProjectObject {

src/config.rs

@@ -372,66 +372,80 @@ fn find_section_and_symbol(obj: &ObjInfo, name: &str) -> Option<(usize, usize)>
     None
 }
 
-pub fn diff_objs(left: &mut ObjInfo, right: &mut ObjInfo) -> Result<()> {
-    for left_section in &mut left.sections {
-        if left_section.kind == ObjSectionKind::Code {
-            for left_symbol in &mut left_section.symbols {
-                if let Some((right_section_idx, right_symbol_idx)) =
-                    find_section_and_symbol(right, &left_symbol.name)
-                {
-                    let right_section = &mut right.sections[right_section_idx];
-                    let right_symbol = &mut right_section.symbols[right_symbol_idx];
-                    left_symbol.diff_symbol = Some(right_symbol.name.clone());
-                    right_symbol.diff_symbol = Some(left_symbol.name.clone());
-                    diff_code(
-                        left.architecture,
-                        &left_section.data,
-                        &right_section.data,
-                        left_symbol,
-                        right_symbol,
-                        &left_section.relocations,
-                        &right_section.relocations,
-                        &left.line_info,
-                        &right.line_info,
-                    )?;
-                } else {
-                    no_diff_code(
-                        left.architecture,
-                        &left_section.data,
-                        left_symbol,
-                        &left_section.relocations,
-                        &left.line_info,
-                    )?;
+pub fn diff_objs(mut left: Option<&mut ObjInfo>, mut right: Option<&mut ObjInfo>) -> Result<()> {
+    if let Some(left) = left.as_mut() {
+        for left_section in &mut left.sections {
+            if left_section.kind == ObjSectionKind::Code {
+                for left_symbol in &mut left_section.symbols {
+                    if let Some((right, (right_section_idx, right_symbol_idx))) =
+                        right.as_mut().and_then(|obj| {
+                            find_section_and_symbol(obj, &left_symbol.name).map(|s| (obj, s))
+                        })
+                    {
+                        let right_section = &mut right.sections[right_section_idx];
+                        let right_symbol = &mut right_section.symbols[right_symbol_idx];
+                        left_symbol.diff_symbol = Some(right_symbol.name.clone());
+                        right_symbol.diff_symbol = Some(left_symbol.name.clone());
+                        diff_code(
+                            left.architecture,
+                            &left_section.data,
+                            &right_section.data,
+                            left_symbol,
+                            right_symbol,
+                            &left_section.relocations,
+                            &right_section.relocations,
+                            &left.line_info,
+                            &right.line_info,
+                        )?;
+                    } else {
+                        no_diff_code(
+                            left.architecture,
+                            &left_section.data,
+                            left_symbol,
+                            &left_section.relocations,
+                            &left.line_info,
+                        )?;
+                    }
                 }
-            }
-        } else {
-            let Some(right_section) =
-                right.sections.iter_mut().find(|s| s.name == left_section.name)
-            else {
-                continue;
-            };
-            if left_section.kind == ObjSectionKind::Data {
-                diff_data(left_section, right_section);
-                // diff_data_symbols(left_section, right_section)?;
-            } else if left_section.kind == ObjSectionKind::Bss {
-                diff_bss_symbols(&mut left_section.symbols, &mut right_section.symbols)?;
+            } else if let Some(right_section) = right
+                .as_mut()
+                .and_then(|obj| obj.sections.iter_mut().find(|s| s.name == left_section.name))
+            {
+                if left_section.kind == ObjSectionKind::Data {
+                    diff_data(left_section, right_section);
+                    // diff_data_symbols(left_section, right_section)?;
+                } else if left_section.kind == ObjSectionKind::Bss {
+                    diff_bss_symbols(&mut left_section.symbols, &mut right_section.symbols)?;
+                }
+            } else if left_section.kind == ObjSectionKind::Data {
+                no_diff_data(left_section);
             }
         }
     }
-    for right_section in right.sections.iter_mut().filter(|s| s.kind == ObjSectionKind::Code) {
-        for right_symbol in &mut right_section.symbols {
-            if right_symbol.instructions.is_empty() {
-                no_diff_code(
-                    right.architecture,
-                    &right_section.data,
-                    right_symbol,
-                    &right_section.relocations,
-                    &right.line_info,
-                )?;
+    if let Some(right) = right.as_mut() {
+        for right_section in right.sections.iter_mut() {
+            if right_section.kind == ObjSectionKind::Code {
+                for right_symbol in &mut right_section.symbols {
+                    if right_symbol.instructions.is_empty() {
+                        no_diff_code(
+                            right.architecture,
+                            &right_section.data,
+                            right_symbol,
+                            &right_section.relocations,
+                            &right.line_info,
+                        )?;
+                    }
+                }
+            } else if right_section.kind == ObjSectionKind::Data
+                && right_section.data_diff.is_empty()
+            {
+                no_diff_data(right_section);
             }
         }
     }
-    diff_bss_symbols(&mut left.common, &mut right.common)?;
+    if let (Some(left), Some(right)) = (left, right) {
+        diff_bss_symbols(&mut left.common, &mut right.common)?;
+    }
     Ok(())
 }
 
@@ -710,3 +724,12 @@ fn diff_data(left: &mut ObjSection, right: &mut ObjSection) {
     left.data_diff = left_diff;
     right.data_diff = right_diff;
 }
+
+fn no_diff_data(section: &mut ObjSection) {
+    section.data_diff = vec![ObjDataDiff {
+        data: section.data.clone(),
+        kind: ObjDataDiffKind::None,
+        len: section.data.len(),
+        symbol: String::new(),
+    }];
+}