lael-labs/gitoxide

Cargo.lock+1−1

@@ -985,7 +985,7 @@ dependencies = [ · 984 unmodified lines
985		985
986	[[package]]	986	[[package]]
987	name = "git-actor"	987	name = "git-actor"
988	version = "0.4.0"	988	version = "0.5.0"
989	dependencies = [	989	dependencies = [
990	"bstr",	990	"bstr",
991	"btoi",	991	"btoi",

cargo-smart-release/src/command/release/git.rs+2−5

         skip_tag,
         ..
     }: Options,
-) -> anyhow::Result<Option<refs::mutable::FullName>> {
+) -> anyhow::Result<Option<refs::FullName>> {
     if skip_tag {
         return Ok(None);
     }
 }
 // TODO: Make this gitoxide
-pub fn push_tags_and_head(
+pub fn push_tags_and_head(tag_names: impl IntoIterator<Item = refs::FullName>, options: Options) -> anyhow::Result<()> {
-    tag_names: impl IntoIterator<Item = refs::mutable::FullName>,
-    options: Options,
-) -> anyhow::Result<()> {
     if options.skip_push {
         return Ok(());
     }

experiments/diffing/src/main.rs+1−1

@@ -32,7 +32,7 @@ fn main() -> anyhow::Result<()> { · 31 unmodified lines
32	let packed = repo.refs.packed_buffer()?;	32	let packed = repo.refs.packed_buffer()?;
33	let commit_id = repo	33	let commit_id = repo
34	.refs	34	.refs
35	.find_existing(&name, packed.as_ref())?	35	.find(&name, packed.as_ref())?
36	.peel_to_id_in_place(&repo.refs, packed.as_ref(), peel::none)?	36	.peel_to_id_in_place(&repo.refs, packed.as_ref(), peel::none)?
37	.to_owned();	37	.to_owned();
38	let db = &repo.odb;	38	let db = &repo.odb;

experiments/traversal/src/main.rs+1−1

@@ -28,7 +28,7 @@ fn main() -> anyhow::Result<()> { · 27 unmodified lines
28	let packed = repo.refs.packed_buffer()?;	28	let packed = repo.refs.packed_buffer()?;
29	let commit_id = repo	29	let commit_id = repo
30	.refs	30	.refs
31	.find_existing(&name, packed.as_ref())?	31	.find(&name, packed.as_ref())?
32	.peel_to_id_in_place(&repo.refs, packed.as_ref(), peel::none)?	32	.peel_to_id_in_place(&repo.refs, packed.as_ref(), peel::none)?
33	.to_owned();	33	.to_owned();
34	(repo, commit_id)	34	(repo, commit_id)

git-actor/Cargo.toml+1−1

@@ -1,6 +1,6 @@
1	[package]	1	[package]
2	name = "git-actor"	2	name = "git-actor"
3	version = "0.4.0"	3	version = "0.5.0"
4	description = "A way to identify git actors"	4	description = "A way to identify git actors"
5	authors = ["Sebastian Thiel <sebastian.thiel@icloud.com>"]	5	authors = ["Sebastian Thiel <sebastian.thiel@icloud.com>"]
6	repository = "https://github.com/Byron/gitoxide"	6	repository = "https://github.com/Byron/gitoxide"

git-actor/src/lib.rs+0−2

@@ -5,8 +5,6 @@ use bstr::{BStr, BString}; · 4 unmodified lines
5		5
6	///	6	///
7	pub mod signature;	7	pub mod signature;
8	///
9	pub mod signature_ref;
10		8
11	const SPACE: &[u8; 1] = b" ";	9	const SPACE: &[u8; 1] = b" ";
12		10

git-actor/src/signature/decode.rsrenamed from git-actor/src/signature_ref/decode.rs+2−5

         use git_testtools::to_bstr_err;
         use nom::IResult;
-        use crate::{
+        use crate::{signature, Sign, SignatureRef, Time};
-            signature_ref::{self, SignatureRef},
-            Sign, Time,
-        };
         fn decode(i: &[u8]) -> IResult<&[u8], SignatureRef<'_>, nom::error::VerboseError<&[u8]>> {
-            signature_ref::decode(i)
+            signature::decode(i)
         }
         fn signature(

git-actor/src/signature/mod.rsrenamed from git-actor/src/signature.rs+17−0

@@ -1,3 +1,16 @@
		1	mod _ref {
		2	use crate::{signature::decode, SignatureRef};
		3
		4	impl<'a> SignatureRef<'a> {
		5	/// Deserialize a signature from the given `data`.
		6	pub fn from_bytes<E: nom::error::ParseError<&'a [u8]> + nom::error::ContextError<&'a [u8]>>(
		7	data: &'a [u8],
		8	) -> Result<SignatureRef<'a>, nom::Err<E>> {
		9	decode(data).map(\|(_, t)\| t)
		10	}
		11	}
		12	}
		13
1	mod convert {	14	mod convert {
2	use crate::{Sign, Signature, SignatureRef, Time};	15	use crate::{Sign, Signature, SignatureRef, Time};
3		16
@@ -85,3 +98,7 @@ mod write { · 81 unmodified lines
85	Ok(name)	98	Ok(name)
86	}	99	}
87	}	100	}
		101
		102	///
		103	mod decode;
		104	pub use decode::decode;

git-actor/src/signature_ref/mod.rs+0−14

@@ -1,14 +0,0 @@
1	use crate::SignatureRef;
2
3	impl<'a> SignatureRef<'a> {
4	/// Deserialize a signature from the given `data`.
5	pub fn from_bytes<E: nom::error::ParseError<&'a [u8]> + nom::error::ContextError<&'a [u8]>>(
6	data: &'a [u8],
7	) -> Result<SignatureRef<'a>, nom::Err<E>> {
8	decode(data).map(\|(_, t)\| t)
9	}
10	}
11
12	///
13	mod decode;
14	pub use decode::decode;

git-object/Cargo.toml+1−1

@@ -21,7 +21,7 @@ all-features = true · 20 unmodified lines
21	[dependencies]	21	[dependencies]
22	git-hash = { version = "^0.5.0", path = "../git-hash" }	22	git-hash = { version = "^0.5.0", path = "../git-hash" }
23	git-validate = { version = "^0.5.0", path = "../git-validate" }	23	git-validate = { version = "^0.5.0", path = "../git-validate" }
24	git-actor = { version ="^0.4.0", path = "../git-actor" }	24	git-actor = { version ="^0.5.0", path = "../git-actor" }
25		25
26	quick-error = "2.0.0"	26	quick-error = "2.0.0"
27	hex = "0.4.2"	27	hex = "0.4.2"

git-object/src/immutable/parse.rs+1−1

@@ -77,5 +77,5 @@ pub fn hex_hash<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], & · 76 unmodified lines
77	pub(crate) fn signature<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(	77	pub(crate) fn signature<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(
78	i: &'a [u8],	78	i: &'a [u8],
79	) -> IResult<&'a [u8], git_actor::SignatureRef<'a>, E> {	79	) -> IResult<&'a [u8], git_actor::SignatureRef<'a>, E> {
80	git_actor::signature_ref::decode(i)	80	git_actor::signature::decode(i)
81	}	81	}

git-object/src/types.rs+1−1

@@ -56,7 +56,7 @@ impl fmt::Display for Kind { · 55 unmodified lines
56	pub mod tree {	56	pub mod tree {
57	/// The mode of items storable in a tree, similar to the file mode on a unix file system.	57	/// The mode of items storable in a tree, similar to the file mode on a unix file system.
58	///	58	///
59	/// Used in [mutable::Entry][crate::mutable::tree::Entry] and [signature_ref::Entry][crate::immutable::tree::Entry].	59	/// Used in [mutable::Entry][crate::mutable::tree::Entry] and [tree::Entry][crate::immutable::tree::Entry].
60	#[derive(Clone, Copy, PartialEq, Eq, Debug, Ord, PartialOrd, Hash)]	60	#[derive(Clone, Copy, PartialEq, Eq, Debug, Ord, PartialOrd, Hash)]
61	#[repr(u16)]	61	#[repr(u16)]
62	#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]	62	#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]

git-ref/Cargo.toml+1−1

@@ -28,7 +28,7 @@ git-features = { version = "^0.16.0", path = "../git-features", features = ["wal · 27 unmodified lines
28	git-hash = { version = "^0.5.0", path = "../git-hash" }	28	git-hash = { version = "^0.5.0", path = "../git-hash" }
29	git-object = { version ="0.12.0", path = "../git-object" }	29	git-object = { version ="0.12.0", path = "../git-object" }
30	git-validate = { version = "^0.5.0", path = "../git-validate" }	30	git-validate = { version = "^0.5.0", path = "../git-validate" }
31	git-actor = { version ="^0.4.0", path = "../git-actor" }	31	git-actor = { version ="^0.5.0", path = "../git-actor" }
32	git-lock = { version ="^1.0.0", path = "../git-lock" }	32	git-lock = { version ="^1.0.0", path = "../git-lock" }
33	git-tempfile = { version ="^1.0.0", path = "../git-tempfile" }	33	git-tempfile = { version ="^1.0.0", path = "../git-tempfile" }
34		34

git-ref/src/fullname.rs+71−0

@@ -0,0 +1,71 @@
	1	use std::{borrow::Cow, convert::TryFrom, path::Path};
	2
	3	use bstr::{BStr, BString, ByteSlice};
	4
	5	use crate::FullName;
	6
	7	impl TryFrom<&str> for FullName {
	8	type Error = git_validate::refname::Error;
	9
	10	fn try_from(value: &str) -> Result<Self, Self::Error> {
	11	Ok(FullName(git_validate::refname(value.as_bytes().as_bstr())?.into()))
	12	}
	13	}
	14
	15	impl TryFrom<String> for FullName {
	16	type Error = git_validate::refname::Error;
	17
	18	fn try_from(value: String) -> Result<Self, Self::Error> {
	19	git_validate::refname(value.as_bytes().as_bstr())?;
	20	Ok(FullName(value.into()))
	21	}
	22	}
	23
	24	impl TryFrom<&BStr> for FullName {
	25	type Error = git_validate::refname::Error;
	26
	27	fn try_from(value: &BStr) -> Result<Self, Self::Error> {
	28	Ok(FullName(git_validate::refname(value)?.into()))
	29	}
	30	}
	31
	32	impl TryFrom<BString> for FullName {
	33	type Error = git_validate::refname::Error;
	34
	35	fn try_from(value: BString) -> Result<Self, Self::Error> {
	36	git_validate::refname(value.as_ref())?;
	37	Ok(FullName(value))
	38	}
	39	}
	40
	41	impl<'a> From<crate::FullNameRef<'a>> for FullName {
	42	fn from(value: crate::FullNameRef<'a>) -> Self {
	43	FullName(value.as_bstr().into())
	44	}
	45	}
	46
	47	impl FullName {
	48	/// Interpret this fully qualified reference name as partial name.
	49	pub fn to_partial(&self) -> crate::PartialNameRef<'_> {
	50	crate::PartialNameRef(self.0.as_bstr())
	51	}
	52
	53	/// Interpret this fully qualified reference as shared full name
	54	pub fn to_ref(&self) -> crate::FullNameRef<'_> {
	55	crate::FullNameRef(self.0.as_bstr())
	56	}
	57
	58	/// Convert this name into the relative path, lossily, identifying the reference location relative to a repository
	59	pub fn to_path(&self) -> Cow<'_, Path> {
	60	self.0.to_path().expect("UTF-8 conversion always succeeds").into()
	61	}
	62
	63	/// Dissolve this instance and return the buffer.
	64	pub fn into_inner(self) -> BString {
	65	self.0
	66	}
	67	/// Return ourselves as byte string which is a valid refname
	68	pub fn as_bstr(&self) -> &BStr {
	69	self.0.as_bstr()
	70	}
	71	}

git-ref/src/lib.rs+22−6

@@ -19,12 +19,12 @@ · 18 unmodified lines
19	#![forbid(unsafe_code)]	19	#![forbid(unsafe_code)]
20	#![deny(missing_docs, rust_2018_idioms)]	20	#![deny(missing_docs, rust_2018_idioms)]
21	use bstr::{BStr, BString};	21	use bstr::{BStr, BString};
22	use git_hash::oid;	22	use git_hash::{oid, ObjectId};
23		23
24	mod store;	24	mod store;
25	pub use store::{file, packed};	25	pub use store::{file, packed};
26	///	26
27	pub mod mutable;	27	mod fullname;
28	///	28	///
29	pub mod name;	29	pub mod name;
30	///	30	///
@@ -32,12 +32,17 @@ pub mod namespace; · 1 unmodified line
32	///	32	///
33	pub mod transaction;	33	pub mod transaction;
34		34
		35	/// Indicate that the given BString is a validate reference name or path that can be used as path on disk or written as target
		36	/// of a symbolic reference
		37	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
		38	pub struct FullName(pub(crate) BString);
		39
35	/// A validated and potentially partial reference name - it can safely be used for common operations.	40	/// A validated and potentially partial reference name - it can safely be used for common operations.
36	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]	41	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
37	pub struct FullName<'a>(&'a BStr);	42	pub struct FullNameRef<'a>(&'a BStr);
38	/// A validated complete and fully qualified reference name, safe to use for all operations.	43	/// A validated complete and fully qualified reference name, safe to use for all operations.
39	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]	44	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
40	pub struct PartialName<'a>(&'a BStr);	45	pub struct PartialNameRef<'a>(&'a BStr);
41		46
42	/// A validated prefix for references to act as a namespace.	47	/// A validated prefix for references to act as a namespace.
43	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]	48	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
@@ -55,9 +60,20 @@ pub enum Kind { · 11 unmodified lines
55	Symbolic,	60	Symbolic,
56	}	61	}
57		62
		63	/// Denotes a ref target, equivalent to [`Kind`], but with mutable data.
		64	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
		65	pub enum Target {
		66	/// A ref that points to an object id
		67	Peeled(ObjectId),
		68	/// A ref that points to another reference by its validated name, adding a level of indirection.
		69	///
		70	/// Note that this is an extension of gitoxide which will be helpful in logging all reference changes.
		71	Symbolic(FullName),
		72	}
		73
