Remove :join filter

Id normally avoid removing filters, but i think this is an exception:
I doubt anyone is using this, as it is just a less capable way to get
to the same result as doing a filter --reverse or push.

Author: christian-schilling

docs/src/reference/filters.md

@@ -168,11 +168,6 @@ for all further ancestors (and so on).
 This special value `0000000000000000000000000000000000000000` can be used as a `<sha_n>` to filter
 commits that don't match any of the other shas.
 
-### Join multiple histories into one **:join(<sha_0>:filter_0,...,<sha_N>:filter_N)**
-
-Produce the history that would be the result of pushing the passed branches with the
-passed filters into the upstream.
-
 ### Start filtering from a specific commit **:from(<sha>:filter)**
 
 Produce a history that keeps the original history up to and including the specified commit `<sha>` unchanged,

josh-core/src/filter/grammar.pest

@@ -26,7 +26,7 @@ filter_spec = { (
   | filter_rev
   | filter_from
   | filter_concat
-  | filter_join
+  | filter_unapply
   | filter_replace
   | filter_squash
   | filter_presub
@@ -74,15 +74,16 @@ filter_concat = {
     ~ ")"
 }
 
-filter_join = {
-    CMD_START ~ "join" ~ "("
+filter_unapply = {
+    CMD_START ~ "unapply" ~ "("
     ~ NEWLINE*
     ~ (rev ~ filter_spec)?
     ~ (CMD_SEP+ ~ (rev ~ filter_spec))*
     ~ NEWLINE*
     ~ ")"
 }
 
+
 filter_replace = {
     CMD_START ~ "replace" ~ "("
     ~ NEWLINE*

josh-core/src/filter/mod.rs

@@ -296,7 +296,6 @@ enum Op {
     // We use BTreeMap rather than HashMap to guarantee deterministic results when
     // converting to Filter
     Rev(std::collections::BTreeMap<LazyRef, Filter>),
-    Join(std::collections::BTreeMap<LazyRef, Filter>),
     Linear,
     Prune,
     Unsign,
@@ -463,17 +462,6 @@ fn lazy_refs2(op: &Op) -> Vec<String> {
             lr.append(&mut lazy_refs(*f));
             lr
         }
-        Op::Join(filters) => {
-            let mut lr = lazy_refs2(&Op::Compose(filters.values().copied().collect()));
-            lr.extend(filters.keys().filter_map(|x| {
-                if let LazyRef::Lazy(s) = x {
-                    Some(s.to_owned())
-                } else {
-                    None
-                }
-            }));
-            lr
-        }
         Op::Squash(Some(revs)) => {
             let mut lr = vec![];
             lr.extend(revs.keys().filter_map(|x| {
@@ -536,24 +524,6 @@ fn resolve_refs2(refs: &std::collections::HashMap<String, git2::Oid>, op: &Op) -
             };
             Op::HistoryConcat(resolved_ref, f)
         }
-        Op::Join(filters) => {
-            let lr = filters
-                .iter()
-                .map(|(r, f)| {
-                    let f = resolve_refs(refs, *f);
-                    if let LazyRef::Lazy(s) = r {
-                        if let Some(res) = refs.get(s) {
-                            (LazyRef::Resolved(*res), f)
-                        } else {
-                            (r.clone(), f)
-                        }
-                    } else {
-                        (r.clone(), f)
-                    }
-                })
-                .collect();
-            Op::Join(lr)
-        }
         Op::Squash(Some(filters)) => {
             let lr = filters
                 .iter()
@@ -614,14 +584,6 @@ fn spec2(op: &Op) -> String {
             v.sort();
             format!(":rev({})", v.join(","))
         }
-        Op::Join(filters) => {
-            let mut v = filters
-                .iter()
-                .map(|(k, v)| format!("{}{}", k.to_string(), spec(*v)))
-                .collect::<Vec<_>>();
-            v.sort();
-            format!(":join({})", v.join(","))
-        }
         Op::Workspace(path) => {
             format!(":workspace={}", parse::quote_if(&path.to_string_lossy()))
         }
@@ -864,34 +826,6 @@ fn apply_to_commit2(
             ))
             .transpose();
         }
-        Op::Join(refs) => {
-            // First loop to populate missing list
-            for (&_, f) in refs.iter() {
-                transaction.get(*f, commit.id());
-            }
-            let mut result = commit.id();
-            for (combine_tip, f) in refs.iter() {
-                if let LazyRef::Resolved(combine_tip) = combine_tip {
-                    let old = some_or!(transaction.get(*f, commit.id()), {
-                        return Ok(None);
-                    });
-                    result = history::unapply_filter(
-                        transaction,
-                        *f,
-                        result,
-                        old,
-                        *combine_tip,
-                        history::OrphansMode::Keep,
-                        None,
-                        &mut None,
-                    )?;
-                } else {
-                    return Err(josh_error("unresolved lazy ref"));
-                }
-            }
-            transaction.insert(filter, commit.id(), result, true);
-            return Ok(Some(result));
-        }
         _ => {
             if let Some(oid) = transaction.get(filter, commit.id()) {
                 return Ok(Some(oid));
@@ -1221,7 +1155,6 @@ fn apply2<'a>(transaction: &'a cache::Transaction, op: &Op, x: Apply<'a>) -> Jos
         Op::Prune => Ok(x),
         Op::Unsign => Ok(x),
         Op::Rev(_) => Err(josh_error("not applicable to tree")),
-        Op::Join(_) => Err(josh_error("not applicable to tree")),
         Op::RegexReplace(replacements) => {
             let mut t = x.tree().clone();
             for (regex, replacement) in replacements {

josh-core/src/filter/parse.rs

@@ -160,17 +160,6 @@ fn parse_item(pair: pest::iterators::Pair<Rule>) -> JoshResult<Op> {
                 _ => Err(josh_error("parse_item: no match {:?}")),
             }
         }
-        Rule::filter_join => {
-            let v: Vec<_> = pair.into_inner().map(|x| x.as_str()).collect();
-
-            let hm = v
-                .iter()
-                .tuples()
-                .map(|(oid, filter)| Ok((LazyRef::parse(oid)?, parse(filter)?)))
-                .collect::<JoshResult<_>>()?;
-
-            Ok(Op::Join(hm))
-        }
         Rule::filter_rev => {
             let v: Vec<_> = pair.into_inner().map(|x| x.as_str()).collect();
 

josh-core/src/filter/persist.rs

@@ -281,15 +281,6 @@ impl InMemoryBuilder {
                 let params_tree = self.build_rev_params(&v)?;
                 push_tree_entries(&mut entries, [("rev", params_tree)]);
             }
-            Op::Join(filters) => {
-                let mut v = filters
-                    .iter()
-                    .map(|(k, v)| (k.to_string(), *v))
-                    .collect::<Vec<_>>();
-                v.sort();
-                let params_tree = self.build_rev_params(&v)?;
-                push_tree_entries(&mut entries, [("join", params_tree)]);
-            }
             Op::HistoryConcat(lr, f) => {
                 let params_tree = self.build_rev_params(&[(lr.to_string(), *f)])?;
                 push_tree_entries(&mut entries, [("concat", params_tree)]);
@@ -613,32 +604,6 @@ fn from_tree2(repo: &git2::Repository, tree_oid: git2::Oid) -> JoshResult<Op> {
             }
             Ok(Op::Rev(filters))
         }
-        "join" => {
-            let join_tree = repo.find_tree(entry.id())?;
-            let mut filters = std::collections::BTreeMap::new();
-            for i in 0..join_tree.len() {
-                let entry = join_tree
-                    .get(i)
-                    .ok_or_else(|| josh_error("join: missing entry"))?;
-                let inner_tree = repo.find_tree(entry.id())?;
-                let key_blob = repo.find_blob(
-                    inner_tree
-                        .get_name("o")
-                        .ok_or_else(|| josh_error("join: missing key"))?
-                        .id(),
-                )?;
-                let filter_tree = repo.find_tree(
-                    inner_tree
-                        .get_name("f")
-                        .ok_or_else(|| josh_error("join: missing filter"))?
-                        .id(),
-                )?;
-                let key = std::str::from_utf8(key_blob.content())?.to_string();
-                let filter = from_tree2(repo, filter_tree.id())?;
-                filters.insert(LazyRef::parse(&key)?, to_filter(filter));
-            }
-            Ok(Op::Join(filters))
-        }
         "concat" => {
             let concat_tree = repo.find_tree(entry.id())?;
             let entry = concat_tree