use crate::{Remote, bstr::BStr, config, remote};use gix_utils::AsBStr; /// The error returned by [`Remote::save_to()`].#[derive(Debug, thiserror::Error)]#[expect(missing_docs)]pub enum Error {    #[error("The remote pointing to {} is anonymous and can't be saved.", url.to_bstring())]    NameMissing { url: gix_url::Url },    #[error(transparent)]    Span(#[from] gix_config::parse::span::Error),    #[error(transparent)]    ConfigValue(#[from] gix_config::file::section::value::Error),} /// The error returned by [`Remote::save_as_to()`].////// Note that this type should rather be in the `as` module, but cannot be as it's part of the Rust syntax.#[derive(Debug, thiserror::Error)]#[expect(missing_docs)]pub enum AsError {    #[error(transparent)]    Save(#[from] Error),    #[error(transparent)]    Name(#[from] crate::remote::name::Error),} /// Serialize into git-config.impl Remote<'_> {    /// Save ourselves to the given `config` if we are a named remote or fail otherwise.    ///    /// Note that all sections named `remote "<name>"` will be cleared of all values we are about to write,    /// and the last `remote "<name>"` section will be containing all relevant values so that reloading the remote    /// from `config` would yield the same in-memory state.    #[expect(        clippy::result_large_err,        reason = "will be removed once `gix-error` is used consistently"    )]    pub fn save_to(&self, config: &mut gix_config::File) -> Result<(), Error> {        let name = self.name().ok_or_else(|| Error::NameMissing {            url: self                .urls                .first()                .or_else(|| self.push_urls.first())                .expect("one url is always set")                .to_owned(),        })?;        let target_meta = config.meta().clone();        let mut needs_url_reset = false;        let mut needs_push_url_reset = false;        if let Some(section_ids) = config.sections_and_ids_by_name("remote").map(|it| {            it.filter_map(|(s, id)| (s.header().subsection_name() == Some(name.as_bstr())).then_some(id))                .collect::<Vec<_>>()        }) {            let mut sections_to_remove = Vec::new();            const KEYS_TO_REMOVE: &[&str] = &[                config::tree::Remote::URL.name,                config::tree::Remote::PUSH_URL.name,                config::tree::Remote::FETCH.name,                config::tree::Remote::PUSH.name,                config::tree::Remote::TAG_OPT.name,            ];            for id in section_ids {                let mut section = config.section_mut_by_id(id).expect("just queried");                let was_empty = section.num_values() == 0;                let url_values = section.values(config::tree::Remote::URL.name);                let push_url_values = section.values(config::tree::Remote::PUSH_URL.name);                if *section.meta() != target_meta {                    needs_url_reset |= !url_values.is_empty();                    needs_push_url_reset |= !push_url_values.is_empty();                } else {                    needs_url_reset |= url_values.iter().any(|url| url.is_empty());                    needs_push_url_reset |= push_url_values.iter().any(|url| url.is_empty());                }                 for key in KEYS_TO_REMOVE {                    while section.remove(key).is_some() {}                }                 let is_empty_after_deletions_of_values_to_be_written = section.num_values() == 0;                if !was_empty && is_empty_after_deletions_of_values_to_be_written {                    sections_to_remove.push(id);                }            }            for id in sections_to_remove {                config.remove_section_by_id(id);            }        }        // Only reuse an existing section that belongs to the file we are writing to. Otherwise a        // section provided by another source (e.g. global config like `remote.<name>.prune`) would        // be mutated in place, mixing foreign metadata with our values and getting lost when the        // caller writes back only the local sections. In that case, create a fresh local section.        // We assume that `config.meta()` is truly the 'identity' of the configuration file.        let mut section = if needs_url_reset || needs_push_url_reset {            // A foreign section may occur after the last local one, notably when an include follows            // it. The reset must follow all such values or reopening the written file would append            // the foreign values once more.            config                .new_section("remote", name.as_bstr())                .expect("section name is validated and 'remote' is acceptable")        } else {            config                .section_mut_or_create_new_filter("remote", name.as_bstr(), |meta| *meta == target_meta)                .expect("section name is validated and 'remote' is acceptable")        };        if needs_url_reset {            section.push(config::tree::Remote::URL.name, "")?;        }        for url in &self.urls {            section.push("url", url.to_bstring())?;        }        if needs_push_url_reset {            section.push(config::tree::Remote::PUSH_URL.name, "")?;        }        for url in &self.push_urls {            section.push("pushurl", url.to_bstring())?;        }        if self.fetch_tags != Default::default() {            section.push(                config::tree::Remote::TAG_OPT.name,                BStr::new(match self.fetch_tags {                    remote::fetch::Tags::All => "--tags",                    remote::fetch::Tags::None => "--no-tags",                    remote::fetch::Tags::Included => unreachable!("BUG: the default shouldn't be written and we try"),                }),            )?;        }        for (key, spec) in self            .fetch_specs            .iter()            .map(|spec| ("fetch", spec))            .chain(self.push_specs.iter().map(|spec| ("push", spec)))        {            section.push(key, spec.to_ref().to_bstring())?;        }        Ok(())    }     /// Forcefully set our name to `name` and write our state to `config` similar to [`save_to()`][Self::save_to()].    ///    /// Note that this sets a name for anonymous remotes, but overwrites the name for those who were named before.    /// If this name is different from the current one, the git configuration will still contain the previous name,    /// and the caller should account for that.    #[expect(        clippy::result_large_err,        reason = "will be removed once `gix-error` is used consistently"    )]    pub fn save_as_to(&mut self, name: impl AsBStr, config: &mut gix_config::File) -> Result<(), AsError> {        let name = crate::remote::name::validated(name.as_bstr().to_owned())?;        let prev_name = self.name.take();        self.name = Some(name.into());        self.save_to(config).map_err(|err| {            self.name = prev_name;            err.into()        })    }}