58	/// Denotes a ref target, equivalent to [`Kind`], but with signature_ref data.	74	/// Denotes a ref target, equivalent to [`Kind`], but with signature_ref data.
59	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]	75	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
60	pub enum Target<'a> {	76	pub enum TargetRef<'a> {
61	/// A ref that points to an object id	77	/// A ref that points to an object id
62	Peeled(&'a oid),	78	Peeled(&'a oid),
63	/// A ref that points to another reference by its validated name, adding a level of indirection.	79	/// A ref that points to another reference by its validated name, adding a level of indirection.

git-ref/src/mutable.rs+0−162

@@ -1,162 +0,0 @@
1	use std::{borrow::Cow, convert::TryFrom, fmt, path::Path};
2
3	use bstr::{BStr, BString, ByteSlice};
4	use git_hash::{oid, ObjectId};
5
6	use crate::Kind;
7
8	/// Indicate that the given BString is a validate reference name or path that can be used as path on disk or written as target
9	/// of a symbolic reference
10	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
11	pub struct FullName(pub(crate) BString);
12
13	impl TryFrom<&str> for FullName {
14	type Error = git_validate::refname::Error;
15
16	fn try_from(value: &str) -> Result<Self, Self::Error> {
17	Ok(FullName(git_validate::refname(value.as_bytes().as_bstr())?.into()))
18	}
19	}
20
21	impl TryFrom<String> for FullName {
22	type Error = git_validate::refname::Error;
23
24	fn try_from(value: String) -> Result<Self, Self::Error> {
25	git_validate::refname(value.as_bytes().as_bstr())?;
26	Ok(FullName(value.into()))
27	}
28	}
29
30	impl TryFrom<&BStr> for FullName {
31	type Error = git_validate::refname::Error;
32
33	fn try_from(value: &BStr) -> Result<Self, Self::Error> {
34	Ok(FullName(git_validate::refname(value)?.into()))
35	}
36	}
37
38	impl TryFrom<BString> for FullName {
39	type Error = git_validate::refname::Error;
40
41	fn try_from(value: BString) -> Result<Self, Self::Error> {
42	git_validate::refname(value.as_ref())?;
43	Ok(FullName(value))
44	}
45	}
46
47	impl<'a> From<crate::FullName<'a>> for FullName {
48	fn from(value: crate::FullName<'a>) -> Self {
49	FullName(value.as_bstr().into())
50	}
51	}
52
53	impl FullName {
54	/// Interpret this fully qualified reference name as partial name.
55	pub fn to_partial(&self) -> crate::PartialName<'_> {
56	crate::PartialName(self.0.as_bstr())
57	}
58
59	/// Interpret this fully qualified reference as shared full name
60	pub fn borrow(&self) -> crate::FullName<'_> {
61	crate::FullName(self.0.as_bstr())
62	}
63
64	/// Convert this name into the relative path, lossily, identifying the reference location relative to a repository
65	pub fn to_path(&self) -> Cow<'_, Path> {
66	self.0.to_path().expect("UTF-8 conversion always succeeds").into()
67	}
68
69	/// Dissolve this instance and return the buffer.
70	pub fn into_inner(self) -> BString {
71	self.0
72	}
73	/// Return ourselves as byte string which is a valid refname
74	pub fn as_bstr(&self) -> &BStr {
75	self.0.as_bstr()
76	}
77	}
78
79	/// Denotes a ref target, equivalent to [`Kind`][super::Kind], but with mutable data.
80	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
81	pub enum Target {
82	/// A ref that points to an object id
83	Peeled(ObjectId),
84	/// A ref that points to another reference by its validated name, adding a level of indirection.
85	///
86	/// Note that this is an extension of gitoxide which will be helpful in logging all reference changes.
87	Symbolic(FullName),
88	}
89
90	impl Target {
91	/// Returns the kind of the target the ref is pointing to.
92	pub fn kind(&self) -> Kind {
93	match self {
94	Target::Symbolic(_) => Kind::Symbolic,
95	Target::Peeled(_) => Kind::Peeled,
96	}
97	}
98
99	/// Return true if this is a peeled target with a null hash
100	pub fn is_null(&self) -> bool {
101	match self {
102	Target::Peeled(oid) => oid.is_null(),
103	Target::Symbolic(_) => false,
104	}
105	}
106
107	/// Interpret this owned Target as shared Target
108	pub fn borrow(&self) -> crate::Target<'_> {
109	match self {
110	Target::Peeled(oid) => crate::Target::Peeled(oid),
111	Target::Symbolic(name) => crate::Target::Symbolic(name.0.as_bstr()),
112	}
113	}
114
115	/// Interpret this target as object id which maybe `None` if it is symbolic.
116	pub fn as_id(&self) -> Option<&oid> {
117	match self {
118	Target::Symbolic(_) => None,
119	Target::Peeled(oid) => Some(oid),
120	}
121	}
122	/// Interpret this target as name of the reference it points to which maybe `None` if it an object id.
123	pub fn as_name(&self) -> Option<&BStr> {
124	match self {
125	Target::Symbolic(name) => Some(name.as_bstr()),
126	Target::Peeled(_) => None,
127	}
128	}
129
130	/// Create an instance that signals that a reference should exist if this value is used in a [`Change`][crate::transaction::Change].
131	pub fn must_exist() -> Self {
132	Target::Peeled(ObjectId::null_sha1())
133	}
134	}
135
136	impl<'a> From<crate::Target<'a>> for Target {
137	fn from(src: crate::Target<'a>) -> Self {
138	match src {
139	crate::Target::Peeled(oid) => Target::Peeled(oid.to_owned()),
140	crate::Target::Symbolic(name) => Target::Symbolic(FullName(name.to_owned())),
141	}
142	}
143	}
144
145	impl<'a> PartialEq<crate::Target<'a>> for Target {
146	fn eq(&self, other: &crate::Target<'a>) -> bool {
147	match (self, other) {
148	(Target::Peeled(lhs), crate::Target::Peeled(rhs)) => lhs == rhs,
149	(Target::Symbolic(lhs), crate::Target::Symbolic(rhs)) => lhs.as_bstr() == *rhs,
150	_ => false,
151	}
152	}
153	}
154
155	impl fmt::Display for Target {
156	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
157	match self {
158	Target::Peeled(oid) => oid.fmt(f),
159	Target::Symbolic(name) => write!(f, "ref: {}", name.as_bstr()),
160	}
161	}
162	}

git-ref/src/name.rs+19−19

@@ -6,12 +6,12 @@ use std::{ · 5 unmodified lines
6		6
7	use bstr::{BStr, ByteSlice};	7	use bstr::{BStr, ByteSlice};
8		8
9	use crate::{FullName, PartialName};	9	use crate::{FullNameRef, PartialNameRef};
10		10
11	/// The error used in the [`PartialName`][super::PartialName]::try_from(…) implementations.	11	/// The error used in the [`PartialNameRef`][super::PartialNameRef]::try_from(…) implementations.
12	pub type Error = git_validate::reference::name::Error;	12	pub type Error = git_validate::reference::name::Error;
13		13
14	impl<'a> FullName<'a> {	14	impl<'a> FullNameRef<'a> {
15	/// Convert this name into the relative path identifying the reference location.	15	/// Convert this name into the relative path identifying the reference location.
16	pub fn to_path(self) -> Cow<'a, Path> {	16	pub fn to_path(self) -> Cow<'a, Path> {
17	self.0.to_path().expect("UTF-8 conversion always succeeds").into()	17	self.0.to_path().expect("UTF-8 conversion always succeeds").into()
@@ -23,7 +23,7 @@ impl<'a> FullName<'a> { · 5 unmodified lines
23	}	23	}
24	}	24	}
25		25
26	impl<'a> PartialName<'a> {	26	impl<'a> PartialNameRef<'a> {
27	/// Convert this name into the relative path possibly identifying the reference location.	27	/// Convert this name into the relative path possibly identifying the reference location.
28	/// Note that it may be only a partial path though.	28	/// Note that it may be only a partial path though.
29	pub fn to_partial_path(self) -> Cow<'a, Path> {	29	pub fn to_partial_path(self) -> Cow<'a, Path> {
@@ -36,62 +36,62 @@ impl<'a> PartialName<'a> { · 6 unmodified lines
36	}	36	}
37	}	37	}
38		38
39	impl<'a> TryFrom<&'a BStr> for FullName<'a> {	39	impl<'a> TryFrom<&'a BStr> for FullNameRef<'a> {
40	type Error = Error;	40	type Error = Error;
41		41
42	fn try_from(v: &'a BStr) -> Result<Self, Self::Error> {	42	fn try_from(v: &'a BStr) -> Result<Self, Self::Error> {
43	Ok(FullName(git_validate::reference::name(v)?))	43	Ok(FullNameRef(git_validate::reference::name(v)?))
44	}	44	}
45	}	45	}
46		46
47	impl<'a> TryFrom<FullName<'a>> for PartialName<'a> {	47	impl<'a> TryFrom<FullNameRef<'a>> for PartialNameRef<'a> {
48	type Error = Infallible;	48	type Error = Infallible;
49		49
50	fn try_from(v: FullName<'a>) -> Result<Self, Self::Error> {	50	fn try_from(v: FullNameRef<'a>) -> Result<Self, Self::Error> {
51	Ok(PartialName(v.0))	51	Ok(PartialNameRef(v.0))
52	}	52	}
53	}	53	}
54		54
55	impl<'a> TryFrom<&'a BStr> for PartialName<'a> {	55	impl<'a> TryFrom<&'a BStr> for PartialNameRef<'a> {
56	type Error = Error;	56	type Error = Error;
57		57
58	fn try_from(v: &'a BStr) -> Result<Self, Self::Error> {	58	fn try_from(v: &'a BStr) -> Result<Self, Self::Error> {
59	Ok(PartialName(git_validate::reference::name_partial(v)?))	59	Ok(PartialNameRef(git_validate::reference::name_partial(v)?))
60	}	60	}
61	}	61	}
62		62
63	impl<'a> TryFrom<&'a str> for FullName<'a> {	63	impl<'a> TryFrom<&'a str> for FullNameRef<'a> {
64	type Error = Error;	64	type Error = Error;
65		65
66	fn try_from(v: &'a str) -> Result<Self, Self::Error> {	66	fn try_from(v: &'a str) -> Result<Self, Self::Error> {
67	let v = v.as_bytes().as_bstr();	67	let v = v.as_bytes().as_bstr();
68	Ok(FullName(git_validate::reference::name(v)?))	68	Ok(FullNameRef(git_validate::reference::name(v)?))
69	}	69	}
70	}	70	}
71		71
72	impl<'a> TryFrom<&'a str> for PartialName<'a> {	72	impl<'a> TryFrom<&'a str> for PartialNameRef<'a> {
73	type Error = Error;	73	type Error = Error;
74		74
75	fn try_from(v: &'a str) -> Result<Self, Self::Error> {	75	fn try_from(v: &'a str) -> Result<Self, Self::Error> {
76	let v = v.as_bytes().as_bstr();	76	let v = v.as_bytes().as_bstr();
77	Ok(PartialName(git_validate::reference::name_partial(v)?))	77	Ok(PartialNameRef(git_validate::reference::name_partial(v)?))
78	}	78	}
79	}	79	}
80		80
81	impl<'a> TryFrom<&'a String> for FullName<'a> {	81	impl<'a> TryFrom<&'a String> for FullNameRef<'a> {
82	type Error = Error;	82	type Error = Error;
83		83
84	fn try_from(v: &'a String) -> Result<Self, Self::Error> {	84	fn try_from(v: &'a String) -> Result<Self, Self::Error> {
85	let v = v.as_bytes().as_bstr();	85	let v = v.as_bytes().as_bstr();
86	Ok(FullName(git_validate::reference::name(v)?))	86	Ok(FullNameRef(git_validate::reference::name(v)?))
87	}	87	}
88	}	88	}
89		89
90	impl<'a> TryFrom<&'a String> for PartialName<'a> {	90	impl<'a> TryFrom<&'a String> for PartialNameRef<'a> {
91	type Error = Error;	91	type Error = Error;
92		92
93	fn try_from(v: &'a String) -> Result<Self, Self::Error> {	93	fn try_from(v: &'a String) -> Result<Self, Self::Error> {
94	let v = v.as_bytes().as_bstr();	94	let v = v.as_bytes().as_bstr();
95	Ok(PartialName(git_validate::reference::name_partial(v)?))	95	Ok(PartialNameRef(git_validate::reference::name_partial(v)?))
96	}	96	}
97	}	97	}

git-ref/src/namespace.rs+2−2

