6 files changed, 45 insertions, 14 deletions

diff --git a/src/repo/git/checkout.rs b/src/repo/git/checkout.rs
index 418a0af..a36b152 100644
--- a/src/repo/git/checkout.rs
+++ b/src/repo/git/checkout.rs
@@ -13,7 +13,7 @@ impl Repo {
     #[tracing::instrument(level = "trace", skip(progress))]
     pub fn checkout(
         &self,
-        remote: remote::Name,
+        remote: &remote::Name,
         head: Id,
         progress: &mut dyn progress::DynNestedProgress,
     ) -> Result<(), RepoError> {
diff --git a/src/repo/git/ffmerge.rs b/src/repo/git/ffmerge.rs
new file mode 100644
index 0000000..382718b
--- /dev/null
+++ b/src/repo/git/ffmerge.rs
@@ -0,0 +1,17 @@
+use super::{Repo, RepoError};
+
+use anyhow::Context;
+use gix::{
+    clone::checkout::main_worktree::ProgressId, interrupt::IS_INTERRUPTED, progress, remote, Id,
+    Progress,
+};
+
+use gix_index::{File, State};
+use tracing::debug;
+
+impl Repo {
+    pub fn ffmerge(&self, a: Id, b: Id) -> Result<(), RepoError> {
+
+        Ok(())
+    }
+}
diff --git a/src/repo/git/mod.rs b/src/repo/git/mod.rs
index 7370ee8..7513ca5 100644
--- a/src/repo/git/mod.rs
+++ b/src/repo/git/mod.rs
@@ -9,8 +9,10 @@ use gix::{
     },
     remote, Id, ObjectId, Remote,
 };
+use tracing::debug;
 
 mod checkout;
+mod ffmerge;
 mod fetch;
 
 impl Repo {
@@ -52,8 +54,11 @@ impl Repo {
             .find_reference(&format!("remotes/{}/HEAD", remote_name.as_bstr()))
             .context("the remotes HEAD references does not exist")?;
 
+        debug!("got ref to origin: {:?}", origin_ref);
+
         if let Some(origin_ref) = origin_ref.target().try_name() {
-            Ok(origin_ref.shorten().to_owned())
+            let shortened = origin_ref.shorten().to_owned();
+            Ok(shortened.split(|x| *x == b'/').last().unwrap().into())
         } else {
             Err(RepoError::NoDefaultBranch)
         }
@@ -77,19 +82,23 @@ impl Repo {
 
     pub fn update_default_branch_ref(
         &self,
-        remote: remote::Name,
+        remote: &remote::Name,
         head: Id,
     ) -> Result<(), RepoError> {
         let default_branch = self.default_branch()?;
+        debug!("default branch: {:?}", default_branch);
+
         let repo = self.repo()?;
 
-        repo.edit_reference(Repo::refedit(
+        let edits = repo.edit_reference(Repo::refedit(
             head.into(),
-            &format!("heads/{}", default_branch),
+            &format!("refs/heads/{}", default_branch),
             &format!("checkout: {}/HEAD with gtree", remote.as_bstr()),
         ))
         .context("checkout: failed to edit ref")?;
 
+        debug!("ref edits: {:?}", edits);
+
         Ok(())
     }
 
diff --git a/src/repo/mod.rs b/src/repo/mod.rs
index 60fb34d..538bf31 100644
--- a/src/repo/mod.rs
+++ b/src/repo/mod.rs
@@ -8,8 +8,8 @@ use tracing::error;
 use crate::forge::Project;
 
 mod aggregate;
-mod git;
 mod repostate;
+mod git;
 
 pub use aggregate::*;
 pub use repostate::*;
diff --git a/src/sync/mod.rs b/src/sync/mod.rs
index a1dab53..1d2c2ca 100644
--- a/src/sync/mod.rs
+++ b/src/sync/mod.rs
@@ -22,12 +22,12 @@ impl Repo {
     pub fn sync(&mut self) -> Result<SyncResult, SyncResult> {
         let repo_name = self.name.clone();
 
-        let repo_state = self
-            .is_clean()
-            .map_err(|err| SyncResult::err(repo_name.clone(), err))?;
-        if self.repo.is_some() && repo_state != LocalRepoState::Clean {
-            return Ok(SyncResult::dirty(repo_name, repo_state));
-        };
+        // let repo_state = self
+        //     .is_clean()
+        //     .map_err(|err| SyncResult::err(repo_name.clone(), err))?;
+        // if self.repo.is_some() && repo_state != LocalRepoState::Clean {
+        //     return Ok(SyncResult::dirty(repo_name, repo_state));
+        // };
 
         if self.repo.is_some() && self.forge.is_some() {
             Ok(SyncResult::no_changes(repo_name))
diff --git a/src/update/mod.rs b/src/update/mod.rs
index 7b51136..e3cd36a 100644
--- a/src/update/mod.rs
+++ b/src/update/mod.rs
@@ -45,8 +45,13 @@ impl Repo {
 
         let _fetched = self.fetch()?;
         let (remote, head) = self.default_remote_head()?;
-        self.update_default_branch_ref(remote.clone(), head)?;
-        self.checkout(remote, head, &mut progress)?;
+        debug!("default remote and head: {:?} {:?}", remote, head);
+        // TODO do not update if there are unpushed commits
+        self.update_default_branch_ref(&remote, head)?;
+        debug!("updated default branch reference");
+        // TODO check out only if the default branch is currently checked out
+        self.checkout(&remote, head, &mut progress)?;
+        debug!("finished checkout");
 
         // let merged = repo.branches(Some(BranchType::Local))?
         //         .filter_map(|x| x.ok())