Adding raw git repository utilitiesHEADmaster

4 files changed, 64 insertions, 14 deletions

diff --git a/supergit/src/bin/test.rs b/supergit/src/bin/test.rs
new file mode 100644
index 0000000..166047e
--- /dev/null
+++ b/supergit/src/bin/test.rs
@@ -0,0 +1,16 @@
+//! A test binary to use during development
+
+use supergit::raw::RawRepository;
+
+fn main() {
+    let path = match std::env::args().nth(1) {
+        Some(p) => p,
+        None => {
+            eprintln!("USAGE: supergit-test <path>");
+            std::process::exit(2);
+        }
+    };
+    
+    let rr = RawRepository::open(path.as_str()).unwrap();
+    
+}
diff --git a/supergit/src/lib.rs b/supergit/src/lib.rs
index e209fac..887ccc0 100644
--- a/supergit/src/lib.rs
+++ b/supergit/src/lib.rs
@@ -1,5 +1,13 @@
 //! Strongly typed git repository explorer library
 //!
+//! This library exposes a read-only view into a git repository.  To
+//! get started, open an existing bare repo, and then call `sync()` to
+//! build a cache of it.  Every time you want your view of the repo to
+//! update, call `sync()` again.  If you want the sync operation to be
+//! blocking, call `sync_blocking()` instead.
+//!
+//! 
+
 
 mod branch;
 pub use branch::{Branch, BranchCommit};
@@ -10,15 +18,20 @@ pub use commit::{CommitId, Commit};
 mod diff;
 pub use diff::Diff;
 
-pub(crate) mod raw;
+pub mod raw;
 
 use std::sync::atomic::{AtomicUsize, Ordering};
+use async_std::sync::{Arc, RwLock};
+
+use raw::RawRepository;
 
 /// Represents a git repository with lazy data loading
-pub struct Repository {}
+pub struct Repository {
+    raw: RawRepository,
+}
 
 impl Repository {
-    pub fn open(path: &std::path::Path) -> Self {
+    pub fn open(path: &std::path::Path) -> Arc<Self> {
         todo!()
     }
     
diff --git a/supergit/src/raw/branch_walk.rs b/supergit/src/raw/branch_walk.rs
index dfc7485..d4232c4 100644
--- a/supergit/src/raw/branch_walk.rs
+++ b/supergit/src/raw/branch_walk.rs
@@ -1 +1,19 @@
 //! Walk along a branch parsing commit metadata
+
+use std::collections::{BTreeMap, BTreeSet};
+
+pub struct CommitHistory {
+    /// The correct order of commit IDs
+    order: Vec<String>,
+    /// Map of commit IDs to commit metadata
+    meta: BTreeMap<String, CommitNode>,
+}
+
+pub struct CommitNode {
+    id: String,
+    author: String,
+    commiter: String,
+    message: String,
+    touches: BTreeSet<String>,
+    time: u64,
+}
diff --git a/supergit/src/raw/mod.rs b/supergit/src/raw/mod.rs
index 98602ca..7bf6c0a 100644
--- a/supergit/src/raw/mod.rs
+++ b/supergit/src/raw/mod.rs
@@ -3,13 +3,14 @@
 mod branch_walk;
 mod tree_walk;
 
+use crate::{Branch, BranchCommit};
 use git2::{self, Repository};
 
-pub(crate) type RawResult<T> = Result<T, RawError>;
+pub type RawResult<T> = Result<T, RawError>;
 
 /// An error abstraction for raw git operations
 #[derive(Debug)]
-pub(crate) enum RawError {
+pub enum RawError {
     AllBad,
 }
 
@@ -19,24 +20,26 @@ impl From<git2::Error> for RawError {
     }
 }
 
+/// Represent a raw branch
+pub struct RawBranch {
+    name: String,
+    head: String,
+}
+
 /// Wrap a libgit2 repository to provide an API fascade
-pub(crate) struct RawRepository {
+pub struct RawRepository {
     inner: Repository,
 }
 
 impl RawRepository {
-    pub(crate) fn open(path: &str) -> RawResult<Self> {
+    pub fn open(path: &str) -> RawResult<Self> {
         Ok(Self {
             inner: Repository::open(path)?,
         })
     }
 
-    /// Sync the backing storage with the backing git repo
-    ///
-    /// This function can be invoked manually, but should be invoked
-    /// basically every time your program expects changes to have
-    /// happened.  Polling this function is not recommended.
-    pub(crate) fn update(&self) -> RawResult<()> {
-        Ok(())
+    /// Parse branch data from repository
+    pub fn parse_branches(&self) -> RawResult<Vec<RawBranch>> {
+        todo!()
     }
 }