use std::borrow::Cow;use bstr::{BStr, BString, ByteSlice};use super::is_git_whitespace;/// Removes quotes, if any, from the provided inputs, and transforms the/// escape sequences `\n`, `\t` and `\b` into newline, tab and backspace/// (byte `0x08`) respectively, matching how `git` interprets them.////// It assumes the input contains a even number of unescaped quotes,/// and will unescape escaped quotes and everything else (even though the latter/// would have been rejected in the parsing stage).////// The return values should be safe for value interpretation./// If normalization requires no byte changes, including when it only trims enclosing quotes,/// the returned value borrows from `input`. Transforming escapes or embedded quotes produces an/// owned value instead.////// This is the function used to normalize raw values from higher level/// abstractions. Generally speaking these/// high level abstractions will handle normalization for you, and you do not/// need to call this yourself. However, if you're directly handling events/// from the parser, you may want to use this to help with value interpretation.////// # Examples////// Internally quoted values are turned into an owned variant with quotes removed.////// ```/// # use gix_config::value::normalize;/// assert_eq!(&*normalize("hello \"world\""), "hello world");/// ```////// Escaped quotes are unescaped.////// ```/// # use gix_config::value::normalize;/// assert_eq!(&*normalize(r#"hello "world\"""#), r#"hello world""#);/// ```#[must_use]pub fn normalize(input: &(impl crate::AsBStr + ?Sized)) -> Cow<'_, BStr> { normalize_inner(input.as_bstr())}fn normalize_inner(input: &BStr) -> Cow<'_, BStr> { // An optimization to strip enclosing quotes without producing a new value/copy it. if input.len() >= 2 && input[0] == b'"' && input[input.len() - 1] == b'"' && input[1..input.len() - 1].find_byteset(br#"\""#).is_none() { return Cow::Borrowed(input[1..input.len() - 1].as_ref()); } if input.find_byteset(br#"\""#).is_none() { return Cow::Borrowed(input); } let mut out: BString = Vec::with_capacity(input.len()).into(); let mut bytes = input.iter().copied(); let mut is_in_quotes = false; while let Some(c) = bytes.next() { match c { b'\\' => match bytes.next() { Some(b'n') => out.push(b'\n'), Some(b't') => out.push(b'\t'), Some(b'b') => out.push(b'\x08'), Some(c) => { out.push(c); } None => break, }, b'"' => is_in_quotes = !is_in_quotes, // Empty quotes contribute no bytes, so Git keeps ignoring unquoted whitespace after them. c if !is_in_quotes && out.is_empty() && is_git_whitespace(c) => {} _ => out.push(c), } } Cow::Owned(out)}
use std::borrow::Cow;
use bstr::{BStr, BString, ByteSlice};
use super::is_git_whitespace;
/// Removes quotes, if any, from the provided inputs, and transforms the
/// escape sequences `\n`, `\t` and `\b` into newline, tab and backspace
/// (byte `0x08`) respectively, matching how `git` interprets them.
///
/// It assumes the input contains a even number of unescaped quotes,
/// and will unescape escaped quotes and everything else (even though the latter
/// would have been rejected in the parsing stage).
///
/// The return values should be safe for value interpretation.
/// If normalization requires no byte changes, including when it only trims enclosing quotes,
/// the returned value borrows from `input`. Transforming escapes or embedded quotes produces an
/// owned value instead.
///
/// This is the function used to normalize raw values from higher level
/// abstractions. Generally speaking these
/// high level abstractions will handle normalization for you, and you do not
/// need to call this yourself. However, if you're directly handling events
/// from the parser, you may want to use this to help with value interpretation.
///
/// # Examples
///
/// Internally quoted values are turned into an owned variant with quotes removed.
///
/// ```
/// # use gix_config::value::normalize;
/// assert_eq!(&*normalize("hello \"world\""), "hello world");
/// ```
///
/// Escaped quotes are unescaped.
///
/// ```
/// # use gix_config::value::normalize;
/// assert_eq!(&*normalize(r#"hello "world\"""#), r#"hello world""#);
/// ```
#[must_use]
pub fn normalize(input: &(impl crate::AsBStr + ?Sized)) -> Cow<'_, BStr> {
normalize_inner(input.as_bstr())
}
fn normalize_inner(input: &BStr) -> Cow<'_, BStr> {
// An optimization to strip enclosing quotes without producing a new value/copy it.
if input.len() >= 2
&& input[0] == b'"'
&& input[input.len() - 1] == b'"'
&& input[1..input.len() - 1].find_byteset(br#"\""#).is_none()
{
return Cow::Borrowed(input[1..input.len() - 1].as_ref());
}
if input.find_byteset(br#"\""#).is_none() {
return Cow::Borrowed(input);
}
let mut out: BString = Vec::with_capacity(input.len()).into();
let mut bytes = input.iter().copied();
let mut is_in_quotes = false;
while let Some(c) = bytes.next() {
match c {
b'\\' => match bytes.next() {
Some(b'n') => out.push(b'\n'),
Some(b't') => out.push(b'\t'),
Some(b'b') => out.push(b'\x08'),
Some(c) => {
out.push(c);
}
None => break,
},
b'"' => is_in_quotes = !is_in_quotes,
// Empty quotes contribute no bytes, so Git keeps ignoring unquoted whitespace after them.
c if !is_in_quotes && out.is_empty() && is_git_whitespace(c) => {}
_ => out.push(c),
}
}
Cow::Owned(out)
}