Update pijul

Author: fossdd

libpijul/src/alive/output.rs

@@ -16,8 +16,8 @@ struct ConflictStackElt {
 
 fn output_conflict<T: ChannelTxnT, B: VertexBuffer, P: ChangeStore>(
     changes: &P,
-    txn: &T,
-    channel: &T::Channel,
+    txn: &ArcTxn<T>,
+    channel: &ChannelRef<T>,
     line_buf: &mut B,
     graph: &Graph,
     sccs: &Vector2<VertexId>,
@@ -34,17 +34,25 @@ fn output_conflict<T: ChannelTxnT, B: VertexBuffer, P: ChangeStore>(
     while let Some(mut elt) = stack.pop() {
         let n_sides = elt.conflict.len();
         if n_sides > 1 && elt.side == 0 && elt.idx == 0 {
+            let txn = txn.read();
+            let channel = channel.read();
             elt.conflict.sort_by(|a, b| {
                 let a_ = a
                     .path
                     .iter()
-                    .map(|a| a.oldest_vertex(changes, txn, channel, graph, sccs).unwrap())
+                    .map(|a| {
+                        a.oldest_vertex(changes, &*txn, &*channel, graph, sccs)
+                            .unwrap()
+                    })
                     .min()
                     .unwrap();
                 let b_ = b
                     .path
                     .iter()
-                    .map(|b| b.oldest_vertex(changes, txn, channel, graph, sccs).unwrap())
+                    .map(|b| {
+                        b.oldest_vertex(changes, &*txn, &*channel, graph, sccs)
+                            .unwrap()
+                    })
                     .min()
                     .unwrap();
                 a_.cmp(&b_)
@@ -70,6 +78,7 @@ fn output_conflict<T: ChannelTxnT, B: VertexBuffer, P: ChangeStore>(
                 match elt.conflict[elt.side].path[elt.idx] {
                     PathElement::Scc { scc } => {
                         let vid = sccs[scc][0];
+                        let txn = txn.read();
                         let ext = txn.get_external(&graph[vid].vertex.change)?.unwrap();
                         line_buf.conflict_next(elt.id, &[&ext.into()])?;
                     }
@@ -184,7 +193,7 @@ impl PathElement {
 
 fn output_scc<T: GraphTxnT, B: VertexBuffer, P: ChangeStore>(
     changes: &P,
-    txn: &T,
+    txn: &ArcTxn<T>,
     graph: &Graph,
     scc: &[VertexId],
     is_zombie: &mut Option<usize>,
@@ -201,6 +210,7 @@ fn output_scc<T: GraphTxnT, B: VertexBuffer, P: ChangeStore>(
         if graph[v].flags.contains(Flags::ZOMBIE) {
             if is_zombie.is_none() {
                 *is_zombie = Some(*id);
+                let txn = txn.read();
                 let hash = txn.get_external(&graph[v].vertex.change)?.unwrap();
                 vbuf.begin_zombie_conflict(*id, &[&hash.into()])?;
                 *id += 1
@@ -216,7 +226,7 @@ fn output_scc<T: GraphTxnT, B: VertexBuffer, P: ChangeStore>(
             let now = std::time::Instant::now();
             let result = changes
                 .get_contents(
-                    |p| txn.get_external(&p).unwrap().map(|x| x.into()),
+                    |p| txn.read().get_external(&p).unwrap().map(|x| x.into()),
                     vertex,
                     buf,
                 )
@@ -241,8 +251,8 @@ fn output_scc<T: GraphTxnT, B: VertexBuffer, P: ChangeStore>(
 
 pub fn output_graph<T: ChannelTxnT, B: VertexBuffer, P: ChangeStore>(
     changes: &P,
-    txn: &T,
-    channel: &T::Channel,
+    txn: &ArcTxn<T>,
+    channel: &ChannelRef<T>,
     line_buf: &mut B,
     graph: &mut Graph,
     forward: &mut Vec<super::Redundant>,
@@ -253,8 +263,11 @@ pub fn output_graph<T: ChannelTxnT, B: VertexBuffer, P: ChangeStore>(
     let now0 = std::time::Instant::now();
     let scc = graph.tarjan(); // SCCs are given here in reverse order.
     let (conflict_tree, forward_scc) = graph.dfs(&scc);
-    graph.collect_forward_edges(txn, txn.graph(channel), &scc, &forward_scc, forward)?;
-
+    {
+        let txn = txn.read();
+        let channel = channel.read();
+        graph.collect_forward_edges(&*txn, txn.graph(&*channel), &scc, &forward_scc, forward)?;
+    }
     crate::TIMERS.lock().unwrap().alive_graph += now0.elapsed();
     let now1 = std::time::Instant::now();
     debug!("conflict_tree = {:?}", conflict_tree);

libpijul/src/change/parse.rs

@@ -70,7 +70,11 @@ fn parse_file_del_hunk(i: &str) -> IResult<&str, PrintableHunk> {
     } else {
         (i, Vec::new())
     };
-    let (i, contents) = parse_contents('-', encoding.clone(), i)?;
+    let (i, contents) = if encoding.is_none() {
+        (i, Vec::new())
+    } else {
+        parse_contents('-', encoding.clone(), i)?
+    };
     Ok((
         i,
         FileDel {

libpijul/src/diff/mod.rs

@@ -129,8 +129,8 @@ impl Recorded {
     pub(crate) fn diff<T: ChannelTxnT, P: ChangeStore>(
         &mut self,
         changes: &P,
-        txn: &T,
-        channel: &T::Channel,
+        txn: &ArcTxn<T>,
+        channel: &ChannelRef<T>,
         algorithm: Algorithm,
         stop_early: bool,
         path: String,
@@ -144,6 +144,8 @@ impl Recorded {
         self.largest_file = self.largest_file.max(b.len() as u64);
         let mut d = vertex_buffer::Diff::new(inode, path.clone(), a);
         output_graph(changes, txn, channel, &mut d, a, &mut self.redundant)?;
+        let txn = txn.read();
+        let channel = channel.read();
         // TODO pass through both encodings and use that to decide
         debug!("encoding = {:?}", encoding);
         let (lines_a, lines_b) = if encoding.is_none() {
@@ -171,8 +173,8 @@ impl Recorded {
         for r in 0..dd.len() {
             if dd[r].old_len > 0 {
                 self.delete(
-                    txn,
-                    txn.graph(channel),
+                    &*txn,
+                    txn.graph(&*channel),
                     &d,
                     &dd,
                     &mut conflict_contexts,

libpijul/src/fs.rs

@@ -168,6 +168,7 @@ pub fn inode_filename<T: TreeTxnT>(
     txn: &T,
     inode: Inode,
 ) -> Result<Option<String>, TreeErr<T::TreeError>> {
+    debug!("inode_filename {:?}", inode);
     let mut components = Vec::new();
     let mut current = inode;
     loop {
@@ -193,12 +194,13 @@ pub fn inode_filename<T: TreeTxnT>(
         }
         path.push_str(c.as_str());
     }
+    debug!("inode_filename = {:?}", path);
     Ok(Some(path))
 }
 
 /// Record the information that `parent_inode` is now a parent of
 /// file `filename`, and `filename` has inode `child_inode`.
-fn make_new_child<T: TreeMutTxnT>(
+pub fn make_new_child<T: TreeMutTxnT>(
     txn: &mut T,
     parent_inode: Inode,
     filename: &str,
@@ -439,7 +441,7 @@ pub struct WorkingCopyIterator<'txn, T: TreeTxnT> {
 }
 
 impl<'txn, T: TreeTxnT> Iterator for WorkingCopyIterator<'txn, T> {
-    type Item = Result<(Inode, String), T::TreeError>;
+    type Item = Result<(Inode, String, bool), T::TreeError>;
     fn next(&mut self) -> Option<Self::Item> {
         loop {
             if let Some((inode, name)) = self.stack.pop() {
@@ -452,6 +454,7 @@ impl<'txn, T: TreeTxnT> Iterator for WorkingCopyIterator<'txn, T> {
                     Ok(iter) => iter,
                     Err(e) => return Some(Err(e.0)),
                 };
+                let mut is_folder = false;
                 for x in iter {
                     let (k, v) = match x {
                         Ok(x) => x,
@@ -462,6 +465,7 @@ impl<'txn, T: TreeTxnT> Iterator for WorkingCopyIterator<'txn, T> {
                     } else if k.parent_inode > inode {
                         break;
                     }
+                    is_folder = true;
                     if !k.basename.is_empty() {
                         let mut name = name.clone();
                         crate::path::push(&mut name, k.basename.as_str());
@@ -470,7 +474,7 @@ impl<'txn, T: TreeTxnT> Iterator for WorkingCopyIterator<'txn, T> {
                 }
                 (&mut self.stack[len..]).reverse();
                 if !name.is_empty() {
-                    return Some(Ok((inode, name)));
+                    return Some(Ok((inode, name, is_folder)));
                 }
             } else {
                 return None;