gix_config/parse/section/

mod.rs

use crate::parse::{MaybeDecoded, Span};

///
pub mod header;

pub(crate) mod unvalidated;

/// A parsed section header.
#[derive(Clone, Debug)]
pub(crate) struct HeaderData {
    /// The name of the header.
    pub(crate) name: Span,
    /// The separator used to determine if the section contains a subsection.
    /// This is either a period `.` or a string of whitespace. Note that
    /// reconstruction of subsection format is dependent on this value. If this
    /// is all whitespace, then the subsection name needs to be surrounded by
    /// quotes to have perfect reconstruction.
    pub(crate) separator: Option<Span>,
    pub(crate) subsection_name: Option<MaybeDecoded>,
}

mod types {
    use bstr::ByteSlice;

    macro_rules! generate_case_insensitive {
        ($name:ident, $module:ident, $err_doc:literal, $validate:ident, $cow_inner_type:ty, $comment:literal) => {
            ///
            pub mod $module {
                /// The error returned when `TryFrom` is invoked to create an instance.
                #[derive(Debug, thiserror::Error, Copy, Clone)]
                #[error($err_doc)]
                pub struct Error;
            }

            #[doc = $comment]
            #[derive(Clone, Eq, Debug, Default)]
            pub struct $name(pub(crate) bstr::BString);

            impl $name {
                pub(crate) fn from_str_unchecked(s: &str) -> Self {
                    $name(s.into())
                }
                /// Clone this instance.
                #[must_use]
                pub fn to_owned(&self) -> $name {
                    self.clone()
                }
            }

            impl PartialEq for $name {
                fn eq(&self, other: &Self) -> bool {
                    self.0.eq_ignore_ascii_case(&other.0)
                }
            }

            impl std::fmt::Display for $name {
                fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                    std::fmt::Display::fmt(&self.0, f)
                }
            }

            impl PartialOrd for $name {
                fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
                    Some(self.cmp(other))
                }
            }

            impl Ord for $name {
                fn cmp(&self, other: &Self) -> std::cmp::Ordering {
                    let a = self.0.iter().map(|c| c.to_ascii_lowercase());
                    let b = other.0.iter().map(|c| c.to_ascii_lowercase());
                    a.cmp(b)
                }
            }

            impl std::hash::Hash for $name {
                fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
                    for b in self.0.iter() {
                        b.to_ascii_lowercase().hash(state);
                    }
                }
            }

            impl std::convert::TryFrom<&str> for $name {
                type Error = $module::Error;

                fn try_from(s: &str) -> Result<Self, Self::Error> {
                    Self::try_from(bstr::ByteSlice::as_bstr(s.as_bytes()))
                }
            }

            impl std::convert::TryFrom<String> for $name {
                type Error = $module::Error;

                fn try_from(s: String) -> Result<Self, Self::Error> {
                    Self::try_from(bstr::BString::from(s))
                }
            }

            impl std::convert::TryFrom<bstr::BString> for $name {
                type Error = $module::Error;

                fn try_from(s: bstr::BString) -> Result<Self, Self::Error> {
                    if $validate(s.as_slice().as_bstr()) {
                        Ok(Self(s.into()))
                    } else {
                        Err($module::Error)
                    }
                }
            }

            impl std::convert::TryFrom<&bstr::BStr> for $name {
                type Error = $module::Error;

                fn try_from(s: &bstr::BStr) -> Result<Self, Self::Error> {
                    if $validate(s) {
                        Ok(Self(s.into()))
                    } else {
                        Err($module::Error)
                    }
                }
            }

            impl std::ops::Deref for $name {
                type Target = $cow_inner_type;

                fn deref(&self) -> &Self::Target {
                    self.0.as_bstr()
                }
            }

            impl std::convert::AsRef<str> for $name {
                fn as_ref(&self) -> &str {
                    std::str::from_utf8(self.0.as_slice()).expect("only valid UTF8 makes it through our validation")
                }
            }
        };
    }

    fn is_valid_name(n: &bstr::BStr) -> bool {
        !n.is_empty() && n.iter().all(|b| b.is_ascii_alphanumeric() || *b == b'-')
    }
    fn is_valid_value_name(n: &bstr::BStr) -> bool {
        is_valid_name(n) && n[0].is_ascii_alphabetic()
    }

    generate_case_insensitive!(
        Name,
        name,
        "Valid names consist of alphanumeric characters or dashes.",
        is_valid_name,
        bstr::BStr,
        "Wrapper struct for section header names, like `remote`, since these are case-insensitive."
    );

    generate_case_insensitive!(
        ValueName,
        value_name,
        "Valid value names consist of alphanumeric characters or dashes, starting with an alphabetic character.",
        is_valid_value_name,
        bstr::BStr,
        "Wrapper struct for value names, like `path` in `include.path`, since keys are case-insensitive."
    );
}
pub(crate) use types::ValueName;
pub use types::{Name, name, value_name};

#[cfg(test)]
mod tests {
    use std::cmp::Ordering;

    use super::ValueName;

    fn key(key: &str) -> ValueName {
        ValueName::try_from(key).expect("valid test key")
    }

    #[test]
    fn value_names_reject_invalid_formats() {
        for invalid in ["", "1a", "a.2", "##", "\""] {
            assert!(ValueName::try_from(invalid).is_err(), "{invalid:?} is invalid");
        }
    }

    #[test]
    fn value_names_are_case_insensitive() {
        assert_eq!(key("aB-c"), key("Ab-C"));
        assert_eq!(key("a").cmp(&key("a")), Ordering::Equal);
        assert_eq!(key("aBc").cmp(&key("AbC")), Ordering::Equal);

        fn calculate_hash<T: std::hash::Hash>(value: T) -> u64 {
            use std::hash::Hasher;
            let mut state = std::collections::hash_map::DefaultHasher::new();
            value.hash(&mut state);
            state.finish()
        }
        assert_eq!(calculate_hash(key("aBc")), calculate_hash(key("AbC")));
    }
}