Extend file filter to support renames

Author: christian-schilling

docs/src/reference/filters.md

@@ -33,9 +33,20 @@ Note that ``:/a/b`` and ``:/a:/b`` are equivalent ways to get the same result.
 ### Directory **`::a/`**
 A shorthand for the commonly occurring filter combination ``:/a:prefix=a``.
 
-### File **`::a`**
-Produces a tree with only the specified file in it's root.
+### File **`::a`** or **`::destination=source`**
+Produces a tree with only the specified file.
+
+When using a single argument (`::a`), the file is placed at the same full path as in the source tree.
+When using the `destination=source` syntax (`::destination=source`), the file is renamed from `source` to `destination` in the filtered tree.
+
+Examples:
+- `::file.txt` - Selects `file.txt` and places it at `file.txt`
+- `::src/file.txt` - Selects `src/file.txt` and places it at `src/file.txt`
+- `::renamed.txt=src/original.txt` - Selects `src/original.txt` and places it at `renamed.txt`
+- `::subdir/file.txt=src/file.txt` - Selects `src/file.txt` and places it at `subdir/file.txt`
+
 Note that `::a/b` is equivalent to `::a/::b`.
+Pattern filters (with `*`) cannot be combined with the `destination=source` syntax.
 
 ### Prefix **`:prefix=a`**
 Take the input tree and place it into subdirectory ``a``.

josh-core/src/filter/grammar.pest

