[ref #140] sketch ref tag peeling

Sebastian Thiel committed 5 years ago

Commit ef906521 parent 8e1a7305 files · +26 −15Browse files

Unified · Split

5 files

git-ref/src/store/file/loose/reference/peel.rs +9 −3
git-ref/src/store/file/reference.rs +3 −2
git-ref/tests/file/reference.rs +5 −4
gitoxide-core/src/hours.rs +4 −2
gitoxide-core/src/pack/create.rs +5 −4

git-ref/src/store/file/loose/reference/peel.rs+9−3

 use quick_error::quick_error;
 use crate::{
-    file::{self},
+    file,
     mutable::Target,
     store::{
         file::{find, loose},
 };
 quick_error! {
-    /// The error returned by [`Reference::peel_one_level()`].
+    /// The error returned by [`loose::Reference::follow_symbolic()`].
     #[derive(Debug)]
     #[allow(missing_docs)]
     pub enum Error {
             display("Could not resolve symbolic reference name that is expected to exist")
             source(err)
         }
-        Decode(err: file::loose::reference::decode::Error) {
+        Decode(err: loose::reference::decode::Error) {
             display("The reference could not be decoded.")
             source(err)
         }
     }
 }
+/// A function for use in [`loose::Reference::peel_to_id_in_place()`] to indicate no peeling should happen.
+pub fn none(_id: &git_hash::oid) -> Result<Option<(git_object::Kind, &'_ [u8])>, Box<dyn std::error::Error>> {
+    Ok(Some((git_object::Kind::Commit, &[])))
+}
 impl loose::Reference {
     /// Follow this symbolic reference one level and return the ref it refers to, possibly providing access to `packed` references for lookup.
     ///
             &mut self,
             store: &file::Store,
             packed: Option<&packed::Buffer>,
+            _find: impl FnMut(&git_hash::oid) -> Result<Option<(git_object::Kind, &[u8])>, Box<dyn std::error::Error>>,
         ) -> Result<&oid, Error> {
             let mut seen = BTreeSet::new();
             let mut storage;

git-ref/src/store/file/reference.rs+3−2

         &mut self,
         store: &file::Store,
         packed: Option<&packed::Buffer>,
+        find: impl FnMut(&git_hash::oid) -> Result<Option<(git_object::Kind, &[u8])>, Box<dyn std::error::Error>>,
     ) -> Result<ObjectId, crate::store::file::loose::reference::peel::to_id::Error> {
         match self {
-            Reference::Loose(r) => r.peel_to_id_in_place(store, packed).map(ToOwned::to_owned),
+            Reference::Loose(r) => r.peel_to_id_in_place(store, packed, find).map(ToOwned::to_owned),
             Reference::Packed(p) => {
                 if let Some(object) = p.object {
                     p.target = object;
         }
     }
-    /// For details, see [crate::file::loose::Reference::peel_one_level].
+    /// For details, see [crate::file::loose::Reference::follow_symbolic()].
     pub fn peel_one_level<'p2>(
         &self,
         store: &file::Store,

git-ref/tests/file/reference.rs+5−4

 mod peel {
     use crate::{file, file::store_with_packed_refs};
+    use git_ref::file::loose::reference::peel;
     use git_testtools::hex_to_id;
     use std::convert::TryFrom;
         let mut head = store.loose_find_existing("HEAD")?;
         let packed = store.packed()?;
         let expected = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");
-        assert_eq!(head.peel_to_id_in_place(&store, packed.as_ref())?, expected);
+        assert_eq!(head.peel_to_id_in_place(&store, packed.as_ref(), peel::none)?, expected);
         assert_eq!(head.target.as_id().map(ToOwned::to_owned), Some(expected));
         let mut head = store.find_existing("dt1", packed.as_ref())?;
-        assert_eq!(head.peel_to_id_in_place(&store, packed.as_ref())?, expected);
+        assert_eq!(head.peel_to_id_in_place(&store, packed.as_ref(), peel::none)?, expected);
         assert_eq!(head.target().as_id().map(ToOwned::to_owned), Some(expected));
         Ok(())
     }
         assert_eq!(r.kind(), git_ref::Kind::Symbolic, "there is something to peel");
         assert_eq!(
-            r.peel_to_id_in_place(&store, None)?,
+            r.peel_to_id_in_place(&store, None, peel::none)?,
             hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03")
         );
         assert_eq!(r.name.as_bstr(), "refs/remotes/origin/multi-link-target3");
         assert_eq!(r.name.as_bstr(), "refs/loop-a");
         assert!(matches!(
-            r.peel_to_id_in_place(&store, None).unwrap_err(),
+            r.peel_to_id_in_place(&store, None, peel::none).unwrap_err(),
             git_ref::file::loose::reference::peel::to_id::Error::Cycle { .. }
         ));
         assert_eq!(r.name.as_bstr(), "refs/loop-a", "the ref is not changed on error");

gitoxide-core/src/hours.rs+4−2

 use anyhow::{anyhow, bail};
 use bstr::BString;
-use git_repository::{actor, interrupt, object, odb, prelude::*, progress, Progress};
+use git_repository::{
+    actor, interrupt, object, odb, prelude::*, progress, refs::file::loose::reference::peel, Progress,
+};
 use itertools::Itertools;
 use rayon::prelude::*;
 use std::{
     let commit_id = repo
         .refs
         .find_existing(refname.to_string_lossy().as_ref(), packed.as_ref())?
-        .peel_to_id_in_place(&repo.refs, packed.as_ref())?
+        .peel_to_id_in_place(&repo.refs, packed.as_ref(), peel::none)?
         .to_owned();
     let all_commits = {

gitoxide-core/src/pack/create.rs+5−4

 use crate::OutputFormat;
 use anyhow::anyhow;
-use git_repository::odb::pack::cache::DecodeEntry;
 use git_repository::{
     hash,
     hash::ObjectId,
     interrupt,
     object::bstr::ByteVec,
-    odb::pack,
+    odb::{pack, pack::cache::DecodeEntry},
     prelude::{Finalize, FindExt},
-    progress, traverse, Progress,
+    progress,
+    refs::file::loose::reference::peel,
+    traverse, Progress,
 };
 use std::{ffi::OsStr, io, path::Path, str::FromStr, sync::Arc, time::Instant};
                             refs.find_existing(tip.as_ref().to_string_lossy().as_ref(), packed.as_ref())
                                 .map_err(anyhow::Error::from)
                                 .and_then(|mut r| {
-                                    r.peel_to_id_in_place(refs, packed.as_ref())
+                                    r.peel_to_id_in_place(refs, packed.as_ref(), peel::none)
                                         .map(|oid| oid.to_owned())
                                         .map_err(anyhow::Error::from)
                                 })

[ref #140] sketch ref tag peeling

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code