Merge branch 'index-information'

git-bitmap/src/ewah.rs

@@ -119,6 +119,6 @@ mod access {
 pub struct Vec {
     num_bits: u32,
     bits: std::vec::Vec<u64>,
-    /// RLW is an offset into the `bits` buffer, so `1` translates into &bits[1] essentially.
+    /// RLW is an offset into the `bits` buffer, so `1` translates into &bits\[1] essentially.
     rlw: usize,
 }

git-hash/src/lib.rs

@@ -96,6 +96,14 @@ impl FromStr for Kind {
     }
 }
 
+impl std::fmt::Display for Kind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Kind::Sha1 => f.write_str("SHA1"),
+        }
+    }
+}
+
 impl Kind {
     /// Returns the shortest hash we support
     #[inline]

git-index/Cargo.toml

@@ -22,7 +22,7 @@ path = "tests/index-single-threaded.rs"
 required-features = ["internal-testing-to-avoid-being-run-by-cargo-test-all"]
 
 [features]
-serde1 = ["serde"]
+serde1 = ["serde", "smallvec/serde", "git-hash/serde1"]
 
 internal-testing-git-features-parallel = ["git-features/parallel"]
 internal-testing-to-avoid-being-run-by-cargo-test-all = []

git-index/src/entry.rs

@@ -61,6 +61,7 @@ pub(crate) mod at_rest {
 bitflags! {
     /// In-memory flags
     pub struct Flags: u32 {
+        const STAGE_MASK = 0x3000;
         // TODO: could we use the pathlen ourselves to save 8 bytes? And how to handle longer paths than that? 0 as sentinel maybe?
         const PATH_LEN = 0x0fff;
         const UPDATE = 1 << 16;
@@ -88,11 +89,21 @@ bitflags! {
     }
 }
 
+impl Flags {
+    pub fn stage(&self) -> u32 {
+        (*self & Flags::STAGE_MASK).bits >> 12
+    }
+}
+
+#[derive(PartialEq, Eq, Hash, Ord, PartialOrd, Clone, Copy)]
+#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
 pub struct Time {
     pub secs: u32,
     pub nsecs: u32,
 }
 
+#[derive(PartialEq, Eq, Hash, Ord, PartialOrd, Clone, Copy)]
+#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
 pub struct Stat {
     pub mtime: Time,
     pub ctime: Time,

git-index/src/extension/fs_monitor.rs

@@ -0,0 +1,37 @@
+use bstr::BString;
+
+use crate::{
+    extension::{FsMonitor, Signature},
+    util::{read_u32, read_u64, split_at_byte_exclusive},
+};
+
+pub enum Token {
+    V1 { nanos_since_1970: u64 },
+    V2 { token: BString },
+}
+
+pub const SIGNATURE: Signature = *b"FSMN";
+
+pub fn decode(data: &[u8]) -> Option<FsMonitor> {
+    let (version, data) = read_u32(data)?;
+    let (token, data) = match version {
+        1 => {
+            let (nanos_since_1970, data) = read_u64(data)?;
+            (Token::V1 { nanos_since_1970 }, data)
+        }
+        2 => {
+            let (token, data) = split_at_byte_exclusive(data, 0)?;
+            (Token::V2 { token: token.into() }, data)
+        }
+        _ => return None,
+    };
+
+    let (ewah_size, data) = read_u32(data)?;
+    let (entry_dirty, data) = git_bitmap::ewah::decode(&data[..ewah_size as usize]).ok()?;
+
+    if !data.is_empty() {
+        return None;
+    }
+
+    FsMonitor { token, entry_dirty }.into()
+}

git-index/src/extension/mod.rs

@@ -15,10 +15,10 @@ pub struct Iter<'a> {
 /// It allows to more quickly build trees by avoiding as it can quickly re-use portions of the index and its associated tree ids
 /// if there was no change to them. Portions of this tree are invalidated as the index is changed.
 pub struct Tree {
-    name: SmallVec<[u8; 23]>,
+    pub name: SmallVec<[u8; 23]>,
     /// Only set if there are any entries in the index we are associated with.
-    id: Option<tree::NodeId>,
-    children: Vec<Tree>,
+    pub id: Option<tree::NodeId>,
+    pub children: Vec<Tree>,
 }
 
 pub struct Link {
@@ -50,45 +50,7 @@ pub struct FsMonitor {
 
 mod iter;
 
-pub(crate) mod fs_monitor {
-    use bstr::BString;
-
-    use crate::{
-        extension::{FsMonitor, Signature},
-        util::{read_u32, read_u64, split_at_byte_exclusive},
-    };
-
-    pub enum Token {
-        V1 { nanos_since_1970: u64 },
-        V2 { token: BString },
-    }
-
-    pub const SIGNATURE: Signature = *b"FSMN";
-
-    pub fn decode(data: &[u8]) -> Option<FsMonitor> {
-        let (version, data) = read_u32(data)?;
-        let (token, data) = match version {
-            1 => {
-                let (nanos_since_1970, data) = read_u64(data)?;
-                (Token::V1 { nanos_since_1970 }, data)
-            }
-            2 => {
-                let (token, data) = split_at_byte_exclusive(data, 0)?;
-                (Token::V2 { token: token.into() }, data)
-            }
-            _ => return None,
-        };
-
-        let (ewah_size, data) = read_u32(data)?;
-        let (entry_dirty, data) = git_bitmap::ewah::decode(&data[..ewah_size as usize]).ok()?;
-
-        if !data.is_empty() {
-            return None;
-        }
-
-        FsMonitor { token, entry_dirty }.into()
-    }
-}
+pub(crate) mod fs_monitor;
 
 pub(crate) mod decode;
 

git-index/src/extension/tree.rs

@@ -9,9 +9,9 @@ pub const SIGNATURE: Signature = *b"TREE";
 
 pub struct NodeId {
     /// The id of the directory tree of the associated tree object.
-    id: git_hash::ObjectId,
+    pub id: git_hash::ObjectId,
     /// The amount of non-tree entries contained within, and definitely not zero.
-    entry_count: u32,
+    pub entry_count: u32,
 }
 
 /// A recursive data structure

git-index/src/lib.rs

@@ -7,12 +7,12 @@ use filetime::FileTime;
 
 pub mod file;
 
-pub(crate) mod extension;
+pub mod extension;
 
 pub mod entry;
 
 mod access {
-    use crate::{Entry, State, Version};
+    use crate::{extension, Entry, State, Version};
 
     impl State {
         pub fn version(&self) -> Version {
@@ -22,6 +22,21 @@ mod access {
         pub fn entries(&self) -> &[Entry] {
             &self.entries
         }
+        pub fn tree(&self) -> Option<&extension::Tree> {
+            self.tree.as_ref()
+        }
+        pub fn link(&self) -> Option<&extension::Link> {
+            self.link.as_ref()
+        }
+        pub fn resolve_undo(&self) -> Option<&extension::resolve_undo::Paths> {
+            self.resolve_undo.as_ref()
+        }
+        pub fn untracked(&self) -> Option<&extension::UntrackedCache> {
+            self.untracked.as_ref()
+        }
+        pub fn fs_monitor(&self) -> Option<&extension::FsMonitor> {
+            self.fs_monitor.as_ref()
+        }
     }
 }
 

git-repository/Cargo.toml

@@ -14,8 +14,8 @@ test = true
 
 [features]
 default = ["max-performance", "one-stop-shop"]
-unstable = []
-serde1 = ["git-pack/serde1", "git-object/serde1", "git-protocol/serde1", "git-transport/serde1", "git-ref/serde1", "git-odb/serde1"]
+unstable = ["git-index"]
+serde1 = ["git-pack/serde1", "git-object/serde1", "git-protocol/serde1", "git-transport/serde1", "git-ref/serde1", "git-odb/serde1", "git-index/serde1"]
 # enable when https://github.com/RustCrypto/asm-hashes/issues/17 is fixed
 # max-performance = ["git-features/parallel", "git-features/zlib-ng-compat", "git-features/fast-sha1"]
 max-performance = ["git-features/parallel", "git-features/zlib-ng-compat", "git-pack/pack-cache-lru-static", "git-pack/pack-cache-lru-dynamic"]
@@ -54,6 +54,9 @@ git-transport = { version = "^0.15.0", path = "../git-transport", optional = tru
 git-diff = { version = "^0.13.0", path = "../git-diff", optional = true }
 git-features = { version = "^0.19.1", path = "../git-features", features = ["progress"] }
 
+# unstable only
+git-index = { version ="^0.1.0", path = "../git-index", optional = true }
+
 signal-hook = { version = "0.3.9", default-features = false }
 thiserror = "1.0.26"
 clru = "0.5.0"

git-repository/src/lib.rs

@@ -86,6 +86,7 @@
 //! * [`url`]
 //! * [`actor`]
 //! * [`bstr`][bstr]
+//! * [`index`]
 //! * [`objs`]
 //! * [`odb`]
 //!   * [`pack`][odb::pack]
@@ -118,6 +119,8 @@ pub use git_features::{parallel, progress, progress::Progress, threading};
 pub use git_hash as hash;
 #[doc(inline)]
 pub use git_hash::{oid, ObjectId};
+#[cfg(all(feature = "unstable", feature = "git-index"))]
+pub use git_index as index;
 pub use git_lock as lock;
 pub use git_object as objs;
 pub use git_object::bstr;

gitoxide-core/src/index/entries.rs

@@ -0,0 +1,63 @@
+use git_repository as git;
+
+#[cfg(feature = "serde1")]
+pub(crate) fn to_json(
+    mut out: &mut impl std::io::Write,
+    file: &git::index::File,
+    entry: &git::index::Entry,
+    is_last: bool,
+) -> anyhow::Result<()> {
+    use git_repository::bstr::ByteSlice;
+
+    #[cfg_attr(feature = "serde1", derive(serde::Serialize))]
+    struct Entry<'a> {
+        stat: &'a git::index::entry::Stat,
+        hex_id: String,
+        flags: u32,
+        mode: u32,
+        path: std::borrow::Cow<'a, str>,
+    }
+
+    serde_json::to_writer(
+        &mut out,
+        &Entry {
+            stat: &entry.stat,
+            hex_id: entry.id.to_hex().to_string(),
+            flags: entry.flags.bits(),
+            mode: entry.mode.bits(),
+            path: entry.path(&file.state).to_str_lossy(),
+        },
+    )?;
+
+    if is_last {
+        out.write_all(b"\n")?;
+    } else {
+        out.write_all(b",\n")?;
+    }
+    Ok(())
+}
+
+pub(crate) fn to_human(
+    out: &mut impl std::io::Write,
+    file: &git::index::File,
+    entry: &git::index::Entry,
+) -> std::io::Result<()> {
+    writeln!(
+        out,
+        "{} {}{:?} {} {}",
+        match entry.flags.stage() {
+            0 => "BASE   ",
+            1 => "OURS   ",
+            2 => "THEIRS ",
+            _ => "UNKNOWN",
+        },
+        if entry.flags.is_empty() {
+            "".to_string()
+        } else {
+            format!("{:?} ", entry.flags)
+        },
+        entry.mode,
+        entry.id,
+        entry.path(&file.state)
+    )
+}