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,27 @@ 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.
+
+#### Limitations
+
+At the moment, this filter only works as a top level filter. This constraint
+also applies within workspaces and hook filters.
+
+Refer to `pin_filter_workspace.t` and `pin_filter_hook.t` for reference.
+
 Filter order matters
 --------------------
 

josh-core/src/filter/mod.rs

@@ -297,6 +297,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 +343,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 +397,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 +435,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 +486,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 +571,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 +717,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 +1096,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 +1827,25 @@ 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(pin_filter) => {
+            let filtered_parent = if let Some(parent) = x.parents.as_ref().and_then(|p| p.first()) {
+                let parent = repo.find_commit(*parent)?;
+                let filtered = apply(transaction, *pin_filter, Apply::from_commit(&parent)?)?;
+                filtered.tree.id()
+            } else {
+                tree::empty_id()
+            };
+
+            // Mask out all the "pinned" files from current tree
+            let exclude = to_filter(Op::Exclude(*pin_filter));
+            let with_mask = apply(transaction, exclude, x.clone())?;
+
+            // Overlay filtered parent tree on current one to override versions
+            let with_overlay = tree::overlay(transaction, with_mask.tree.id(), filtered_parent)?;
+
+            Ok(x.with_tree(repo.find_tree(with_overlay)?))
+        }
     }
 }
 

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,
@@ -502,6 +505,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))),

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");
+  }