Update pijul

Author: fossdd

libpijul/src/apply.rs

@@ -173,10 +173,16 @@ pub fn apply_change_ws<T: MutTxnT, P: ChangeStore>(
         internal
     };
     debug!("internal = {:?}", internal);
-    Ok(
-        apply_change_to_channel(txn, channel, internal, &hash, &change, workspace)
-            .map_err(ApplyError::LocalChange)?,
+    Ok(apply_change_to_channel(
+        txn,
+        channel,
+        &mut |h| changes.knows(h, hash).unwrap(),
+        internal,
+        &hash,
+        &change,
+        workspace,
     )
+    .map_err(ApplyError::LocalChange)?)
 }
 
 pub fn apply_change_rec_ws<T: TxnT + MutTxnT, P: ChangeStore>(
@@ -230,8 +236,16 @@ pub fn apply_change_rec_ws<T: TxnT + MutTxnT, P: ChangeStore>(
                 };
                 debug!("internal = {:?}", internal);
                 workspace.clear();
-                apply_change_to_channel(txn, channel, internal, &hash, &change, workspace)
-                    .map_err(ApplyError::LocalChange)?;
+                apply_change_to_channel(
+                    txn,
+                    channel,
+                    &mut |h| changes.knows(h, &hash).unwrap(),
+                    internal,
+                    &hash,
+                    &change,
+                    workspace,
+                )
+                .map_err(ApplyError::LocalChange)?;
             }
         }
     }
@@ -282,9 +296,10 @@ pub fn apply_change_rec<T: MutTxnT, P: ChangeStore>(
     )
 }
 
