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" }
+quick-error = "2.0.1"
+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,126 @@
 #![forbid(unsafe_code, rust_2018_idioms)]
+//! Git Worktree
+
+use git_hash::oid;
+use git_object::bstr::ByteSlice;
+use quick_error::quick_error;
+use std::convert::TryFrom;
+use std::fs;
+use std::fs::create_dir_all;
+use std::path::Path;
+use std::time::Duration;
+
+#[cfg(unix)]
+use std::os::unix::fs::PermissionsExt;
+
+quick_error! {
+    #[derive(Debug)]
+    pub enum Error {
+        Utf8Error(err: git_object::bstr::Utf8Error) {
+            from()
+            display("Could not convert path to UTF8: {}", err)
+        }
+        TimeError(err: std::time::SystemTimeError) {
+            from()
+            display("Could not read file time in proper format: {}", err)
+        }
+        ToU32Error(err: std::num::TryFromIntError) {
+            from()
+            display("Could not convert seconds to u32: {}", err)
+        }
+        IoError(err: std::io::Error) {
+            from()
+            display("IO Error: {}", err)
+        }
+    }
+}
+
+/// Copy index to `path`
+pub fn copy_index<P, Find>(state: &mut git_index::State, path: P, mut find: Find, opts: Options) -> Result<(), Error>
+where
+    P: AsRef<Path>,
+    Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Option<git_object::BlobRef<'a>>,
+{
+    let path = path.as_ref();
+    let mut buf = Vec::new();
+    let mut entry_time = Vec::new(); // Entries whose timestamps have to be updated
+    for (i, entry) in state.entries().iter().enumerate() {
+        if entry.flags.contains(git_index::entry::Flags::SKIP_WORKTREE) {
+            continue;
+        }
+        let dest = path.join(entry.path(state).to_path()?);
+        create_dir_all(dest.parent().expect("path is empty"))?;
+        match entry.mode {
+            git_index::entry::Mode::FILE | git_index::entry::Mode::FILE_EXECUTABLE => {
+                let obj = find(&entry.id, &mut buf).unwrap();
+                std::fs::write(&dest, obj.data)?;
+                if entry.mode == git_index::entry::Mode::FILE_EXECUTABLE {
+                    #[cfg(unix)]
+                    fs::set_permissions(&dest, fs::Permissions::from_mode(0o777)).unwrap();
+                }
+                let met = std::fs::symlink_metadata(&dest)?;
+                // Set both fields to mtime if ctime is not present and vice-versa
+                // If both fields are not present, will raise an Err
+                let ctime = met
+                    .created()
+                    .map_or(Ok(Duration::from_secs(0)), |x| x.duration_since(std::time::UNIX_EPOCH));
+                let mtime = met
+                    .modified()
+                    .map_or(Ok(Duration::from_secs(0)), |x| x.duration_since(std::time::UNIX_EPOCH));
+                entry_time.push((ctime?, mtime?, i));
+            }
+            git_index::entry::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 {
+                    std::fs::write(&dest, obj.data)?;
+                }
+                let met = std::fs::symlink_metadata(&dest)?;
+                // Set both fields to mtime if ctime is not present and vice-versa
+                // If both fields are not present, will raise an Err
+                let ctime = met
+                    .created()
+                    .map_or(Ok(Duration::from_secs(0)), |x| x.duration_since(std::time::UNIX_EPOCH));
+                let mtime = met
+                    .modified()
+                    .map_or(Ok(Duration::from_secs(0)), |x| x.duration_since(std::time::UNIX_EPOCH));
+                entry_time.push((ctime?, mtime?, i));
+            }
+            git_index::entry::Mode::DIR => todo!(),
+            git_index::entry::Mode::COMMIT => todo!(),
+            _ => unreachable!(),
+        }
+    }
+    let entries = state.entries_mut();
+    for (ctime, mtime, i) in entry_time {
+        let stat = &mut entries[i].stat;
+        stat.mtime.secs = u32::try_from(mtime.as_secs())?;
+        stat.mtime.nsecs = mtime.subsec_nanos();
+        stat.ctime.secs = u32::try_from(ctime.as_secs())?;
+        stat.ctime.nsecs = ctime.subsec_nanos();
+    }
+    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,91 @@
+use crate::{dir_structure, fixture_path};
+use git_object::bstr::ByteSlice;
+use git_odb::FindExt;
+use git_worktree::{copy_index, Options};
+use std::fs;
+
+#[cfg(unix)]
+use std::os::unix::prelude::MetadataExt;
+
+type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
+
+#[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()
+                .map(|x| git_object::BlobRef::from_bytes(x.data).unwrap())
+        },
+        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::symlink_metadata(file1)?.mode() & 0b111 << 6 == fs::symlink_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()
+                .map(|x| git_object::BlobRef::from_bytes(x.data).unwrap())
+        },
+        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 file1.is_symlink() {
+            assert!(!file2.is_symlink());
+            assert!(fs::read(file2)?.to_path()? == fs::read_link(file1)?);
+        } else {
+            assert!(fs::read(file1)? == fs::read(file2)?);
+            #[cfg(unix)]
+            assert!(
+                fs::symlink_metadata(file1)?.mode() & 0b111 << 6 == fs::symlink_metadata(file2)?.mode() & 0b111 << 6
+            );
+        }
+    }
+
+    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
+}