Implemented git-worktree

Author: Limits0x

Cargo.lock

@@ -22,6 +22,10 @@ mod access {
         pub fn entries(&self) -> &[Entry] {
             &self.entries
         }
+
+        pub fn entries_mut(&mut self) -> &mut [Entry] {
+            &mut self.entries
+        }
     }
 }
 

git-index/src/lib.rs

@@ -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,95 @@
 #![forbid(unsafe_code, rust_2018_idioms)]
+//! Git Worktree
+
+use anyhow::Result;
+use git_hash::oid;
+use git_index::{
+    entry::{Flags, Mode},
+    State,
+};
+use git_object::bstr::ByteSlice;
+use git_object::Data;
+use std::convert::TryFrom;
+use std::fs;
+use std::fs::create_dir_all;
+use std::path::Path;
+use std::time::SystemTime;
+
+#[cfg(unix)]
+use std::os::unix::fs::PermissionsExt;
+
+/// Copy index to `path`
+pub fn copy_index<P, Find>(state: &mut 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 paths = state
+        .entries()
+        .iter()
+        .map(|e| e.path(state).to_path().map(|p| p.to_path_buf()))
+        .collect::<Result<Vec<_>, _>>()?;
+    let mut buf = Vec::new();
+    for (i, entry) in state.entries_mut().iter_mut().enumerate() {
+        if entry.flags.contains(Flags::SKIP_WORKTREE) {
+            continue;
+        }
+        let time = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH)?;
+        entry.stat.mtime.secs = u32::try_from(time.as_secs())?;
+        entry.stat.mtime.nsecs = time.subsec_nanos();
+        entry.stat.ctime.secs = u32::try_from(time.as_secs())?;
+        entry.stat.ctime.nsecs = time.subsec_nanos();
+        let dest = path.join(&paths[i]);
+        create_dir_all(dest.parent().expect("path is empty"))?;
+        match entry.mode {
+            Mode::FILE | Mode::FILE_EXECUTABLE => {
+                let obj = find(&entry.id, &mut buf).unwrap();
+                std::fs::write(&dest, obj.data)?;
+                if entry.mode == Mode::FILE_EXECUTABLE {
+                    #[cfg(unix)]
+                    fs::set_permissions(dest, fs::Permissions::from_mode(0o777)).unwrap();
+                }
+            }
+            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!(),
+            _ => unreachable!(),
+        }
+    }
+    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,76 @@
+use crate::{dir_structure, fixture_path};
+use anyhow::Result;
+use git_odb::FindExt;
+use git_worktree::{copy_index, Options};
+use std::fs;
+
+#[cfg(unix)]
+use std::os::unix::prelude::MetadataExt;
+
+#[test]
+fn test_copy_index() -> Result<()> {
+    let path = fixture_path("make_repo");
+    let path_git = path.join(".git");
+    let mut 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();
+
+    copy_index(
+        &mut 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::read(file1)? == fs::read(file2)?);
+        #[cfg(unix)]
+        assert!(fs::metadata(file1)?.mode() & 0b111 << 6 == fs::metadata(file2)?.mode() & 0b111 << 6);
+    }
+
+    Ok(())
+}
+
+#[test]
+fn test_copy_index_without_symlinks() -> Result<()> {
+    let path = fixture_path("make_repo");
+    let path_git = path.join(".git");
+    let mut 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();
+
+    copy_index(
+        &mut 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 {
+            #[cfg(unix)]
+            assert!(fs::metadata(file1)?.mode() & 0b111 << 6 == fs::metadata(file2)?.mode() & 0b111 << 6);
+        }
+        assert!(fs::read(file1)? == fs::read(file2)?);
+    }
+
+    Ok(())
+}

git-worktree/tests/copy_index/mod.rs

@@ -0,0 +1,19 @@
+#!/bin/bash
+set -eu -o pipefail
+
+git init -q
+
+touch a
+echo "Test Vals" > a
+touch b
+touch c
+touch executable.sh
+chmod +x executable.sh
+
+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
+}