Ortham / libloadorder / 12968526079

    pub fn new(filename: &str, game_settings: &GameSettings) -> Result<Plugin, Error> {

        Plugin::with_active(filename, game_settings, false)

    }

    pub fn with_active(

        filename: &str,

        game_settings: &GameSettings,

        active: bool,

    ) -> Result<Plugin, Error> {

        let filepath = game_settings.plugin_path(filename);

        let filepath = if game_settings.id().allow_plugin_ghosting() {

            if active {

                filepath.unghost()?

                filepath.resolve_path()?

            filepath

        Plugin::with_path(&filepath, game_settings.id(), active)

    }

    pub(crate) fn with_path(path: &Path, game_id: GameId, active: bool) -> Result<Plugin, Error> {

        let filename = match path.file_name().and_then(OsStr::to_str) {

            Some(n) => n,

        if !has_plugin_extension(filename, game_id) {

            return Err(Error::InvalidPath(path.to_path_buf()));

        }

        let file = File::open(path).map_err(|e| Error::IoError(path.to_path_buf(), e))?;

        let modification_time = file

            .metadata()

            .and_then(|m| m.modified())

            .map_err(|e| Error::IoError(path.to_path_buf(), e))?;

        let mut data = esplugin::Plugin::new(game_id.to_esplugin_id(), path);

        data.parse_reader(file, ParseOptions::header_only())

            .map_err(|e| file_error(path, e))?;

        Ok(Plugin {

            active,

            modification_time,

            data,

            name: trim_dot_ghost(game_id, filename).to_string(),

            game_id,

        })

    }

    pub fn name(&self) -> &str {

        &self.name

    }

    pub fn name_matches(&self, string: &str) -> bool {

        eq(self.name(), trim_dot_ghost(self.game_id, string))

    }

    pub fn modification_time(&self) -> SystemTime {

        self.modification_time

    }

    pub fn is_active(&self) -> bool {

        self.active

    }

    pub fn is_master_file(&self) -> bool {

        self.data.is_master_file()

    }

    pub fn is_light_plugin(&self) -> bool {

        self.data.is_light_plugin()

    }

    pub fn is_medium_plugin(&self) -> bool {

        self.data.is_medium_plugin()

    }

    pub fn is_blueprint_master(&self) -> bool {

        self.data.is_blueprint_plugin() && self.is_master_file()

    }

    pub fn masters(&self) -> Result<Vec<String>, Error> {

        self.data

            .masters()

            .map_err(|e| file_error(self.data.path(), e))

    }

    pub fn set_modification_time(&mut self, time: SystemTime) -> Result<(), Error> {

        // Always write the file time. This has a huge performance impact, but

        // is important for correctness, as otherwise external changes to plugin

        // timestamps between calls to WritableLoadOrder::load() and

        // WritableLoadOrder::save() could lead to libloadorder not setting all

        // the timestamps it needs to and producing an incorrect load order.

        let times = FileTimes::new()

            .set_accessed(SystemTime::now())

            .set_modified(time);

        File::options()

            .write(true)

            .open(self.data.path())

            .and_then(|f| f.set_times(times))

            .map_err(|e| Error::IoError(self.data.path().to_path_buf(), e))?;

        self.modification_time = time;

        Ok(())

    }

    pub fn activate(&mut self) -> Result<(), Error> {

        if !self.is_active() {

            if self.game_id.allow_plugin_ghosting() {

                if self.data.path().has_ghost_extension() {

                    let new_path = self.data.path().unghost()?;

                    self.data = esplugin::Plugin::new(self.data.game_id(), &new_path);

                    self.data

                        .parse_file(ParseOptions::header_only())

                        .map_err(|e| file_error(self.data.path(), e))?;

                    let modification_time = self.modification_time();

                    self.set_modification_time(modification_time)?;

                }

            }

            self.active = true;

        }

        Ok(())

    }

    pub fn deactivate(&mut self) {

        self.active = false;

    }

pub fn has_plugin_extension(filename: &str, game: GameId) -> bool {

    let valid_extensions = if game == GameId::OpenMW {

        VALID_EXTENSIONS_OPENMW

    } else if game.supports_light_plugins() {

        VALID_EXTENSIONS_WITH_ESL

        VALID_EXTENSIONS

    valid_extensions

        .iter()

        .any(|e| iends_with_ascii(filename, e))

}

fn iends_with_ascii(string: &str, suffix: &str) -> bool {

    // as_bytes().into_iter() is faster than bytes().

    string.len() >= suffix.len()

        && string

            .as_bytes()

            .iter()

            .rev()

            .zip(suffix.as_bytes().iter().rev())

            .all(|(string_byte, suffix_byte)| string_byte.eq_ignore_ascii_case(suffix_byte))

}

pub fn trim_dot_ghost(game_id: GameId, string: &str) -> &str {

    if game_id.allow_plugin_ghosting() {

        trim_dot_ghost_unchecked(string)

        string

}

pub fn trim_dot_ghost_unchecked(string: &str) -> &str {

    if iends_with_ascii(string, GHOST_FILE_EXTENSION) {

        &string[..(string.len() - GHOST_FILE_EXTENSION.len())]

        string

}

fn file_error(file_path: &Path, error: esplugin::Error) -> Error {

    match error {

        esplugin::Error::IoError(x) => Error::IoError(file_path.to_path_buf(), x),

}

    fn game_settings(game_id: GameId, game_path: &Path) -> GameSettings {

        GameSettings::with_local_and_my_games_paths(

            game_id,

            game_path,

            &PathBuf::default(),

            PathBuf::default(),

        )

        .unwrap()

    }

    fn with_active_should_unghost_active_ghosted_plugin_paths() {

        let tmp_dir = tempdir().unwrap();

        let game_dir = tmp_dir.path();

        let settings = game_settings(GameId::Oblivion, game_dir);

        let name = "Blank.esp";

        let ghosted_name = "Blank.esp.ghost";

        copy_to_test_dir(name, ghosted_name, &settings);

        let plugin = Plugin::with_active(ghosted_name, &settings, true).unwrap();

        assert_eq!(name, plugin.name());

        assert!(game_dir.join("Data").join(name).exists());

        assert!(!game_dir.join("Data").join(ghosted_name).exists());

    }

    fn with_active_should_resolve_inactive_ghosted_plugin_paths() {

        let tmp_dir = tempdir().unwrap();

        let game_dir = tmp_dir.path();

        let settings = game_settings(GameId::Oblivion, game_dir);

        let name = "Blank.esp";

        let ghosted_name = "Blank.esp.ghost";

        copy_to_test_dir(name, ghosted_name, &settings);

        let plugin = Plugin::with_active(ghosted_name, &settings, false).unwrap();

        assert_eq!(name, plugin.name());

        assert!(!game_dir.join("Data").join(name).exists());

        assert!(game_dir.join("Data").join(ghosted_name).exists());

    }

    fn with_active_should_not_resolve_ghosted_plugin_paths_for_openmw() {

        let tmp_dir = tempdir().unwrap();

        let tmp_path = tmp_dir.path();

        let game_path = tmp_path.join("game");

        let my_games_path = tmp_path.join("my games");

        let data_files_path = game_path.join("Data Files");

        if !data_files_path.exists() {

            create_dir_all(&data_files_path).unwrap();

        }

        if !my_games_path.exists() {

            create_dir(&my_games_path).unwrap();

            std::fs::write(my_games_path.join("openmw.cfg"), "").unwrap();

        }

        let settings =

            GameSettings::with_local_path(GameId::OpenMW, &game_path, &my_games_path).unwrap();

        let name = "Blank.esp";

        let ghosted_name = "Blank.esp.ghost";

        copy_to_test_dir(name, ghosted_name, &settings);

        match Plugin::with_active(ghosted_name, &settings, false).unwrap_err() {

            Error::InvalidPath(p) => assert_eq!(game_path.join("Data Files").join(ghosted_name), p),

    }

    fn name_should_return_the_plugin_filename_without_any_ghost_extension() {

        let tmp_dir = tempdir().unwrap();

        let game_dir = tmp_dir.path();

        let settings = game_settings(GameId::Oblivion, game_dir);

        copy_to_test_dir("Blank.esp", "Blank.esp", &settings);

        let plugin = Plugin::new("Blank.esp.ghost", &settings).unwrap();

        assert_eq!("Blank.esp", plugin.name());

        copy_to_test_dir("Blank.esp", "Blank.esp", &settings);

        let plugin = Plugin::new("Blank.esp", &settings).unwrap();

        assert_eq!("Blank.esp", plugin.name());

        copy_to_test_dir("Blank.esm", "Blank.esm.ghost", &settings);

        let plugin = Plugin::new("Blank.esm", &settings).unwrap();

        assert_eq!("Blank.esm", plugin.name());

    }

    fn name_matches_should_ignore_plugin_ghost_extension() {

        let tmp_dir = tempdir().unwrap();

        let settings = game_settings(GameId::Skyrim, tmp_dir.path());

        copy_to_test_dir("Blank.esp", "BlanK.esp.GHoSt", &settings);

        let plugin = Plugin::new("BlanK.esp.GHoSt", &settings).unwrap();

        assert!(plugin.name_matches("Blank.esp"));

    }

    fn name_matches_should_ignore_string_ghost_suffix() {

        let tmp_dir = tempdir().unwrap();

        let settings = game_settings(GameId::Skyrim, tmp_dir.path());

        copy_to_test_dir("Blank.esp", "BlanK.esp", &settings);

        let plugin = Plugin::new("BlanK.esp", &settings).unwrap();

        assert!(plugin.name_matches("Blank.esp.GHoSt"));

    }

    fn modification_time_should_return_the_plugin_modification_time_at_creation() {

        let tmp_dir = tempdir().unwrap();

        let game_dir = tmp_dir.path();

        let settings = game_settings(GameId::Oblivion, game_dir);

        copy_to_test_dir("Blank.esp", "Blank.esp", &settings);

        let plugin_path = game_dir.join("Data").join("Blank.esp");

        let mtime = plugin_path.metadata().unwrap().modified().unwrap();

        let plugin = Plugin::new("Blank.esp", &settings).unwrap();

        assert_eq!(mtime, plugin.modification_time());

    }

    fn is_active_should_be_false() {

        let tmp_dir = tempdir().unwrap();

        let game_dir = tmp_dir.path();

        let settings = game_settings(GameId::Oblivion, game_dir);

        copy_to_test_dir("Blank.esp", "Blank.esp", &settings);

        let plugin = Plugin::new("Blank.esp", &settings).unwrap();

        assert!(!plugin.is_active());

    }

    fn is_master_file_should_be_true_if_the_plugin_is_a_master_file() {

        let tmp_dir = tempdir().unwrap();

        let game_dir = tmp_dir.path();

        let settings = game_settings(GameId::Oblivion, game_dir);

        copy_to_test_dir("Blank.esm", "Blank.esm", &settings);

        let plugin = Plugin::new("Blank.esm", &settings).unwrap();

        assert!(plugin.is_master_file());

    }

    fn is_master_file_should_be_false_if_the_plugin_is_not_a_master_file() {

        let tmp_dir = tempdir().unwrap();

        let game_dir = tmp_dir.path();

        let settings = game_settings(GameId::Oblivion, game_dir);

        copy_to_test_dir("Blank.esp", "Blank.esp", &settings);

        let plugin = Plugin::new("Blank.esp", &settings).unwrap();

        assert!(!plugin.is_master_file());

    }

    fn is_light_plugin_should_be_true_for_esl_files_only() {

        let tmp_dir = tempdir().unwrap();

        let game_dir = tmp_dir.path();

        let settings = game_settings(GameId::SkyrimSE, game_dir);

        copy_to_test_dir("Blank.esp", "Blank.esp", &settings);

        let plugin = Plugin::new("Blank.esp", &settings).unwrap();

        assert!(!plugin.is_master_file());

        copy_to_test_dir("Blank.esm", "Blank.esm", &settings);

        let plugin = Plugin::new("Blank.esm", &settings).unwrap();

        assert!(!plugin.is_light_plugin());

        copy_to_test_dir("Blank.esm", "Blank.esl", &settings);

        let plugin = Plugin::new("Blank.esl", &settings).unwrap();

        assert!(plugin.is_light_plugin());

        copy_to_test_dir("Blank - Different.esp", "Blank - Different.esl", &settings);

        let plugin = Plugin::new("Blank - Different.esl", &settings).unwrap();

        assert!(plugin.is_light_plugin());

    }

    fn set_modification_time_should_update_the_file_modification_time() {

        let tmp_dir = tempdir().unwrap();

        let game_dir = tmp_dir.path();

        let settings = game_settings(GameId::Oblivion, game_dir);

        copy_to_test_dir("Blank.esp", "Blank.esp", &settings);

        let path = game_dir.join("Data").join("Blank.esp");

        let file_size = path.metadata().unwrap().len();

        let mut plugin = Plugin::new("Blank.esp", &settings).unwrap();

        assert_ne!(UNIX_EPOCH, plugin.modification_time());

        plugin.set_modification_time(UNIX_EPOCH).unwrap();

        let metadata = path.metadata().unwrap();

        let new_mtime = metadata.modified().unwrap();

        let new_size = metadata.len();

        assert_eq!(UNIX_EPOCH, plugin.modification_time());

        assert_eq!(UNIX_EPOCH, new_mtime);

        assert_eq!(file_size, new_size);

    }

    fn set_modification_time_should_be_able_to_handle_pre_unix_timestamps() {

        let tmp_dir = tempdir().unwrap();

        let game_dir = tmp_dir.path();

        let settings = game_settings(GameId::Oblivion, game_dir);

        copy_to_test_dir("Blank.esp", "Blank.esp", &settings);

        let mut plugin = Plugin::new("Blank.esp", &settings).unwrap();

        let target_mtime = UNIX_EPOCH - Duration::from_secs(1);

        assert_ne!(target_mtime, plugin.modification_time());

        plugin.set_modification_time(target_mtime).unwrap();

        let new_mtime = game_dir

            .join("Data")

            .join("Blank.esp")

            .metadata()

            .unwrap()

            .modified()

            .unwrap();

        assert_eq!(target_mtime, plugin.modification_time());

        assert_eq!(target_mtime, new_mtime);

    }

    fn activate_should_unghost_a_ghosted_plugin() {

        let tmp_dir = tempdir().unwrap();

        let game_dir = tmp_dir.path();

        let settings = game_settings(GameId::Oblivion, game_dir);

        copy_to_test_dir("Blank.esp", "Blank.esp.ghost", &settings);

        let mut plugin = Plugin::new("Blank.esp", &settings).unwrap();

        plugin.activate().unwrap();

        assert!(plugin.is_active());

        assert_eq!("Blank.esp", plugin.name());

        assert!(game_dir.join("Data").join("Blank.esp").exists());

    }

    fn activate_should_not_unghost_an_openmw_plugin() {

        // It's not possible to create an OpenMW Plugin from a path ending in

        // .ghost outside of this module, so this is just for internal

        // consistency.

        let tmp_dir = tempdir().unwrap();

        let game_dir = tmp_dir.path();

        let settings = game_settings(GameId::Oblivion, game_dir);

        let plugin_name = "Blank.esp.ghost";

        copy_to_test_dir("Blank.esp", plugin_name, &settings);

        let data = esplugin::Plugin::new(

            GameId::OpenMW.to_esplugin_id(),

            &game_dir.join("Data Files").join(plugin_name),

        );

        let mut plugin = Plugin {

            active: false,

            modification_time: SystemTime::now(),

            data,

            name: plugin_name.to_string(),

            game_id: GameId::OpenMW,

        };

        plugin.activate().unwrap();

        assert!(plugin.is_active());

        assert_eq!(plugin_name, plugin.name());

    }

    fn deactivate_should_not_ghost_a_plugin() {

        let tmp_dir = tempdir().unwrap();

        let game_dir = tmp_dir.path();

        let settings = game_settings(GameId::Oblivion, game_dir);

        copy_to_test_dir("Blank.esp", "Blank.esp", &settings);

        let mut plugin = Plugin::new("Blank.esp", &settings).unwrap();

        plugin.deactivate();

        assert!(!plugin.is_active());

        assert!(game_dir.join("Data").join("Blank.esp").exists());

    }

    fn trim_dot_ghost_should_trim_the_ghost_extension_if_the_game_allows_ghosting() {

        let ghosted = "plugin.esp.ghost";

        let unghosted = "plugin.esp";

        assert_eq!(ghosted, trim_dot_ghost(GameId::OpenMW, ghosted));

        assert_eq!(unghosted, trim_dot_ghost(GameId::Morrowind, ghosted));

        assert_eq!(unghosted, trim_dot_ghost(GameId::Oblivion, ghosted));

        assert_eq!(unghosted, trim_dot_ghost(GameId::Skyrim, ghosted));

        assert_eq!(unghosted, trim_dot_ghost(GameId::SkyrimSE, ghosted));

        assert_eq!(unghosted, trim_dot_ghost(GameId::SkyrimVR, ghosted));

        assert_eq!(unghosted, trim_dot_ghost(GameId::Fallout3, ghosted));

        assert_eq!(unghosted, trim_dot_ghost(GameId::FalloutNV, ghosted));

        assert_eq!(unghosted, trim_dot_ghost(GameId::Fallout4, ghosted));

        assert_eq!(unghosted, trim_dot_ghost(GameId::Fallout4VR, ghosted));

        assert_eq!(unghosted, trim_dot_ghost(GameId::Starfield, ghosted));

    }

    fn trim_dot_ghost_unchecked_should_trim_the_ghost_extension() {

        let ghosted = "plugin.esp.ghost";

        let unghosted = "plugin.esp";

        assert_eq!(unghosted, trim_dot_ghost_unchecked(ghosted));

        assert_eq!(unghosted, trim_dot_ghost_unchecked(ghosted));

    }