Add :prune=trivial-merge filter

The default history simplification will not drop merge
commits if their tree differs from any parent.
In most cases however merges that don't differ from the first
parent are not wanted in the output history.
This new filter allows to prune them.

Change: prune-trivial-merges

Author: christian-schilling

josh-core/src/filter/mod.rs

@@ -144,6 +144,7 @@ enum Op {
     Rev(std::collections::BTreeMap<LazyRef, Filter>),
     Join(std::collections::BTreeMap<LazyRef, Filter>),
     Linear,
+    Prune,
     Unsign,
 
     RegexReplace(Vec<(regex::Regex, String)>),
@@ -485,6 +486,7 @@ fn spec2(op: &Op) -> String {
         Op::Unsign => ":unsign".to_string(),
         Op::Subdir(path) => format!(":/{}", parse::quote_if(&path.to_string_lossy())),
         Op::File(path) => format!("::{}", parse::quote_if(&path.to_string_lossy())),
+        Op::Prune => ":prune=trivial-merge".to_string(),
         Op::Prefix(path) => format!(":prefix={}", parse::quote_if(&path.to_string_lossy())),
         Op::Pattern(pattern) => format!("::{}", parse::quote_if(pattern)),
         Op::Author(author, email) => {
@@ -811,6 +813,33 @@ fn apply_to_commit2(
             ))
             .transpose();
         }
+        Op::Prune => {
+            let p: Vec<_> = commit.parent_ids().collect();
+
+            if p.len() > 0 {
+                let parent = some_or!(transaction.get(filter, p[0]), {
+                    return Ok(None);
+                });
+
+                let parent_tree = transaction.repo().find_commit(parent)?.tree_id();
+
+                if parent_tree == commit.tree_id() {
+                    return Ok(Some(history::drop_commit(
+                        commit,
+                        vec![parent],
+                        transaction,
+                        filter,
+                    )?));
+                }
+            }
+
+            RewriteData {
+                tree: commit.tree()?,
+                message: None,
+                author: None,
+                committer: None,
+            }
+        }
         Op::Unsign => {
             let parents: Vec<_> = commit.parent_ids().collect();
 
@@ -998,6 +1027,7 @@ fn apply2<'a>(
         Op::Committer(_, _) => Ok(tree),
         Op::Squash(Some(_)) => Err(josh_error("not applicable to tree")),
         Op::Linear => Ok(tree),
+        Op::Prune => Ok(tree),
         Op::Unsign => Ok(tree),
         Op::Rev(_) => Err(josh_error("not applicable to tree")),
         Op::Join(_) => Err(josh_error("not applicable to tree")),

josh-core/src/filter/opt.rs

@@ -489,6 +489,7 @@ pub fn invert(filter: Filter) -> JoshResult<Filter> {
     let result = match to_op(filter) {
         Op::Nop => Some(Op::Nop),
         Op::Linear => Some(Op::Nop),
+        Op::Prune => Some(Op::Prune),
         Op::Unsign => Some(Op::Unsign),
         Op::Empty => Some(Op::Empty),
         Op::Subdir(path) => Some(Op::Prefix(path)),

josh-core/src/filter/parse.rs

@@ -35,6 +35,7 @@ fn make_op(args: &[&str]) -> JoshResult<Op> {
         ["SQUASH"] => Ok(Op::Squash(None)),
         ["SQUASH", _ids @ ..] => Err(josh_error("SQUASH with ids can't be parsed")),
         ["linear"] => Ok(Op::Linear),
+        ["prune", "trivial-merge"] => Ok(Op::Prune),
         ["unsign"] => Ok(Op::Unsign),
         ["PATHS"] => Ok(Op::Paths),
         ["INDEX"] => Ok(Op::Index),