@@ -2,7 +2,7 @@ use std::{borrow::Cow, convert::TryInto, path::Path}; · 1 unmodified line
2		2
3	use bstr::{BStr, BString, ByteSlice, ByteVec};	3	use bstr::{BStr, BString, ByteSlice, ByteVec};
4		4
5	use crate::{Namespace, PartialName};	5	use crate::{Namespace, PartialNameRef};
6		6
7	impl Namespace {	7	impl Namespace {
8	/// Dissolve ourselves into the interior representation	8	/// Dissolve ourselves into the interior representation
@@ -24,7 +24,7 @@ impl Namespace { · 15 unmodified lines
24	/// For more information, consult the [git namespace documentation](https://git-scm.com/docs/gitnamespaces).	24	/// For more information, consult the [git namespace documentation](https://git-scm.com/docs/gitnamespaces).
25	pub fn expand<'a, Name, E>(namespace: Name) -> Result<Namespace, git_validate::refname::Error>	25	pub fn expand<'a, Name, E>(namespace: Name) -> Result<Namespace, git_validate::refname::Error>
26	where	26	where
27	Name: TryInto<PartialName<'a>, Error = E>,	27	Name: TryInto<PartialNameRef<'a>, Error = E>,
28	git_validate::refname::Error: From<E>,	28	git_validate::refname::Error: From<E>,
29	{	29	{
30	let namespace = namespace.try_into()?.0;	30	let namespace = namespace.try_into()?.0;

git-ref/src/store/file/find.rs+19−16

 use crate::{
     file,
-    mutable::FullName,
     store::{
         file::{loose, path_to_name},
         packed,
     },
-    PartialName,
+    FullName, PartialNameRef,
 };
 enum Transform {
     /// The lookup algorithm follows the one in [the git documentation][git-lookup-docs].
     ///
     /// [git-lookup-docs]: https://github.com/git/git/blob/5d5b1473453400224ebb126bf3947e0a3276bdf5/Documentation/revisions.txt#L34-L46
-    pub fn find<'a, 'p, 's, Name, E>(
+    pub fn try_find<'a, 'p, 's, Name, E>(
         &'s self,
         partial: Name,
         packed: Option<&'p packed::Buffer>,
     ) -> Result<Option<file::Reference<'p>>, Error>
     where
-        Name: TryInto<PartialName<'a>, Error = E>,
+        Name: TryInto<PartialNameRef<'a>, Error = E>,
         Error: From<E>,
     {
         let path = partial.try_into()?;
     }
     /// Similar to [`file::Store::find()`] but a non-existing ref is treated as error.
-    pub fn loose_find<'a, Name, E>(&self, partial: Name) -> Result<Option<loose::Reference>, Error>
+    ///
+    /// Find only loose references, that is references that aren't in the packed-refs buffer.
+    /// All symbolic references are loose references.
+    /// `HEAD` is always a loose reference.
+    pub fn try_find_loose<'a, Name, E>(&self, partial: Name) -> Result<Option<loose::Reference>, Error>
     where
-        Name: TryInto<PartialName<'a>, Error = E>,
+        Name: TryInto<PartialNameRef<'a>, Error = E>,
         Error: From<E>,
     {
-        self.find(partial, None)
+        self.try_find(partial, None)
             .map(|r| r.map(|r| r.try_into().expect("only loose refs are found without pack")))
     }
                 if is_definitely_absolute {
                     if let Some(packed) = packed {
                         let full_name = path_to_name(relative_path);
-                        let full_name = PartialName((*full_name).as_bstr());
+                        let full_name = PartialNameRef((*full_name).as_bstr());
-                        if let Some(packed_ref) = packed.find(full_name)? {
+                        if let Some(packed_ref) = packed.try_find(full_name)? {
                             return Ok(Some(file::Reference::Packed(packed_ref)));
                         };
                     }
             file::{find, loose},
             packed,
         },
-        PartialName,
+        PartialNameRef,
     };
     impl file::Store {
-        /// Similar to [`file::Store::find_existing()`] but a non-existing ref is treated as error.
+        /// Similar to [`file::Store::find()`] but a non-existing ref is treated as error.
-        pub fn find_existing<'a, 'p, 's, Name, E>(
+        pub fn find<'a, 'p, 's, Name, E>(
             &'s self,
             partial: Name,
             packed: Option<&'p packed::Buffer>,
         ) -> Result<file::Reference<'p>, Error>
         where
-            Name: TryInto<PartialName<'a>, Error = E>,
+            Name: TryInto<PartialNameRef<'a>, Error = E>,
             crate::name::Error: From<E>,
         {
             let path = partial
         }
         /// Similar to [`file::Store::find()`] won't handle packed-refs.
-        pub fn loose_find_existing<'a, Name, E>(&self, partial: Name) -> Result<loose::Reference, Error>
+        pub fn find_loose<'a, Name, E>(&self, partial: Name) -> Result<loose::Reference, Error>
         where
-            Name: TryInto<PartialName<'a>, Error = E>,
+            Name: TryInto<PartialNameRef<'a>, Error = E>,
             crate::name::Error: From<E>,
         {
-            self.find_existing(partial, None)
+            self.find(partial, None)
                 .map(|r| r.try_into().expect("always loose without packed"))
         }
     }

git-ref/src/store/file/log/iter.rs+6−5

 use bstr::ByteSlice;
+use crate::store::file;
 use crate::store::file::{log, log::iter::decode::LineNumber};
 ///
 /// This iterator is useful when the ref log file is going to be rewritten which forces processing of the entire file.
 /// It will continue parsing even if individual log entries failed to parse, leaving it to the driver to decide whether to
 /// abort or continue.
-pub fn forward(lines: &[u8]) -> impl Iterator<Item = Result<log::Line<'_>, decode::Error>> {
+pub fn forward(lines: &[u8]) -> impl Iterator<Item = Result<log::LineRef<'_>, decode::Error>> {
     lines.as_bstr().lines().enumerate().map(|(ln, line)| {
-        log::Line::from_bytes(line).map_err(|err| decode::Error::new(err, decode::LineNumber::FromStart(ln)))
+        log::LineRef::from_bytes(line).map_err(|err| decode::Error::new(err, decode::LineNumber::FromStart(ln)))
     })
 }
 where
     F: std::io::Read + std::io::Seek,
 {
-    type Item = std::io::Result<Result<log::mutable::Line, decode::Error>>;
+    type Item = std::io::Result<Result<file::log::Line, decode::Error>>;
     fn next(&mut self) -> Option<Self::Item> {
         match (self.last_nl_pos.take(), self.read_and_pos.take()) {
                     self.read_and_pos = Some(read_and_pos);
                     self.last_nl_pos = Some(start);
                     let buf = &self.buf[start + 1..end];
-                    let res = Some(Ok(log::Line::from_bytes(buf)
+                    let res = Some(Ok(log::LineRef::from_bytes(buf)
                         .map_err(|err| decode::Error::new(err, LineNumber::FromEnd(self.count)))
                         .map(Into::into)));
                     self.count += 1;
                     let (mut read, last_read_pos) = read_and_pos;
                     if last_read_pos == 0 {
                         let buf = &self.buf[..end];
-                        Some(Ok(log::Line::from_bytes(buf)
+                        Some(Ok(log::LineRef::from_bytes(buf)
                             .map_err(|err| decode::Error::new(err, LineNumber::FromEnd(self.count)))
                             .map(Into::into)))
                     } else {

git-ref/src/store/file/log/line.rs+71−9

 use git_hash::ObjectId;
 use crate::store::file::log::Line;
+use crate::store::file::log::LineRef;
-impl<'a> Line<'a> {
+impl<'a> LineRef<'a> {
+    /// Convert this instance into its mutable counterpart
+    pub fn to_owned(&self) -> Line {
+        self.clone().into()
+    }
+}
+mod write {
+    use std::io;
+    use bstr::{BStr, ByteSlice};
+    use quick_error::quick_error;
+    use crate::store::file::log::Line;
+    quick_error! {
+        /// The Error produced by [`Line::write_to()`] (but wrapped in an io error).
+        #[derive(Debug)]
+        #[allow(missing_docs)]
+        enum Error {
+            IllegalCharacter {
+                display("Messages must not contain newlines\\n")
+            }
+        }
+    }
+    impl From<Error> for io::Error {
+        fn from(err: Error) -> Self {
+            io::Error::new(io::ErrorKind::Other, err)
+        }
+    }
+    /// Output
+    impl Line {
+        /// Serialize this instance to `out` in the git serialization format for ref log lines.
+        pub fn write_to(&self, mut out: impl io::Write) -> io::Result<()> {
+            write!(out, "{} {} ", self.previous_oid, self.new_oid)?;
+            self.signature.write_to(&mut out)?;
+            writeln!(out, "\t{}", check_newlines(self.message.as_ref())?)
+        }
+    }
+    fn check_newlines(input: &BStr) -> Result<&BStr, Error> {
+        if input.find_byte(b'\n').is_some() {
+            return Err(Error::IllegalCharacter);
+        }
+        Ok(input)
+    }
+}
+impl<'a> LineRef<'a> {
     /// The previous object id of the ref. It will be a null hash if there was no previous id as
     /// this ref is being created.
     pub fn previous_oid(&self) -> ObjectId {
     }
 }
+impl<'a> From<LineRef<'a>> for Line {
+    fn from(v: LineRef<'a>) -> Self {
+        Line {
+            previous_oid: v.previous_oid(),
+            new_oid: v.new_oid(),
+            signature: v.signature.into(),
+            message: v.message.into(),
+        }
+    }
+}
 ///
 pub mod decode {
     use bstr::{BStr, ByteSlice};
         IResult,
     };
-    use crate::{file::log::Line, parse::hex_hash};
+    use crate::{file::log::LineRef, parse::hex_hash};
     ///
     mod error {
     }
     pub use error::Error;
-    impl<'a> Line<'a> {
+    impl<'a> LineRef<'a> {
         /// Decode a line from the given bytes which are expected to start at a hex sha.
-        pub fn from_bytes(input: &'a [u8]) -> Result<Line<'a>, Error> {
+        pub fn from_bytes(input: &'a [u8]) -> Result<LineRef<'a>, Error> {
             one::<()>(input).map(|(_, l)| l).map_err(|_| Error::new(input))
         }
     }
         }
     }
-    fn one<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(bytes: &'a [u8]) -> IResult<&[u8], Line<'a>, E> {
+    fn one<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(bytes: &'a [u8]) -> IResult<&[u8], LineRef<'a>, E> {
         let (i, (old, new, signature, message_sep, message)) = context(
             "<old-hexsha> <new-hexsha> <name> <<email>> <timestamp> <tz>\\t<message>",
             tuple((
                 context("<old-hexsha>", terminated(hex_hash, tag(b" "))),
                 context("<new-hexsha>", terminated(hex_hash, tag(b" "))),
-                context("<name> <<email>> <timestamp>", git_actor::signature_ref::decode),
+                context("<name> <<email>> <timestamp>", git_actor::signature::decode),
                 opt(tag(b"\t")),
                 context("<optional message>", message),
             )),
         Ok((
             i,
-            Line {
+            LineRef {
                 previous_oid: old,
                 new_oid: new,
                 signature,
             for input in &[line_without_nl, line_with_nl] {
                 assert_eq!(
                     one::<nom::error::Error<_>>(input).expect("successful parsing").1,
-                    Line {
+                    LineRef {
                         previous_oid: NULL_SHA1.as_bstr(),
                         new_oid: NULL_SHA1.as_bstr(),
                         signature: git_actor::SignatureRef {
             for input in &[line_without_nl, line_with_nl] {
                 let (remaining, res) = one::<nom::error::Error<_>>(input).expect("successful parsing");
                 assert!(remaining.is_empty(), "all consuming even without trailing newline");
-                let actual = Line {
+                let actual = LineRef {
                     previous_oid: b"a5828ae6b52137b913b978e16cd2334482eb4c1f".as_bstr(),
                     new_oid: b"89b43f80a514aee58b662ad606e6352e03eaeee4".as_bstr(),
                     signature: git_actor::SignatureRef {

git-ref/src/store/file/log/mod.rs+22−86

@@ -1,15 +1,22 @@
1	use bstr::BStr;	1	use bstr::BStr;
2		2
		3	use git_hash::ObjectId;
		4	use git_object::bstr::BString;
		5
3	pub use super::loose::reflog::{create_or_update, Error};	6	pub use super::loose::reflog::{create_or_update, Error};
4		7
		8	///
		9	pub mod iter;
		10	mod line;
		11
5	/// A parsed ref log line.	12	/// A parsed ref log line.
6	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]	13	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
7	#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]	14	#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
8	#[non_exhaustive]	15	#[non_exhaustive]
9	pub struct Line<'a> {	16	pub struct LineRef<'a> {
10	/// The previous object id in hexadecimal. Use [`Line::previous_oid()`] to get a more usable form.	17	/// The previous object id in hexadecimal. Use [`LineRef::previous_oid()`] to get a more usable form.
11	pub previous_oid: &'a BStr,	18	pub previous_oid: &'a BStr,
12	/// The new object id in hexadecimal. Use [`Line::new_oid()`] to get a more usable form.	19	/// The new object id in hexadecimal. Use [`LineRef::new_oid()`] to get a more usable form.
13	pub new_oid: &'a BStr,	20	pub new_oid: &'a BStr,
14	/// The signature of the currently configured committer.	21	/// The signature of the currently configured committer.
15	#[cfg_attr(feature = "serde1", serde(borrow))]	22	#[cfg_attr(feature = "serde1", serde(borrow))]
@@ -18,87 +25,16 @@ pub struct Line<'a> { · 2 unmodified lines
18	pub message: &'a BStr,	25	pub message: &'a BStr,
19	}	26	}
20		27
21	///	28	/// A parsed ref log line that can be changed
22	pub mod mutable {	29	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
23	use bstr::BString;	30	#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
24	use git_hash::ObjectId;	31	pub struct Line {
25		32	/// The previous object id. Can be a null-sha to indicate this is a line for a new ref.
26	/// A parsed ref log line that can be changed	33	pub previous_oid: ObjectId,
27	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]	34	/// The new object id. Can be a null-sha to indicate this ref is being deleted.
28	#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]	35	pub new_oid: ObjectId,
29	pub struct Line {	36	/// The signature of the currently configured committer.
30	/// The previous object id. Can be a null-sha to indicate this is a line for a new ref.	37	pub signature: git_actor::Signature,
31	pub previous_oid: ObjectId,	38	/// The message providing details about the operation performed in this log line.
32	/// The new object id. Can be a null-sha to indicate this ref is being deleted.	39	pub message: BString,
33	pub new_oid: ObjectId,
34	/// The signature of the currently configured committer.
35	pub signature: git_actor::Signature,
36	/// The message providing details about the operation performed in this log line.
37	pub message: BString,
38	}
39
40	impl<'a> From<super::Line<'a>> for Line {
41	fn from(v: super::Line<'a>) -> Self {
42	Line {
43	previous_oid: v.previous_oid(),
44	new_oid: v.new_oid(),
45	signature: v.signature.into(),
46	message: v.message.into(),
47	}
48	}
49	}
50
51	impl<'a> super::Line<'a> {
52	/// Convert this instance into its mutable counterpart
53	pub fn to_mutable(&self) -> Line {
54	self.clone().into()
55	}
56	}
57
58	mod write {
59	use std::io;
60
61	use bstr::{BStr, ByteSlice};
62	use quick_error::quick_error;
63
64	use super::Line;
65
66	quick_error! {
67	/// The Error produced by [`Line::write_to()`] (but wrapped in an io error).
68	#[derive(Debug)]
69	#[allow(missing_docs)]
70	enum Error {
71	IllegalCharacter {
72	display("Messages must not contain newlines\\n")
73	}
74	}
75	}
76
77	impl From<Error> for io::Error {
78	fn from(err: Error) -> Self {
79	io::Error::new(io::ErrorKind::Other, err)
80	}
81	}
82
83	/// Output
84	impl Line {
85	/// Serialize this instance to `out` in the git serialization format for ref log lines.
86	pub fn write_to(&self, mut out: impl io::Write) -> io::Result<()> {
87	write!(out, "{} {} ", self.previous_oid, self.new_oid)?;
88	self.signature.write_to(&mut out)?;
89	writeln!(out, "\t{}", check_newlines(self.message.as_ref())?)
90	}
91	}
92
93	fn check_newlines(input: &BStr) -> Result<&BStr, Error> {
94	if input.find_byte(b'\n').is_some() {
95	return Err(Error::IllegalCharacter);
96	}
97	Ok(input)
98	}
99	}
100	}	40	}
101
102	///
103	pub mod iter;
104	mod line;

git-ref/src/store/file/loose/iter.rs+1−1

@@ -8,8 +8,8 @@ use git_features::fs::walkdir::DirEntryIter; · 7 unmodified lines
8	use os_str_bytes::OsStrBytes;	8	use os_str_bytes::OsStrBytes;
9		9
10	use crate::{	10	use crate::{
11	mutable::FullName,
12	store::file::{self, loose::Reference},	11	store::file::{self, loose::Reference},
		12	FullName,
13	};	13	};
14		14
15	/// An iterator over all valid loose reference paths as seen from a particular base directory.	15	/// An iterator over all valid loose reference paths as seen from a particular base directory.

git-ref/src/store/file/loose/mod.rs+3−3

@@ -1,12 +1,12 @@
1	use crate::{mutable, Kind};	1	use crate::{FullName, Kind, Target};
2		2
3	/// A git _ref_ which is stored in a file.	3	/// A git _ref_ which is stored in a file.
4	#[derive(Debug, PartialOrd, PartialEq, Ord, Eq, Hash, Clone)]	4	#[derive(Debug, PartialOrd, PartialEq, Ord, Eq, Hash, Clone)]
5	pub struct Reference {	5	pub struct Reference {
6	/// The path to uniquely identify this ref within its store.	6	/// The path to uniquely identify this ref within its store.
7	pub name: mutable::FullName,	7	pub name: FullName,
8	/// The target of the reference, either a symbolic reference by full name or an object by its id.	8	/// The target of the reference, either a symbolic reference by full name or an object by its id.
9	pub target: mutable::Target,	9	pub target: Target,
10	}	10	}
11		11
12	impl Reference {	12	impl Reference {

git-ref/src/store/file/loose/reference/decode.rs+8−10

 use quick_error::quick_error;
 use crate::{
-    mutable,
     parse::{hex_hash, newline},
     store::file::loose::Reference,
+    FullName, Target,
 };
 enum MaybeUnsafeState {
     }
 }
-impl TryFrom<MaybeUnsafeState> for mutable::Target {
+impl TryFrom<MaybeUnsafeState> for Target {
     type Error = Error;
     fn try_from(v: MaybeUnsafeState) -> Result<Self, Self::Error> {
         Ok(match v {
-            MaybeUnsafeState::Id(id) => mutable::Target::Peeled(id),
+            MaybeUnsafeState::Id(id) => Target::Peeled(id),
-            MaybeUnsafeState::UnvalidatedPath(name) => {
+            MaybeUnsafeState::UnvalidatedPath(name) => Target::Symbolic(match git_validate::refname(name.as_ref()) {
-                mutable::Target::Symbolic(match git_validate::refname(name.as_ref()) {
+                Ok(_) => FullName(name),
-                    Ok(_) => mutable::FullName(name),
+                Err(err) => return Err(Error::RefnameValidation { err, path: name }),
-                    Err(err) => return Err(Error::RefnameValidation { err, path: name }),
+            }),
-                })
-            }
         })
     }
 }
 impl Reference {
     /// Create a new reference of the given `parent` store with `relative_path` service as unique identifier
     /// at which the `path_contents` was read to obtain the refs value.
-    pub fn try_from_path(name: mutable::FullName, path_contents: &[u8]) -> Result<Self, Error> {
+    pub fn try_from_path(name: FullName, path_contents: &[u8]) -> Result<Self, Error> {
         Ok(Reference {
             name,
             target: parse(path_contents)

git-ref/src/store/file/loose/reference/logiter.rs+4−4

@@ -18,7 +18,7 @@ impl Reference { · 17 unmodified lines
18	/// If the caller needs to know if it's readable, try to read the log instead with a reverse or forward iterator.	18	/// If the caller needs to know if it's readable, try to read the log instead with a reverse or forward iterator.
19	pub fn log_exists(&self, store: &file::Store) -> bool {	19	pub fn log_exists(&self, store: &file::Store) -> bool {
20	store	20	store
21	.reflog_exists(self.name.borrow())	21	.reflog_exists(self.name.to_ref())
22	.expect("name conversion infallible")	22	.expect("name conversion infallible")
23	}	23	}
24	/// Return a reflog reverse iterator for this ref, reading chunks from the back into the fixed buffer `buf`, in the given `store`.	24	/// Return a reflog reverse iterator for this ref, reading chunks from the back into the fixed buffer `buf`, in the given `store`.
@@ -30,7 +30,7 @@ impl Reference { · 5 unmodified lines
30	store: &file::Store,	30	store: &file::Store,
31	buf: &'b mut [u8],	31	buf: &'b mut [u8],
32	) -> std::io::Result<Option<log::iter::Reverse<'b, std::fs::File>>> {	32	) -> std::io::Result<Option<log::iter::Reverse<'b, std::fs::File>>> {
33	store.reflog_iter_rev(self.name.borrow(), buf).map_err(must_be_io_err)	33	store.reflog_iter_rev(self.name.to_ref(), buf).map_err(must_be_io_err)
34	}	34	}
35		35
36	/// Return a reflog forward iterator for this ref and write its file contents into `buf`, in the given `store`.	36	/// Return a reflog forward iterator for this ref and write its file contents into `buf`, in the given `store`.
@@ -41,7 +41,7 @@ impl Reference { · 4 unmodified lines
41	&'a self,	41	&'a self,
42	store: &file::Store,	42	store: &file::Store,
43	buf: &'b mut Vec<u8>,	43	buf: &'b mut Vec<u8>,
44	) -> std::io::Result<Option<impl Iterator<Item = Result<log::Line<'b>, log::iter::decode::Error>> + 'a>> {	44	) -> std::io::Result<Option<impl Iterator<Item = Result<log::LineRef<'b>, log::iter::decode::Error>> + 'a>> {
45	store.reflog_iter(self.name.borrow(), buf).map_err(must_be_io_err)	45	store.reflog_iter(self.name.to_ref(), buf).map_err(must_be_io_err)
46	}	46	}
47	}	47	}

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

 use crate::{
     file,
-    mutable::Target,
     store::{
         file::{find, loose},
         packed,
     },
+    Target,
 };
 quick_error! {
     use quick_error::quick_error;
     use crate::{
-        mutable::{FullName, Target},
         store::{file, file::loose, packed},
+        FullName, Target,
     };
     quick_error! {

git-ref/src/store/file/loose/reflog.rs+8−8

@@ -2,7 +2,7 @@ use std::{convert::TryInto, io::Read, path::PathBuf}; · 1 unmodified line
2		2
3	use crate::{	3	use crate::{
4	store::{file, file::log},	4	store::{file, file::log},
5	FullName,	5	FullNameRef,
6	};	6	};
7		7
8	impl file::Store {	8	impl file::Store {
@@ -13,7 +13,7 @@ impl file::Store { · 4 unmodified lines
13	/// If the caller needs to know if it's readable, try to read the log instead with a reverse or forward iterator.	13	/// If the caller needs to know if it's readable, try to read the log instead with a reverse or forward iterator.
14	pub fn reflog_exists<'a, Name, E>(&self, name: Name) -> Result<bool, E>	14	pub fn reflog_exists<'a, Name, E>(&self, name: Name) -> Result<bool, E>
15	where	15	where
16	Name: TryInto<FullName<'a>, Error = E>,	16	Name: TryInto<FullNameRef<'a>, Error = E>,
17	crate::name::Error: From<E>,	17	crate::name::Error: From<E>,
18	{	18	{
19	Ok(self.reflog_path(name.try_into()?).is_file())	19	Ok(self.reflog_path(name.try_into()?).is_file())
@@ -29,10 +29,10 @@ impl file::Store { · 9 unmodified lines
29	buf: &'b mut [u8],	29	buf: &'b mut [u8],
30	) -> Result<Option<log::iter::Reverse<'b, std::fs::File>>, Error>	30	) -> Result<Option<log::iter::Reverse<'b, std::fs::File>>, Error>
31	where	31	where
32	Name: TryInto<FullName<'a>, Error = E>,	32	Name: TryInto<FullNameRef<'a>, Error = E>,
33	crate::name::Error: From<E>,	33	crate::name::Error: From<E>,
34	{	34	{
35	let name: FullName<'_> = name.try_into().map_err(\|err\| Error::RefnameValidation(err.into()))?;	35	let name: FullNameRef<'_> = name.try_into().map_err(\|err\| Error::RefnameValidation(err.into()))?;
36	let path = self.reflog_path(name);	36	let path = self.reflog_path(name);
37	if path.is_dir() {	37	if path.is_dir() {
38	return Ok(None);	38	return Ok(None);
@@ -52,12 +52,12 @@ impl file::Store { · 13 unmodified lines
52	&self,	52	&self,
53	name: Name,	53	name: Name,
54	buf: &'b mut Vec<u8>,	54	buf: &'b mut Vec<u8>,
55	) -> Result<Option<impl Iterator<Item = Result<log::Line<'b>, log::iter::decode::Error>>>, Error>	55	) -> Result<Option<impl Iterator<Item = Result<log::LineRef<'b>, log::iter::decode::Error>>>, Error>
56	where	56	where
57	Name: TryInto<FullName<'a>, Error = E>,	57	Name: TryInto<FullNameRef<'a>, Error = E>,
58	crate::name::Error: From<E>,	58	crate::name::Error: From<E>,
59	{	59	{
60	let name: FullName<'_> = name.try_into().map_err(\|err\| Error::RefnameValidation(err.into()))?;	60	let name: FullNameRef<'_> = name.try_into().map_err(\|err\| Error::RefnameValidation(err.into()))?;
61	let path = self.reflog_path(name);	61	let path = self.reflog_path(name);
62	match std::fs::File::open(&path) {	62	match std::fs::File::open(&path) {
63	Ok(mut file) => {	63	Ok(mut file) => {
@@ -77,7 +77,7 @@ impl file::Store { · 13 unmodified lines
77		77
78	impl file::Store {	78	impl file::Store {
79	/// Implements the logic required to transform a fully qualified refname into its log name	79	/// Implements the logic required to transform a fully qualified refname into its log name
80	pub(crate) fn reflog_path(&self, name: FullName<'_>) -> PathBuf {	80	pub(crate) fn reflog_path(&self, name: FullNameRef<'_>) -> PathBuf {
81	self.reflog_path_inner(&name.to_path())	81	self.reflog_path_inner(&name.to_path())
82	}	82	}
83	}	83	}

git-ref/src/store/file/loose/reflog/create_or_update/tests.rs+6−6

@@ -1,5 +1,5 @@
1	use super::*;	1	use super::*;
2	use crate::{file::WriteReflog, store::file::log, FullName};	2	use crate::{file::WriteReflog, store::file::log, FullNameRef};
3	use bstr::ByteSlice;	3	use bstr::ByteSlice;
4	use git_actor::{Sign, Signature, Time};	4	use git_actor::{Sign, Signature, Time};
5	use git_lock::acquire::Fail;	5	use git_lock::acquire::Fail;
@@ -16,7 +16,7 @@ fn empty_store(writemode: WriteReflog) -> Result<(TempDir, file::Store)> { · 10 unmodified lines
16	}	16	}
17		17
18	fn reflock(store: &file::Store, full_name: &str) -> Result<git_lock::Marker> {	18	fn reflock(store: &file::Store, full_name: &str) -> Result<git_lock::Marker> {
19	let full_name: FullName<'_> = full_name.try_into()?;	19	let full_name: FullNameRef<'_> = full_name.try_into()?;
20	git_lock::Marker::acquire_to_hold_resource(	20	git_lock::Marker::acquire_to_hold_resource(
21	store.reference_path(&full_name.to_path()),	21	store.reference_path(&full_name.to_path()),
22	Fail::Immediately,	22	Fail::Immediately,
@@ -25,11 +25,11 @@ fn reflock(store: &file::Store, full_name: &str) -> Result<git_lock::Marker> { · 2 unmodified lines
25	.map_err(Into::into)	25	.map_err(Into::into)
26	}	26	}
27		27
28	fn reflog_lines(store: &file::Store, name: &str, buf: &mut Vec<u8>) -> Result<Vec<log::mutable::Line>> {	28	fn reflog_lines(store: &file::Store, name: &str, buf: &mut Vec<u8>) -> Result<Vec<log::Line>> {
29	store	29	store
30	.reflog_iter(name, buf)?	30	.reflog_iter(name, buf)?
31	.expect("existing reflog")	31	.expect("existing reflog")
32	.map(\|l\| l.map(log::mutable::Line::from))	32	.map(\|l\| l.map(log::Line::from))
33	.collect::<std::result::Result<Vec<_>, _>>()	33	.collect::<std::result::Result<Vec<_>, _>>()
34	.map_err(Into::into)	34	.map_err(Into::into)
35	}	35	}
@@ -83,7 +83,7 @@ fn missing_reflog_creates_it_even_if_similarly_named_empty_dir_exists_and_append · 47 unmodified lines
83	WriteReflog::Normal => {	83	WriteReflog::Normal => {
84	assert_eq!(	84	assert_eq!(
85	reflog_lines(&store, full_name, &mut buf)?,	85	reflog_lines(&store, full_name, &mut buf)?,
86	vec![log::mutable::Line {	86	vec![log::Line {
87	previous_oid: ObjectId::null_sha1(),	87	previous_oid: ObjectId::null_sha1(),
88	new_oid: new,	88	new_oid: new,
89	signature: committer.clone(),	89	signature: committer.clone(),
@@ -104,7 +104,7 @@ fn missing_reflog_creates_it_even_if_similarly_named_empty_dir_exists_and_append · 14 unmodified lines
104	assert_eq!(lines.len(), 2, "now there is another line");	104	assert_eq!(lines.len(), 2, "now there is another line");
105	assert_eq!(	105	assert_eq!(
106	lines.last().expect("non-empty"),	106	lines.last().expect("non-empty"),
107	&log::mutable::Line {	107	&log::Line {
108	previous_oid: previous,	108	previous_oid: previous,
109	new_oid: new,	109	new_oid: new,
110	signature: committer.clone(),	110	signature: committer.clone(),

git-ref/src/store/file/overlay.rs+1−1

@@ -7,8 +7,8 @@ use std::{ · 6 unmodified lines
7		7
8	use crate::{	8	use crate::{
9	file::{loose, path_to_name, Reference},	9	file::{loose, path_to_name, Reference},
10	mutable::FullName,
11	store::{file, packed},	10	store::{file, packed},
		11	FullName,
12	};	12	};
13		13
14	/// An iterator stepping through sorted input of loose references and packed references, preferring loose refs over otherwise	14	/// An iterator stepping through sorted input of loose references and packed references, preferring loose refs over otherwise

git-ref/src/store/file/reference.rs+12−13

 use crate::{
     file::loose::reference::logiter::must_be_io_err,
-    mutable,
     store::{
         file,
         file::{log, loose},
         packed,
     },
-    FullName, Namespace,
+    FullNameRef, Namespace, Target,
 };
 /// Either a loose or packed reference, depending on where it was found.
         match self {
             Reference::Loose(r) => r.follow_symbolic(store, packed),
             Reference::Packed(p) => packed
-                .and_then(|packed| packed.find(p.name).ok().flatten()) // needed to get data with 'p2 lifetime
+                .and_then(|packed| packed.try_find(p.name).ok().flatten()) // needed to get data with 'p2 lifetime
                 .and_then(|np| {
                     p.object.and(np.object).map(|peeled| {
                         Ok(Reference::Packed(packed::Reference {
         &'a self,
         store: &file::Store,
         buf: &'b mut Vec<u8>,
-    ) -> std::io::Result<Option<impl Iterator<Item = Result<log::Line<'b>, log::iter::decode::Error>> + 'a>> {
+    ) -> std::io::Result<Option<impl Iterator<Item = Result<log::LineRef<'b>, log::iter::decode::Error>> + 'a>> {
         match self {
-            Reference::Loose(r) => store.reflog_iter(r.name.borrow(), buf).map_err(must_be_io_err),
+            Reference::Loose(r) => store.reflog_iter(r.name.to_ref(), buf).map_err(must_be_io_err),
             Reference::Packed(p) => store.reflog_iter(p.name, buf).map_err(must_be_io_err),
         }
     }
     }
     /// Transform this reference into an owned `Target`
-    pub fn into_target(self) -> mutable::Target {
+    pub fn into_target(self) -> Target {
         match self {
-            Reference::Packed(p) => mutable::Target::Peeled(p.object()),
+            Reference::Packed(p) => Target::Peeled(p.object()),
             Reference::Loose(r) => r.target,
         }
     }
     }
     /// Return the full validated name of the reference, which may include a namespace.
-    pub fn name(&self) -> FullName<'_> {
+    pub fn name(&self) -> FullNameRef<'_> {
         match self {
             Reference::Packed(p) => p.name,
-            Reference::Loose(l) => l.name.borrow(),
+            Reference::Loose(l) => l.name.to_ref(),
         }
     }
     /// Return the full validated name of the reference, with the given namespace stripped if possible.
     ///
     /// If the reference name wasn't prefixed with `namespace`, `None` is returned instead.
-    pub fn name_without_namespace(&self, namespace: &Namespace) -> Option<FullName<'_>> {
+    pub fn name_without_namespace(&self, namespace: &Namespace) -> Option<FullNameRef<'_>> {
         self.name()
             .0
             .as_bstr()
             .strip_prefix(namespace.0.as_bstr().as_ref())
-            .map(|stripped| FullName(stripped.as_bstr()))
+            .map(|stripped| FullNameRef(stripped.as_bstr()))
     }
     /// Return the target to which the reference points to.
-    pub fn target(&self) -> mutable::Target {
+    pub fn target(&self) -> Target {
         match self {
-            Reference::Packed(p) => mutable::Target::Peeled(p.target()),
+            Reference::Packed(p) => Target::Peeled(p.target()),
             Reference::Loose(l) => l.target.clone(),
         }
     }

git-ref/src/store/file/transaction/commit.rs+2−2

 use crate::{
-    mutable::Target,
     store::file::{transaction::PackedRefs, Transaction},
     transaction::{Change, LogChange, RefEdit, RefLog},
+    Target,
 };
 impl<'s> Transaction<'s> {
                 Change::Delete { .. } => {
                     // Reflog deletion happens first in case it fails a ref without log is less terrible than
                     // a log without a reference.
-                    let reflog_path = self.store.reflog_path(change.update.name.borrow());
+                    let reflog_path = self.store.reflog_path(change.update.name.to_ref());
                     if let Err(err) = std::fs::remove_file(&reflog_path) {
                         if err.kind() != std::io::ErrorKind::NotFound {
                             return Err(Error::DeleteReflog {

git-ref/src/store/file/transaction/prepare.rs+6−6

 use crate::{
-    mutable::Target,
     packed,
     store::{
         file,
         },
     },
     transaction::{Change, Create, LogChange, RefEdit, RefEditsExt, RefLog},
+    Target,
 };
 impl<'s> Transaction<'s> {
             })
             .and_then(|maybe_loose| match (maybe_loose, packed) {
                 (None, Some(packed)) => packed
-                    .find(change.update.name.borrow())
+                    .try_find(change.update.name.to_ref())
                     .map(|opt| opt.map(file::Reference::Packed))
                     .map_err(Error::from),
                 (None, None) => Ok(None),
                 let existing_ref = existing_ref?;
                 match (&previous, &existing_ref) {
-                    (Create::Only, Some(existing)) if existing.target() != new.borrow() => {
+                    (Create::Only, Some(existing)) if existing.target() != new.to_ref() => {
                         let new = new.clone();
                         return Err(Error::MustNotExist {
                             full_name: change.name(),
                 |name| {
                     let symbolic_refs_are_never_packed = None;
                     store
-                        .find_existing(name, symbolic_refs_are_never_packed)
+                        .find(name, symbolic_refs_are_never_packed)
                         .map(|r| r.into_target())
                         .ok()
                 },
             // traverse parent chain from leaf/peeled ref and set the leaf previous oid accordingly
             // to help with their reflog entries
-            if let (Some(crate::Target::Peeled(oid)), Some(parent_idx)) =
+            if let (Some(crate::TargetRef::Peeled(oid)), Some(parent_idx)) =
                 (change.update.change.previous_value(), change.parent_index)
             {
                 let oid = oid.to_owned();
     use quick_error::quick_error;
     use crate::{
-        mutable::Target,
         store::{file, packed},
+        Target,
     };
     quick_error! {

git-ref/src/store/packed/decode.rs+1−1

@@ -73,7 +73,7 @@ pub fn reference<'a, E: ParseError<&'a [u8]> + FromExternalError<&'a [u8], crate · 72 unmodified lines
73	) -> IResult<&'a [u8], packed::Reference<'a>, E> {	73	) -> IResult<&'a [u8], packed::Reference<'a>, E> {
74	let (input, (target, name)) = tuple((	74	let (input, (target, name)) = tuple((
75	terminated(hex_hash, tag(b" ")),	75	terminated(hex_hash, tag(b" ")),
76	map_res(until_newline, crate::FullName::try_from),	76	map_res(until_newline, crate::FullNameRef::try_from),
77	))(input)?;	77	))(input)?;
78	let (rest, object) = opt(delimited(tag(b"^"), hex_hash, newline))(input)?;	78	let (rest, object) = opt(delimited(tag(b"^"), hex_hash, newline))(input)?;
79	Ok((rest, packed::Reference { name, target, object }))	79	Ok((rest, packed::Reference { name, target, object }))

git-ref/src/store/packed/decode/tests.rs+3−3

@@ -7,7 +7,7 @@ mod reference { · 6 unmodified lines
7	use super::Result;	7	use super::Result;
8	use crate::{	8	use crate::{
9	store::{packed, packed::decode},	9	store::{packed, packed::decode},
10	FullName,	10	FullNameRef,
11	};	11	};
12		12
13	#[test]	13	#[test]
@@ -28,7 +28,7 @@ mod reference { · 14 unmodified lines
28	assert_eq!(	28	assert_eq!(
29	parsed,	29	parsed,
30	packed::Reference {	30	packed::Reference {
31	name: FullName("refs/heads/alternates-after-packs-and-loose".into()),	31	name: FullNameRef("refs/heads/alternates-after-packs-and-loose".into()),
32	target: "d53c4b0f91f1b29769c9430f2d1c0bcab1170c75".into(),	32	target: "d53c4b0f91f1b29769c9430f2d1c0bcab1170c75".into(),
33	object: Some("e9cdc958e7ce2290e2d7958cdb5aa9323ef35d37".into())	33	object: Some("e9cdc958e7ce2290e2d7958cdb5aa9323ef35d37".into())
34	}	34	}
@@ -38,7 +38,7 @@ mod reference { · 3 unmodified lines
38		38
39	let (input, parsed) = decode::reference::<VerboseError<_>>(input)?;	39	let (input, parsed) = decode::reference::<VerboseError<_>>(input)?;
40	assert!(input.is_empty(), "exhausted");	40	assert!(input.is_empty(), "exhausted");
41	assert_eq!(parsed.name, FullName("refs/heads/avoid-double-lookup".into()));	41	assert_eq!(parsed.name, FullNameRef("refs/heads/avoid-double-lookup".into()));
42	assert_eq!(parsed.target, "eaae9c1bc723209d793eb93f5587fa2604d5cd92");	42	assert_eq!(parsed.target, "eaae9c1bc723209d793eb93f5587fa2604d5cd92");
43	assert!(parsed.object.is_none());	43	assert!(parsed.object.is_none());
44	Ok(())	44	Ok(())

git-ref/src/store/packed/find.rs+6−6

@@ -2,14 +2,14 @@ use std::{borrow::Cow, convert::TryInto}; · 1 unmodified line
2		2
3	use bstr::{BStr, BString, ByteSlice};	3	use bstr::{BStr, BString, ByteSlice};
4		4
5	use crate::{store::packed, PartialName};	5	use crate::{store::packed, PartialNameRef};
6		6
7	/// packed-refs specific functionality	7	/// packed-refs specific functionality
8	impl packed::Buffer {	8	impl packed::Buffer {
9	/// Find a reference with the given `name` and return it.	9	/// Find a reference with the given `name` and return it.
10	pub fn find<'a, Name, E>(&self, name: Name) -> Result<Option<packed::Reference<'_>>, Error>	10	pub fn try_find<'a, Name, E>(&self, name: Name) -> Result<Option<packed::Reference<'_>>, Error>
11	where	11	where
12	Name: TryInto<PartialName<'a>, Error = E>,	12	Name: TryInto<PartialNameRef<'a>, Error = E>,
13	Error: From<E>,	13	Error: From<E>,
14	{	14	{
15	let name = name.try_into()?;	15	let name = name.try_into()?;
@@ -52,12 +52,12 @@ impl packed::Buffer { · 36 unmodified lines
52	}	52	}
53		53
54	/// Find a reference with the given `name` and return it.	54	/// Find a reference with the given `name` and return it.
55	pub fn find_existing<'a, Name, E>(&self, name: Name) -> Result<packed::Reference<'_>, existing::Error>	55	pub fn find<'a, Name, E>(&self, name: Name) -> Result<packed::Reference<'_>, existing::Error>
56	where	56	where
57	Name: TryInto<PartialName<'a>, Error = E>,	57	Name: TryInto<PartialNameRef<'a>, Error = E>,
58	Error: From<E>,	58	Error: From<E>,
59	{	59	{
60	match self.find(name) {	60	match self.try_find(name) {
61	Ok(Some(r)) => Ok(r),	61	Ok(Some(r)) => Ok(r),
62	Ok(None) => Err(existing::Error::NotFound),	62	Ok(None) => Err(existing::Error::NotFound),
63	Err(err) => Err(existing::Error::Find(err)),	63	Err(err) => Err(existing::Error::Find(err)),

git-ref/src/store/packed/mod.rs+2−2

@@ -4,7 +4,7 @@ use bstr::{BStr, BString}; · 3 unmodified lines
4	use filebuffer::FileBuffer;	4	use filebuffer::FileBuffer;
5	use git_hash::ObjectId;	5	use git_hash::ObjectId;
6		6
7	use crate::{transaction::RefEdit, FullName};	7	use crate::{transaction::RefEdit, FullNameRef};
8		8
9	enum Backing {	9	enum Backing {
10	/// The buffer is loaded entirely in memory, along with the `offset` to the first record past the header.	10	/// The buffer is loaded entirely in memory, along with the `offset` to the first record past the header.
@@ -42,7 +42,7 @@ pub(crate) struct Transaction { · 31 unmodified lines
42	#[derive(Debug, PartialEq, Eq)]	42	#[derive(Debug, PartialEq, Eq)]
43	pub struct Reference<'a> {	43	pub struct Reference<'a> {
44	/// The validated full name of the reference.	44	/// The validated full name of the reference.
45	pub name: FullName<'a>,	45	pub name: FullNameRef<'a>,
46	/// The target object id of the reference, hex encoded.	46	/// The target object id of the reference, hex encoded.
47	pub target: &'a BStr,	47	pub target: &'a BStr,
48	/// The fully peeled object id, hex encoded, that the ref is ultimately pointing to	48	/// The fully peeled object id, hex encoded, that the ref is ultimately pointing to

git-ref/src/store/packed/transaction.rs+2−4

 use std::io::Write;
 use crate::{
-    mutable::Target,
     store::{file::transaction::FindObjectFn, packed, packed::Edit},
     transaction::{Change, RefEdit},
+    Target,
 };
 pub(crate) const HEADER_LINE: &[u8] = b"# pack-refs with: peeled fully-peeled sorted \n";
             .into_iter()
             .filter(|edit| {
                 if let Change::Delete { .. } = edit.change {
-                    buffer
+                    buffer.as_ref().map_or(true, |b| b.find(edit.name.to_ref()).is_ok())
-                        .as_ref()
-                        .map_or(true, |b| b.find_existing(edit.name.borrow()).is_ok())
                 } else {
                     true
                 }

git-ref/src/target.rs+83−8

@@ -1,9 +1,38 @@
1	use bstr::BStr;	1	use bstr::{BStr, ByteSlice};
2	use git_hash::oid;	2	use git_hash::{oid, ObjectId};
		3	use std::fmt;
3		4
4	use crate::{Kind, Target};	5	use crate::{FullName, Kind, Target, TargetRef};
5		6
6	impl<'a> Target<'a> {	7	impl<'a> TargetRef<'a> {
		8	/// Returns the kind of the target the ref is pointing to.
		9	pub fn kind(&self) -> Kind {
		10	match self {
		11	TargetRef::Symbolic(_) => Kind::Symbolic,
		12	TargetRef::Peeled(_) => Kind::Peeled,
		13	}
		14	}
		15	/// Interpret this target as object id which maybe `None` if it is symbolic.
		16	pub fn as_id(&self) -> Option<&oid> {
		17	match self {
		18	TargetRef::Symbolic(_) => None,
		19	TargetRef::Peeled(oid) => Some(oid),
		20	}
		21	}
		22	/// Interpret this target as name of the reference it points to which maybe `None` if it an object id.
		23	pub fn as_name(&self) -> Option<&BStr> {
		24	match self {
		25	TargetRef::Symbolic(path) => Some(path),
		26	TargetRef::Peeled(_) => None,
		27	}
		28	}
		29	/// Convert this instance into an owned version, without consuming it.
		30	pub fn into_owned(self) -> crate::Target {
		31	self.into()
		32	}
		33	}
		34
		35	impl Target {
7	/// Returns the kind of the target the ref is pointing to.	36	/// Returns the kind of the target the ref is pointing to.
8	pub fn kind(&self) -> Kind {	37	pub fn kind(&self) -> Kind {
9	match self {	38	match self {
@@ -11,6 +40,23 @@ impl<'a> Target<'a> { · 1 unmodified line
11	Target::Peeled(_) => Kind::Peeled,	40	Target::Peeled(_) => Kind::Peeled,
12	}	41	}
13	}	42	}
		43
		44	/// Return true if this is a peeled target with a null hash
		45	pub fn is_null(&self) -> bool {
		46	match self {
		47	Target::Peeled(oid) => oid.is_null(),
		48	Target::Symbolic(_) => false,
		49	}
		50	}
		51
		52	/// Interpret this owned Target as shared Target
		53	pub fn to_ref(&self) -> crate::TargetRef<'_> {
		54	match self {
		55	Target::Peeled(oid) => crate::TargetRef::Peeled(oid),
		56	Target::Symbolic(name) => crate::TargetRef::Symbolic(name.0.as_bstr()),
		57	}
		58	}
		59
14	/// Interpret this target as object id which maybe `None` if it is symbolic.	60	/// Interpret this target as object id which maybe `None` if it is symbolic.
15	pub fn as_id(&self) -> Option<&oid> {	61	pub fn as_id(&self) -> Option<&oid> {
16	match self {	62	match self {
@@ -21,12 +67,41 @@ impl<'a> Target<'a> { · 4 unmodified lines
21	/// Interpret this target as name of the reference it points to which maybe `None` if it an object id.	67	/// Interpret this target as name of the reference it points to which maybe `None` if it an object id.
22	pub fn as_name(&self) -> Option<&BStr> {	68	pub fn as_name(&self) -> Option<&BStr> {
23	match self {	69	match self {
24	Target::Symbolic(path) => Some(path),	70	Target::Symbolic(name) => Some(name.as_bstr()),
25	Target::Peeled(_) => None,	71	Target::Peeled(_) => None,
26	}	72	}
27	}	73	}
28	/// Convert this instance into an owned version, without consuming it.	74
29	pub fn to_owned(self) -> crate::mutable::Target {	75	/// Create an instance that signals that a reference should exist if this value is used in a [`Change`][crate::transaction::Change].
30	self.into()	76	pub fn must_exist() -> Self {
		77	Target::Peeled(ObjectId::null_sha1())
		78	}
		79	}
		80
		81	impl<'a> From<crate::TargetRef<'a>> for Target {
		82	fn from(src: crate::TargetRef<'a>) -> Self {
		83	match src {
		84	crate::TargetRef::Peeled(oid) => Target::Peeled(oid.to_owned()),
		85	crate::TargetRef::Symbolic(name) => Target::Symbolic(FullName(name.to_owned())),
		86	}
		87	}
		88	}
		89
		90	impl<'a> PartialEq<crate::TargetRef<'a>> for Target {
		91	fn eq(&self, other: &crate::TargetRef<'a>) -> bool {
		92	match (self, other) {
		93	(Target::Peeled(lhs), crate::TargetRef::Peeled(rhs)) => lhs == rhs,
		94	(Target::Symbolic(lhs), crate::TargetRef::Symbolic(rhs)) => lhs.as_bstr() == *rhs,
		95	_ => false,
		96	}
		97	}
		98	}
		99
		100	impl fmt::Display for Target {
		101	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		102	match self {
		103	Target::Peeled(oid) => oid.fmt(f),
		104	Target::Symbolic(name) => write!(f, "ref: {}", name.as_bstr()),
		105	}
31	}	106	}
32	}	107	}

git-ref/src/transaction.rs+7−7

@@ -15,7 +15,7 @@ · 14 unmodified lines
15	use bstr::BString;	15	use bstr::BString;
16	use git_hash::ObjectId;	16	use git_hash::ObjectId;
17		17
18	use crate::mutable::{FullName, Target};	18	use crate::{FullName, Target};
19		19
20	/// A change to the reflog.	20	/// A change to the reflog.
21	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]	21	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
@@ -101,14 +101,14 @@ pub enum Change { · 79 unmodified lines
101		101
102	impl Change {	102	impl Change {
103	/// Return references to values that are in common between all variants.	103	/// Return references to values that are in common between all variants.
104	pub fn previous_value(&self) -> Option<crate::Target<'_>> {	104	pub fn previous_value(&self) -> Option<crate::TargetRef<'_>> {
105	match self {	105	match self {
106	Change::Update { mode: Create::Only, .. } => None,	106	Change::Update { mode: Create::Only, .. } => None,
107	Change::Update {	107	Change::Update {
108	mode: Create::OrUpdate { previous },	108	mode: Create::OrUpdate { previous },
109	..	109	..
110	}	110	}
111	\| Change::Delete { previous, .. } => previous.as_ref().map(\|t\| t.borrow()),	111	\| Change::Delete { previous, .. } => previous.as_ref().map(\|t\| t.to_ref()),
112	}	112	}
113	}	113	}
114	}	114	}
@@ -139,7 +139,7 @@ mod ext { · 24 unmodified lines
139		139
140	use crate::{	140	use crate::{
141	transaction::{Change, LogChange, RefEdit, RefLog, Target},	141	transaction::{Change, LogChange, RefEdit, RefLog, Target},
142	Namespace, PartialName,	142	Namespace, PartialNameRef,
143	};	143	};
144		144
145	/// An extension trait to perform commonly used operations on edits across different ref stores.	145	/// An extension trait to perform commonly used operations on edits across different ref stores.
@@ -155,7 +155,7 @@ mod ext { · 9 unmodified lines
155	/// Note no action is performed if deref isn't specified.	155	/// Note no action is performed if deref isn't specified.
156	fn extend_with_splits_of_symbolic_refs(	156	fn extend_with_splits_of_symbolic_refs(
157	&mut self,	157	&mut self,
158	find: impl FnMut(PartialName<'_>) -> Option<Target>,	158	find: impl FnMut(PartialNameRef<'_>) -> Option<Target>,
159	make_entry: impl FnMut(usize, RefEdit) -> T,	159	make_entry: impl FnMut(usize, RefEdit) -> T,
160	) -> Result<(), std::io::Error>;	160	) -> Result<(), std::io::Error>;
161		161
@@ -168,7 +168,7 @@ mod ext { · 6 unmodified lines
168	/// Users call this to assure derefs are honored and duplicate checks are done.	168	/// Users call this to assure derefs are honored and duplicate checks are done.
169	fn pre_process(	169	fn pre_process(
170	&mut self,	170	&mut self,
171	find: impl FnMut(PartialName<'_>) -> Option<Target>,	171	find: impl FnMut(PartialNameRef<'_>) -> Option<Target>,
172	make_entry: impl FnMut(usize, RefEdit) -> T,	172	make_entry: impl FnMut(usize, RefEdit) -> T,
173	namespace: impl Into<Option<Namespace>>,	173	namespace: impl Into<Option<Namespace>>,
174	) -> Result<(), std::io::Error> {	174	) -> Result<(), std::io::Error> {
@@ -198,7 +198,7 @@ mod ext { · 23 unmodified lines
198		198
199	fn extend_with_splits_of_symbolic_refs(	199	fn extend_with_splits_of_symbolic_refs(
200	&mut self,	200	&mut self,
201	mut find: impl FnMut(PartialName<'_>) -> Option<Target>,	201	mut find: impl FnMut(PartialNameRef<'_>) -> Option<Target>,
202	mut make_entry: impl FnMut(usize, RefEdit) -> E,	202	mut make_entry: impl FnMut(usize, RefEdit) -> E,
203	) -> Result<(), std::io::Error> {	203	) -> Result<(), std::io::Error> {
204	let mut new_edits = Vec::new();	204	let mut new_edits = Vec::new();

git-ref/tests/file/log.rs+5−5

@@ -6,7 +6,7 @@ mod line { · 5 unmodified lines
6	#[test]	6	#[test]
7	fn newlines_in_message_of_the_input_fails_and_we_trust_signature_writing_validation() -> crate::Result {	7	fn newlines_in_message_of_the_input_fails_and_we_trust_signature_writing_validation() -> crate::Result {
8	let line = "0000000000000000000000000000000000000000 134385f6d781b7e97062102c6a483440bfda2a03 committer <committer@example.com> 946771200 +0000 commit (initial): c1";	8	let line = "0000000000000000000000000000000000000000 134385f6d781b7e97062102c6a483440bfda2a03 committer <committer@example.com> 946771200 +0000 commit (initial): c1";
9	let mut line = log::Line::from_bytes(line.as_bytes())?.to_mutable();	9	let mut line = log::LineRef::from_bytes(line.as_bytes())?.to_owned();
10	line.message.push_str("and here come\nthe newline");	10	line.message.push_str("and here come\nthe newline");
11	let err = line	11	let err = line
12	.write_to(&mut Vec::new())	12	.write_to(&mut Vec::new())
@@ -20,10 +20,10 @@ mod line { · 7 unmodified lines
20	let lines = &["0000000000000000000000000000000000000000 134385f6d781b7e97062102c6a483440bfda2a03 committer <committer@example.com> 946771200 +0000 commit (initial): c1\n",	20	let lines = &["0000000000000000000000000000000000000000 134385f6d781b7e97062102c6a483440bfda2a03 committer <committer@example.com> 946771200 +0000 commit (initial): c1\n",
21	"0000000000000000000000000000000000000000 134385f6d781b7e97062102c6a483440bfda2a03 committer <committer@example.com> 946771200 +0000 \n"];	21	"0000000000000000000000000000000000000000 134385f6d781b7e97062102c6a483440bfda2a03 committer <committer@example.com> 946771200 +0000 \n"];
22	for line in lines {	22	for line in lines {
23	let line = log::Line::from_bytes(line.as_bytes())?;	23	let line = log::LineRef::from_bytes(line.as_bytes())?;
24	let mut buf = Vec::new();	24	let mut buf = Vec::new();
25	line.to_mutable().write_to(&mut buf)?;	25	line.to_owned().write_to(&mut buf)?;
26	let same_line = log::Line::from_bytes(&buf)?;	26	let same_line = log::LineRef::from_bytes(&buf)?;
27	assert_eq!(line, same_line);	27	assert_eq!(line, same_line);
28	}	28	}
29	Ok(())	29	Ok(())
@@ -75,7 +75,7 @@ mod iter { · 45 unmodified lines
75	}	75	}
76		76
77	mod with_buffer_big_enough_for_largest_line {	77	mod with_buffer_big_enough_for_largest_line {
78	use git_ref::file::log::mutable::Line;	78	use git_ref::file::log::Line;
79	use git_testtools::hex_to_id;	79	use git_testtools::hex_to_id;
80		80
81	#[test]	81	#[test]

git-ref/tests/file/reference.rs+16−16

@@ -6,7 +6,7 @@ mod reflog { · 5 unmodified lines
6	fn iter() -> crate::Result {	6	fn iter() -> crate::Result {
7	let store = file::store_with_packed_refs()?;	7	let store = file::store_with_packed_refs()?;
8	let packed = store.packed_buffer()?;	8	let packed = store.packed_buffer()?;
9	let r = store.find_existing("main", packed.as_ref())?;	9	let r = store.find("main", packed.as_ref())?;
10	let mut buf = Vec::new();	10	let mut buf = Vec::new();
11	assert_eq!(r.log_iter(&store, &mut buf)?.expect("log exists").count(), 1);	11	assert_eq!(r.log_iter(&store, &mut buf)?.expect("log exists").count(), 1);
12	assert!(r.log_exists(&store), "it exists if its readable");	12	assert!(r.log_exists(&store), "it exists if its readable");
@@ -17,7 +17,7 @@ mod reflog { · 4 unmodified lines
17	fn iter_rev() -> crate::Result {	17	fn iter_rev() -> crate::Result {
18	let store = file::store_with_packed_refs()?;	18	let store = file::store_with_packed_refs()?;
19	let packed = store.packed_buffer()?;	19	let packed = store.packed_buffer()?;
20	let r = store.find_existing("main", packed.as_ref())?;	20	let r = store.find("main", packed.as_ref())?;
21	let mut buf = [0u8; 256];	21	let mut buf = [0u8; 256];
22	assert_eq!(r.log_iter_rev(&store, &mut buf)?.expect("log exists").count(), 1);	22	assert_eq!(r.log_iter_rev(&store, &mut buf)?.expect("log exists").count(), 1);
23	Ok(())	23	Ok(())
@@ -30,7 +30,7 @@ mod reflog { · 6 unmodified lines
30	#[test]	30	#[test]
31	fn iter() -> crate::Result {	31	fn iter() -> crate::Result {
32	let store = file::store()?;	32	let store = file::store()?;
33	let r = store.loose_find_existing("HEAD")?;	33	let r = store.find_loose("HEAD")?;
34	let mut buf = Vec::new();	34	let mut buf = Vec::new();
35	assert_eq!(r.log_iter(&store, &mut buf)?.expect("log exists").count(), 1);	35	assert_eq!(r.log_iter(&store, &mut buf)?.expect("log exists").count(), 1);
36	assert!(r.log_exists(&store), "it exists if its readable");	36	assert!(r.log_exists(&store), "it exists if its readable");
@@ -40,7 +40,7 @@ mod reflog { · 3 unmodified lines
40	#[test]	40	#[test]
41	fn iter_rev() -> crate::Result {	41	fn iter_rev() -> crate::Result {
42	let store = file::store()?;	42	let store = file::store()?;
43	let r = store.loose_find_existing("HEAD")?;	43	let r = store.find_loose("HEAD")?;
44	let mut buf = [0u8; 256];	44	let mut buf = [0u8; 256];
45	assert_eq!(r.log_iter_rev(&store, &mut buf)?.expect("log exists").count(), 1);	45	assert_eq!(r.log_iter_rev(&store, &mut buf)?.expect("log exists").count(), 1);
46	Ok(())	46	Ok(())
@@ -60,7 +60,7 @@ mod peel { · 13 unmodified lines
60	#[test]	60	#[test]
61	fn one_level() -> crate::Result {	61	fn one_level() -> crate::Result {
62	let store = file::store()?;	62	let store = file::store()?;
63	let r = store.loose_find_existing("HEAD")?;	63	let r = store.find_loose("HEAD")?;
64	assert_eq!(r.kind(), git_ref::Kind::Symbolic, "there is something to peel");	64	assert_eq!(r.kind(), git_ref::Kind::Symbolic, "there is something to peel");
65		65
66	let nr = git_ref::file::loose::Reference::try_from(	66	let nr = git_ref::file::loose::Reference::try_from(
@@ -68,13 +68,13 @@ mod peel { · 1 unmodified line
68	)	68	)
69	.expect("loose ref");	69	.expect("loose ref");
70	assert!(	70	assert!(
71	matches!(nr.target.borrow(), git_ref::Target::Peeled(_)),	71	matches!(nr.target.to_ref(), git_ref::TargetRef::Peeled(_)),
72	"iteration peels a single level"	72	"iteration peels a single level"
73	);	73	);
74	assert!(nr.follow_symbolic(&store, None).is_none(), "end of iteration");	74	assert!(nr.follow_symbolic(&store, None).is_none(), "end of iteration");
75	assert_eq!(	75	assert_eq!(
76	nr.target.borrow(),	76	nr.target.to_ref(),
77	git_ref::Target::Peeled(&hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03")),	77	git_ref::TargetRef::Peeled(&hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03")),
78	"we still have the peeled target"	78	"we still have the peeled target"
79	);	79	);
80	Ok(())	80	Ok(())
@@ -83,13 +83,13 @@ mod peel { · 2 unmodified lines
83	#[test]	83	#[test]
84	fn peel_with_packed_involvement() -> crate::Result {	84	fn peel_with_packed_involvement() -> crate::Result {
85	let store = store_with_packed_refs()?;	85	let store = store_with_packed_refs()?;
86	let mut head = store.loose_find_existing("HEAD")?;	86	let mut head = store.find_loose("HEAD")?;
87	let packed = store.packed_buffer()?;	87	let packed = store.packed_buffer()?;
88	let expected = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");	88	let expected = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");
89	assert_eq!(head.peel_to_id_in_place(&store, packed.as_ref(), peel::none)?, expected);	89	assert_eq!(head.peel_to_id_in_place(&store, packed.as_ref(), peel::none)?, expected);
90	assert_eq!(head.target.as_id().map(ToOwned::to_owned), Some(expected));	90	assert_eq!(head.target.as_id().map(ToOwned::to_owned), Some(expected));
91		91
92	let mut head = store.find_existing("dt1", packed.as_ref())?;	92	let mut head = store.find("dt1", packed.as_ref())?;
93	assert_eq!(head.peel_to_id_in_place(&store, packed.as_ref(), peel::none)?, expected);	93	assert_eq!(head.peel_to_id_in_place(&store, packed.as_ref(), peel::none)?, expected);
94	assert_eq!(head.target().as_id().map(ToOwned::to_owned), Some(expected));	94	assert_eq!(head.target().as_id().map(ToOwned::to_owned), Some(expected));
95	Ok(())	95	Ok(())
@@ -100,7 +100,7 @@ mod peel { · 4 unmodified lines
100	let store = store_with_packed_refs()?;	100	let store = store_with_packed_refs()?;
101	let packed = store.packed_buffer()?;	101	let packed = store.packed_buffer()?;
102		102
103	let head = store.find_existing("dt1", packed.as_ref())?;	103	let head = store.find("dt1", packed.as_ref())?;
104	assert!(head.is_packed());	104	assert!(head.is_packed());
105	assert_eq!(	105	assert_eq!(
106	head.target().as_id().map(ToOwned::to_owned),	106	head.target().as_id().map(ToOwned::to_owned),
@@ -128,14 +128,14 @@ mod peel { · 21 unmodified lines
128	#[test]	128	#[test]
129	fn to_id_multi_hop() -> crate::Result {	129	fn to_id_multi_hop() -> crate::Result {
130	let store = file::store()?;	130	let store = file::store()?;
131	let mut r = store.loose_find_existing("multi-link")?;	131	let mut r = store.find_loose("multi-link")?;
132	assert_eq!(r.kind(), git_ref::Kind::Symbolic, "there is something to peel");	132	assert_eq!(r.kind(), git_ref::Kind::Symbolic, "there is something to peel");
133		133
134	let commit = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");	134	let commit = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");
135	assert_eq!(r.peel_to_id_in_place(&store, None, peel::none)?, commit);	135	assert_eq!(r.peel_to_id_in_place(&store, None, peel::none)?, commit);
136	assert_eq!(r.name.as_bstr(), "refs/remotes/origin/multi-link-target3");	136	assert_eq!(r.name.as_bstr(), "refs/remotes/origin/multi-link-target3");
137		137
138	let mut r = store.loose_find_existing("dt1")?;	138	let mut r = store.find_loose("dt1")?;
139	assert_eq!(	139	assert_eq!(
140	r.peel_to_id_in_place(&store, None, peel::none)?,	140	r.peel_to_id_in_place(&store, None, peel::none)?,
141	hex_to_id("4c3f4cce493d7beb45012e478021b5f65295e5a3"),	141	hex_to_id("4c3f4cce493d7beb45012e478021b5f65295e5a3"),
@@ -158,7 +158,7 @@ mod peel { · 16 unmodified lines
158	#[test]	158	#[test]
159	fn to_id_cycle() -> crate::Result {	159	fn to_id_cycle() -> crate::Result {
160	let store = file::store()?;	160	let store = file::store()?;
161	let mut r = store.loose_find_existing("loop-a")?;	161	let mut r = store.find_loose("loop-a")?;
162	assert_eq!(r.kind(), git_ref::Kind::Symbolic, "there is something to peel");	162	assert_eq!(r.kind(), git_ref::Kind::Symbolic, "there is something to peel");
163	assert_eq!(r.name.as_bstr(), "refs/loop-a");	163	assert_eq!(r.name.as_bstr(), "refs/loop-a");
164		164
@@ -203,8 +203,8 @@ mod parse { · 38 unmodified lines
203	let reference =	203	let reference =
204	Reference::try_from_path("HEAD".try_into().expect("valid static name"), $input).unwrap();	204	Reference::try_from_path("HEAD".try_into().expect("valid static name"), $input).unwrap();
205	assert_eq!(reference.kind(), $kind);	205	assert_eq!(reference.kind(), $kind);
206	assert_eq!(reference.target.borrow().as_id(), $id);	206	assert_eq!(reference.target.to_ref().as_id(), $id);
207	assert_eq!(reference.target.borrow().as_name(), $ref);	207	assert_eq!(reference.target.to_ref().as_name(), $ref);
208	}	208	}
209	};	209	};
210	}	210	}

git-ref/tests/file/store/find.rs+6−6

@@ -8,8 +8,8 @@ mod existing { · 7 unmodified lines
8	let store = store_at("make_packed_ref_repository_for_overlay.sh")?;	8	let store = store_at("make_packed_ref_repository_for_overlay.sh")?;
9	let c1 = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");	9	let c1 = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");
10	let packed = store.packed_buffer()?;	10	let packed = store.packed_buffer()?;
11	let r = store.find_existing("main", packed.as_ref())?;	11	let r = store.find("main", packed.as_ref())?;
12	assert_eq!(r.target().borrow().as_id().expect("peeled"), c1);	12	assert_eq!(r.target().to_ref().as_id().expect("peeled"), c1);
13	assert_eq!(r.name().as_bstr(), "refs/heads/main");	13	assert_eq!(r.name().as_bstr(), "refs/heads/main");
14	Ok(())	14	Ok(())
15	}	15	}
@@ -27,7 +27,7 @@ mod loose { · 11 unmodified lines
27	fn success_and_failure() -> crate::Result {	27	fn success_and_failure() -> crate::Result {
28	let store = store()?;	28	let store = store()?;
29	for (partial_name, expected_path) in &[("main", Some("refs/heads/main")), ("does-not-exist", None)] {	29	for (partial_name, expected_path) in &[("main", Some("refs/heads/main")), ("does-not-exist", None)] {
30	let reference = store.loose_find_existing(*partial_name);	30	let reference = store.find_loose(*partial_name);
31	match expected_path {	31	match expected_path {
32	Some(expected_path) => assert_eq!(reference?.name.as_bstr(), expected_path),	32	Some(expected_path) => assert_eq!(reference?.name.as_bstr(), expected_path),
33	None => match reference {	33	None => match reference {
@@ -60,9 +60,9 @@ mod loose { · 26 unmodified lines
60	("heads/main", "refs/heads/main", git_ref::Kind::Peeled),	60	("heads/main", "refs/heads/main", git_ref::Kind::Peeled),
61	("refs/heads/main", "refs/heads/main", git_ref::Kind::Peeled),	61	("refs/heads/main", "refs/heads/main", git_ref::Kind::Peeled),
62	] {	62	] {
63	let reference = store.loose_find(*partial_name)?.expect("exists");	63	let reference = store.try_find_loose(*partial_name)?.expect("exists");
64	assert_eq!(reference.name.as_bstr(), expected_path);	64	assert_eq!(reference.name.as_bstr(), expected_path);
65	assert_eq!(reference.target.borrow().kind(), *expected_ref_kind);	65	assert_eq!(reference.target.to_ref().kind(), *expected_ref_kind);
66	}	66	}
67	Ok(())	67	Ok(())
68	}	68	}
@@ -75,7 +75,7 @@ mod loose { · 6 unmodified lines
75	("broken", "does not parse", true),	75	("broken", "does not parse", true),
76	("../escaping", "an invalid ref name", true),	76	("../escaping", "an invalid ref name", true),
77	] {	77	] {
78	let reference = store.loose_find(*partial_name);	78	let reference = store.try_find_loose(*partial_name);
79	if *is_err {	79	if *is_err {
80	assert!(reference.is_err(), "{}", reason);	80	assert!(reference.is_err(), "{}", reason);
81	} else {	81	} else {

git-ref/tests/file/store/iter.rs+2−2

@@ -202,7 +202,7 @@ fn loose_iter_with_prefix() -> crate::Result { · 201 unmodified lines
202		202
203	#[test]	203	#[test]
204	fn overlay_iter() -> crate::Result {	204	fn overlay_iter() -> crate::Result {
205	use git_ref::mutable::Target::*;	205	use git_ref::Target::*;
206		206
207	let store = store_at("make_packed_ref_repository_for_overlay.sh")?;	207	let store = store_at("make_packed_ref_repository_for_overlay.sh")?;
208	let ref_names = store	208	let ref_names = store
@@ -249,7 +249,7 @@ fn overlay_iter_with_prefix_wont_allow_absolute_paths() -> crate::Result { · 40 unmodified lines
249		249
250	#[test]	250	#[test]
251	fn overlay_prefixed_iter() -> crate::Result {	251	fn overlay_prefixed_iter() -> crate::Result {
252	use git_ref::mutable::Target::*;	252	use git_ref::Target::*;
253		253
254	let store = store_at("make_packed_ref_repository_for_overlay.sh")?;	254	let store = store_at("make_packed_ref_repository_for_overlay.sh")?;
255	let ref_names = store	255	let ref_names = store

git-ref/tests/file/transaction/mod.rs+6−5

@@ -1,15 +1,16 @@
1	mod prepare_and_commit {	1	mod prepare_and_commit {
2	use bstr::BString;	2	use bstr::BString;
		3
3	use git_actor::{Sign, Time};	4	use git_actor::{Sign, Time};
4	use git_hash::ObjectId;	5	use git_hash::ObjectId;
5	use git_ref::{file, file::log};	6	use git_ref::file;
6		7
7	fn reflog_lines(store: &file::Store, name: &str) -> crate::Result<Vec<log::mutable::Line>> {	8	fn reflog_lines(store: &file::Store, name: &str) -> crate::Result<Vec<file::log::Line>> {
8	let mut buf = Vec::new();	9	let mut buf = Vec::new();
9	let res = store	10	let res = store
10	.reflog_iter(name, &mut buf)?	11	.reflog_iter(name, &mut buf)?
11	.expect("existing reflog")	12	.expect("existing reflog")
12	.map(\|l\| l.map(log::mutable::Line::from))	13	.map(\|l\| l.map(file::log::Line::from))
13	.collect::<std::result::Result<Vec<_>, _>>()?;	14	.collect::<std::result::Result<Vec<_>, _>>()?;
14	Ok(res)	15	Ok(res)
15	}	16	}
@@ -32,8 +33,8 @@ mod prepare_and_commit { · 16 unmodified lines
32	}	33	}
33	}	34	}
34		35
35	fn log_line(previous: ObjectId, new: ObjectId, message: impl Into<BString>) -> log::mutable::Line {	36	fn log_line(previous: ObjectId, new: ObjectId, message: impl Into<BString>) -> file::log::Line {
36	log::mutable::Line {	37	file::log::Line {
37	previous_oid: previous,	38	previous_oid: previous,
38	new_oid: new,	39	new_oid: new,
39	signature: committer(),	40	signature: committer(),

git-ref/tests/file/transaction/prepare_and_commit/create_or_update.rs+27−28

         transaction::{self, PackedRefs},
         WriteReflog,
     },
-    mutable::Target,
     transaction::{Change, Create, LogChange, RefEdit, RefLog},
+    Target,
 };
 use git_testtools::hex_to_id;
 use std::convert::TryInto;
         if *is_empty {
             let edits = edits?;
             assert!(
-                store.loose_find(edits[0].name.to_partial())?.is_some(),
+                store.try_find_loose(edits[0].name.to_partial())?.is_some(),
                 "HEAD was created despite a directory being in the way"
             );
         } else {
 #[test]
 fn reference_with_explicit_value_must_match_the_value_on_update() -> crate::Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
-    let head = store.loose_find("HEAD")?.expect("head exists already");
+    let head = store.try_find_loose("HEAD")?.expect("head exists already");
     let target = head.target;
     let res = store.transaction().prepare(
 #[test]
 fn reference_with_create_only_must_not_exist_already_when_creating_it_if_the_value_does_not_match() -> crate::Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
-    let head = store.loose_find("HEAD")?.expect("head exists already");
+    let head = store.try_find_loose("HEAD")?.expect("head exists already");
     let target = head.target;
     let res = store.transaction().prepare(
 #[test]
 fn reference_with_create_only_must_not_exist_already_when_creating_it_unless_the_value_matches() -> crate::Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
-    let head = store.loose_find("HEAD")?.expect("head exists already");
+    let head = store.try_find_loose("HEAD")?.expect("head exists already");
     let target = head.target;
     let previous_reflog_count = reflog_lines(&store, "HEAD")?.len();
         let (_keep, mut store) = empty_store()?;
         store.write_reflog = *reflog_writemode;
         let referent = "refs/heads/alt-main";
-        assert!(store.loose_find(referent)?.is_none(), "the reference does not exist");
+        assert!(
+            store.try_find_loose(referent)?.is_none(),
+            "the reference does not exist"
+        );
         let log_ignored = LogChange {
             mode: RefLog::AndReference,
             force_create_reflog: false,
             "no split was performed"
         );
-        let head = store.loose_find_existing(edits[0].name.to_partial())?;
+        let head = store.find_loose(edits[0].name.to_partial())?;
         assert_eq!(head.name.as_bstr(), "HEAD");
         assert_eq!(head.kind(), git_ref::Kind::Symbolic);
-        assert_eq!(head.target.borrow().as_name(), Some(referent.as_bytes().as_bstr()));
+        assert_eq!(head.target.to_ref().as_name(), Some(referent.as_bytes().as_bstr()));
         assert!(!head.log_exists(&store), "no reflog is written for symbolic ref");
-        assert!(store.loose_find(referent)?.is_none(), "referent wasn't created");
+        assert!(store.try_find_loose(referent)?.is_none(), "referent wasn't created");
         let new_oid = hex_to_id("28ce6a8b26aa170e1de65536fe8abe1832bd3242");
         let new = Target::Peeled(new_oid);
             ]
         );
-        let head = store.loose_find_existing("HEAD")?;
+        let head = store.find_loose("HEAD")?;
         assert_eq!(
             head.kind(),
             git_ref::Kind::Symbolic,
             "head is still symbolic, not detached"
         );
         assert_eq!(
-            head.target.borrow().as_name(),
+            head.target.to_ref().as_name(),
             Some(referent.as_bytes().as_bstr()),
             "it still points to the referent"
         );
-        let referent_ref = store.loose_find_existing(referent)?;
+        let referent_ref = store.find_loose(referent)?;
         assert_eq!(referent_ref.kind(), git_ref::Kind::Peeled, "referent is a peeled ref");
         assert_eq!(
-            referent_ref.target.borrow().as_id(),
+            referent_ref.target.to_ref().as_id(),
             Some(new_oid.as_ref()),
             "referent points to desired hash"
         );
 /// be needed to keep the reflog consistent
 fn write_reference_to_which_head_points_to_does_not_update_heads_reflog_even_though_it_should() -> crate::Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
-    let head = store.loose_find_existing("HEAD")?;
+    let head = store.find_loose("HEAD")?;
-    let referent = head.target.borrow().as_name().expect("symbolic ref").to_owned();
+    let referent = head.target.to_ref().as_name().expect("symbolic ref").to_owned();
     let previous_head_reflog = reflog_lines(&store, "HEAD")?;
     let new_id = hex_to_id("01dd4e2a978a9f5bd773dae6da7aa4a5ac1cdbbc");
 fn packed_refs_are_looked_up_when_checking_existing_values() -> crate::Result {
     let (_keep, store) = store_writable("make_packed_ref_repository.sh")?;
     assert!(
-        store.loose_find("main")?.is_none(),
+        store.try_find_loose("main")?.is_none(),
         "no loose main available, it's packed"
     );
     let new_id = hex_to_id("0000000000000000000000000000000000000001");
     let packed = store.packed_buffer().unwrap().expect("packed refs is available");
     assert_eq!(
-            packed.find_existing("main")?.target(),
+        packed.find("main")?.target(),
-            old_id,
+        old_id,
-            "packed refs aren't rewritten, the change goes into the loose ref instead which shadows packed refs of same name"
+        "packed refs aren't rewritten, the change goes into the loose ref instead which shadows packed refs of same name"
         );
     assert_eq!(
-        store.loose_find_existing("main")?.target.as_id(),
+        store.find_loose("main")?.target.as_id(),
         Some(new_id.as_ref()),
         "the new id was written to the loose ref"
     );
 #[test]
 fn packed_refs_creation_with_packed_refs_mode_leave_keeps_original_loose_refs() -> crate::Result {
     let (_keep, store) = store_writable("make_packed_ref_repository_for_overlay.sh")?;
-    let branch = store.find_existing("newer-as-loose", None)?;
+    let branch = store.find("newer-as-loose", None)?;
     let packed = store.packed_buffer()?.expect("packed-refs");
     assert_ne!(
-        packed.find_existing("newer-as-loose")?.target(),
+        packed.find("newer-as-loose")?.target(),
         branch.target().as_id().expect("peeled"),
         "the packed ref is outdated"
     );
         "the amount of packed refs doesn't change"
     );
     assert_eq!(
-        packed.find_existing("newer-as-loose")?.target(),
+        packed.find("newer-as-loose")?.target(),
-        store
+        store.find("newer-as-loose", None)?.target().as_id().expect("peeled"),
-            .find_existing("newer-as-loose", None)?
-            .target()
-            .as_id()
-            .expect("peeled"),
         "the packed ref is now up to date and the loose ref definitely still exists"
     );
     Ok(())

git-ref/tests/file/transaction/prepare_and_commit/delete.rs+31−29

 };
 use git_lock::acquire::Fail;
 use git_ref::{
-    mutable::Target,
     transaction::{Change, RefEdit, RefLog},
+    Target,
 };
 use git_testtools::hex_to_id;
 use std::convert::TryInto;
 #[test]
 fn delete_ref_and_reflog_on_symbolic_no_deref() -> crate::Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
-    let head = store.loose_find_existing("HEAD")?;
+    let head = store.find_loose("HEAD")?;
     assert!(head.log_exists(&store));
-    let _main = store.loose_find_existing("main")?;
+    let _main = store.find_loose("main")?;
     let edits = store
         .transaction()
         store.reflog_iter_rev("HEAD", &mut [0u8; 128])?.is_none(),
         "reflog was deleted"
     );
-    assert!(store.loose_find("HEAD")?.is_none(), "ref was deleted");
+    assert!(store.try_find_loose("HEAD")?.is_none(), "ref was deleted");
-    assert!(store.loose_find("main")?.is_some(), "referent still exists");
+    assert!(store.try_find_loose("main")?.is_some(), "referent still exists");
     Ok(())
 }
 #[test]
 fn delete_ref_with_incorrect_previous_value_fails() -> crate::Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
-    let head = store.loose_find_existing("HEAD")?;
+    let head = store.find_loose("HEAD")?;
     assert!(head.log_exists(&store));
     let res = store.transaction().prepare(
         Ok(_) => unreachable!("must be err"),
     }
     // everything stays as is
-    let head = store.loose_find_existing("HEAD")?;
+    let head = store.find_loose("HEAD")?;
     assert!(head.log_exists(&store));
-    let main = store.loose_find_existing("main").expect("referent still exists");
+    let main = store.find_loose("main").expect("referent still exists");
     assert!(main.log_exists(&store));
     Ok(())
 }
 #[test]
 fn delete_reflog_only_of_symbolic_no_deref() -> crate::Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
-    let head = store.loose_find_existing("HEAD")?;
+    let head = store.find_loose("HEAD")?;
     assert!(head.log_exists(&store));
     let edits = store
         .commit(&committer())?;
     assert_eq!(edits.len(), 1);
-    let head = store.loose_find_existing("HEAD")?;
+    let head = store.find_loose("HEAD")?;
     assert!(!head.log_exists(&store));
-    let main = store.loose_find_existing("main").expect("referent still exists");
+    let main = store.find_loose("main").expect("referent still exists");
     assert!(main.log_exists(&store), "log is untouched, too");
     assert_eq!(
         main.target,
 #[test]
 fn delete_reflog_only_of_symbolic_with_deref() -> crate::Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
-    let head = store.loose_find_existing("HEAD")?;
+    let head = store.find_loose("HEAD")?;
     assert!(head.log_exists(&store));
     let edits = store
         .commit(&committer())?;
     assert_eq!(edits.len(), 2);
-    let head = store.loose_find_existing("HEAD")?;
+    let head = store.find_loose("HEAD")?;
     assert!(!head.log_exists(&store));
-    let main = store.loose_find_existing("main").expect("referent still exists");
+    let main = store.find_loose("main").expect("referent still exists");
     assert!(!main.log_exists(&store), "log is removed");
     assert_eq!(
         main.target,
 fn delete_broken_ref_that_must_exist_fails_as_it_is_no_valid_ref() -> crate::Result {
     let (_keep, store) = empty_store()?;
     std::fs::write(store.base.join("HEAD"), &b"broken")?;
-    assert!(store.loose_find("HEAD").is_err(), "the ref is truly broken");
+    assert!(store.try_find_loose("HEAD").is_err(), "the ref is truly broken");
     let res = store.transaction().prepare(
         Some(RefEdit {
 fn delete_broken_ref_that_may_not_exist_works_even_in_deref_mode() -> crate::Result {
     let (_keep, store) = empty_store()?;
     std::fs::write(store.base.join("HEAD"), &b"broken")?;
-    assert!(store.loose_find("HEAD").is_err(), "the ref is truly broken");
+    assert!(store.try_find_loose("HEAD").is_err(), "the ref is truly broken");
     let edits = store
         .transaction()
         )?
         .commit(&committer())?;
-    assert!(store.loose_find("HEAD")?.is_none(), "the ref was deleted");
+    assert!(store.try_find_loose("HEAD")?.is_none(), "the ref was deleted");
     assert_eq!(
         edits,
         vec![RefEdit {
     for reflog_writemode in &[git_ref::file::WriteReflog::Normal, git_ref::file::WriteReflog::Disable] {
         let (_keep, mut store) = store_writable("make_repo_for_reflog.sh")?;
         store.write_reflog = *reflog_writemode;
-        assert!(store.loose_find_existing("HEAD")?.log_exists(&store));
+        assert!(store.find_loose("HEAD")?.log_exists(&store));
         assert!(store.packed_buffer()?.is_none(), "there is no pack");
         let edits = store
             )?
             .commit(&committer())?;
         assert_eq!(edits.len(), 1);
-        assert!(
+        assert!(!store.find_loose("HEAD")?.log_exists(&store), "log was deleted");
-            !store.loose_find_existing("HEAD")?.log_exists(&store),
-            "log was deleted"
-        );
         assert!(store.packed_buffer()?.is_none(), "there still is no pack");
     }
     Ok(())
 ) -> crate::Result {
     let (_keep, store) = store_writable("make_packed_ref_repository.sh")?;
     assert!(
-        store.loose_find("main")?.is_none(),
+        store.try_find_loose("main")?.is_none(),
         "no loose main available, it's packed"
     );
     assert!(
-        store.packed_buffer()?.expect("packed").find("main")?.is_some(),
+        store.packed_buffer()?.expect("packed").try_find("main")?.is_some(),
         "packed main is available"
     );
     assert_eq!(edits.len(), 1, "an edit was performed in the packed refs store");
     let packed = store.packed_buffer()?.expect("packed ref present");
-    assert!(packed.find("main")?.is_none(), "no main present after deletion");
+    assert!(packed.try_find("main")?.is_none(), "no main present after deletion");
     Ok(())
 }
 fn a_loose_ref_with_old_value_check_and_outdated_packed_refs_value_deletes_both_refs() -> crate::Result {
     let (_keep, store) = store_writable("make_packed_ref_repository_for_overlay.sh")?;
     let packed = store.packed_buffer()?.expect("packed-refs");
-    let branch = store.find_existing("newer-as-loose", Some(&packed))?;
+    let branch = store.find("newer-as-loose", Some(&packed))?;
     let branch_id = branch.target().as_id().map(ToOwned::to_owned).expect("peeled");
     assert_ne!(
-        packed.find_existing("newer-as-loose")?.target(),
+        packed.find("newer-as-loose")?.target(),
         branch_id,
         "the packed ref is outdated"
     );
         "only one edit even though technically two places were changed"
     );
     assert!(
-        store.find("newer-as-loose", store.packed_buffer()?.as_ref())?.is_none(),
+        store
+            .try_find("newer-as-loose", store.packed_buffer()?.as_ref())?
+            .is_none(),
         "reference is deleted everywhere"
     );
     Ok(())
     assert!(packed.is_none(), "it won't make up packed refs");
     for edit in edits {
         assert!(
-            store.find(edit.name.to_partial(), packed.as_ref()).unwrap().is_none(),
+            store
+                .try_find(edit.name.to_partial(), packed.as_ref())
+                .unwrap()
+                .is_none(),
             "delete ref cannot be found"
         );
     }

git-ref/tests/packed/find.rs+25−21

 use std::convert::{TryFrom, TryInto};
-use git_ref::{packed, PartialName};
+use git_ref::{packed, PartialNameRef};
 use git_testtools::fixture_path;
 use crate::{
 #[test]
 fn a_lock_file_would_not_be_a_valid_partial_name() {
     // doesn't really belong here but want to make sure refname validation works as expected.
-    let err = PartialName::try_from("heads/hello.lock").expect_err("this should fail");
+    let err = PartialNameRef::try_from("heads/hello.lock").expect_err("this should fail");
     assert_eq!(err.to_string(), "A reference must be a valid tag name as well");
 }
     for reference in packed_refs.iter()? {
         let reference = reference?;
-        let found = packed_refs.find(reference.name)?.expect("reference exists");
+        let found = packed_refs.try_find(reference.name)?.expect("reference exists");
         assert_eq!(reference, found, "both refs are exactly the same");
-        let found = packed_refs.find_existing(reference.name)?;
+        let found = packed_refs.find(reference.name)?;
         assert_eq!(reference, found);
     }
     Ok(())
 #[test]
 fn binary_search_a_name_past_the_end_of_the_packed_refs_file() -> crate::Result {
     let packed_refs = packed::Buffer::open(fixture_path("packed-refs").join("triggers-out-of-bounds"), 32)?;
-    assert!(packed_refs.find("v0.0.1")?.is_none());
+    assert!(packed_refs.try_find("v0.0.1")?.is_none());
     Ok(())
 }
     let buf = packed::Buffer::open(path, 1024)?;
     let name = "refs/tags/TEST-0.0.1";
     assert_eq!(
-        buf.find(name)?.expect("reference exists"),
+        buf.try_find(name)?.expect("reference exists"),
         packed::Reference {
             name: name.try_into()?,
             target: "916840c0e2f67d370291042cb5274a597f4fa9bc".into(),
     );
     let name = "refs/tags/git-actor-v0.1.0";
     assert_eq!(
-        buf.find(name)?.expect("reference exists"),
+        buf.try_find(name)?.expect("reference exists"),
         packed::Reference {
             name: name.try_into()?,
             target: "c4cebba92af964f2d126be90b8a6298c4cf84d45".into(),
     );
     let name = "refs/tags/git-actor-v0.1.1";
     assert_eq!(
-        buf.find(name)?.expect("reference exists"),
+        buf.try_find(name)?.expect("reference exists"),
         packed::Reference {
             name: name.try_into()?,
             target: "0b92c8a256ae06c189e3b9c30b646d62ac8f7d10".into(),
     let packed = store.packed_buffer()?.expect("packed-refs exists");
     assert_eq!(
-        store.loose_find_existing("origin")?.name.as_bstr(),
+        store.find_loose("origin")?.name.as_bstr(),
         "refs/remotes/origin/HEAD",
         "a special that only applies to loose refs"
     );
     assert!(
-        packed.find("origin")?.is_none(),
+        packed.try_find("origin")?.is_none(),
         "packed refs don't have this special case as they don't store HEADs or symrefs"
     );
     assert_eq!(
-        store.loose_find_existing("HEAD")?.name.as_bstr(),
+        store.find_loose("HEAD")?.name.as_bstr(),
         "HEAD",
         "HEAD can be found in loose stores"
     );
     assert!(
-        packed.find("HEAD")?.is_none(),
+        packed.try_find("HEAD")?.is_none(),
         "packed refs definitely don't contain HEAD"
     );
     assert_eq!(
-        packed.find("head-or-tag")?.expect("present").name.as_bstr(),
+        packed.try_find("head-or-tag")?.expect("present").name.as_bstr(),
         "refs/tags/head-or-tag",
         "it finds tags first"
     );
     assert_eq!(
-        packed.find("heads/head-or-tag")?.expect("present").name.as_bstr(),
+        packed.try_find("heads/head-or-tag")?.expect("present").name.as_bstr(),
         "refs/heads/head-or-tag",
         "it finds heads when disambiguated"
     );
     assert_eq!(
-        packed.find("main")?.expect("present").name.as_bstr(),
+        packed.try_find("main")?.expect("present").name.as_bstr(),
         "refs/heads/main",
         "it finds local heads before remote ones"
     );
     assert_eq!(
-        packed.find("origin/main")?.expect("present").name.as_bstr(),
+        packed.try_find("origin/main")?.expect("present").name.as_bstr(),
         "refs/remotes/origin/main",
         "it finds remote heads when disambiguated"
     );
     assert_eq!(
-        packed.find("remotes/origin/main")?.expect("present").name.as_bstr(),
+        packed.try_find("remotes/origin/main")?.expect("present").name.as_bstr(),
         "refs/remotes/origin/main",
         "more specification is possible, too"
     );
     assert_eq!(
-        packed.find("tag-object")?.expect("present"),
+        packed.try_find("tag-object")?.expect("present"),
         packed::Reference {
             name: "refs/tags/tag-object".try_into()?,
             target: "b3109a7e51fc593f85b145a76c70ddd1d133fafd".into(),
     let name = "refs/tags/git-actor-v0.1.1";
     assert_eq!(
-        buf.find(name)?.expect("reference exists"),
+        buf.try_find(name)?.expect("reference exists"),
         packed::Reference {
             name: name.try_into()?,
             target: "0b92c8a256ae06c189e3b9c30b646d62ac8f7d10".into(),
     for failing_name in &["refs/tags/TEST-0.0.1", "refs/tags/git-actor-v0.1.0"] {
         assert_eq!(
-            buf.find(*failing_name)
+            buf.try_find(*failing_name)
                 .expect_err("it should detect an err")
                 .to_string(),
             "The reference could not be parsed"
     for r in packed.iter()?.take(10_000) {
         num_refs += 1;
         let r = r?;
-        assert_eq!(packed.find(r.name)?.expect("ref was found"), r, "the refs are the same");
+        assert_eq!(
+            packed.try_find(r.name)?.expect("ref was found"),
+            r,
+            "the refs are the same"
+        );
     }
     let elapsed = start.elapsed().as_secs_f32();
     eprintln!(

git-ref/tests/packed/open.rs+1−1

@@ -27,7 +27,7 @@ fn unsorted_buffers_or_those_without_a_header_can_be_opened_and_searched() { · 26 unmodified lines
27	.unwrap();	27	.unwrap();
28	for packed_ref in buffer.iter().unwrap().map(Result::unwrap) {	28	for packed_ref in buffer.iter().unwrap().map(Result::unwrap) {
29	let found_ref = buffer	29	let found_ref = buffer
30	.find_existing(packed_ref.name)	30	.find(packed_ref.name)
31	.expect("ref can be found as buffer is sorted");	31	.expect("ref can be found as buffer is sorted");
32	assert_eq!(	32	assert_eq!(
33	found_ref, packed_ref,	33	found_ref, packed_ref,

git-ref/tests/transaction/mod.rs+5−7

     use bstr::{BString, ByteSlice};
     use git_ref::{
-        mutable::Target,
         transaction::{Change, Create, RefEdit, RefEditsExt, RefLog},
-        PartialName,
+        PartialNameRef, Target,
     };
     #[derive(Default)]
                 },
             }
         }
-        fn find_existing(&self, name: PartialName<'_>) -> Option<Target> {
+        fn find_existing(&self, name: PartialNameRef<'_>) -> Option<Target> {
             self.targets.borrow_mut().remove(name.as_bstr())
         }
     }
         use git_hash::ObjectId;
         use git_ref::{
-            mutable::Target,
             transaction::{Change, Create, LogChange, RefEdit, RefEditsExt, RefLog},
-            FullName, PartialName,
+            FullNameRef, PartialNameRef, Target,
         };
         use git_testtools::hex_to_id;
         use crate::transaction::refedit_ext::MockStore;
         fn find<'a>(edits: &'a [RefEdit], name: &str) -> &'a RefEdit {
-            let name: FullName = name.try_into().unwrap();
+            let name: FullNameRef = name.try_into().unwrap();
             edits
                 .iter()
                 .find(|e| e.name.as_bstr() == name.as_bstr())
                 next_item: Cell<bool>,
             }
             impl Cycler {
-                fn find_existing(&self, _name: PartialName<'_>) -> Option<Target> {
+                fn find_existing(&self, _name: PartialNameRef<'_>) -> Option<Target> {
                     let item: bool = self.next_item.get();
                     self.next_item.set(!item);
                     Some(Target::Symbolic(

git-repository/Cargo.toml+1−1

@@ -42,7 +42,7 @@ git-validate = { version = "^0.5.0", path = "../git-validate" } · 41 unmodified lines
42	git-odb = { version ="0.20.0", path = "../git-odb" }	42	git-odb = { version ="0.20.0", path = "../git-odb" }
43	git-hash = { version = "^0.5.0", path = "../git-hash" }	43	git-hash = { version = "^0.5.0", path = "../git-hash" }
44	git-object = { version ="0.12.0", path = "../git-object" }	44	git-object = { version ="0.12.0", path = "../git-object" }
45	git-actor = { version ="^0.4.0", path = "../git-actor" }	45	git-actor = { version ="^0.5.0", path = "../git-actor" }
46	git-pack = { version ="^0.9.0", path = "../git-pack" }	46	git-pack = { version ="^0.9.0", path = "../git-pack" }
47		47
48	git-url = { version = "0.3.0", path = "../git-url", optional = true }	48	git-url = { version = "0.3.0", path = "../git-url", optional = true }

git-repository/src/easy/ext/reference.rs+4−5

 use git_lock as lock;
 use git_ref::{
     file::find::Error,
-    mutable::Target,
     transaction::{Change, Create, RefEdit},
-    PartialName,
+    PartialNameRef, Target,
 };
 /// Obtain and alter references comfortably
     fn find_reference<'a, Name, E>(&self, name: Name) -> Result<Reference<'_, Self>, reference::find::existing::Error>
     where
-        Name: TryInto<PartialName<'a>, Error = E>,
+        Name: TryInto<PartialNameRef<'a>, Error = E>,
         Error: From<E>,
     {
         self.try_find_reference(name)?
     fn try_find_reference<'a, Name, E>(&self, name: Name) -> Result<Option<Reference<'_, Self>>, reference::find::Error>
     where
-        Name: TryInto<PartialName<'a>, Error = E>,
+        Name: TryInto<PartialNameRef<'a>, Error = E>,
         Error: From<E>,
     {
         let state = self.state();
         let repo = self.repo()?;
         match repo
             .refs
-            .find(name, state.assure_packed_refs_uptodate(&repo.refs)?.as_ref())
+            .try_find(name, state.assure_packed_refs_uptodate(&repo.refs)?.as_ref())
         {
             Ok(r) => match r {
                 Some(r) => Ok(Some(Reference::from_file_ref(r, self))),

git-repository/src/easy/reference.rs+5−5

@@ -12,7 +12,7 @@ use git_ref as refs; · 11 unmodified lines
12	pub(crate) enum Backing {	12	pub(crate) enum Backing {
13	OwnedPacked {	13	OwnedPacked {
14	/// The validated full name of the reference.	14	/// The validated full name of the reference.
15	name: refs::mutable::FullName,	15	name: refs::FullName,
16	/// The target object id of the reference, hex encoded.	16	/// The target object id of the reference, hex encoded.
17	target: ObjectId,	17	target: ObjectId,
18	/// The fully peeled object id, hex encoded, that the ref is ultimately pointing to	18	/// The fully peeled object id, hex encoded, that the ref is ultimately pointing to
@@ -107,19 +107,19 @@ where · 88 unmodified lines
107	access,	107	access,
108	}	108	}
109	}	109	}
110	pub fn target(&self) -> refs::mutable::Target {	110	pub fn target(&self) -> refs::Target {
111	match self.backing.as_ref().expect("always set") {	111	match self.backing.as_ref().expect("always set") {
112	Backing::OwnedPacked { target, .. } => refs::mutable::Target::Peeled(target.to_owned()),	112	Backing::OwnedPacked { target, .. } => refs::Target::Peeled(target.to_owned()),
113	Backing::LooseFile(r) => r.target.clone(),	113	Backing::LooseFile(r) => r.target.clone(),
114	}	114	}
115	}	115	}
116		116
117	pub fn name(&self) -> refs::FullName<'_> {	117	pub fn name(&self) -> refs::FullNameRef<'_> {
118	match self.backing.as_ref().expect("always set") {	118	match self.backing.as_ref().expect("always set") {
119	Backing::OwnedPacked { name, .. } => name,	119	Backing::OwnedPacked { name, .. } => name,
120	Backing::LooseFile(r) => &r.name,	120	Backing::LooseFile(r) => &r.name,
121	}	121	}
122	.borrow()	122	.to_ref()
123	}	123	}
124		124
125	pub fn peel_to_oid_in_place(&mut self) -> Result<Oid<'repo, A>, peel_to_oid_in_place::Error> {	125	pub fn peel_to_oid_in_place(&mut self) -> Result<Oid<'repo, A>, peel_to_oid_in_place::Error> {

git-repository/src/path/is_git.rs+1−1

@@ -42,7 +42,7 @@ pub fn is_git(git_dir: impl AsRef<Path>) -> Result<crate::Kind, Error> { · 41 unmodified lines
42		42
43	{	43	{
44	let refs = git_ref::file::Store::at(&dot_git, Default::default());	44	let refs = git_ref::file::Store::at(&dot_git, Default::default());
45	let head = refs.loose_find_existing("HEAD")?;	45	let head = refs.find_loose("HEAD")?;
46	if head.name.as_bstr() != "HEAD" {	46	if head.name.as_bstr() != "HEAD" {
47	return Err(Error::MisplacedHead(head.name.into_inner()));	47	return Err(Error::MisplacedHead(head.name.into_inner()));
48	}	48	}

git-repository/tests/reference/mod.rs+1−1

@@ -19,7 +19,7 @@ mod find { · 18 unmodified lines
19		19
20	assert_eq!(	20	assert_eq!(
21	packed_tag_ref.target(),	21	packed_tag_ref.target(),
22	refs::mutable::Target::Peeled(hex_to_id("4c3f4cce493d7beb45012e478021b5f65295e5a3")),	22	refs::Target::Peeled(hex_to_id("4c3f4cce493d7beb45012e478021b5f65295e5a3")),
23	"it points to a tag object"	23	"it points to a tag object"
24	);	24	);
25		25

gitoxide-core/src/hours.rs+1−1

@@ -49,7 +49,7 @@ where · 48 unmodified lines
49	let packed = repo.refs.packed_buffer()?;	49	let packed = repo.refs.packed_buffer()?;
50	let commit_id = repo	50	let commit_id = repo
51	.refs	51	.refs
52	.find_existing(refname.to_string_lossy().as_ref(), packed.as_ref())?	52	.find(refname.to_string_lossy().as_ref(), packed.as_ref())?
53	.peel_to_id_in_place(&repo.refs, packed.as_ref(), \|oid, buf\| {	53	.peel_to_id_in_place(&repo.refs, packed.as_ref(), \|oid, buf\| {
54	repo.odb	54	repo.odb
55	.find(oid, buf, &mut pack::cache::Never)	55	.find(oid, buf, &mut pack::cache::Never)

gitoxide-core/src/pack/create.rs+1−1

@@ -117,7 +117,7 @@ where · 116 unmodified lines
117	let refs = &repo.refs;	117	let refs = &repo.refs;
118	let repo = Arc::clone(&repo);	118	let repo = Arc::clone(&repo);
119	move \|_\| {	119	move \|_\| {
120	refs.find_existing(tip.as_ref().to_string_lossy().as_ref(), packed.as_ref())	120	refs.find(tip.as_ref().to_string_lossy().as_ref(), packed.as_ref())
121	.map_err(anyhow::Error::from)	121	.map_err(anyhow::Error::from)
122	.and_then(\|mut r\| {	122	.and_then(\|mut r\| {
123	r.peel_to_id_in_place(refs, packed.as_ref(), \|oid, buf\| {	123	r.peel_to_id_in_place(refs, packed.as_ref(), \|oid, buf\| {