}

}

    #[inline]

    fn encode<W: Write>(&self, e: &mut Encoder<W>) -> Result<(), encode::Error<W::Error>> {

        e.str(self.as_str())?;

    }

}

    #[inline]

    fn encode<W: Write>(&self, e: &mut Encoder<W>) -> Result<(), encode::Error<W::Error>> {

        e.str(self.as_str())?;

    }

}

    #[inline]

    fn encode<W: Write>(&self, e: &mut Encoder<W>) -> Result<(), encode::Error<W::Error>> {

        self.as_str().encode(e)

    }

}

    #[inline]

    fn encode<W: Write>(&self, e: &mut Encoder<W>) -> Result<(), encode::Error<W::Error>> {

        self.as_str().encode(e)

    }

}

    #[inline]

    fn as_ref(&self) -> &RefStr {

        self

    }

}

    #[inline]

    fn next_back(&mut self) -> Option<Self::Item> {

        self.inner

    }

}

    type Target = RefStr;

    #[inline]

    }

}

    #[inline]

    fn next_back(&mut self) -> Option<Self::Item> {

        self.inner.next_back().map(|next| match next {

    }

}

    #[inline]

    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

    where

    }

}

    #[inline]

    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

    where

    }

}

    fn from(s: String) -> Self {

        Self::Name(Cow::Owned(s))

    }

pub mod headers;

pub mod trailers;

use git2::{ObjectType, Oid};

    }

    /// Iterate over the [`Headers`] values that match the provided `name`.

        self.headers.values(name)

    }

    }

}

        for parent in self.parents() {

        }

        for (name, value) in self.headers.iter() {

        }

        if !self.trailers.is_empty() {

        }

        for trailer in self.trailers.iter() {

        }

    }

}

use std::borrow::Cow;

const BEGIN_SSH: &str = "-----BEGIN SSH SIGNATURE-----\n";

    }

}

        match self {

        }

    }

}

impl Headers {

    pub fn new() -> Self {

        Headers(Vec::new())

        self.0.iter().map(|(k, v)| (k.as_str(), v.as_str()))

    }

        self.iter()

            .filter_map(move |(k, v)| (k == name).then_some(v))

    }

    separator: &'a str,

}

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

        write!(

            f,

        {

            struct OidVisitor;

                type Value = Oid;

                fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {

    pub(crate) inner: git2::Blob<'a>,

}

    pub fn id(&self) -> Oid {

        self.inner.id().into()

    }

}

#[cfg(feature = "serde")]

    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

    where

        S: Serializer,

    }

}

    type Error = str::Utf8Error;

    fn try_from(signature: git2::Signature) -> Result<Self, Self::Error> {

    }

}

    type Error = Error;

    fn try_from(commit: git2::Commit) -> Result<Self, Self::Error> {

    }

}

    type Error = error::FileMode;

    fn try_from(value: git2::DiffFile) -> Result<Self, Self::Error> {

    }

}

    type Error = error::Modification;

    fn try_from(line: git2::DiffLine) -> Result<Self, Self::Error> {

    }

}

    type Error = error::Diff;

    fn try_from(git_diff: git2::Diff) -> Result<Diff, Self::Error> {

    }

}

    type Item = Result<Commit, Error>;

    fn next(&mut self) -> Option<Self::Item> {

    }

}

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        write!(f, "History of {}", self.head.id)

    }

    }

}

    type Item = Result<Tag, error::Tag>;

    fn next(&mut self) -> Option<Self::Item> {

    }

}

    type Item = Result<Qualified<'static>, error::Tag>;

    fn next(&mut self) -> Option<Self::Item> {

    }

}

    type Item = Result<Branch, error::Branch>;

    fn next(&mut self) -> Option<Self::Item> {

    }

}

    type Item = Result<Qualified<'static>, error::Branch>;

    fn next(&mut self) -> Option<Self::Item> {

    }

}

    type Item = Result<(RefString, RefString), error::Category>;

    fn next(&mut self) -> Option<Self::Item> {

#[test]

fn test_file_history() {

    let repo = Repository::open(GIT_PLATINUM).unwrap();

    let path = Path::new("README.md");

    let mut file_history = history.by_path(&path);

    let commit = file_history.next().unwrap().unwrap();

        .map(|commit| commit.id);

    let expected_oid = repo

        .unwrap()

        .head()

        .id;

fn binary_file() {

    let repo = Repository::open(GIT_PLATINUM)

        .expect("Could not retrieve ./data/git-platinum as git repository");

    let file_commit = history.by_path(&"bin/cat").next();

    assert!(file_commit.is_some());

    println!("file commit: {:?}", &file_commit);

#[test]

fn switch_to_banana() -> Result<(), Error> {

    let repo = Repository::open(GIT_PLATINUM)?;

    repo.switch_namespace(&refname!("golden"))?;

    assert_ne!(history_master.head(), history_banana.head());

#[test]

fn me_namespace() -> Result<(), Error> {

    let repo = Repository::open(GIT_PLATINUM)?;

    assert_eq!(repo.which_namespace().unwrap(), None);

    repo.switch_namespace(&refname!("me"))?;

    assert_eq!(repo.which_namespace().unwrap(), Some("me".parse()?));

    assert_eq!(history.head(), history_feature.head());

    let expected_branches: Vec<Branch> = vec![Branch::local(refname!("feature/#1194"))];

#[test]

fn golden_namespace() -> Result<(), Error> {

    let repo = Repository::open(GIT_PLATINUM)?;

    assert_eq!(repo.which_namespace().unwrap(), None);

    assert_eq!(repo.which_namespace().unwrap(), Some("golden".parse()?));

    assert_eq!(history.head(), golden_history.head());

    let expected_branches: Vec<Branch> = vec![

#[test]

fn silver_namespace() -> Result<(), Error> {

    let repo = Repository::open(GIT_PLATINUM)?;

    assert_eq!(repo.which_namespace().unwrap(), None);

        repo.which_namespace().unwrap(),

        Some("golden/silver".parse()?)

    );

    assert_ne!(history.head(), silver_history.head());

    let expected_branches: Vec<Branch> = vec![Branch::local(refname!("master"))];

#[test]

fn _master() -> Result<(), Error> {

    let repo = Repository::open(GIT_PLATINUM)?;

    let commit1 = Oid::from_str("3873745c8f6ffb45c990eb23b491d4b4b6182f95")?;

    assert!(