first stab at basic index file parsing (#293)

Sebastian Thiel committed 4 years ago

Commit 826ca0c1 parent 494ed466 files · +74 −14Browse files

Showing the changes to git-index/src (2 of 6 files). Show all

Unified · Split

2 files

git-index/src/file.rs +40 −8
git-index/src/lib.rs +25 −5

@@ -1,8 +1,8 @@
1	pub mod init {	1	pub mod init {
2	#![allow(unused)]	2	#![allow(unused)]
3	use crate::File;	3	use crate::{File, State};
4	use memmap2::Mmap;	4	use memmap2::Mmap;
5	use std::path::Path;	5	use std::path::{Path, PathBuf};
6		6
7	mod error {	7	mod error {
8	use quick_error::quick_error;	8	use quick_error::quick_error;
@@ -11,7 +11,7 @@ pub mod init { · 2 unmodified lines
11	#[derive(Debug)]	11	#[derive(Debug)]
12	pub enum Error {	12	pub enum Error {
13	Io(err: std::io::Error) {	13	Io(err: std::io::Error) {
14	display("An IO error occurred while reading the index")	14	display("An IO error occurred while opening the index")
15	source(err)	15	source(err)
16	from()	16	from()
17	}	17	}
@@ -21,12 +21,44 @@ pub mod init { · 3 unmodified lines
21	pub use error::Error;	21	pub use error::Error;
22		22
23	impl File {	23	impl File {
24	pub fn at(path: impl AsRef<Path>, object_hash: git_hash::Kind) -> Result<Self, Error> {	24	pub fn at(path: impl Into<PathBuf>, object_hash: git_hash::Kind) -> Result<Self, Error> {
25	// SAFETY: we have to take the risk of somebody changing the file underneath. Git never writes into the same file.	25	let path = path.into();
26	#[allow(unsafe_code)]	26	let (data, mtime) = {
27	let data = unsafe { Mmap::map(&std::fs::File::open(path)?)? };	27	// SAFETY: we have to take the risk of somebody changing the file underneath. Git never writes into the same file.
		28	let file = std::fs::File::open(&path)?;
		29	#[allow(unsafe_code)]
		30	let data = unsafe { Mmap::map(&file)? };
		31	(data, filetime::FileTime::from_last_modification_time(&file.metadata()?))
		32	};
28		33
29	todo!("read file")	34	Ok(File {
		35	state: State { timestamp: mtime },
		36	path,
		37	})
30	}	38	}
31	}	39	}
32	}	40	}
		41
		42	pub mod decode {
		43	pub mod header {
		44	mod error {
		45	use quick_error::quick_error;
		46
		47	quick_error! {
		48	#[derive(Debug)]
		49	pub enum Error {
		50	Io(err: std::io::Error) {
		51	display("An IO error occurred while opening the index")
		52	source(err)
		53	from()
		54	}
		55	}
		56	}
		57	}
		58	pub use error::Error;
		59	}
		60
		61	fn header(data: &[u8]) -> Result<(crate::Version, &[u8]), header::Error> {
		62	todo!("header parsing")
		63	}
		64	}

git-index/src/lib.rs+25−5

 #![deny(unsafe_code, missing_docs, rust_2018_idioms)]
-#![allow(missing_docs)]
+#![allow(missing_docs, unused)]
+use filetime::FileTime;
 use std::path::PathBuf;
 pub mod file;
 pub mod init {
     use crate::State;
+    use filetime::FileTime;
     impl State {
         /// Returns an empty state.
-        /// TODO: figure out if it needs to know some configuration
+        /// TODO: figure out if it needs to know some configuration, and if this would actually be used somewhere
-        pub fn new() -> Self {
+        fn new() -> Self {
-            State
+            State {
+                timestamp: FileTime::from_system_time(std::time::SystemTime::UNIX_EPOCH),
+            }
         }
     }
     }
 }
+/// All known versions of a git index file.
+#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
+#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
+#[allow(missing_docs)]
+pub enum Version {
+    V2 = 2,
+    V3 = 3,
+    V4 = 4,
+}
 /// An index file whose state was read from a file on disk.
 pub struct File {
     pub state: State,
 ///
 /// As opposed to a snapshot, it's meant to be altered and eventually be written back to disk or converted into a tree.
 /// We treat index and its state synonymous.
-pub struct State;
+pub struct State {
+    /// The time at which the state was created, indicating its freshness compared to other files on disk.
+    ///
+    /// Note that on platforms that only have a precisions of a second for this time, we will treat all entries with the
+    /// same timestamp as this as potentially changed, checking more thoroughly if a change actually happened.
+    timestamp: FileTime,
+}