It would be nice to have an ability to hook into underlying stream(s) to have this. This might be more tricky to get right WRT multiple files, though. Opening issue first to discuss.

Fixes #61 Fixes #84 Fixes #60

• [ ] optimize and refactor
• [x] update docs
• [x] add better typescript types
• [x] write more tests
• [x] handle rename option
• [x] copying folders structure
• [x] flattening file structure
• [x] current tests passing on windows
• [x] current tests passing on linux

Examples:

cpy('node_modules', 'web_modules') outputs web_modules/node_modules/module1 node_modules files are copied recursively and structure is preserved.

cpy('node_modules/**', 'web_modules') outputs web_modules/module1 node_modules files are copied recursively and structure is preserved. Only node_modules content will be copied to web_modules.

cpy('node_modules/**', 'web_modules', {flat: true}) outputs web_modules/file1 node_modules files are copied recursively and structure is not preserved. Only node_modules content will be copied to web_modules.

cpy('node_modules/**/*.cmd', 'web_modules') will recreate node_modules structure but all non cmd files will be ommited

• Add filter option

Fixes #63

Is this expected behavior for the CLI?

(at root of module)

flet@lappy:~/code/someproject$ ls assets/markup/
mock.html

flet@lappy:~/code/someproject$ cpy assets/markup/*.html dist

flet@lappy:~/code/someproject$ tree dist
dist
└── assets
    └── markup
        └── mock.html

I guess I was expecting it to work similarly to cp in linux?

flet@lappy:~/code/someproject$ cp assets/markup/*.html dist

flet@lappy:~/code/someproject$ tree dist
dist
└── mock.html

I realize this might not be the goal of this module and I'm prepared for this issue to be closed immediately :)

I'd like to copy an existing file to a new path, with a possible new name. The idea would be something like

cpy package.json Build/$npm_package_name-$npm_package_version.json

I think we would need an option for that. Or we could check for a trailing slash, like cp does. I would prefer the later one, I'm not sure if that's a good idea because it might break existing use cases.

It seems really unlikely to me that copying a bunch of files in parallel would speed anything up. Indeed, I would not be surprised to find it slowed things down. Increasing the number of files read simultaneously seems likely to encourage lots of seek delays for HDD's, and SSD's should be able to saturate their bandwidth regardless of how many files are being copied simultaneously.

It's probably worth running some benchmarks to prove this, but I think you would have seen Operating Systems commands / GUI's doing parallel copies if there were any advantage to it.

I guess technically, you could be copying from multiple slow network mounted drives - in which case parallelization might make sense. But I think that's a very small (possibly non-existent) percentage of users.

Hi,

If I want to copy all the html in assets directory and keep the directory structure inside dist directory I have to do the following command :

cpy '**/*.html' '../dist/' --cwd=assets --parents

I think the following command would be easier :

cpy 'assets/**/*.html' dist --parents

assets
├── index.html
├── robots.txt
└── test
    └── test.html

should return

dist
├── index.html
└── test
    └── test.html

not

dist
└── assets
    ├── index.html
    └── test
        └── test.html

npm -v
2.14.7

node -v
4.2.3

uname -a
Linux guillaume-x240 3.19.0-39-generic #44~14.04.1-Ubuntu SMP Wed Dec 2 10:00:35 UTC 2015 x86_64 x86_64 x86_64 GNU/Linux

here the red test https://github.com/guillaumevincent/cpy/commit/fad2b31882100ef914cc570cb84e8fd66b0197cf

cpy depends on globby @ ^12.0.2. Following the dependency chain, this also pulls in globby @ 9.2.0. That version of globby depends on fast-glob which depends on glob-parent at a specific version with a vulnerability.

