Implemented git-worktree

Author: Limits0x

Cargo.lock

@@ -13,3 +13,13 @@ doctest = false
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+git-index = { version = "^0.1.0", path = "../git-index" }
+anyhow = "1.0.42"
+git-hash = { version = "^0.9.0", path = "../git-hash" }
+git-object = { version = "^0.17.0", path = "../git-object" }
+
+[dev-dependencies]
+git-odb = { path = "../git-odb" }
+walkdir = "2.3.2"
+git-testtools = { path = "../tests/tools" }
+tempfile = "3.2.0"

git-worktree/Cargo.toml

@@ -1 +1,70 @@
 #![forbid(unsafe_code, rust_2018_idioms)]
+//! Git Worktree
+
+use anyhow::Result;
+use git_hash::oid;
+use git_index::{entry::Mode, State};
+use git_object::bstr::ByteSlice;
+use git_object::Data;
+use std::fs::create_dir_all;
+use std::path::Path;
+
+/// Copy index to `path`
+pub fn copy_index<P, Find>(state: &State, path: P, mut find: Find, opts: Options) -> Result<()>
+where
+    P: AsRef<Path>,
+    Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Option<Data<'a>>,
+{
+    let path = path.as_ref();
+    let entries = state.entries();
+    let mut buf = Vec::new();
+    for entry in entries {
+        let dest = path.join(entry.path(state).to_path()?);
+        create_dir_all(dest.parent().expect("Path has no parent"))?;
+        match entry.mode {
+            Mode::FILE | Mode::FILE_EXECUTABLE => {
+                let obj = find(&entry.id, &mut buf).unwrap();
+                std::fs::write(dest, obj.data)?;
+            }
+            Mode::SYMLINK => {
+                let obj = find(&entry.id, &mut buf).unwrap();
+                let linked_to = obj.data.to_path()?;
+                if opts.symlinks {
+                    #[cfg(unix)]
+                    std::os::unix::fs::symlink(linked_to, dest)?;
+                    #[cfg(windows)]
+                    if dest.exists() {
+                        if dest.is_file() {
+                            std::os::windows::fs::symlink_file(linked_to, dest)?;
+                        } else {
+                            std::os::windows::fs::symlink_dir(linked_to, dest)?;
+                        }
+                    }
+                } else {
+                    let linked_to_path = path.join(linked_to);
+                    if linked_to_path.exists() {
+                        std::fs::copy(linked_to_path, dest)?;
+                    } else {
+                        std::fs::write(dest, obj.data)?;
+                    }
+                }
+            }
+            Mode::DIR => todo!(),
+            Mode::COMMIT => todo!(),
+            _ => {}
+        }
+    }
+    Ok(())
+}
+
+/// Options for [copy_index](crate::copy_index)
+pub struct Options {
+    /// Enable/disable symlinks
+    pub symlinks: bool,
+}
+
+impl Default for Options {
+    fn default() -> Self {
+        Options { symlinks: true }
+    }
+}

git-worktree/src/lib.rs

@@ -0,0 +1,71 @@
+use crate::{dir_structure, fixture_path};
+use anyhow::Result;
+use git_odb::FindExt;
+use git_worktree::{copy_index, Options};
+use std::fs;
+
+#[test]
+fn test_copy_index() -> Result<()> {
+    let path = fixture_path("make_repo");
+    let path_git = path.join(".git");
+    let file = git_index::File::at(path_git.join("index"), git_index::decode::Options::default())?;
+    let output_dir = tempfile::tempdir()?;
+    let output = output_dir.path();
+    let odb_handle = git_odb::at(path_git.join("objects")).unwrap();
+
+    let res = copy_index(
+        &file,
+        &output,
+        move |oid, buf| odb_handle.find(oid, buf).ok(),
+        Options::default(),
+    );
+
+    let repo_files = dir_structure(&path);
+    let copy_files = dir_structure(output);
+
+    let srepo_files: Vec<_> = repo_files.iter().flat_map(|p| p.strip_prefix(&path)).collect();
+    let scopy_files: Vec<_> = copy_files.iter().flat_map(|p| p.strip_prefix(output)).collect();
+    assert!(srepo_files == scopy_files);
+
+    for (file1, file2) in repo_files.iter().zip(copy_files.iter()) {
+        assert!(fs::metadata(file1)?.file_type() == fs::metadata(file2)?.file_type());
+        assert!(fs::read(file1)? == fs::read(file2)?);
+    }
+
+    res
+}
+
+#[test]
+fn test_copy_index_without_symlinks() -> Result<()> {
+    let path = fixture_path("make_repo");
+    let path_git = path.join(".git");
+    let file = git_index::File::at(path_git.join("index"), git_index::decode::Options::default())?;
+    let output_dir = tempfile::tempdir()?;
+    let output = output_dir.path();
+    let odb_handle = git_odb::at(path_git.join("objects")).unwrap();
+
+    let res = copy_index(
+        &file,
+        &output,
+        move |oid, buf| odb_handle.find(oid, buf).ok(),
+        Options { symlinks: false },
+    );
+
+    let repo_files = dir_structure(&path);
+    let copy_files = dir_structure(output);
+
+    let srepo_files: Vec<_> = repo_files.iter().flat_map(|p| p.strip_prefix(&path)).collect();
+    let scopy_files: Vec<_> = copy_files.iter().flat_map(|p| p.strip_prefix(output)).collect();
+    assert!(srepo_files == scopy_files);
+
+    for (file1, file2) in repo_files.iter().zip(copy_files.iter()) {
+        if file2.is_symlink() {
+            assert!(!file1.is_symlink());
+        } else {
+            assert!(fs::metadata(file1)?.file_type() == fs::metadata(file2)?.file_type());
+        }
+        assert!(fs::read(file1)? == fs::read(file2)?);
+    }
+
+    res
+}

git-worktree/tests/copy_index/mod.rs

@@ -0,0 +1,17 @@
+#!/bin/bash
+set -eu -o pipefail
+
+git init -q
+
+touch a
+echo "Test Vals" > a
+touch b
+touch c
+
+mkdir d
+touch d/a
+echo "Subdir" > d/a
+ln -sf d/a sa
+
+git add -A
+git commit -m "Commit"

git-worktree/tests/fixtures/make_repo.sh

@@ -0,0 +1,23 @@
+use std::path::{Path, PathBuf};
+use walkdir::WalkDir;
+
+mod copy_index;
+
+pub fn dir_structure<P: AsRef<Path>>(path: P) -> Vec<PathBuf> {
+    let path = path.as_ref();
+    let mut ps: Vec<_> = WalkDir::new(path)
+        .into_iter()
+        .filter_entry(|e| e.path() == path || !e.file_name().to_str().map(|s| s.starts_with('.')).unwrap_or(false))
+        .flatten()
+        .filter(|e| e.path().is_file())
+        .map(|p| p.path().to_path_buf())
+        .collect();
+    ps.sort();
+    ps
+}
+
+pub fn fixture_path(name: &str) -> PathBuf {
+    let dir =
+        git_testtools::scripted_fixture_repo_read_only(Path::new(name).with_extension("sh")).expect("script works");
+    dir
+}