[repository #164] refactor

git-repository/src/easy/ext/reference.rs

@@ -207,14 +207,13 @@ pub trait ReferenceAccessExt: easy::Access + Sized {
 
     /// Return a platform for iterating references.
     ///
-    /// Common kinds of iteration are [all][easy::iter::references::State::all()] or [prefixed][easy::iter::references::State::prefixed()]
+    /// Common kinds of iteration are [all][easy::reference::iter::State::all()] or [prefixed][easy::reference::iter::State::prefixed()]
     /// references.
-    // TODO: put this into easy::reference::iter::State
-    fn references(&self) -> Result<easy::iter::references::State<'_, Self>, easy::iter::references::Error> {
+    fn references(&self) -> Result<easy::reference::iter::State<'_, Self>, easy::reference::iter::Error> {
         let state = self.state();
         let repo = self.repo()?;
         let packed_refs = state.assure_packed_refs_uptodate(&repo.refs)?;
-        Ok(easy::iter::references::State {
+        Ok(easy::reference::iter::State {
             repo,
             packed_refs,
             access: self,

git-repository/src/easy/mod.rs

@@ -27,7 +27,6 @@ pub(crate) mod ext;
 pub mod borrow;
 pub mod commit;
 pub mod head;
-pub mod iter;
 pub mod object;
 pub mod odb;
 pub mod oid;

git-repository/src/easy/reference/iter.rs

@@ -0,0 +1,90 @@
+#![allow(missing_docs)]
+use std::cell::Ref;
+
+use crate::easy;
+
+/// An iterator over references
+#[must_use]
+pub struct State<'r, A>
+where
+    A: easy::Access + Sized,
+{
+    pub(crate) repo: A::RepoRef,
+    pub(crate) packed_refs: Ref<'r, easy::reference::packed::ModifieablePackedRefsBuffer>,
+    pub(crate) access: &'r A,
+}
+
+pub struct Iter<'r, A> {
+    inner: git_ref::file::iter::LooseThenPacked<'r, 'r>,
+    access: &'r A,
+}
+
+impl<'r, A> State<'r, A>
+where
+    A: easy::Access + Sized,
+{
+    pub fn all(&self) -> Result<Iter<'_, A>, init::Error> {
+        let repo = self.repo.deref();
+        Ok(Iter {
+            inner: repo.refs.iter(self.packed_refs.packed_refs.as_ref())?,
+            access: self.access,
+        })
+    }
+
+    pub fn prefixed(&self, prefix: impl AsRef<Path>) -> Result<Iter<'_, A>, init::Error> {
+        let repo = self.repo.deref();
+        Ok(Iter {
+            inner: repo.refs.iter_prefixed(self.packed_refs.packed_refs.as_ref(), prefix)?,
+            access: self.access,
+        })
+    }
+}
+
+impl<'r, A> Iterator for Iter<'r, A>
+where
+    A: easy::Access + Sized,
+{
+    type Item = Result<easy::Reference<'r, A>, Box<dyn std::error::Error + Send + Sync + 'static>>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next().map(|res| {
+            res.map_err(|err| Box::new(err) as Box<dyn std::error::Error + Send + Sync + 'static>)
+                .map(|r| easy::Reference::from_ref(r, self.access))
+        })
+    }
+}
+
+pub mod init {
+    #[derive(Debug, thiserror::Error)]
+    pub enum Error {
+        #[error(transparent)]
+        Io(#[from] std::io::Error),
+    }
+}
+
+mod error {
+    use crate::easy;
+
+    #[derive(Debug, thiserror::Error)]
+    pub enum Error {
+        #[error(transparent)]
+        PackedRefsOpen(#[from] git_ref::packed::buffer::open::Error),
+        #[error("BUG: Part of interior state could not be borrowed.")]
+        BorrowState(#[from] easy::borrow::state::Error),
+        #[error("BUG: The repository could not be borrowed")]
+        BorrowRepo(#[from] easy::borrow::repo::Error),
+    }
+
+    impl From<easy::reference::packed::Error> for Error {
+        fn from(err: easy::reference::packed::Error) -> Self {
+            match err {
+                easy::reference::packed::Error::PackedRefsOpen(err) => Error::PackedRefsOpen(err),
+                easy::reference::packed::Error::BorrowState(err) => Error::BorrowState(err),
+            }
+        }
+    }
+}
+
+use std::{ops::Deref, path::Path};
+
+pub use error::Error;

git-repository/src/easy/reference/mod.rs

@@ -9,6 +9,8 @@ use crate::{
     easy::{Oid, Reference},
 };
 
+pub mod iter;
+
 pub mod namespace {
     pub mod set {
         use crate::easy;