From 8d05cae3027e3731602292c9e2d8c3cd53ebeec9 Mon Sep 17 00:00:00 2001 From: Sebastian Thiel Date: Fri, 10 Nov 2023 10:48:16 +0100 Subject: [PATCH 1/4] fix: adjust tree parser to deal with even more unusual trees (#1096). --- gix-object/src/tree/ref_iter.rs | 11 +++++++---- gix-object/tests/fixtures/tree/special-5.tree | Bin 0 -> 651 bytes gix-object/tests/tree/mod.rs | 1 + 3 files changed, 8 insertions(+), 4 deletions(-) create mode 100644 gix-object/tests/fixtures/tree/special-5.tree diff --git a/gix-object/src/tree/ref_iter.rs b/gix-object/src/tree/ref_iter.rs index c18a0d5f532..510ae34b997 100644 --- a/gix-object/src/tree/ref_iter.rs +++ b/gix-object/src/tree/ref_iter.rs @@ -101,12 +101,15 @@ impl TryFrom for tree::EntryMode { fn try_from(mode: u32) -> Result { Ok(match mode { 0o40000 => tree::EntryMode::Tree, - 0o100644 => tree::EntryMode::Blob, - 0o100755 => tree::EntryMode::BlobExecutable, 0o120000 => tree::EntryMode::Link, 0o160000 => tree::EntryMode::Commit, - 0o100664 => tree::EntryMode::Blob, // rare and found in the linux kernel - 0o100640 => tree::EntryMode::Blob, // rare and found in the Rust repo + blob_mode if blob_mode & 0o100000 == 0o100000 => { + if blob_mode & 0o000100 == 0o000100 { + tree::EntryMode::BlobExecutable + } else { + tree::EntryMode::Blob + } + } _ => return Err(mode), }) } diff --git a/gix-object/tests/fixtures/tree/special-5.tree b/gix-object/tests/fixtures/tree/special-5.tree new file mode 100644 index 0000000000000000000000000000000000000000..67843b90078c9a54fc349b92662c09cf19de64c1 GIT binary patch literal 651 zcmXpsFfcPQQPA^nj1O}S3ikB(W60)d-mW$GNpVJ0^q&o!to$o(orpJtDof8S$xP47 zFG^+DX17S>GpuU*mjaD42ilmNpO==IURnfJs8^Yoo5QeRv)QiFpJ%R1-bz~bzV{cSo@iAl z)Z*mQVxXa!RjCk_^F%vT-Hy30>w5GoXf^BJ1a8@P-4M&ui}Fhg7?xaEFTZ{ckKMIN z3!i8=fAGH6)Wrdj&&(?*Es0Oc&(BFs%wy2#_~|<Cost1C{; zNlh+c$g7elJ;<ObLyYJY&n8OT}Pt7aNFJkz*Oe#0&3Ky@5e8-&6o9k38maJBR+EWZx z5#$E3X_9wRk%7OVbL*yO6Y~vb&Wt;sx&)}u+|*Q|xID8YIRm0B?URdi_$9A^nGP3T zv^D?Xm{i!_4mGbNBQ-a*7^2MOMELEA?6vW1TRr7Ad=N3L$ufNkRaTywl#`j44N-UL zsnsQmCo&J7|D1eo;x~^b`<2_-Anq?OFK1XNK2O8?`JH=JIUl Date: Fri, 10 Nov 2023 14:01:10 +0100 Subject: [PATCH 2/4] fix CI failure This failure happens on CI as the "0" is missing there, and it's not reproducing anywhere else. Probably related to the HTTP client doing something differently there for some reason. Let's not be bothred by it by simply removing it from the expectation. --- .../tests/client/blocking_io/http/mod.rs | 20 +++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/gix-transport/tests/client/blocking_io/http/mod.rs b/gix-transport/tests/client/blocking_io/http/mod.rs index 87c3de5fc9c..94dac048c2c 100644 --- a/gix-transport/tests/client/blocking_io/http/mod.rs +++ b/gix-transport/tests/client/blocking_io/http/mod.rs @@ -181,12 +181,18 @@ Authorization: Basic dXNlcjpwYXNzd29yZA== client.request(client::WriteMode::Binary, client::MessageKind::Flush, false)?; assert_eq!( - server - .received_as_string() - .lines() - .map(str::to_lowercase) - .filter(|l| !l.starts_with("expect: ")) - .collect::>(), + { + let mut m = server + .received_as_string() + .lines() + .map(str::to_lowercase) + .filter(|l| !l.starts_with("expect: ")) + .collect::>(); + // On linux on CI, for some reason, it won't have this chunk id here, but + // it has it whenever and where-ever I run it. + m.remove("0"); + m + }, format!( "POST /path/not-important/git-upload-pack HTTP/1.1 Host: 127.0.0.1:{} @@ -196,8 +202,6 @@ Content-Type: application/x-git-upload-pack-request Accept: application/x-git-upload-pack-result Authorization: Basic dXNlcjpwYXNzd29yZA== -0 - ", server.addr.port(), env!("CARGO_PKG_VERSION") From 3ac5d0b7feed9554ddbf249748cb1591a7977d9b Mon Sep 17 00:00:00 2001 From: Sebastian Thiel Date: Fri, 10 Nov 2023 14:33:46 +0100 Subject: [PATCH 3/4] fix!: Keep verbatim tree-entry mode, but support discretization using the new `EntryKind`. Please note that `EntryKind` and `EntryMode` can be converted from and to each other. --- gix-object/src/tree/mod.rs | 138 +++++++++++++++++++++++++------- gix-object/src/tree/ref_iter.rs | 58 ++++++-------- gix-object/src/tree/write.rs | 12 ++- gix-object/tests/tree/mod.rs | 47 ++++++++--- 4 files changed, 180 insertions(+), 75 deletions(-) diff --git a/gix-object/src/tree/mod.rs b/gix-object/src/tree/mod.rs index 89e4def4801..7375f1c69c3 100644 --- a/gix-object/src/tree/mod.rs +++ b/gix-object/src/tree/mod.rs @@ -13,9 +13,17 @@ pub mod write; /// /// Used in [`mutable::Entry`][crate::tree::Entry] and [`EntryRef`]. #[derive(Clone, Copy, PartialEq, Eq, Debug, Ord, PartialOrd, Hash)] +#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] +pub struct EntryMode(u16); + +/// A discretized version of ideal and valid values for entry modes. +/// +/// Note that even though it can represent every valid [mode](EntryMode), it might +/// loose information due to that as well. +#[derive(Clone, Copy, PartialEq, Eq, Debug, Ord, PartialOrd, Hash)] #[repr(u16)] #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] -pub enum EntryMode { +pub enum EntryKind { /// A tree, or directory Tree = 0o040000u16, /// A file that is not executable @@ -28,31 +36,101 @@ pub enum EntryMode { Commit = 0o160000, } +impl From for EntryMode { + fn from(value: EntryKind) -> Self { + EntryMode(value as u16) + } +} + +impl From for EntryKind { + fn from(value: EntryMode) -> Self { + value.kind() + } +} + +/// Serialization +impl EntryKind { + /// Return the representation as used in the git internal format. + pub fn as_octal_str(&self) -> &'static BStr { + use EntryKind::*; + let bytes: &[u8] = match self { + Tree => b"40000", + Blob => b"100644", + BlobExecutable => b"100755", + Link => b"120000", + Commit => b"160000", + }; + bytes.into() + } +} + +impl std::ops::Deref for EntryMode { + type Target = u16; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + impl EntryMode { + /// Discretize the raw mode into an enum with well-known state while dropping unnecessary details. + pub const fn kind(&self) -> EntryKind { + match self.0 { + 0o40000 => EntryKind::Tree, + 0o120000 => EntryKind::Link, + 0o160000 => EntryKind::Commit, + blob_mode => { + if blob_mode & 0o000100 == 0o000100 { + EntryKind::BlobExecutable + } else { + EntryKind::Blob + } + } + } + } + /// Return true if this entry mode represents a Tree/directory - pub fn is_tree(&self) -> bool { - *self == EntryMode::Tree + pub const fn is_tree(&self) -> bool { + self.0 == EntryKind::Tree as u16 + } + + /// Return true if this entry mode represents the commit of a submodule. + pub const fn is_commit(&self) -> bool { + self.0 == EntryKind::Commit as u16 + } + + /// Return true if this entry mode represents a symbolic link + pub const fn is_link(&self) -> bool { + self.0 == EntryKind::Link as u16 } /// Return true if this entry mode represents anything BUT Tree/directory - pub fn is_no_tree(&self) -> bool { - *self != EntryMode::Tree + pub const fn is_no_tree(&self) -> bool { + self.0 != EntryKind::Tree as u16 } /// Return true if the entry is any kind of blob. - pub fn is_blob(&self) -> bool { - matches!(self, EntryMode::Blob | EntryMode::BlobExecutable) + pub const fn is_blob(&self) -> bool { + matches!(self.kind(), EntryKind::Blob | EntryKind::BlobExecutable) + } + + /// Return true if the entry is an executable blob. + pub const fn is_executable(&self) -> bool { + matches!(self.kind(), EntryKind::BlobExecutable) } /// Return true if the entry is any kind of blob or symlink. - pub fn is_blob_or_symlink(&self) -> bool { - matches!(self, EntryMode::Blob | EntryMode::BlobExecutable | EntryMode::Link) + pub const fn is_blob_or_symlink(&self) -> bool { + matches!( + self.kind(), + EntryKind::Blob | EntryKind::BlobExecutable | EntryKind::Link + ) } /// Represent the mode as descriptive string. - pub fn as_str(&self) -> &'static str { - use EntryMode::*; - match self { + pub const fn as_str(&self) -> &'static str { + use EntryKind::*; + match self.kind() { Tree => "tree", Blob => "blob", BlobExecutable => "exe", @@ -60,6 +138,27 @@ impl EntryMode { Commit => "commit", } } + + /// Return the representation as used in the git internal format, which is octal and written + /// to the `backing` buffer. The respective sub-slice that was written to is returned. + pub fn as_bytes<'a>(&self, backing: &'a mut [u8; 6]) -> &'a BStr { + if self.0 == 0 { + std::slice::from_ref(&b'0') + } else { + let mut nb = 0; + let mut n = self.0; + while n > 0 { + let remainder = (n % 8) as u8; + backing[nb] = b'0' + remainder; + n /= 8; + nb += 1; + } + let res = &mut backing[..nb]; + res.reverse(); + res + } + .into() + } } /// An element of a [`TreeRef`][crate::TreeRef::entries]. @@ -124,18 +223,3 @@ impl Ord for Entry { }) } } - -/// Serialization -impl EntryMode { - /// Return the representation as used in the git internal format. - pub fn as_bytes(&self) -> &'static [u8] { - use EntryMode::*; - match self { - Tree => b"40000", - Blob => b"100644", - BlobExecutable => b"100755", - Link => b"120000", - Commit => b"160000", - } - } -} diff --git a/gix-object/src/tree/ref_iter.rs b/gix-object/src/tree/ref_iter.rs index 510ae34b997..e09044d30ec 100644 --- a/gix-object/src/tree/ref_iter.rs +++ b/gix-object/src/tree/ref_iter.rs @@ -26,10 +26,11 @@ impl<'a> TreeRef<'a> { let search = EntryRef { mode: if is_dir { - tree::EntryMode::Tree + tree::EntryKind::Tree } else { - tree::EntryMode::Blob - }, + tree::EntryKind::Blob + } + .into(), filename: name, oid: &NULL_HASH, }; @@ -82,34 +83,33 @@ impl<'a> TryFrom<&'a [u8]> for tree::EntryMode { type Error = &'a [u8]; fn try_from(mode: &'a [u8]) -> Result { - Ok(match mode { - b"40000" => tree::EntryMode::Tree, - b"100644" => tree::EntryMode::Blob, - b"100755" => tree::EntryMode::BlobExecutable, - b"120000" => tree::EntryMode::Link, - b"160000" => tree::EntryMode::Commit, - b"100664" => tree::EntryMode::Blob, // rare and found in the linux kernel - b"100640" => tree::EntryMode::Blob, // rare and found in the Rust repo - _ => return Err(mode), - }) + mode_from_decimal(mode) + .map(|(mode, _rest)| tree::EntryMode(mode as u16)) + .ok_or(mode) } } +fn mode_from_decimal(i: &[u8]) -> Option<(u32, &[u8])> { + let mut mode = 0u32; + let mut spacer_pos = 1; + for b in i.iter().take_while(|b| **b != b' ') { + if *b < b'0' || *b > b'7' { + return None; + } + mode = (mode << 3) + (b - b'0') as u32; + spacer_pos += 1; + } + let (_, i) = i.split_at(spacer_pos); + Some((mode, i)) +} + impl TryFrom for tree::EntryMode { type Error = u32; fn try_from(mode: u32) -> Result { Ok(match mode { - 0o40000 => tree::EntryMode::Tree, - 0o120000 => tree::EntryMode::Link, - 0o160000 => tree::EntryMode::Commit, - blob_mode if blob_mode & 0o100000 == 0o100000 => { - if blob_mode & 0o000100 == 0o000100 { - tree::EntryMode::BlobExecutable - } else { - tree::EntryMode::Blob - } - } + 0o40000 | 0o120000 | 0o160000 => tree::EntryMode(mode as u16), + blob_mode if blob_mode & 0o100000 == 0o100000 => tree::EntryMode(mode as u16), _ => return Err(mode), }) } @@ -121,19 +121,11 @@ mod decode { use bstr::ByteSlice; use winnow::{error::ParserError, prelude::*}; + use crate::tree::ref_iter::mode_from_decimal; use crate::{tree, tree::EntryRef, TreeRef}; pub fn fast_entry(i: &[u8]) -> Option<(&[u8], EntryRef<'_>)> { - let mut mode = 0u32; - let mut spacer_pos = 1; - for b in i.iter().take_while(|b| **b != b' ') { - if *b < b'0' || *b > b'7' { - return None; - } - mode = (mode << 3) + (b - b'0') as u32; - spacer_pos += 1; - } - let (_, i) = i.split_at(spacer_pos); + let (mode, i) = mode_from_decimal(i)?; let mode = tree::EntryMode::try_from(mode).ok()?; let (filename, i) = i.split_at(i.find_byte(0)?); let i = &i[1..]; diff --git a/gix-object/src/tree/write.rs b/gix-object/src/tree/write.rs index e1a82720f1f..e60b9b9b882 100644 --- a/gix-object/src/tree/write.rs +++ b/gix-object/src/tree/write.rs @@ -35,8 +35,9 @@ impl crate::WriteTo for Tree { &self.entries, "entries for serialization must be sorted by filename" ); + let mut buf = Default::default(); for Entry { mode, filename, oid } in &self.entries { - out.write_all(mode.as_bytes())?; + out.write_all(mode.as_bytes(&mut buf))?; out.write_all(SPACE)?; if filename.find_byte(b'\n').is_some() { @@ -58,10 +59,11 @@ impl crate::WriteTo for Tree { } fn size(&self) -> u64 { + let mut buf = Default::default(); self.entries .iter() .map(|Entry { mode, filename, oid }| { - (mode.as_bytes().len() + 1 + filename.len() + 1 + oid.as_bytes().len()) as u64 + (mode.as_bytes(&mut buf).len() + 1 + filename.len() + 1 + oid.as_bytes().len()) as u64 }) .sum() } @@ -80,8 +82,9 @@ impl<'a> crate::WriteTo for TreeRef<'a> { &self.entries, "entries for serialization must be sorted by filename" ); + let mut buf = Default::default(); for EntryRef { mode, filename, oid } in &self.entries { - out.write_all(mode.as_bytes())?; + out.write_all(mode.as_bytes(&mut buf))?; out.write_all(SPACE)?; if filename.find_byte(b'\n').is_some() { @@ -103,10 +106,11 @@ impl<'a> crate::WriteTo for TreeRef<'a> { } fn size(&self) -> u64 { + let mut buf = Default::default(); self.entries .iter() .map(|EntryRef { mode, filename, oid }| { - (mode.as_bytes().len() + 1 + filename.len() + 1 + oid.as_bytes().len()) as u64 + (mode.as_bytes(&mut buf).len() + 1 + filename.len() + 1 + oid.as_bytes().len()) as u64 }) .sum() } diff --git a/gix-object/tests/tree/mod.rs b/gix-object/tests/tree/mod.rs index e06984d77ea..4e8f66fcef4 100644 --- a/gix-object/tests/tree/mod.rs +++ b/gix-object/tests/tree/mod.rs @@ -25,27 +25,27 @@ mod iter { TreeRefIter::from_bytes(&fixture_name("tree", "everything.tree")).collect::, _>>()?, vec![ EntryRef { - mode: tree::EntryMode::BlobExecutable, + mode: tree::EntryKind::BlobExecutable.into(), filename: b"exe".as_bstr(), oid: &hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391") }, EntryRef { - mode: tree::EntryMode::Blob, + mode: tree::EntryKind::Blob.into(), filename: b"file".as_bstr(), oid: &hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391") }, EntryRef { - mode: tree::EntryMode::Commit, + mode: tree::EntryKind::Commit.into(), filename: b"grit-submodule".as_bstr(), oid: &hex_to_id("b2d1b5d684bdfda5f922b466cc13d4ce2d635cf8") }, EntryRef { - mode: tree::EntryMode::Tree, + mode: tree::EntryKind::Tree.into(), filename: b"subdir".as_bstr(), oid: &hex_to_id("4d5fcadc293a348e88f777dc0920f11e7d71441c") }, EntryRef { - mode: tree::EntryMode::Link, + mode: tree::EntryKind::Link.into(), filename: b"symlink".as_bstr(), oid: &hex_to_id("1a010b1c0f081b2e8901d55307a15c29ff30af0e") } @@ -77,27 +77,27 @@ mod from_bytes { TreeRef { entries: vec![ EntryRef { - mode: tree::EntryMode::BlobExecutable, + mode: tree::EntryKind::BlobExecutable.into(), filename: b"exe".as_bstr(), oid: &hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391") }, EntryRef { - mode: tree::EntryMode::Blob, + mode: tree::EntryKind::Blob.into(), filename: b"file".as_bstr(), oid: &hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391") }, EntryRef { - mode: tree::EntryMode::Commit, + mode: tree::EntryKind::Commit.into(), filename: b"grit-submodule".as_bstr(), oid: &hex_to_id("b2d1b5d684bdfda5f922b466cc13d4ce2d635cf8") }, EntryRef { - mode: tree::EntryMode::Tree, + mode: tree::EntryKind::Tree.into(), filename: b"subdir".as_bstr(), oid: &hex_to_id("4d5fcadc293a348e88f777dc0920f11e7d71441c") }, EntryRef { - mode: tree::EntryMode::Link, + mode: tree::EntryKind::Link.into(), filename: b"symlink".as_bstr(), oid: &hex_to_id("1a010b1c0f081b2e8901d55307a15c29ff30af0e") } @@ -199,7 +199,7 @@ mod entries { } mod entry_mode { - use gix_object::tree::EntryMode; + use gix_object::tree::{EntryKind, EntryMode}; #[test] fn size_in_bytes() { @@ -209,4 +209,29 @@ mod entry_mode { "it should not change without notice" ); } + + #[test] + fn as_bytes() { + let mut buf = Default::default(); + for (mode, expected) in [ + (EntryMode::from(EntryKind::Tree), EntryKind::Tree.as_octal_str()), + (EntryKind::Blob.into(), EntryKind::Blob.as_octal_str()), + ( + EntryKind::BlobExecutable.into(), + EntryKind::BlobExecutable.as_octal_str(), + ), + (EntryKind::Link.into(), EntryKind::Link.as_octal_str()), + (EntryKind::Commit.into(), EntryKind::Commit.as_octal_str()), + ( + EntryMode::try_from(b"100744 ".as_ref()).expect("valid"), + "100744".into(), + ), + ( + EntryMode::try_from(b"100644 ".as_ref()).expect("valid"), + "100644".into(), + ), + ] { + assert_eq!(mode.as_bytes(&mut buf), expected) + } + } } From 203d69c8890acc716bd4f7a7b1b2b91a8c828bde Mon Sep 17 00:00:00 2001 From: Sebastian Thiel Date: Fri, 10 Nov 2023 17:52:50 +0100 Subject: [PATCH 4/4] adapt to changes in `gix-object` --- examples/ls-tree.rs | 23 ++- gitoxide-core/src/repository/archive.rs | 2 +- gitoxide-core/src/repository/tree.rs | 8 +- gix-archive/src/write.rs | 34 ++-- gix-archive/tests/archive.rs | 22 +-- gix-diff/src/tree/changes.rs | 23 ++- gix-diff/tests/tree/mod.rs | 151 +++++++++--------- gix-fsck/src/lib.rs | 11 +- gix-index/src/extension/tree/verify.rs | 5 +- gix-index/src/init.rs | 18 +-- gix-odb/tests/odb/store/loose.rs | 7 +- .../src/data/output/count/objects/tree.rs | 12 +- gix-pack/src/index/verify.rs | 25 +-- gix-traverse/src/tree/breadthfirst.rs | 37 ++--- gix-traverse/tests/tree/mod.rs | 26 +-- gix-worktree-stream/src/lib.rs | 11 +- gix-worktree-stream/src/protocol.rs | 7 +- gix-worktree-stream/tests/stream.rs | 33 ++-- gix/examples/init-repo-and-commit.rs | 2 +- gix/examples/stats.rs | 4 +- gix/src/object/tree/diff/tracked.rs | 8 +- gix/src/object/tree/iter.rs | 2 +- gix/src/object/tree/mod.rs | 2 +- gix/src/submodule/mod.rs | 2 +- gix/tests/object/tree/diff.rs | 7 +- 25 files changed, 227 insertions(+), 255 deletions(-) diff --git a/examples/ls-tree.rs b/examples/ls-tree.rs index fbdc4be182d..ecf607bf124 100644 --- a/examples/ls-tree.rs +++ b/examples/ls-tree.rs @@ -1,12 +1,7 @@ use std::io::{stdout, Write}; use clap::Parser; -use gix::{ - bstr::BString, - objs::tree::{EntryMode, EntryMode::Tree}, - traverse::tree::Recorder, - ObjectId, -}; +use gix::{bstr::BString, objs::tree::EntryMode, traverse::tree::Recorder, ObjectId}; fn main() { let args = Args::parse_from(gix::env::args_os()); @@ -43,14 +38,14 @@ fn run(args: Args) -> anyhow::Result<()> { recorder .records .into_iter() - .filter(|entry| args.tree_recursing || args.tree_only || entry.mode != Tree) - .filter(|entry| !args.tree_only || (entry.mode == Tree)) + .filter(|entry| args.tree_recursing || args.tree_only || entry.mode.is_no_tree()) + .filter(|entry| !args.tree_only || (entry.mode.is_tree())) .map(|entry| Entry::new(entry.mode, entry.oid, entry.filepath)) .collect::>() } else { tree.iter() .filter_map(|res| res.ok().map(|entry| entry.inner)) // dropping errors silently - .filter(|entry| !args.tree_only || (entry.mode == Tree)) + .filter(|entry| !args.tree_only || (entry.mode.is_tree())) .map(|entry| Entry::new(entry.mode, entry.oid.to_owned(), entry.filename.to_owned())) .collect::>() }; @@ -60,8 +55,8 @@ fn run(args: Args) -> anyhow::Result<()> { writeln!( out, "{:06o} {:4} {} {}", - entry.kind as u16, - entry.kind.as_str(), + *entry.mode, + entry.mode.as_str(), entry.hash, entry.path )?; @@ -71,13 +66,13 @@ fn run(args: Args) -> anyhow::Result<()> { } struct Entry { - kind: EntryMode, + mode: EntryMode, hash: ObjectId, path: BString, } impl Entry { - fn new(kind: EntryMode, hash: ObjectId, path: BString) -> Self { - Self { kind, hash, path } + fn new(mode: EntryMode, hash: ObjectId, path: BString) -> Self { + Self { mode, hash, path } } } diff --git a/gitoxide-core/src/repository/archive.rs b/gitoxide-core/src/repository/archive.rs index 9fdf6fbeace..d064e952c4c 100644 --- a/gitoxide-core/src/repository/archive.rs +++ b/gitoxide-core/src/repository/archive.rs @@ -40,7 +40,7 @@ pub fn stream( for (path, content) in files { stream.add_entry(gix::worktree::stream::AdditionalEntry { id: gix::hash::Kind::Sha1.null(), - mode: gix::object::tree::EntryMode::Blob, + mode: gix::object::tree::EntryKind::Blob.into(), relative_path: path.into(), source: gix::worktree::stream::entry::Source::Memory(content.into()), }); diff --git a/gitoxide-core/src/repository/tree.rs b/gitoxide-core/src/repository/tree.rs index 5e9eee33472..4cf06d0b309 100644 --- a/gitoxide-core/src/repository/tree.rs +++ b/gitoxide-core/src/repository/tree.rs @@ -89,7 +89,6 @@ mod entries { } fn visit_nontree(&mut self, entry: &EntryRef<'_>) -> Action { - use gix::objs::tree::EntryMode::*; let size = self .repo .and_then(|repo| repo.find_object(entry.oid).map(|o| o.data.len()).ok()); @@ -100,7 +99,8 @@ mod entries { self.stats.num_bytes += size as u64; } - match entry.mode { + use gix::object::tree::EntryKind::*; + match entry.mode.kind() { Commit => self.stats.num_submodules += 1, Blob => self.stats.num_blobs += 1, BlobExecutable => self.stats.num_blobs_exec += 1, @@ -184,11 +184,11 @@ fn format_entry( filename: &gix::bstr::BStr, size: Option, ) -> std::io::Result<()> { - use gix::objs::tree::EntryMode::*; + use gix::objs::tree::EntryKind::*; writeln!( out, "{} {}{} {}", - match entry.mode { + match entry.mode.kind() { Tree => "TREE", Blob => "BLOB", BlobExecutable => " EXE", diff --git a/gix-archive/src/write.rs b/gix-archive/src/write.rs index 870c833df34..5c5dc885eca 100644 --- a/gix-archive/src/write.rs +++ b/gix-archive/src/write.rs @@ -169,23 +169,19 @@ fn append_zip_entry( .compression_level(compression_level) .large_file(entry.bytes_remaining().map_or(true, |len| len > u32::MAX as usize)) .last_modified_time(mtime) - .unix_permissions(if matches!(entry.mode, gix_object::tree::EntryMode::BlobExecutable) { - 0o755 - } else { - 0o644 - }); + .unix_permissions(if entry.mode.is_executable() { 0o755 } else { 0o644 }); let path = add_prefix(entry.relative_path(), tree_prefix).into_owned(); - match entry.mode { - gix_object::tree::EntryMode::Blob | gix_object::tree::EntryMode::BlobExecutable => { + match entry.mode.kind() { + gix_object::tree::EntryKind::Blob | gix_object::tree::EntryKind::BlobExecutable => { ar.start_file(path.to_string(), file_opts) .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?; std::io::copy(&mut entry, ar)?; } - gix_object::tree::EntryMode::Tree | gix_object::tree::EntryMode::Commit => { + gix_object::tree::EntryKind::Tree | gix_object::tree::EntryKind::Commit => { ar.add_directory(path.to_string(), file_opts) .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?; } - gix_object::tree::EntryMode::Link => { + gix_object::tree::EntryKind::Link => { use bstr::ByteSlice; std::io::copy(&mut entry, buf)?; ar.add_symlink(path.to_string(), buf.as_bstr().to_string(), file_opts) @@ -206,18 +202,14 @@ fn append_tar_entry( let mut header = tar::Header::new_gnu(); header.set_mtime(mtime_seconds_since_epoch as u64); header.set_entry_type(tar_entry_type(entry.mode)); - header.set_mode(if matches!(entry.mode, gix_object::tree::EntryMode::BlobExecutable) { - 0o755 - } else { - 0o644 - }); + header.set_mode(if entry.mode.is_executable() { 0o755 } else { 0o644 }); buf.clear(); std::io::copy(&mut entry, buf)?; let path = gix_path::from_bstr(add_prefix(entry.relative_path(), opts.tree_prefix.as_ref())); header.set_size(buf.len() as u64); - if entry.mode == gix_object::tree::EntryMode::Link { + if entry.mode.is_link() { use bstr::ByteSlice; let target = gix_path::from_bstr(buf.as_bstr()); header.set_entry_type(tar::EntryType::Symlink); @@ -231,13 +223,13 @@ fn append_tar_entry( #[cfg(any(feature = "tar", feature = "tar_gz"))] fn tar_entry_type(mode: gix_object::tree::EntryMode) -> tar::EntryType { - use gix_object::tree::EntryMode; + use gix_object::tree::EntryKind; use tar::EntryType; - match mode { - EntryMode::Tree | EntryMode::Commit => EntryType::Directory, - EntryMode::Blob => EntryType::Regular, - EntryMode::BlobExecutable => EntryType::Regular, - EntryMode::Link => EntryType::Link, + match mode.kind() { + EntryKind::Tree | EntryKind::Commit => EntryType::Directory, + EntryKind::Blob => EntryType::Regular, + EntryKind::BlobExecutable => EntryType::Regular, + EntryKind::Link => EntryType::Link, } } diff --git a/gix-archive/tests/archive.rs b/gix-archive/tests/archive.rs index 3e43f755f9b..b9bbcaaffda 100644 --- a/gix-archive/tests/archive.rs +++ b/gix-archive/tests/archive.rs @@ -8,7 +8,7 @@ mod from_tree { use gix_archive::Format; use gix_attributes::glob::pattern::Case; - use gix_object::tree::EntryMode; + use gix_object::tree::EntryKind; use gix_testtools::bstr::ByteSlice; use gix_worktree::stack::state::attributes::Source; @@ -22,32 +22,32 @@ mod from_tree { let mut stream = gix_worktree_stream::Stream::from_read(std::io::Cursor::new(buf)); let mut paths_and_modes = Vec::new(); while let Some(mut entry) = stream.next_entry().expect("entry retrieval does not fail") { - paths_and_modes.push((entry.relative_path().to_owned(), entry.mode, entry.id)); + paths_and_modes.push((entry.relative_path().to_owned(), entry.mode.kind(), entry.id)); let mut buf = Vec::new(); entry.read_to_end(&mut buf).expect("stream can always be read"); } let expected_link_mode = if cfg!(windows) { - EntryMode::Blob + EntryKind::Blob } else { - EntryMode::Link + EntryKind::Link }; let expected_exe_mode = if cfg!(windows) { - EntryMode::Blob + EntryKind::Blob } else { - EntryMode::BlobExecutable + EntryKind::BlobExecutable }; assert_eq!( paths_and_modes, &[ ( ".gitattributes".into(), - EntryMode::Blob, + EntryKind::Blob, hex_to_id("45c160c35c17ad264b96431cceb9793160396e99") ), ( "a".into(), - EntryMode::Blob, + EntryKind::Blob, hex_to_id("45b983be36b73c0788dc9cbcb76cbb80fc7bb057") ), ( @@ -61,7 +61,7 @@ mod from_tree { ), ( "dir/b".into(), - EntryMode::Blob, + EntryKind::Blob, hex_to_id("ab4a98190cf776b43cb0fe57cef231fb93fd07e6") ), ( @@ -71,7 +71,7 @@ mod from_tree { ), ( "extra-file".into(), - EntryMode::Blob, + EntryKind::Blob, hex_to_id("0000000000000000000000000000000000000000") ), ( @@ -81,7 +81,7 @@ mod from_tree { ), ( "extra-dir-empty".into(), - EntryMode::Tree, + EntryKind::Tree, hex_to_id("0000000000000000000000000000000000000000") ), ( diff --git a/gix-diff/src/tree/changes.rs b/gix-diff/src/tree/changes.rs index 9da3bb568b4..867ea366045 100644 --- a/gix-diff/src/tree/changes.rs +++ b/gix-diff/src/tree/changes.rs @@ -250,9 +250,8 @@ fn handle_lhs_and_rhs_with_equal_filenames( queue: &mut VecDeque, delegate: &mut R, ) -> Result<(), Error> { - use gix_object::tree::EntryMode::*; - match (lhs.mode, rhs.mode) { - (Tree, Tree) => { + match (lhs.mode.is_tree(), rhs.mode.is_tree()) { + (true, true) => { delegate.push_back_tracked_path_component(lhs.filename); if lhs.oid != rhs.oid && delegate @@ -268,7 +267,7 @@ fn handle_lhs_and_rhs_with_equal_filenames( } queue.push_back((Some(lhs.oid.to_owned()), Some(rhs.oid.to_owned()))); } - (_, Tree) => { + (_, true) => { delegate.push_back_tracked_path_component(lhs.filename); if delegate .visit(Change::Deletion { @@ -290,7 +289,7 @@ fn handle_lhs_and_rhs_with_equal_filenames( }; queue.push_back((None, Some(rhs.oid.to_owned()))); } - (Tree, _) => { + (true, _) => { delegate.push_back_tracked_path_component(lhs.filename); if delegate .visit(Change::Deletion { @@ -312,9 +311,9 @@ fn handle_lhs_and_rhs_with_equal_filenames( }; queue.push_back((Some(lhs.oid.to_owned()), None)); } - (lhs_non_tree, rhs_non_tree) => { + (false, false) => { delegate.push_path_component(lhs.filename); - debug_assert!(lhs_non_tree.is_no_tree() && rhs_non_tree.is_no_tree()); + debug_assert!(lhs.mode.is_no_tree() && lhs.mode.is_no_tree()); if lhs.oid != rhs.oid && delegate .visit(Change::Modification { @@ -342,7 +341,7 @@ fn peekable(iter: I) -> IteratorType { mod tests { use std::cmp::Ordering; - use gix_object::tree::EntryMode; + use gix_object::tree::EntryKind; use super::*; @@ -351,12 +350,12 @@ mod tests { let null = gix_hash::ObjectId::null(gix_hash::Kind::Sha1); let actual = compare( &EntryRef { - mode: EntryMode::Blob, + mode: EntryKind::Blob.into(), filename: "plumbing-cli.rs".into(), oid: &null, }, &EntryRef { - mode: EntryMode::Tree, + mode: EntryKind::Tree.into(), filename: "plumbing".into(), oid: &null, }, @@ -364,12 +363,12 @@ mod tests { assert_eq!(actual, Ordering::Less); let actual = compare( &EntryRef { - mode: EntryMode::Tree, + mode: EntryKind::Tree.into(), filename: "plumbing-cli.rs".into(), oid: &null, }, &EntryRef { - mode: EntryMode::Blob, + mode: EntryKind::Blob.into(), filename: "plumbing".into(), oid: &null, }, diff --git a/gix-diff/tests/tree/mod.rs b/gix-diff/tests/tree/mod.rs index f853ff259dd..6544d75ddd4 100644 --- a/gix-diff/tests/tree/mod.rs +++ b/gix-diff/tests/tree/mod.rs @@ -7,7 +7,8 @@ mod changes { recorder::{Change::*, Location}, }; use gix_hash::{oid, ObjectId}; - use gix_object::{bstr::ByteSlice, tree::EntryMode, TreeRefIter}; + use gix_object::tree::EntryKind; + use gix_object::{bstr::ByteSlice, TreeRefIter}; use gix_odb::pack::Find; use crate::hex_to_id; @@ -160,7 +161,7 @@ mod changes { assert_eq!( diff_with_previous_commit_from(&db, &all_commits["f added"])?, vec![Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "f".into() }], @@ -170,9 +171,9 @@ mod changes { assert_eq!( diff_with_previous_commit_from(&db, &all_commits["f modified"])?, vec![Modification { - previous_entry_mode: EntryMode::Blob, + previous_entry_mode: EntryKind::Blob.into(), previous_oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("28ce6a8b26aa170e1de65536fe8abe1832bd3242"), path: "f".into() }], @@ -182,7 +183,7 @@ mod changes { assert_eq!( diff_with_previous_commit_from(&db, &all_commits["f deleted"])?, vec![Deletion { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("28ce6a8b26aa170e1de65536fe8abe1832bd3242"), path: "f".into() }], @@ -194,17 +195,17 @@ mod changes { diff_with_previous_commit_from(&db, &all_commits["f mode modified to dir f/"])?, vec![ Deletion { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("28ce6a8b26aa170e1de65536fe8abe1832bd3242"), path: "f".into() }, Addition { - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: hex_to_id("10f2f4b82222d2b5c31985130979a91fd87410f7"), path: "f".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("28ce6a8b26aa170e1de65536fe8abe1832bd3242"), path: "f/f".into() } @@ -217,12 +218,12 @@ mod changes { diff_with_previous_commit_from(&db, &all_commits["a renamed to b"])?, vec![ Deletion { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "a".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "b".into() } @@ -237,16 +238,16 @@ mod changes { diff_with_previous_commit_from(&db, &all_commits["f/f modified"])?, vec![ Modification { - previous_entry_mode: EntryMode::Tree, + previous_entry_mode: EntryKind::Tree.into(), previous_oid: hex_to_id("10f2f4b82222d2b5c31985130979a91fd87410f7"), - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: hex_to_id("ebbe0b3000afdfd1aed15000094b59a2800328eb"), path: "f".into() }, Modification { - previous_entry_mode: EntryMode::Blob, + previous_entry_mode: EntryKind::Blob.into(), previous_oid: hex_to_id("28ce6a8b26aa170e1de65536fe8abe1832bd3242"), - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("13c2aca72ab576cb5f22dc8e7f8ba8ddab553a8a"), path: "f/f".into() }, @@ -259,27 +260,27 @@ mod changes { #[cfg(windows)] let link_entry_oid = hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"); #[cfg(windows)] - let link_entry_mode = EntryMode::Blob; + let link_entry_mode = EntryKind::Blob; #[cfg(not(windows))] let tree_with_link_id = hex_to_id("7e26dba59b6336f87d1d4ae3505a2da302b91c76"); #[cfg(not(windows))] let link_entry_oid = hex_to_id("2e65efe2a145dda7ee51d1741299f848e5bf752e"); #[cfg(not(windows))] - let link_entry_mode = EntryMode::Link; + let link_entry_mode = EntryKind::Link; assert_eq!( diff_with_previous_commit_from(&db, &all_commits["f/f mode changed to link"])?, vec![ Modification { - previous_entry_mode: EntryMode::Tree, + previous_entry_mode: EntryKind::Tree.into(), previous_oid: hex_to_id("849bd76db90b65ebbd2e6d3970ca70c96ee5592c"), - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: tree_with_link_id, path: "f".into() }, Modification { - previous_entry_mode: EntryMode::Blob, + previous_entry_mode: EntryKind::Blob.into(), previous_oid: hex_to_id("13c2aca72ab576cb5f22dc8e7f8ba8ddab553a8a"), - entry_mode: link_entry_mode, + entry_mode: link_entry_mode.into(), oid: link_entry_oid, path: "f/f".into() }, @@ -291,27 +292,27 @@ mod changes { diff_with_previous_commit_from(&db, &all_commits["f/ changed into file f"])?, vec![ Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "f".into() }, Deletion { - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: tree_with_link_id, path: "f".into() }, Deletion { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "f/a".into() }, Deletion { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "f/b".into() }, Deletion { - entry_mode: link_entry_mode, + entry_mode: link_entry_mode.into(), oid: link_entry_oid, path: "f/f".into() }, @@ -325,12 +326,12 @@ mod changes { diff_with_previous_commit_from(&db, &all_commits["delete d/"])?, vec![ Deletion { - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: hex_to_id("3d5a503f4062d198b443db5065ca727f8354e7df"), path: "d".into() }, Deletion { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "d/f".into() }, @@ -341,17 +342,17 @@ mod changes { diff_with_previous_commit_from(&db, &all_commits["add /c /d /e"])?, vec![ Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "c".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "d".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "e".into() }, @@ -364,12 +365,12 @@ mod changes { diff_with_previous_commit_from(&db, &all_commits["add g/a"])?, vec![ Addition { - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: hex_to_id("496d6428b9cf92981dc9495211e6e1120fb6f2ba"), path: "g".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "g/a".into() }, @@ -380,17 +381,17 @@ mod changes { diff_with_previous_commit_from(&db, &all_commits["remove /c /d /e"])?, vec![ Deletion { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "c".into() }, Deletion { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "d".into() }, Deletion { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "e".into() }, @@ -403,12 +404,12 @@ mod changes { diff_with_previous_commit_from(&db, &all_commits["rm /f, add /ff"])?, vec![ Deletion { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "f".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "ff".into() }, @@ -420,19 +421,19 @@ mod changes { diff_with_previous_commit_from(&db, &all_commits["rm g/a, add g/aa"])?, vec![ Modification { - previous_entry_mode: EntryMode::Tree, + previous_entry_mode: EntryKind::Tree.into(), previous_oid: hex_to_id("496d6428b9cf92981dc9495211e6e1120fb6f2ba"), - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: hex_to_id("6e5931346904b020301f74f581142826eacc4678"), path: "g".into() }, Deletion { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "g/a".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "g/aa".into() }, @@ -444,12 +445,12 @@ mod changes { diff_with_previous_commit_from(&db, &all_commits["rm /ff, add /f"])?, vec![ Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "f".into() }, Deletion { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "ff".into() }, @@ -461,19 +462,19 @@ mod changes { diff_with_previous_commit_from(&db, &all_commits["rm g/aa, add g/a"])?, vec![ Modification { - previous_entry_mode: EntryMode::Tree, + previous_entry_mode: EntryKind::Tree.into(), previous_oid: hex_to_id("6e5931346904b020301f74f581142826eacc4678"), - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: hex_to_id("496d6428b9cf92981dc9495211e6e1120fb6f2ba"), path: "g".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "g/a".into() }, Deletion { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "g/aa".into() }, @@ -493,12 +494,12 @@ mod changes { diff_with_previous_commit_from(&db, &all_commits["f added"])?, vec![ Addition { - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: hex_to_id("3d5a503f4062d198b443db5065ca727f8354e7df"), path: "a".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "a/f".into() } @@ -509,16 +510,16 @@ mod changes { diff_with_previous_commit_from(&db, &all_commits["f modified"])?, vec![ Modification { - previous_entry_mode: EntryMode::Tree, + previous_entry_mode: EntryKind::Tree.into(), previous_oid: hex_to_id("3d5a503f4062d198b443db5065ca727f8354e7df"), - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: hex_to_id("10f2f4b82222d2b5c31985130979a91fd87410f7"), path: "a".into() }, Modification { - previous_entry_mode: EntryMode::Blob, + previous_entry_mode: EntryKind::Blob.into(), previous_oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("28ce6a8b26aa170e1de65536fe8abe1832bd3242"), path: "a/f".into() } @@ -546,17 +547,17 @@ mod changes { diff_commits(&db, first_commit.to_owned(), &last_commit, None)?, vec![ Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "".into() }, Addition { - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: hex_to_id("496d6428b9cf92981dc9495211e6e1120fb6f2ba"), path: "".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "".into() } @@ -566,17 +567,17 @@ mod changes { diff_commits(&db, last_commit.to_owned(), &first_commit, Location::FileName.into())?, vec![ Deletion { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "b".into() }, Deletion { - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: hex_to_id("496d6428b9cf92981dc9495211e6e1120fb6f2ba"), path: "g".into() }, Deletion { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "a".into() } @@ -594,42 +595,42 @@ mod changes { diff_commits(&db, None::, &all_commits["add g/a"], Some(Location::Path))?, vec![ Addition { - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: hex_to_id("0df4d0ed769eacd0a231e7512fca25d3cabdeca4"), path: "a".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "a/b".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "a/c".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "a/d".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "a/e".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "a/f".into() }, Addition { - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: hex_to_id("496d6428b9cf92981dc9495211e6e1120fb6f2ba"), path: "a/g".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "a/g/a".into() } @@ -647,22 +648,22 @@ mod changes { diff_with_previous_commit_from(&db, &all_commits["interesting rename 1"])?, vec![ Deletion { - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: hex_to_id("f84fc275158a2973cb4a79b1618b79ec7f573a95"), path: "git-sec".into() }, Addition { - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: hex_to_id("f84fc275158a2973cb4a79b1618b79ec7f573a95"), path: "gix-sec".into() }, Deletion { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "git-sec/2".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "gix-sec/2".into() } @@ -680,22 +681,22 @@ mod changes { diff_with_previous_commit_from(&db, &all_commits["interesting rename 2"])?, vec![ Addition { - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: hex_to_id("f84fc275158a2973cb4a79b1618b79ec7f573a95"), path: "git-sec".into() }, Deletion { - entry_mode: EntryMode::Tree, + entry_mode: EntryKind::Tree.into(), oid: hex_to_id("f84fc275158a2973cb4a79b1618b79ec7f573a95"), path: "gix-sec".into() }, Addition { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "git-sec/2".into() }, Deletion { - entry_mode: EntryMode::Blob, + entry_mode: EntryKind::Blob.into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), path: "gix-sec/2".into() } diff --git a/gix-fsck/src/lib.rs b/gix-fsck/src/lib.rs index c99e718c938..ac536c1ba25 100644 --- a/gix-fsck/src/lib.rs +++ b/gix-fsck/src/lib.rs @@ -3,7 +3,8 @@ use gix_hash::ObjectId; use gix_hashtable::HashSet; -use gix_object::{tree::EntryMode, Exists, FindExt, Kind}; +use gix_object::tree::EntryKind; +use gix_object::{Exists, FindExt, Kind}; use std::collections::VecDeque; /// Perform a connectivity check. @@ -76,20 +77,20 @@ where }; for entry_ref in tree.entries.iter() { - match entry_ref.mode { - EntryMode::Tree => { + match entry_ref.mode.kind() { + EntryKind::Tree => { let tree_id = entry_ref.oid.to_owned(); if self.seen.insert(tree_id) { tree_ids.push_back(tree_id); } } - EntryMode::Blob | EntryMode::BlobExecutable | EntryMode::Link => { + EntryKind::Blob | EntryKind::BlobExecutable | EntryKind::Link => { let blob_id = entry_ref.oid.to_owned(); if self.seen.insert(blob_id) { check_blob(&self.db, &blob_id, &mut self.missing_cb); } } - EntryMode::Commit => { + EntryKind::Commit => { // Skip submodules as it's not in this repository! } } diff --git a/gix-index/src/extension/tree/verify.rs b/gix-index/src/extension/tree/verify.rs index b0faae2db88..9bb3670f57b 100644 --- a/gix-index/src/extension/tree/verify.rs +++ b/gix-index/src/extension/tree/verify.rs @@ -69,10 +69,7 @@ impl Tree { if let Some(buf) = object_buf.as_mut() { let tree_entries = objects.find_tree_iter(&parent_id, buf)?; let mut num_entries = 0; - for entry in tree_entries - .filter_map(Result::ok) - .filter(|e| e.mode == gix_object::tree::EntryMode::Tree) - { + for entry in tree_entries.filter_map(Result::ok).filter(|e| e.mode.is_tree()) { children .binary_search_by(|e| e.name.as_bstr().cmp(entry.filename)) .map_err(|_| Error::MissingTreeDirectory { diff --git a/gix-index/src/init.rs b/gix-index/src/init.rs index b49dac51783..88fd8a91c25 100644 --- a/gix-index/src/init.rs +++ b/gix-index/src/init.rs @@ -2,10 +2,8 @@ mod from_tree { use std::collections::VecDeque; use bstr::{BStr, BString, ByteSlice, ByteVec}; - use gix_object::{ - tree::{self, EntryMode}, - FindExt, - }; + use gix_object::tree::EntryKind; + use gix_object::{tree, FindExt}; use gix_traverse::tree::{breadthfirst, visit::Action, Visit}; use crate::{ @@ -95,12 +93,12 @@ mod from_tree { } pub fn add_entry(&mut self, entry: &tree::EntryRef<'_>) { - let mode = match entry.mode { - EntryMode::Tree => unreachable!("visit_non_tree() called us"), - EntryMode::Blob => Mode::FILE, - EntryMode::BlobExecutable => Mode::FILE_EXECUTABLE, - EntryMode::Link => Mode::SYMLINK, - EntryMode::Commit => Mode::COMMIT, + let mode = match entry.mode.kind() { + EntryKind::Tree => unreachable!("visit_non_tree() called us"), + EntryKind::Blob => Mode::FILE, + EntryKind::BlobExecutable => Mode::FILE_EXECUTABLE, + EntryKind::Link => Mode::SYMLINK, + EntryKind::Commit => Mode::COMMIT, }; let path_start = self.path_backing.len(); diff --git a/gix-odb/tests/odb/store/loose.rs b/gix-odb/tests/odb/store/loose.rs index c998522100d..316b8a23451 100644 --- a/gix-odb/tests/odb/store/loose.rs +++ b/gix-odb/tests/odb/store/loose.rs @@ -224,7 +224,8 @@ mod lookup_prefix { } mod find { - use gix_object::{bstr::ByteSlice, tree::EntryMode, BlobRef, CommitRef, Kind, TagRef, TreeRef}; + use gix_object::tree::EntryKind; + use gix_object::{bstr::ByteSlice, BlobRef, CommitRef, Kind, TagRef, TreeRef}; use gix_odb::loose; use crate::{ @@ -368,14 +369,14 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB let expected = TreeRef { entries: vec![ gix_object::tree::EntryRef { - mode: EntryMode::Tree, + mode: EntryKind::Tree.into(), filename: b"dir".as_bstr(), oid: as_id(&[ 150, 174, 134, 139, 53, 57, 245, 81, 200, 143, 213, 240, 35, 148, 208, 34, 88, 27, 17, 176, ]), }, gix_object::tree::EntryRef { - mode: EntryMode::Blob, + mode: EntryKind::Blob.into(), filename: b"file.txt".as_bstr(), oid: as_id(&[ 55, 212, 230, 197, 196, 139, 160, 210, 69, 22, 76, 78, 16, 213, 244, 17, 64, 202, 185, 128, diff --git a/gix-pack/src/data/output/count/objects/tree.rs b/gix-pack/src/data/output/count/objects/tree.rs index d3f4f6b9ad8..824b48062ce 100644 --- a/gix-pack/src/data/output/count/objects/tree.rs +++ b/gix-pack/src/data/output/count/objects/tree.rs @@ -4,7 +4,7 @@ pub mod changes { Visit, }; use gix_hash::ObjectId; - use gix_object::{bstr::BStr, tree::EntryMode}; + use gix_object::bstr::BStr; use crate::data::output::count::objects_impl::util::InsertImmutable; @@ -43,7 +43,7 @@ pub mod changes { fn visit(&mut self, change: Change) -> Action { match change { Change::Addition { oid, entry_mode } | Change::Modification { oid, entry_mode, .. } => { - if entry_mode == EntryMode::Commit { + if entry_mode.is_commit() { return Action::Continue; } let inserted = self.all_seen.insert(oid); @@ -60,10 +60,7 @@ pub mod changes { pub mod traverse { use gix_hash::ObjectId; - use gix_object::{ - bstr::BStr, - tree::{EntryMode, EntryRef}, - }; + use gix_object::{bstr::BStr, tree::EntryRef}; use gix_traverse::tree::{visit::Action, Visit}; use crate::data::output::count::objects_impl::util::InsertImmutable; @@ -110,8 +107,7 @@ pub mod traverse { } fn visit_nontree(&mut self, entry: &EntryRef<'_>) -> Action { - if entry.mode == EntryMode::Commit { - // links don't have a representation + if entry.mode.is_commit() { return Action::Continue; } let inserted = self.all_seen.insert(entry.oid.to_owned()); diff --git a/gix-pack/src/index/verify.rs b/gix-pack/src/index/verify.rs index d259a6a382d..343a647b4f0 100644 --- a/gix-pack/src/index/verify.rs +++ b/gix-pack/src/index/verify.rs @@ -1,7 +1,7 @@ use std::sync::atomic::AtomicBool; use gix_features::progress::{DynNestedProgress, Progress}; -use gix_object::{bstr::ByteSlice, WriteTo}; +use gix_object::WriteTo; use crate::index; @@ -235,7 +235,7 @@ impl index::File { object_kind: gix_object::Kind, buf: &[u8], index_entry: &index::Entry, - progress: &dyn gix_features::progress::Progress, + _progress: &dyn gix_features::progress::Progress, ) -> Result<(), integrity::Error> { if let Mode::HashCrc32Decode | Mode::HashCrc32DecodeEncode = verify_mode { use gix_object::Kind::*; @@ -252,21 +252,12 @@ impl index::File { encode_buf.clear(); object.write_to(&mut *encode_buf)?; if encode_buf.as_slice() != buf { - let mut should_return_error = true; - if let Tree = object_kind { - if buf.as_bstr().find(b"100664").is_some() || buf.as_bstr().find(b"100640").is_some() { - progress.info(format!("Tree object {} would be cleaned up during re-serialization, replacing mode '100664|100640' with '100644'", index_entry.oid)); - should_return_error = false - } - } - if should_return_error { - return Err(integrity::Error::ObjectEncodeMismatch { - kind: object_kind, - id: index_entry.oid, - expected: buf.into(), - actual: encode_buf.clone().into(), - }); - } + return Err(integrity::Error::ObjectEncodeMismatch { + kind: object_kind, + id: index_entry.oid, + expected: buf.into(), + actual: encode_buf.clone().into(), + }); } } } diff --git a/gix-traverse/src/tree/breadthfirst.rs b/gix-traverse/src/tree/breadthfirst.rs index a6c0a4c780f..bb5b3f7d2d0 100644 --- a/gix-traverse/src/tree/breadthfirst.rs +++ b/gix-traverse/src/tree/breadthfirst.rs @@ -31,7 +31,7 @@ impl State { pub(crate) mod impl_ { use std::borrow::BorrowMut; - use gix_object::{tree::EntryMode, FindExt, TreeRefIter}; + use gix_object::{FindExt, TreeRefIter}; use super::{Error, State}; use crate::tree::Visit; @@ -65,29 +65,26 @@ pub(crate) mod impl_ { loop { for entry in tree { let entry = entry?; - match entry.mode { - EntryMode::Tree => { - use crate::tree::visit::Action::*; - delegate.push_path_component(entry.filename); - let action = delegate.visit_tree(&entry); - match action { - Skip => {} - Continue => { - delegate.pop_path_component(); - delegate.push_back_tracked_path_component(entry.filename); - state.next.push_back(entry.oid.to_owned()) - } - Cancel => { - return Err(Error::Cancelled); - } + if entry.mode.is_tree() { + use crate::tree::visit::Action::*; + delegate.push_path_component(entry.filename); + let action = delegate.visit_tree(&entry); + match action { + Skip => {} + Continue => { + delegate.pop_path_component(); + delegate.push_back_tracked_path_component(entry.filename); + state.next.push_back(entry.oid.to_owned()) } - } - _non_tree => { - delegate.push_path_component(entry.filename); - if delegate.visit_nontree(&entry).cancelled() { + Cancel => { return Err(Error::Cancelled); } } + } else { + delegate.push_path_component(entry.filename); + if delegate.visit_nontree(&entry).cancelled() { + return Err(Error::Cancelled); + } } delegate.pop_path_component(); } diff --git a/gix-traverse/tests/tree/mod.rs b/gix-traverse/tests/tree/mod.rs index 50efc62fe3a..417a6bec9fb 100644 --- a/gix-traverse/tests/tree/mod.rs +++ b/gix-traverse/tests/tree/mod.rs @@ -28,68 +28,68 @@ fn breadth_first_full_path() -> crate::Result<()> { &mut recorder, )?; - use gix_object::tree::EntryMode::*; + use gix_object::tree::EntryKind::*; use gix_traverse::tree::recorder::Entry; assert_eq!( recorder.records, vec![ Entry { - mode: Blob, + mode: Blob.into(), filepath: "a".into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391") }, Entry { - mode: Blob, + mode: Blob.into(), filepath: "b".into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391") }, Entry { - mode: Blob, + mode: Blob.into(), filepath: "c".into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391") }, Entry { - mode: Tree, + mode: Tree.into(), filepath: "d".into(), oid: hex_to_id("496d6428b9cf92981dc9495211e6e1120fb6f2ba") }, Entry { - mode: Tree, + mode: Tree.into(), filepath: "e".into(), oid: hex_to_id("4277b6e69d25e5efa77c455340557b384a4c018a") }, Entry { - mode: Tree, + mode: Tree.into(), filepath: "f".into(), oid: hex_to_id("70fb16fc77b03e16acb4a5b1a6caf79ba302919a") }, Entry { - mode: Blob, + mode: Blob.into(), filepath: "d/a".into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391") }, Entry { - mode: Blob, + mode: Blob.into(), filepath: "e/b".into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391") }, Entry { - mode: Blob, + mode: Blob.into(), filepath: "f/c".into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391") }, Entry { - mode: Tree, + mode: Tree.into(), filepath: "f/d".into(), oid: hex_to_id("5805b676e247eb9a8046ad0c4d249cd2fb2513df") }, Entry { - mode: Blob, + mode: Blob.into(), filepath: "f/z".into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391") }, Entry { - mode: Blob, + mode: Blob.into(), filepath: "f/d/x".into(), oid: hex_to_id("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391") } diff --git a/gix-worktree-stream/src/lib.rs b/gix-worktree-stream/src/lib.rs index 4734044c899..8169f888d46 100644 --- a/gix-worktree-stream/src/lib.rs +++ b/gix-worktree-stream/src/lib.rs @@ -138,23 +138,24 @@ impl Stream { let content = gix_path::into_bstr(content).into_owned(); AdditionalEntry { id, - mode: gix_object::tree::EntryMode::Link, + mode: gix_object::tree::EntryKind::Link.into(), relative_path, source: entry::Source::Memory(content.into()), } } else if meta.is_dir() { AdditionalEntry { id, - mode: gix_object::tree::EntryMode::Tree, + mode: gix_object::tree::EntryKind::Tree.into(), relative_path, source: entry::Source::Null, } } else { let mode = if gix_fs::is_executable(&meta) { - gix_object::tree::EntryMode::BlobExecutable + gix_object::tree::EntryKind::BlobExecutable } else { - gix_object::tree::EntryMode::Blob - }; + gix_object::tree::EntryKind::Blob + } + .into(); AdditionalEntry { id, mode, diff --git a/gix-worktree-stream/src/protocol.rs b/gix-worktree-stream/src/protocol.rs index c7ad0286dc0..e2017d0d097 100644 --- a/gix-worktree-stream/src/protocol.rs +++ b/gix-worktree-stream/src/protocol.rs @@ -96,7 +96,7 @@ fn byte_to_hash(b: u8) -> gix_hash::Kind { } fn byte_to_mode(b: u8) -> gix_object::tree::EntryMode { - use gix_object::tree::EntryMode::*; + use gix_object::tree::EntryKind::*; match b { 0 => Tree, 1 => Blob, @@ -105,6 +105,7 @@ fn byte_to_mode(b: u8) -> gix_object::tree::EntryMode { 4 => Commit, _ => unreachable!("BUG: we control the protocol"), } + .into() } fn hash_to_byte(h: gix_hash::Kind) -> u8 { @@ -114,8 +115,8 @@ fn hash_to_byte(h: gix_hash::Kind) -> u8 { } fn mode_to_byte(m: gix_object::tree::EntryMode) -> u8 { - use gix_object::tree::EntryMode::*; - match m { + use gix_object::tree::EntryKind::*; + match m.kind() { Tree => 0, Blob => 1, BlobExecutable => 2, diff --git a/gix-worktree-stream/tests/stream.rs b/gix-worktree-stream/tests/stream.rs index d9452281757..5d4366c728b 100644 --- a/gix-worktree-stream/tests/stream.rs +++ b/gix-worktree-stream/tests/stream.rs @@ -13,8 +13,9 @@ mod from_tree { use gix_attributes::glob::pattern::Case; use gix_hash::oid; + use gix_object::bstr::ByteSlice; + use gix_object::tree::EntryKind; use gix_object::Data; - use gix_object::{bstr::ByteSlice, tree::EntryMode}; use gix_testtools::once_cell::sync::Lazy; use gix_worktree::stack::state::attributes::Source; @@ -89,7 +90,7 @@ mod from_tree { let mut stream = gix_worktree_stream::Stream::from_read(tee_read); while let Some(mut entry) = stream.next_entry().expect("entry retrieval does not fail") { - paths_and_modes.push((entry.relative_path().to_owned(), entry.mode, entry.id)); + paths_and_modes.push((entry.relative_path().to_owned(), entry.mode.kind(), entry.id)); let mut buf = Vec::new(); entry.read_to_end(&mut buf).expect("stream can always be read"); if !buf.is_empty() && entry.mode.is_blob() { @@ -112,31 +113,31 @@ mod from_tree { } let expected_exe_mode = if cfg!(windows) { - EntryMode::Blob + EntryKind::Blob } else { - EntryMode::BlobExecutable + EntryKind::BlobExecutable }; let expected_link_mode = if cfg!(windows) { - EntryMode::Blob + EntryKind::Blob } else { - EntryMode::Link + EntryKind::Link }; assert_eq!( paths_and_modes, &[ ( ".gitattributes".into(), - EntryMode::Blob, + EntryKind::Blob, hex_to_id("45c160c35c17ad264b96431cceb9793160396e99") ), ( "a".into(), - EntryMode::Blob, + EntryKind::Blob, hex_to_id("45b983be36b73c0788dc9cbcb76cbb80fc7bb057") ), ( "bigfile".into(), - EntryMode::Blob, + EntryKind::Blob, hex_to_id("4995fde49ed64e043977e22539f66a0d372dd129") ), ( @@ -150,12 +151,12 @@ mod from_tree { ), ( "dir/.gitattributes".into(), - EntryMode::Blob, + EntryKind::Blob, hex_to_id("81b9a375276405703e05be6cecf0fc1c8b8eed64") ), ( "dir/b".into(), - EntryMode::Blob, + EntryKind::Blob, hex_to_id("ab4a98190cf776b43cb0fe57cef231fb93fd07e6") ), ( @@ -165,17 +166,17 @@ mod from_tree { ), ( "dir/subdir/streamed".into(), - EntryMode::Blob, + EntryKind::Blob, hex_to_id("08991f58f4de5d85b61c0f87f3ac053c79d0e739") ), ( "extra-file".into(), - EntryMode::Blob, + EntryKind::Blob, hex_to_id("0000000000000000000000000000000000000000") ), ( "extra-bigfile".into(), - EntryMode::Blob, + EntryKind::Blob, hex_to_id("0000000000000000000000000000000000000000") ), ( @@ -185,7 +186,7 @@ mod from_tree { ), ( "extra-dir-empty".into(), - EntryMode::Tree, + EntryKind::Tree, hex_to_id("0000000000000000000000000000000000000000") ), ( @@ -206,7 +207,7 @@ mod from_tree { let mut copied_paths_and_modes = Vec::new(); let mut buf = Vec::new(); while let Some(mut entry) = copied_stream.next_entry().expect("entry retrieval does not fail") { - copied_paths_and_modes.push((entry.relative_path().to_owned(), entry.mode, entry.id)); + copied_paths_and_modes.push((entry.relative_path().to_owned(), entry.mode.kind(), entry.id)); buf.clear(); entry.read_to_end(&mut buf).expect("stream can always be read"); } diff --git a/gix/examples/init-repo-and-commit.rs b/gix/examples/init-repo-and-commit.rs index 9c811cd8350..4dbe7cd056c 100644 --- a/gix/examples/init-repo-and-commit.rs +++ b/gix/examples/init-repo-and-commit.rs @@ -30,7 +30,7 @@ fn main() -> anyhow::Result<()> { let blob_id = repo.write_blob("hello world")?.into(); let entry = tree::Entry { - mode: tree::EntryMode::Blob, + mode: tree::EntryKind::Blob.into(), oid: blob_id, filename: "hello.txt".into(), }; diff --git a/gix/examples/stats.rs b/gix/examples/stats.rs index a2aa0ba507e..b1b78542a29 100644 --- a/gix/examples/stats.rs +++ b/gix/examples/stats.rs @@ -119,8 +119,8 @@ mod visit { } fn visit_nontree(&mut self, entry: &EntryRef<'_>) -> Action { - use gix::objs::tree::EntryMode::*; - match entry.mode { + use gix::objs::tree::EntryKind::*; + match entry.mode.kind() { Commit => self.num_submodules += 1, Blob => { self.count_bytes(entry.oid); diff --git a/gix/src/object/tree/diff/tracked.rs b/gix/src/object/tree/diff/tracked.rs index 64d71e2637f..318ce295063 100644 --- a/gix/src/object/tree/diff/tracked.rs +++ b/gix/src/object/tree/diff/tracked.rs @@ -1,7 +1,7 @@ use std::ops::Range; use gix_diff::tree::visit::Change; -use gix_object::tree::EntryMode; +use gix_object::tree::{EntryKind, EntryMode}; use crate::{ bstr::BStr, @@ -29,9 +29,9 @@ impl Item { backing[self.location.clone()].as_ref() } fn entry_mode_compatible(&self, mode: EntryMode) -> bool { - use EntryMode::*; + use EntryKind::*; matches!( - (mode, self.change.entry_mode()), + (mode.kind(), self.change.entry_mode().kind()), (Blob | BlobExecutable, Blob | BlobExecutable) | (Link, Link) ) } @@ -331,7 +331,7 @@ fn find_match<'a>( stats: &mut Outcome, ) -> Result>, crate::object::tree::diff::for_each::Error> { let (item_id, item_mode) = item.change.oid_and_entry_mode(); - if needs_exact_match(percentage) || item_mode == gix_object::tree::EntryMode::Link { + if needs_exact_match(percentage) || item_mode.is_link() { let first_idx = items.partition_point(|a| a.change.oid() < item_id); let range = match items.get(first_idx..).map(|items| { let end = items diff --git a/gix/src/object/tree/iter.rs b/gix/src/object/tree/iter.rs index 848d9eeabd7..cc9c4bd2890 100644 --- a/gix/src/object/tree/iter.rs +++ b/gix/src/object/tree/iter.rs @@ -51,7 +51,7 @@ impl<'repo, 'a> std::fmt::Display for EntryRef<'repo, 'a> { write!( f, "{:06o} {:>6} {}\t{}", - self.mode() as u32, + *self.mode(), self.mode().as_str(), self.id().shorten_or_id(), self.filename() diff --git a/gix/src/object/tree/mod.rs b/gix/src/object/tree/mod.rs index 75c2d9a9825..0173e770e51 100644 --- a/gix/src/object/tree/mod.rs +++ b/gix/src/object/tree/mod.rs @@ -1,6 +1,6 @@ use gix_hash::ObjectId; use gix_macros::momo; -pub use gix_object::tree::EntryMode; +pub use gix_object::tree::{EntryKind, EntryMode}; use gix_object::FindExt; use gix_object::{bstr::BStr, TreeRefIter}; diff --git a/gix/src/submodule/mod.rs b/gix/src/submodule/mod.rs index 14a054e8b49..fcfffd26f16 100644 --- a/gix/src/submodule/mod.rs +++ b/gix/src/submodule/mod.rs @@ -181,7 +181,7 @@ impl<'repo> Submodule<'repo> { .head_commit()? .tree()? .peel_to_entry_by_path(gix_path::from_bstr(path.as_ref()))? - .and_then(|entry| (entry.mode() == gix_object::tree::EntryMode::Commit).then_some(entry.inner.oid))) + .and_then(|entry| (entry.mode().is_commit()).then_some(entry.inner.oid))) } /// Return the path at which the repository of the submodule should be located. diff --git a/gix/tests/object/tree/diff.rs b/gix/tests/object/tree/diff.rs index 8a4e6836ab9..75a6549d8ea 100644 --- a/gix/tests/object/tree/diff.rs +++ b/gix/tests/object/tree/diff.rs @@ -4,7 +4,8 @@ use gix::{ bstr::BString, object::{blob::diff::line::Change, tree::diff::change::Event}, }; -use gix_object::{bstr::ByteSlice, tree::EntryMode}; +use gix_object::bstr::ByteSlice; +use gix_object::tree::EntryKind; use crate::named_repo; @@ -23,8 +24,8 @@ fn changes_against_tree_modified() -> crate::Result { entry_mode, id, } => { - assert_eq!(previous_entry_mode, EntryMode::Blob); - assert_eq!(entry_mode, EntryMode::Blob); + assert_eq!(previous_entry_mode.kind(), EntryKind::Blob); + assert_eq!(entry_mode.kind(), EntryKind::Blob); assert_eq!(previous_id.object().unwrap().data.as_bstr(), "a\n"); assert_eq!(id.object().unwrap().data.as_bstr(), "a\na1\n"); }