Add "pin" filter

"pin" filter holds off updates to the tree, choosing versions from parent,
or preventing versions from appearing.

Author: vlad-ivanov-name

docs/src/reference/filters.md

@@ -121,6 +121,22 @@ tree.
 Normally Josh will keep all commits in the filtered history whose tree differs from any of it's
 parents.
 
+### Pin tree contents
+
+Pin revision of a subtree to revision of the parent commit.
+
+In practical terms, it means that file and folder updates are "held off", and revisions are "pinned".
+If a tree entry already existed in the parent revision, that version will be chosen.
+Otherwise, the tree entry will not appear in the filtered commit.
+
+The source of the parent revision is always the first commit parent.
+
+Note that this filter is only practical when used with `:hook` or `workspace.josh`,
+as it should apply per-revision only. Applying `:pin` for the whole history
+will result in the subtree being excluded from all revisions.
+
+Refer to `pin_filter_workspace.t` and `pin_filter_hook.t` for reference.
+
 Filter order matters
 --------------------
 

josh-core/src/filter/mod.rs

@@ -57,6 +57,7 @@ impl std::fmt::Debug for Filter {
     }
 }
 
+#[derive(Debug)]
 pub struct Apply<'a> {
     tree: git2::Tree<'a>,
     pub author: Option<(String, String)>,
@@ -297,6 +298,7 @@ enum Op {
     Chain(Filter, Filter),
     Subtract(Filter, Filter),
     Exclude(Filter),
+    Pin(Filter),
 }
 
 /// Pretty print the filter on multiple lines with initial indentation level.
@@ -342,6 +344,10 @@ fn pretty2(op: &Op, indent: usize, compose: bool) -> String {
             Op::Compose(filters) => ff(&filters, "exclude", indent),
             b => format!(":exclude[{}]", pretty2(&b, indent, false)),
         },
