Method initialize

src/prefs.rs:411–450

Initialize (the) PreferenceManager (a global var). 'rules_dir' is the path to "Rules" unless the env var MathCATRulesDir is set If rules_dir is an empty PathBuf, the existing rules_dir is used (an error if it doesn't exist)

(&mut self, rules_dir: PathBuf)

    /// 
    /// If rules_dir is an empty PathBuf, the existing rules_dir is used (an error if it doesn't exist)
    pub fn initialize(&mut self, rules_dir: PathBuf) -> Result<()> {
        let mut rules_dir = rules_dir;
        if rules_dir.as_os_str().is_empty() {
            assert!(self.rules_dir.is_some());
            rules_dir = self.rules_dir.clone().unwrap();
        }

        // first, read in the preferences -- need to determine which files to read next
        // the prefs files are in the rules dir and the user dir; differs from other files
        if self.api_prefs.prefs.is_empty() {
            self.api_prefs = Preferences{ prefs: DEFAULT_API_PREFERENCES.with(|defaults| defaults.prefs.clone()) };
        }

        let pref_files;
        if  self.user_prefs.prefs.is_empty() || !PreferenceManager::is_file_up_to_date(&self.pref_files) {
            let (user_prefs, pref_files_internal) = Preferences::from_file(&rules_dir)?;
            self.user_prefs = user_prefs;
            pref_files = Some(pref_files_internal);
        } else {
            pref_files = None;
        }

        match PreferenceManager::find_rules_dir(&rules_dir) {
            Ok(rules_dir) => {
                #[allow(clippy::unnecessary_unwrap)]  // using 'if let...' is messy here
                let pref_files = if pref_files.is_some() {pref_files.unwrap()} else {Preferences::get_prefs_file_and_time(&rules_dir)};
                match self.set_all_files(&rules_dir, pref_files) {
                    Ok(_) => {
                        self.error = String::new();
                        return Ok(())
                    },
                    Err(e) => self.error = errors_to_string(&e),
                }
            },
            Err(e) => {
                self.error = errors_to_string(&e);
            },
        };
        bail!("{}", self.error);
    }

    pub fn get() -> Rc<RefCell<PreferenceManager>> {
        return PREF_MANAGER.with( |pm| pm.clone() );