-fn apply_change_to_channel<T: ChannelMutTxnT + TreeTxnT>(
+fn apply_change_to_channel<T: ChannelMutTxnT + TreeTxnT, F: FnMut(&Hash) -> bool>(
     txn: &mut T,
     channel: &mut T::Channel,
+    changes: &mut F,
     change_id: ChangeId,
     hash: &Hash,
     change: &Change,
@@ -305,9 +320,15 @@ fn apply_change_to_channel<T: ChannelMutTxnT + TreeTxnT>(
         debug!("Applying {:?} (1)", change_);
         for change_ in change_.iter() {
             match *change_ {
-                Atom::NewVertex(ref n) => {
-                    put_newvertex(txn, T::graph_mut(channel), change, ws, change_id, n)?
-                }
+                Atom::NewVertex(ref n) => put_newvertex(
+                    txn,
+                    T::graph_mut(channel),
+                    changes,
+                    change,
+                    ws,
+                    change_id,
+                    n,
+                )?,
                 Atom::EdgeMap(ref n) => {
                     for edge in n.edges.iter() {
                         if !edge.flag.contains(EdgeFlags::DELETED) {
@@ -400,7 +421,15 @@ pub fn apply_local_change_ws<
     }
 
     register_change(txn, &internal, hash, &change)?;
-    let n = apply_change_to_channel(txn, &mut channel, internal, &hash, &change, workspace)?;
+    let n = apply_change_to_channel(
+        txn,
+        &mut channel,
+        &mut |_| true,
+        internal,
+        &hash,
+        &change,
+        workspace,
+    )?;
     for (_, update) in inode_updates.iter() {
         info!("updating {:?}", update);
         update_inode(txn, &channel, internal, update)?;

libpijul/src/apply/edge.rs

@@ -83,6 +83,7 @@ where
         if apply_check(source, target) {
             put_graph_with_rev(txn, graph, n.flag, source, target, change)?;
             for intro in zombies.drain(..) {
+                debug!("putting zombie {:?} {:?} {:?}", source, target, intro);
                 assert!(!n.flag.contains(EdgeFlags::FOLDER));
                 put_graph_with_rev(txn, graph, EdgeFlags::DELETED, source, target, intro)?;
             }
@@ -142,6 +143,7 @@ where
         for v in iter_deleted_parents(txn, graph, target)? {
             let v = v?;
             let intro = v.introduced_by();
+            debug!("known {:?} ?", intro);
             if !known(&txn.get_external(&intro)?.unwrap().into()) {
                 zombies.push(intro)
             }

libpijul/src/apply/vertex.rs

@@ -3,9 +3,10 @@ use crate::change::{Change, NewVertex};
 use crate::pristine::*;
 use crate::{ChangeId, EdgeFlags, Hash, Vertex};
 
-pub fn put_newvertex<T: GraphMutTxnT + TreeTxnT>(
+pub fn put_newvertex<T: GraphMutTxnT + TreeTxnT, F: FnMut(&Hash) -> bool>(
     txn: &mut T,
     graph: &mut T::Graph,
+    changes: &mut F,
     ch: &Change,
     ws: &mut Workspace,
     change: ChangeId,
@@ -29,7 +30,7 @@ pub fn put_newvertex<T: GraphMutTxnT + TreeTxnT>(
     assert!(ws.deleted_by.is_empty());
     for up in n.up_context.iter() {
         let up = internal_pos(txn, up, change)?;
-        if put_up_context(txn, graph, ch, ws, up)? && n.flag.contains(EdgeFlags::FOLDER) {
+        if put_up_context(txn, graph, changes, ws, up)? && n.flag.contains(EdgeFlags::FOLDER) {
             return Err(LocalApplyError::InvalidChange);
         }
     }
@@ -70,10 +71,10 @@ pub fn put_newvertex<T: GraphMutTxnT + TreeTxnT>(
     Ok(())
 }
 
-fn put_up_context<T: GraphMutTxnT + TreeTxnT>(
+fn put_up_context<T: GraphMutTxnT + TreeTxnT, F: FnMut(&Hash) -> bool>(
     txn: &mut T,
     graph: &mut T::Graph,
-    ch: &Change,
+    knows: &mut F,
     ws: &mut Workspace,
     up: Position<ChangeId>,
 ) -> Result<bool, LocalApplyError<T>> {
@@ -110,7 +111,7 @@ fn put_up_context<T: GraphMutTxnT + TreeTxnT>(
             .contains(EdgeFlags::PARENT | EdgeFlags::DELETED | EdgeFlags::BLOCK)
         {
             let introduced_by = txn.get_external(&parent.introduced_by())?.unwrap().into();
-            if !ch.knows(&introduced_by) {
+            if !knows(&introduced_by) {
                 ws.deleted_by.insert(parent.introduced_by());
             }
         }

libpijul/src/unrecord/mod.rs

@@ -177,7 +177,6 @@ fn unapply<
                 T::graph_mut(channel),
                 change_id,
                 newedges,
-                change,
                 &mut ws,
             )?,
             Atom::NewVertex(ref newvertex) => {
@@ -389,7 +388,6 @@ fn unapply_edges<T: GraphMutTxnT + TreeTxnT, P: ChangeStore>(
     channel: &mut T::Graph,
     change_id: ChangeId,
     newedges: &EdgeMap<Option<Hash>>,
-    change: &Change,
     ws: &mut Workspace,
 ) -> Result<(), UnrecordError<P::Error, T>> {
     debug!("newedges = {:#?}", newedges);
@@ -433,6 +431,7 @@ fn unapply_edges<T: GraphMutTxnT + TreeTxnT, P: ChangeStore>(
         }
     }
     let reintro = std::mem::take(&mut ws.must_reintroduce);
+    let hash: Hash = (*txn.get_external(&change_id).unwrap().unwrap()).into();
     for edge in newedges.edges.iter() {
         let intro = internal(txn, &edge.introduced_by, change_id)?.unwrap();
         apply::put_newedge(
@@ -443,7 +442,23 @@ fn unapply_edges<T: GraphMutTxnT + TreeTxnT, P: ChangeStore>(
             newedges.inode,
             &edge.reverse(Some(ext)),
             |a, b| reintro.contains(&(a, b)),
-            |h| change.knows(h),
+            |h| {
+                if edge.previous.contains(EdgeFlags::DELETED) {
+                    // When reintroducing a deleted flag, check whether
+                    // the re-introduction patch knows about the alive
+                    // edges around the target.
+                    changes
+                        .knows(edge.introduced_by.as_ref().unwrap_or(&hash), h)
+                        .unwrap()
+                } else {
+                    // When the edge we are re-introducing is not a
+                    // deletion edge, this check isn't actually used: the
+                    // only zombies in that case are from a deleted
+                    // context, and these aren't detected with known
+                    // patches.
+                    true
+                }
+            },
         )?;
     }
     ws.must_reintroduce = reintro;