Inside /my/source/.git there is a non-bare git repo with objects, history, etc... Then I want to copy the contents of that directory to a whole other directory at /my/dest/.git, which is empty.

let source = PathBuf::from("/my/source/.git");
let dest = PathBuf::from("/my/dest/.git");

fs_extra::dir::create(&dest, true); // create with erase

let mut copts = fs_extra::dir::CopyOptions::new();
copts.overwrite = true;
copts.copy_inside = true;

let _ = fs_extra::dir::copy(&source, &dest, &copts);

After this I would expect to see the following inside /my/dest/.git:

/
    my/
        dest/
            .git/
                refs/
                objects/
                ...

But instead I see (note nested .git inside .git)

/
    my/
        dest/
            .git/
                .git/
                    refs/
                    objects/
                    ...

This looks like the dest path should be the parent directory to where I want to copy the first directory? Documentation states:

Copies the directory contents from one place to another using recursive method.

I would assume this means that the contents from source directory become the contents of destination directory, while the directory itself is not copied anywhere?

I'm using fs_extra 1.1.0 and latest stable Rust.

hey. I want to copy all files and folders from "a" folder to "b" folder. I tried to use dir::get_dir_content and iterate with ::copy_item, but I couldn't came up with a simple solution. I was able to copy "a" folder inside the "b" folder, but this is not what I want to do.

Is there a simple solution to this problem? If yes, I would love to see it in examples. If no, an additional function would be great.

~This makes dir::get_size give a correct calculation of the size of a path of directory, that now matches that returned by eg: du --bytes -s <path>.~ (Due to changes requested during review, this is no longer the case.)

Before:

• Symlinks were followed, causing double-counting of symlinked files (see #59).
• Whilst the metadata size of subdirectory entries was counted correctly, the metadata size of the parent directory (the initial path passed into dir::get_size) was not counted. See: https://github.com/webdesus/fs_extra/issues/25#issuecomment-1172428052

Now:

• Symlinks are no longer followed (fixing the regression from #34), so that only the size of the symlink itself is included (as expected), and not the size of the symlink's target.
• ~If the initial path passed into dir::get_size is a directory, the size of that directory entry itself is now correctly counted (like it was already being counted for subdirectories).~ Due to changes requested during review, this is no longer the case. The metadata size of the directory entries (entries only, not the contents) is now excluded entirely from the total size.

In addition, the size calculations are performed using DirEntry::metadata, rather than unnecessarily converting to a path and then passing that path to fs::{metadata,symlink_metadata}.

Fixes #25. Fixes #59.

I am using standard example from documentation.

dir::copy(&src, &dst, &dir_options)?;
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `std::convert::From<fs_extra::error::Error>` is not implemented for `std::io::Error`

Same for file::copy.

I hope fs_extra's copy for directory can simulate cp command. e.g., cp d1 d2, if d2 does not exist it copy the whole directory d1 to d2 (in this ase d1 and d2 in same folder with same substructure); if d2 exists, copy d1 into d2 (as what has been implemented). The default behavior can be changed by modifying CopyOptions.

In my application, I need to get the size of a directory, and in order to avoid having to re-invent the wheel I was planning to use the dir::get_size method provided by this library (thanks for your work!).

Unfortunately though, the results I am getting differ from the ones expected (I am targeting a Linux machine). This is because the implementation does not return the size of a directory, but the sum of all the sizes of its files, without taking into account the size of the directory structure itself.

You can quickly test this behaviour on a Linux machine by running the mention method on a given directory, and then running for the same directory the command du --bytes -s {dir_path}.

If this is the expected behaviour, I would simply suggest to explicitly state it in the documentation in a clear way.

If this is not the expected behaviour, it can be easily fixed by slightly changing the implementation:

pub fn get_size<P>(path: P) -> Result<u64>
where
    P: AsRef<Path>,
{
    let mut result = 0;

    if path.as_ref().is_dir() {
        for entry in read_dir(&path)? {
            let _path = entry?.path();
            if _path.is_file() {
                result += _path.metadata()?.len();
            } else {
                result += get_size(_path)?;
            }
        }
        // add the directory data structure size
        result += path.as_ref().metadata()?.len();
    } else {
        result = path.as_ref().metadata()?.len();
    }
    Ok(result)
}

I understand this will also require some work to update the tests to reflect the new implementation. Please let me know if support is needed for this (can't promise when I'll be able to have a deeper look into this in case it's required).

Using Default trait for default values is probably more idiomatic for Rust. In this case, it has a benefit that if a user doesn't need to change anything from the default value, they can simply do Default::default() rather than having to reference the CopyOptions types.

Currently DirInfo.directories returns all directories recursively, but I need only to loop through children directories. I thought it was weird that it returns a recursive result by default. Can you add child_directories or change it to get_directories(recursive: bool)?

Hey, what's the difference between SkipExisting and Overwrite? I mean doesn't overwrite selected mean don't skip existing and and not checked means skip existing? fs_extra::dir::CopyOptions

Err(Error { kind: NotFound, message: "Path "/Users/edison/Downloads/123\ aaaa/归档(5)/panda" does not exist or you don't have access!" })

I'm getting the following error:

thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Error { kind: NotFound, message: "No such file or directory (os err
or 2)" }', src/main.rs:4:82

although it should work (I think).

Reproduction steps

Create test directory:

mkdir -p /tmp/rofl1/yeet
touch /tmp/rofl1/test.txt
touch /tmp/rofl1/yeet/bruh.txt

Cargo.toml

[package]
name = "rust_tmp"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
fs_extra = "1.2.0"

src/main.rs

use fs_extra::dir::CopyOptions;

fn main() {
    fs_extra::dir::copy("/tmp/rofl1", "/tmp/rofl2", &CopyOptions::new()).unwrap();
}

What am I doing wrong?

Hi, we use fs_extra in Nushell; thanks for writing it!

We recently had a scary bug report, and it looks like the root cause is fs_extra::dir::move_dir(). If you use move_dir() to change the case of a directory name on Windows (ex: "Test" -> "test"), the directory is deleted and fs_extra reports success.

For example:

// This deletes the directory named Test and does not panic!
fs_extra::dir::move_dir("Test", "test", &options).unwrap();

Steps to Reproduce

I've put together a minimal repro: https://github.com/rgwood/fs-extra-repro

Version Info

fs-extra v1.2.0 Windows 11 (can't reproduce on Linux) rustc v1.63.0

Summary

If one of the file entries being copied by fs_extra::dir::copy happens to be a symlink to a directory, then that symlink is converted to a real directory as part of copying, resulting in (a) duplicate file contents in the destination directory, (b) non-identical contents between source and destination (which defeats the point of copying a directory verbatim).

Note: Symlinks to files are preserved, this is just about symlinks that target directories.

Steps to reproduce

Using fs_extra = "=1.2.0" with rustc 1.63.0-beta.3 on macOS 12.4, run the following:

use fs_extra::dir::CopyOptions;
use std::fs::{self, File};
use std::path::{Path, PathBuf};

fn main() {
    let source_dir = PathBuf::from("source");
    let destination_dir = PathBuf::from("destination");
    if source_dir.exists() {
        fs::remove_dir_all(&source_dir).unwrap();
    }
    if destination_dir.exists() {
        fs::remove_dir_all(&destination_dir).unwrap();
    }

    let subdir = source_dir.join("subdir");
    fs::create_dir_all(&subdir).unwrap();
    File::create(&subdir.join("file.txt")).unwrap();
    create_dir_symlink("subdir", &source_dir.join("symlink-to-subdir")).unwrap();

    let options = &CopyOptions {
        content_only: true,
        ..CopyOptions::default()
    };
    fs_extra::dir::copy(source_dir, destination_dir, options).unwrap();
}

#[cfg(target_family = "unix")]
fn create_dir_symlink<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> std::io::Result<()> {
    std::os::unix::fs::symlink(original.as_ref(), link.as_ref())
}

#[cfg(target_family = "windows")]
fn create_dir_symlink<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> std::io::Result<()> {
    std::os::windows::fs::symlink_dir(original.as_ref(), link.as_ref())
}

Expected

The contents of source/ and destination/ to be identical, and for any symlinks targetting directories to be preserved as symlinks.

Actual

The source/ and destination/ directories have different contents, with the symlinked directory now being a real directory containing duplicate files.

Source:

$ ls -alR source/
source/:
total 0
drwxr-xr-x  4 emorley staff 128 Jul  6 14:03 .
drwxr-xr-x 10 emorley staff 320 Jul  6 14:03 ..
drwxr-xr-x  3 emorley staff  96 Jul  6 14:03 subdir
lrwxr-xr-x  1 emorley staff   6 Jul  6 14:03 symlink-to-subdir -> subdir

source/subdir:
total 0
drwxr-xr-x 3 emorley staff  96 Jul  6 14:03 .
drwxr-xr-x 4 emorley staff 128 Jul  6 14:03 ..
-rw-r--r-- 1 emorley staff   0 Jul  6 14:03 file.txt

Destination:

$ ls -alR destination/
destination/:
total 0
drwxr-xr-x  4 emorley staff 128 Jul  6 14:03 .
drwxr-xr-x 10 emorley staff 320 Jul  6 14:03 ..
drwxr-xr-x  3 emorley staff  96 Jul  6 14:03 subdir
drwxr-xr-x  3 emorley staff  96 Jul  6 14:03 symlink-to-subdir

destination/subdir:
total 0
drwxr-xr-x 3 emorley staff  96 Jul  6 14:03 .
drwxr-xr-x 4 emorley staff 128 Jul  6 14:03 ..
-rw-r--r-- 1 emorley staff   0 Jul  6 14:03 file.txt

destination/symlink-to-subdir:
total 0
drwxr-xr-x 3 emorley staff  96 Jul  6 14:03 .
drwxr-xr-x 4 emorley staff 128 Jul  6 14:03 ..
-rw-r--r-- 1 emorley staff   0 Jul  6 14:03 file.txt

          if let Err(e) = fs_extra::dir::move_dir(&thing, &destination_file, &fs_extra::dir::CopyOptions::new()) {
                messages += format!("Failed to move folder {}, reason {}\n", thing, e).as_str();
                continue 'next_result;
            }

such code prints(error contains file name)

Failed to move file /home/rafal/TESTTT/TT/AutoSave_0091.sav, reason Path "/home/rafal/TESTTT/TT/AutoSave_0091.sav" is exist

but such code from std::fs don't print name of file/folder which is I think better, because I can put this name in any other place

        if let Err(e) = fs::metadata("/hehe") {
            messages += format!("HEHE {}, reason {}\n", thing, e).as_str();
            continue 'next_result;
        }

HEHE /hehe reason No such file or directory (os error 2)