| +-- [email protected]
| | +-- @types/[email protected]
| | | +-- @types/[email protected]
| | | `-- @types/[email protected]
| | +-- [email protected]
| | | `-- [email protected]
| | +-- [email protected]
| | | `-- [email protected]
| | |   `-- [email protected]
| | +-- [email protected]
| | | +-- @mrmlnc/[email protected]
| | | | +-- [email protected]
| | | | `-- [email protected]
| | | +-- @nodelib/[email protected]
| | | +-- [email protected] <---
| | | | +-- [email protected]
| | | | | `-- [email protected] deduped
| | | | `-- [email protected]

+-------------+------------------+----------+-------------------+---------------+---------------------------------------+
|   LIBRARY   | VULNERABILITY ID | SEVERITY | INSTALLED VERSION | FIXED VERSION |                 TITLE                 |
+-------------+------------------+----------+-------------------+---------------+---------------------------------------+
| glob-parent | CVE-2020-28469   | HIGH     | 3.1.0             | 5.1.2         | nodejs-glob-parent: Regular           |
|             |                  |          |                   |               | expression denial of service          |
|             |                  |          |                   |               | -->avd.aquasec.com/nvd/cve-2020-28469 |
+-------------+------------------+----------+-------------------+---------------+---------------------------------------+

The latest version of globby has a dependency tree which does pull in a fixed version of glob-parent.

cpy("path/to/__*.ext", destination)

doesn't copy, and throws no errors.

With the files renamed, this copies just fine:

cpy("path/to/_*.ext", destination)

At least copying recursively makes it necessary to use a two step approach:

1. gather all files and folders to process
2. do the actual copy

Substantial advantages:

• [x] determine errors due to mutually recursively linked directories in advance (see test below)
• [ ] remove duplicated tasks (same source and destination)
• [ ] determine copy tasks with same destination to throw errors in advance
• [ ] calculate the total size during the first step, and emitting the progress during the second step

The current approach of the first step:

1. use globby to gather all files and directories
2. for each directory path: re-glob with path + '/**/*'

@all Comments on all aspects are highly welcome.

When no destination directory is present, the attempt to copy files there results in error:

CpyError: `src` and `dest` required

Is there any way to configure to have it instead created like e.g. the default cp?

It would be great if the progress object would provide the information about the sourcePath and destinationPath.

One of my use cases requires copying folders with many files. The information about which file is being copied would be very useful.

I took a quick look at the code and the internal library cp-file already provides the desired information.

Is there any reason not to add this information to the ProgressData object?

{
  sourcePath: string,         <--
  destinationPath: string,    <--
  completedFiles: number,
  totalFiles: number,
  completedSize: number,
  percent: number,
}

given the following file structure:

src/
├── hello-world.js
└── README.md

running the following with 9.0.1:

cpy([
  'src/*.md', 
  'src/hello-world.js'
], 'dist')

creates:

dist/
├── src/
│   └── hello-world.js
└── README.md

Apologies if I misunderstood, but is this expected?

I would expect both globs to create the same out structure.

example here: https://replit.com/join/obiaxjzgca-sndrs

AFAICT: cpy uses graceful-fs, which in turn should use fs.copyFile to copy files. How fs.copyFile handles timestamps seems to be platform dependent. Now there's a new fs.cp in recent NodeJs versions that has a special option called preserveTimestamps, fs-extra has it too.

So I would like to propose to add this option in cpy as well - not only for files, but for directories too (cp -a).

Hey, i am not able to copy a directory structure with the whole structure any more. With v9.x i always end up getting a flattened result - what is my error?

In v8 i used

await cpy('**', destination, { parents: true, cwd: source });

and now i thought

await cpy(source, destination); or maybe await cpy(source+'/**', destination);

should work?

I tried cpy and it's awesome! However, when I try it on windows, copying a file from C: to the basedir of E:, I got an error saying it failed to create the E: directory. This is the error message:

Cannot copy from `C:/hello.txt` to `E:\hello.txt`: Cannot create directory `E:\`: EPERM: operation not permitted, mkdir 'E:\'

Hope it will be fixed soon :)