@@ -37,7 +37,7 @@ filter_spec = { (
 filter_group = { CMD_START ~ cmd? ~ GROUP_START ~ compose ~ GROUP_END }
 filter_subdir = { CMD_START ~ "/" ~ argument }
 filter_nop = { CMD_START ~ "/" }
-filter_presub = { CMD_START ~ ":" ~ argument }
+filter_presub = { CMD_START ~ ":" ~ argument ~ ("=" ~ argument)? }
 filter = { CMD_START ~ cmd ~ "=" ~ (argument ~ (";" ~ argument)*)? }
 filter_noarg = { CMD_START ~ cmd }
 filter_message = { CMD_START ~ string ~ (";" ~ string)? }

josh-core/src/filter/mod.rs

@@ -212,6 +212,11 @@ pub fn message(m: &str) -> Filter {
     to_filter(Op::Message(m.to_string(), MESSAGE_MATCH_ALL_REGEX.clone()))
 }
 
+pub fn file(path: impl Into<std::path::PathBuf>) -> Filter {
+    let p = path.into();
+    to_filter(Op::File(p.clone(), p))
+}
+
 pub fn hook(h: &str) -> Filter {
     to_filter(Op::Hook(h.to_string()))
 }
@@ -303,7 +308,7 @@ enum Op {
     Index,
     Invert,
 
-    File(std::path::PathBuf),
+    File(std::path::PathBuf, std::path::PathBuf), // File(dest_path, source_path)
     Prefix(std::path::PathBuf),
     Subdir(std::path::PathBuf),
     Workspace(std::path::PathBuf),
@@ -619,7 +624,17 @@ fn spec2(op: &Op) -> String {
         Op::Linear => ":linear".to_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::File(dest_path, source_path) => {
+            if source_path == dest_path {
+                format!("::{}", parse::quote_if(&dest_path.to_string_lossy()))
+            } else {
+                format!(
+                    "::{}={}",
+                    parse::quote_if(&dest_path.to_string_lossy()),
+                    parse::quote_if(&source_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)),
@@ -652,7 +667,7 @@ pub fn src_path(filter: Filter) -> std::path::PathBuf {
 fn src_path2(op: &Op) -> std::path::PathBuf {
     normalize_path(&match op {
         Op::Subdir(path) => path.to_owned(),
-        Op::File(path) => path.to_owned(),
+        Op::File(_, source_path) => source_path.to_owned(),
         Op::Chain(a, b) => src_path(*a).join(src_path(*b)),
         _ => std::path::PathBuf::new(),
     })
@@ -665,7 +680,7 @@ pub fn dst_path(filter: Filter) -> std::path::PathBuf {
 fn dst_path2(op: &Op) -> std::path::PathBuf {
     normalize_path(&match op {
         Op::Prefix(path) => path.to_owned(),
-        Op::File(path) => path.to_owned(),
+        Op::File(dest_path, _) => dest_path.to_owned(),
         Op::Chain(a, b) => dst_path(*b).join(dst_path(*a)),
         _ => std::path::PathBuf::new(),
     })
@@ -706,13 +721,7 @@ fn resolve_workspace_redirect<'a>(
         .unwrap_or_else(|_| to_filter(Op::Empty));
 
     if let Op::Workspace(p) = to_op(f) {
-        Some((
-            chain(
-                to_filter(Op::Exclude(to_filter(Op::File(path.to_owned())))),
-                f,
-            ),
-            p,
-        ))
+        Some((chain(to_filter(Op::Exclude(file(path))), f), p))
     } else {
         None
     }
@@ -724,7 +733,7 @@ fn get_workspace<'a>(repo: &'a git2::Repository, tree: &'a git2::Tree<'a>, path:
     } else {
         path.to_owned()
     };
-    let wsj_file = to_filter(Op::File(Path::new("workspace.josh").to_owned()));
+    let wsj_file = file("workspace.josh");
     let base = to_filter(Op::Subdir(path.to_owned()));
     let wsj_file = chain(base, wsj_file);
     compose(
@@ -1145,13 +1154,19 @@ fn apply2<'a>(transaction: &'a cache::Transaction, op: &Op, x: Apply<'a>) -> Jos
                 to_filter(op.clone()).id(),
             )?))
         }
-        Op::File(path) => {
+        Op::File(dest_path, source_path) => {
             let (file, mode) = x
                 .tree()
-                .get_path(path)
+                .get_path(source_path)
                 .map(|x| (x.id(), x.filemode()))
                 .unwrap_or((git2::Oid::zero(), git2::FileMode::Blob.into()));
-            Ok(x.with_tree(tree::insert(repo, &tree::empty(repo), path, file, mode)?))
+            Ok(x.with_tree(tree::insert(
+                repo,
+                &tree::empty(repo),
+                dest_path,
+                file,
+                mode,
+            )?))
         }
 
         Op::Subdir(path) => Ok(x.clone().with_tree(
@@ -1295,7 +1310,10 @@ fn unapply_workspace<'a>(
             );
 
             let root = to_filter(Op::Subdir(path.to_owned()));
-            let wsj_file = to_filter(Op::File(Path::new("workspace.josh").to_owned()));
+            let wsj_file = to_filter(Op::File(
+                Path::new("workspace.josh").to_owned(),
+                Path::new("workspace.josh").to_owned(),
+            ));
             let wsj_file = chain(root, wsj_file);
             let filter = compose(wsj_file, compose(workspace, root));
             let original_filter = compose(wsj_file, compose(original_workspace, root));

josh-core/src/filter/opt.rs

@@ -501,7 +501,7 @@ pub fn invert(filter: Filter) -> JoshResult<Filter> {
         Op::Unsign => Some(Op::Unsign),
         Op::Empty => Some(Op::Empty),
         Op::Subdir(path) => Some(Op::Prefix(path)),
-        Op::File(path) => Some(Op::File(path)),
+        Op::File(dest_path, source_path) => Some(Op::File(source_path, dest_path)),
         Op::Prefix(path) => Some(Op::Subdir(path)),
         Op::Pattern(pattern) => Some(Op::Pattern(pattern)),
         Op::Rev(_) => Some(Op::Nop),

josh-core/src/filter/parse.rs

@@ -87,16 +87,38 @@ fn parse_item(pair: pest::iterators::Pair<Rule>) -> JoshResult<Op> {
         Rule::filter_presub => {
             let mut inner = pair.into_inner();
             let arg = &unquote(inner.next().unwrap().as_str());
+            let second_arg = inner.next().map(|x| unquote(x.as_str()));
+
             if arg.ends_with('/') {
                 let arg = arg.trim_end_matches('/');
                 Ok(Op::Chain(
                     to_filter(Op::Subdir(std::path::PathBuf::from(arg))),
                     to_filter(make_op(&["prefix", arg])?),
                 ))
             } else if arg.contains('*') {
+                // Pattern case - error if combined with = (destination=source syntax)
+                if second_arg.is_some() {
+                    return Err(josh_error(&format!(
+                        "Pattern filters cannot use destination=source syntax: {}",
+                        arg
+                    )));
+                }
                 Ok(Op::Pattern(arg.to_string()))
             } else {
-                Ok(Op::File(Path::new(arg).to_owned()))
+                // File case - error if source contains * (patterns not supported in source)
+                if let Some(ref source_arg) = second_arg
+                    && source_arg.contains('*')
+                {
+                    return Err(josh_error(&format!(
+                        "Pattern filters not supported in source path: {}",
+                        source_arg
+                    )));
+                }
+                let dest_path = Path::new(arg).to_owned();
+                let source_path = second_arg
+                    .map(|s| Path::new(&s).to_owned())
+                    .unwrap_or_else(|| dest_path.clone());
+                Ok(Op::File(dest_path, source_path))
             }
         }
         Rule::filter_noarg => {

josh-core/src/filter/persist.rs

@@ -205,9 +205,20 @@ impl InMemoryBuilder {
                 let blob = self.write_blob(path.to_string_lossy().as_bytes());
                 push_blob_entries(&mut entries, [("prefix", blob)]);
             }
-            Op::File(path) => {
-                let blob = self.write_blob(path.to_string_lossy().as_bytes());
-                push_blob_entries(&mut entries, [("file", blob)]);
+            Op::File(dest_path, source_path) => {
+                if source_path == dest_path {
+                    // Backward compatibility: use blob format when source and dest are the same
+                    let blob = self.write_blob(dest_path.to_string_lossy().as_bytes());
+                    push_blob_entries(&mut entries, [("file", blob)]);
+                } else {
+                    // New format: use tree format when source and dest differ
+                    // Store as (dest_path, source_path) to match enum order
+                    let params_tree = self.build_str_params(&[
+                        dest_path.to_string_lossy().as_ref(),
+                        source_path.to_string_lossy().as_ref(),
+                    ]);
+                    push_tree_entries(&mut entries, [("file", params_tree)]);
+                }
             }
             Op::Pattern(pattern) => {
                 let blob = self.write_blob(pattern.as_bytes());
@@ -454,9 +465,37 @@ fn from_tree2(repo: &git2::Repository, tree_oid: git2::Oid) -> JoshResult<Op> {
             Ok(Op::Prefix(std::path::PathBuf::from(path)))
         }
         "file" => {
-            let blob = repo.find_blob(entry.id())?;
-            let path = std::str::from_utf8(blob.content())?;
-            Ok(Op::File(std::path::PathBuf::from(path)))
+            // Try to read as tree (new format with destination path)
+            if let Ok(inner) = repo.find_tree(entry.id()) {
+                let dest_blob = repo.find_blob(
+                    inner
+                        .get_name("0")
+                        .ok_or_else(|| josh_error("file: missing destination path"))?
+                        .id(),
+                )?;
+                let dest_path_str = std::str::from_utf8(dest_blob.content())?.to_string();
+                let source_path = inner
+                    .get_name("1")
+                    .and_then(|entry| repo.find_blob(entry.id()).ok())
+                    .and_then(|blob| {
+                        std::str::from_utf8(blob.content())
+                            .ok()
+                            .map(|s| s.to_string())
+                    })
+                    .map(|s| std::path::PathBuf::from(s))
+                    .unwrap_or_else(|| std::path::PathBuf::from(&dest_path_str));
+                Ok(Op::File(
+                    std::path::PathBuf::from(dest_path_str),
+                    source_path,
+                ))
+            } else {
+                // Fall back to blob format (old format, backward compatibility)
+                let blob = repo.find_blob(entry.id())?;
+                let path_str = std::str::from_utf8(blob.content())?.to_string();
+                let path_buf = std::path::PathBuf::from(&path_str);
+                // When reading from blob format, destination is the same as source
+                Ok(Op::File(path_buf.clone(), path_buf))
+            }
         }
         "pattern" => {
             let blob = repo.find_blob(entry.id())?;