fix: EntryMode canonicalization (#1259)

This means that `mode.kind()` and `mode.is_*` will also work correctly
if the underlying mode wasn't canonicalized, which could happen when
looking at trees that were stored with very old versions of Git.

Author: Byron

gix-object/src/tree/mod.rs

@@ -72,46 +72,50 @@ impl std::ops::Deref for EntryMode {
     }
 }
 
+const IFMT: u16 = 0o170000;
+
 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
-                }
+        let etype = self.0 & IFMT;
+        if etype == 0o100000 {
+            if self.0 & 0o000100 == 0o000100 {
+                EntryKind::BlobExecutable
+            } else {
+                EntryKind::Blob
             }
+        } else if etype == EntryKind::Link as u16 {
+            EntryKind::Link
+        } else if etype == EntryKind::Tree as u16 {
+            EntryKind::Tree
+        } else {
+            EntryKind::Commit
         }
     }
 
     /// Return true if this entry mode represents a Tree/directory
     pub const fn is_tree(&self) -> bool {
-        self.0 == EntryKind::Tree as u16
+        self.0 & IFMT == 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
+        self.0 & IFMT == 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
+        self.0 & IFMT == EntryKind::Link as u16
     }
 
     /// Return true if this entry mode represents anything BUT Tree/directory
     pub const fn is_no_tree(&self) -> bool {
-        self.0 != EntryKind::Tree as u16
+        self.0 & IFMT != EntryKind::Tree as u16
     }
 
     /// Return true if the entry is any kind of blob.
     pub const fn is_blob(&self) -> bool {
-        matches!(self.kind(), EntryKind::Blob | EntryKind::BlobExecutable)
+        self.0 & IFMT == 0o100000
     }
 
     /// Return true if the entry is an executable blob.

gix-object/tests/tree/mod.rs

@@ -213,6 +213,25 @@ mod entry_mode {
         );
     }
 
+    #[test]
+    fn is_methods() {
+        fn mode(kind: EntryKind) -> EntryMode {
+            kind.into()
+        }
+
+        assert!(mode(EntryKind::Blob).is_blob());
+        assert!(!mode(EntryKind::Blob).is_link());
+        assert!(mode(EntryKind::BlobExecutable).is_blob());
+        assert!(mode(EntryKind::Blob).is_blob_or_symlink());
+        assert!(mode(EntryKind::BlobExecutable).is_blob_or_symlink());
+
+        assert!(!mode(EntryKind::Link).is_blob());
+        assert!(mode(EntryKind::Link).is_link());
+        assert!(mode(EntryKind::Link).is_blob_or_symlink());
+        assert!(mode(EntryKind::Tree).is_tree());
+        assert!(mode(EntryKind::Commit).is_commit());
+    }
+
     #[test]
     fn as_bytes() {
         let mut buf = Default::default();