+        Op::Pin(filter) => match to_op(*filter) {
+            Op::Compose(filters) => ff(&filters, "pin", indent),
+            b => format!(":pin[{}]", pretty2(&b, indent, false)),
+        },
         Op::Chain(a, b) => match (to_op(*a), to_op(*b)) {
             (Op::Subdir(p1), Op::Prefix(p2)) if p1 == p2 => {
                 format!("::{}/", parse::quote_if(&p1.to_string_lossy()))
@@ -392,7 +398,7 @@ pub fn nesting(filter: Filter) -> usize {
 fn nesting2(op: &Op) -> usize {
     match op {
         Op::Compose(filters) => 1 + filters.iter().map(|f| nesting(*f)).fold(0, |a, b| a.max(b)),
-        Op::Exclude(filter) => 1 + nesting(*filter),
+        Op::Exclude(filter) | Op::Pin(filter) => 1 + nesting(*filter),
         Op::Workspace(_) => usize::MAX / 2, // divide by 2 to make sure there is enough headroom to avoid overflows
         Op::Hook(_) => usize::MAX / 2, // divide by 2 to make sure there is enough headroom to avoid overflows
         Op::Chain(a, b) => 1 + nesting(*a).max(nesting(*b)),
@@ -430,7 +436,7 @@ fn lazy_refs2(op: &Op) -> Vec<String> {
                     acc
                 })
         }
-        Op::Exclude(filter) => lazy_refs(*filter),
+        Op::Exclude(filter) | Op::Pin(filter) => lazy_refs(*filter),
         Op::Chain(a, b) => {
             let mut av = lazy_refs(*a);
             av.append(&mut lazy_refs(*b));
@@ -481,6 +487,7 @@ fn resolve_refs2(refs: &std::collections::HashMap<String, git2::Oid>, op: &Op) -
             Op::Compose(filters.iter().map(|f| resolve_refs(refs, *f)).collect())
         }
         Op::Exclude(filter) => Op::Exclude(resolve_refs(refs, *filter)),
+        Op::Pin(filter) => Op::Pin(resolve_refs(refs, *filter)),
         Op::Chain(a, b) => Op::Chain(resolve_refs(refs, *a), resolve_refs(refs, *b)),
         Op::Subtract(a, b) => Op::Subtract(resolve_refs(refs, *a), resolve_refs(refs, *b)),
         Op::Rev(filters) => {
@@ -565,6 +572,9 @@ fn spec2(op: &Op) -> String {
         Op::Exclude(b) => {
             format!(":exclude[{}]", spec(*b))
         }
+        Op::Pin(filter) => {
+            format!(":pin[{}]", spec(*filter))
+        }
         Op::Rev(filters) => {
             let mut v = filters
                 .iter()
@@ -708,6 +718,9 @@ fn as_tree2(repo: &git2::Repository, op: &Op) -> JoshResult<git2::Oid> {
         Op::Exclude(b) => {
             builder.insert("exclude", as_tree(repo, *b)?, git2::FileMode::Tree.into())?;
         }
+        Op::Pin(b) => {
+            builder.insert("pin", as_tree(repo, *b)?, git2::FileMode::Tree.into())?;
+        }
         Op::Subdir(path) => {
             builder.insert(
                 "subdir",
@@ -1084,6 +1097,11 @@ fn from_tree2(repo: &git2::Repository, tree_oid: git2::Oid) -> JoshResult<Op> {
             let filter = from_tree2(repo, exclude_tree.id())?;
             Ok(Op::Exclude(to_filter(filter)))
         }
+        "pin" => {
+            let pin_tree = repo.find_tree(entry.id())?;
+            let filter = from_tree2(repo, pin_tree.id())?;
+            Ok(Op::Pin(to_filter(filter)))
+        }
         "rev" => {
             let rev_tree = repo.find_tree(entry.id())?;
             let mut filters = std::collections::BTreeMap::new();
@@ -1810,6 +1828,8 @@ fn apply2<'a>(transaction: &'a cache::Transaction, op: &Op, x: Apply<'a>) -> Jos
             return apply(transaction, *b, apply(transaction, *a, x.clone())?);
         }
         Op::Hook(_) => Err(josh_error("not applicable to tree")),
+
+        Op::Pin(_) => Ok(x),
     }
 }
 
@@ -2055,6 +2075,23 @@ pub fn is_linear(filter: Filter) -> bool {
     }
 }
 
+fn legalize_pin<F>(f: Filter, c: &F) -> Filter
+where
+    F: Fn(Filter) -> Filter,
+{
+    match to_op(f) {
+        Op::Compose(f) => {
+            let f = f.into_iter().map(|f| legalize_pin(f, c)).collect();
+            to_filter(Op::Compose(f))
+        }
+        Op::Chain(a, b) => to_filter(Op::Chain(legalize_pin(a, c), legalize_pin(b, c))),
+        Op::Subtract(a, b) => to_filter(Op::Subtract(legalize_pin(a, c), legalize_pin(b, c))),
+        Op::Exclude(f) => to_filter(Op::Exclude(legalize_pin(f, c))),
+        Op::Pin(f) => c(f),
+        _ => f,
+    }
+}
+
 fn per_rev_filter(
     transaction: &cache::Transaction,
     commit: &git2::Commit,
@@ -2085,13 +2122,48 @@ fn per_rev_filter(
         .map(|parent| transaction.get(filter, parent))
         .collect::<Option<Vec<git2::Oid>>>();
     let normal_parents = some_or!(normal_parents, { return Ok(None) });
+
+    // Special case: `:pin` filter needs to be aware of filtered history
+    let pin_details = if let Some(&parent) = normal_parents.first() {
+        let legalized_a = legalize_pin(cw, &|f| f);
+        let legalized_b = legalize_pin(cw, &|f| to_filter(Op::Exclude(f)));
+
+        if legalized_a != legalized_b {
+            let pin_subtract = apply(
+                transaction,
+                opt::optimize(to_filter(Op::Subtract(legalized_a, legalized_b))),
+                Apply::from_commit(commit)?,
+            )?;
+
+            let parent = transaction.repo().find_commit(parent)?;
+            let parent = parent.tree()?;
+
+            let pin_subtract = pin_subtract.tree();
+            let pin_overlay = tree::transpose(transaction, pin_subtract, &parent)?;
+
+            Some((pin_subtract.id(), pin_overlay.id()))
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
     let filtered_parent_ids: Vec<_> = normal_parents.into_iter().chain(extra_parents).collect();
 
-    let tree_data = apply(
+    let mut tree_data = apply(
         transaction,
         commit_filter,
         Apply::from_commit(commit)?.with_parents(filtered_parent_ids.clone()),
     )?;
+
+    if let Some((pin_subtract, pin_overlay)) = pin_details {
+        let with_exclude = tree::subtract(transaction, tree_data.tree().id(), pin_subtract)?;
+        let with_overlay = tree::overlay(transaction, pin_overlay, with_exclude)?;
+
+        tree_data = tree_data.with_tree(transaction.repo().find_tree(with_overlay)?);
+    }
+
     return Some(history::create_filtered_commit(
         commit,
         filtered_parent_ids,

josh-core/src/filter/opt.rs

@@ -82,6 +82,7 @@ pub fn simplify(filter: Filter) -> Filter {
             Op::Subtract(simplify(to_filter(a)), simplify(to_filter(b)))
         }
         Op::Exclude(b) => Op::Exclude(simplify(b)),
+        Op::Pin(b) => Op::Pin(simplify(b)),
         _ => to_op(filter),
     });
 
@@ -137,6 +138,7 @@ pub fn flatten(filter: Filter) -> Filter {
             Op::Subtract(flatten(to_filter(a)), flatten(to_filter(b)))
         }
         Op::Exclude(b) => Op::Exclude(flatten(b)),
+        Op::Pin(b) => Op::Pin(flatten(b)),
         _ => to_op(filter),
     });
 
@@ -440,8 +442,9 @@ fn step(filter: Filter) -> Filter {
             (a, b) => Op::Chain(step(to_filter(a)), step(to_filter(b))),
         },
         Op::Exclude(b) if b == to_filter(Op::Nop) => Op::Empty,
-        Op::Exclude(b) if b == to_filter(Op::Empty) => Op::Nop,
+        Op::Exclude(b) | Op::Pin(b) if b == to_filter(Op::Empty) => Op::Nop,
         Op::Exclude(b) => Op::Exclude(step(b)),
+        Op::Pin(b) => Op::Pin(step(b)),
         Op::Subtract(a, b) if a == b => Op::Empty,
         Op::Subtract(af, bf) => match (to_op(af), to_op(bf)) {
             (Op::Empty, _) => Op::Empty,
@@ -504,6 +507,7 @@ pub fn invert(filter: Filter) -> JoshResult<Filter> {
         Op::Pattern(pattern) => Some(Op::Pattern(pattern)),
         Op::Rev(_) => Some(Op::Nop),
         Op::RegexReplace(_) => Some(Op::Nop),
+        Op::Pin(_) => Some(Op::Nop),
         _ => None,
     };
 

josh-core/src/filter/parse.rs

@@ -115,6 +115,7 @@ fn parse_item(pair: pest::iterators::Pair<Rule>) -> JoshResult<Op> {
                 [cmd, args] => {
                     let g = parse_group(args)?;
                     match *cmd {
+                        "pin" => Ok(Op::Pin(to_filter(Op::Compose(g)))),
                         "exclude" => Ok(Op::Exclude(to_filter(Op::Compose(g)))),
                         "subtract" if g.len() == 2 => Ok(Op::Subtract(g[0], g[1])),
                         _ => Err(josh_error(&format!("parse_item: no match {:?}", cmd))),

josh-core/src/filter/tree.rs

@@ -1,4 +1,5 @@
 use super::*;
+use std::path::PathBuf;
 
 use crate::cache::TransactionContext;
 use crate::cache_stack::CacheStack;
@@ -1001,6 +1002,41 @@ pub fn get_blob(repo: &git2::Repository, tree: &git2::Tree, path: &Path) -> Stri
     content.to_owned()
 }
 
+/// Compose a new tree by taking paths out of `paths`,
+/// and actual blobs out of `blobs`.
+pub fn transpose<'a>(
+    transaction: &'a cache::Transaction,
+    paths: &'a git2::Tree,
+    blobs: &'a git2::Tree,
+) -> JoshResult<git2::Tree<'a>> {
+    use git2::build::TreeUpdateBuilder;
+    use git2::{TreeWalkMode, TreeWalkResult};
+
+    let mut builder = TreeUpdateBuilder::new();
+
+    paths.walk(TreeWalkMode::PostOrder, |path, entry| {
+        let path = PathBuf::from(path).join(entry.name().unwrap_or(""));
+
+        let entry = match blobs.get_path(&path) {
+            Ok(entry) => entry,
+            Err(e) if e.code() == git2::ErrorCode::NotFound => return TreeWalkResult::Ok,
+            Err(_) => return TreeWalkResult::Abort,
+        };
+
+        if entry.kind() != Some(git2::ObjectType::Blob) {
+            return TreeWalkResult::Ok;
+        }
+
+        builder.upsert(path, entry.id(), git2::FileMode::Blob);
+        TreeWalkResult::Ok
+    })?;
+
+    let repo = transaction.repo();
+    let tree = builder.create_updated(repo, &empty(repo))?;
+
+    Ok(repo.find_tree(tree)?)
+}
+
 pub fn empty_id() -> git2::Oid {
     git2::Oid::from_str("4b825dc642cb6eb9a060e54bf8d69288fbee4904").unwrap()
 }

tests/filter/pin_compose.t

@@ -0,0 +1,117 @@
+  $ export GIT_TREE_FMT='%(objectmode) %(objecttype) %(objectname) %(path)'
+
+  $ export TESTTMP=${PWD}
+  $ cd ${TESTTMP}
+
+  $ git init -q repo
+  $ cd repo
+  $ mkdir -p josh/overlay
+  $ mkdir -p code
+
+Populate repo contents for the first commit
+
+  $ cat << EOF > code/app.js
+  > async fn main() {
+  >   await fetch("http://127.0.0.1");
+  > }
+  > EOF
+
+  $ cat << EOF > code/lib.js
+  > fn log() {
+  >   console.log("logged!");
+  > }
+  > EOF
+
+Also create a workspace with the tree overlay filter
+
+We first select files in josh/overlay, whatever is in there
+will take priority over the next tree in the composition filter
+
+  $ mkdir -p workspaces/overlay
+  $ cat << EOF > workspaces/overlay/workspace.josh
+  > :[
+  >   :/code
+  >   :/josh/overlay
+  > ]
+  > EOF
+
+Here's the repo layout at this point:
+
+  $ tree .
+  .
+  |-- code
+  |   |-- app.js
+  |   `-- lib.js
+  |-- josh
+  |   `-- overlay
+  `-- workspaces
+      `-- overlay
+          `-- workspace.josh
+  
+  6 directories, 3 files
+
+Commit this:
+
+  $ git add .
+  $ git commit -q -m "first commit"
+
+Now, filter the ws and check the result
+
+  $ josh-filter ':workspace=workspaces/overlay'
+  $ git ls-tree --format="${GIT_TREE_FMT}" -r FILTERED_HEAD
+  100644 blob 0747fcb9cd688a7876932dcc30006e6ffa9106d6 app.js
+  100644 blob 5910ad90fda519a6cc9299d4688679d56dc8d6dd lib.js
+  100644 blob 39dc0f50ad353a5ee880b4a87ecc06dee7b48c92 workspace.josh
+
+Save the OID of app.js before making changes:
+
+  $ export ORIGINAL_APP_OID=$(git ls-tree --format="%(objectname)" FILTERED_HEAD app.js)
+  $ echo "${ORIGINAL_APP_OID}"
+  0747fcb9cd688a7876932dcc30006e6ffa9106d6
+
+Make next commit: both files will change
+
+  $ cat << EOF > code/app.js
+  > async fn main() {
+  >   await fetch("http://internal-secret-portal.company.com");
+  > }
+  > EOF
+
+  $ cat << EOF > code/lib.js
+  > fn log() {
+  >   console.log("INFO: logged!");
+  > }
+  > EOF
+
+  $ git add code/app.js code/lib.js
+
+Insert the old app.js OID into the overlay.
+Note that we aren't copying the file -- we are directly referencing the OID.
+This ensures it's the same entry in git ODB.
+
+  $ git update-index --add --cacheinfo 100644,"${ORIGINAL_APP_OID}","josh/overlay/app.js"
+  $ git commit -q -m "second commit"
+
+Verify commit tree looks right:
+
+  $ git ls-tree -r --format="${GIT_TREE_FMT}" HEAD
+  100644 blob 1540d15e1bdc499e31ea05703a0daaf520774a85 code/app.js
+  100644 blob 627cdb2ef7a3eb1a2b4537ce17fea1d93bfecdd2 code/lib.js
+  100644 blob 0747fcb9cd688a7876932dcc30006e6ffa9106d6 josh/overlay/app.js
+  100644 blob 39dc0f50ad353a5ee880b4a87ecc06dee7b48c92 workspaces/overlay/workspace.josh
+
+Filter the workspace and check the result:
+
+  $ josh-filter ':workspace=workspaces/overlay'
+
+We can see now that the app.js file was held at the previous version:
+
+  $ git ls-tree --format="${GIT_TREE_FMT}" -r FILTERED_HEAD
+  100644 blob 0747fcb9cd688a7876932dcc30006e6ffa9106d6 app.js
+  100644 blob 627cdb2ef7a3eb1a2b4537ce17fea1d93bfecdd2 lib.js
+  100644 blob 39dc0f50ad353a5ee880b4a87ecc06dee7b48c92 workspace.josh
+
+  $ git show FILTERED_HEAD:app.js
+  async fn main() {
+    await fetch("http://127.0.0.1");
+  }