oliver 0.4.3

Lightweight CLI mod development tool for Baldur's Gate 3 on Linux
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use crate::Settings;
use anyhow::Result;
use std::{fs::DirEntry, path::PathBuf};

#[allow(dead_code)]
impl Settings {
    fn get_mod_info(&self, entry: DirEntry) -> Result<Option<(String, PathBuf)>> {
        if !entry.file_type()?.is_file() {
            return Ok(None);
        }
        let path = PathBuf::from(entry.file_name());

        let extension = path.extension();
        if !extension.map_or(false, |e| e.eq_ignore_ascii_case("pak")) {
            return Ok(None);
        }

        let info = self
            .read_mod_file(&path)?
            .deserialize_meta_lsx()?
            .module_info;
        Ok(Some((info.uuid, path)))
    }

    pub(crate) fn uninstall_all_helper(
        &self,
        _dry_run: bool,
        _indexes_to_delete: Vec<usize>,
    ) -> Result<()> {
        todo!()
        // let mut order = self.get_load_order()?;

        // let uuid_paths: Result<HashMap<_, _>> = self
        //     .read_mod_files_dir()?
        //     .filter_map(|e| self.get_mod_info(e?).transpose())
        //     .collect();

        // let mut uuid_paths = uuid_paths?;

        // if !dry_run {
        //     indexes_to_delete.sort_unstable_by_key(|i| usize::MAX - i);

        //     for index in indexes_to_delete {
        //         let mod_info = order.get(index).

        //         let Some(entry) = uuid_paths.get(uuid)

        //         std::fs::remove_file()?;
        //         order.remove(entry.index);

        //         if dry_run {
        //             println!("{} would be uninstalled with a non-dry run", info.name);
        //         } else {
        //             println!("uninstalling {}", info.name);
        //             let mod_file = self.get_mod_file_path(path);
        //         }
        //     }

        //     todo!("write order");
        // }

        // Ok(())
    }
}

// fn get_unordered_index<'a>(
//     ordered: &'a ModulesChildren,
//     mod_index: usize,
//     mods: &'a ModuleInfoNode,
// ) -> Result<Option<(ModuleInfo, usize)>> {
//     let Some(order_entry) = ordered.node.get(mod_index) else {
//         return Ok(None);
//     };

//     let uuid = order_entry
//         .get_attribute_value_where_id(|id| id == "UUID")
//         .ok_or_else(|| anyhow!("missing UUID for mod order index {mod_index}"))?
//         .to_string();

//     let Some(index) = mods.find_index_where_child_id(&uuid) else {
//         return Ok(None);
//     };

//     let pak = mods.children[0].node[index].clone().try_into()?;

//     Ok(Some((pak, index)))
// }