Error when glob matches directory

[conradz]

Currently it throws an error (EISDIR) when the glob matches a directory. I want to copy all files and directory structure to another directory. I am using cpy(['**/*'], '../output/dist', { cwd: 'assets', parents: true }, cb);. This does not work since **/* also matches the directory names.

I could make a PR to fix this if you know what behavior we should have. Should we just ignore empty directories or create them? I'm currently leaning toward creating any directories, which I think is the most intuitive.

[schnittstabil]

The options are also passed to node-glob. This should do what you want:

cpy(['**/*'], '../output/dist', { cwd: 'assets', parents: true, nodir: true }, cb);

[schnittstabil]

Or did you expect, that cpy should also copy (empty) directories? (Atm cpy only copies files.)

[conradz]

OK, the nodir option does fix my use case (somehow I never saw that option in the list). I think it would be nicest to copy empty directories, but I don't actually need it.

[pgilad]

I ran into the same issue. I think cpy(['**/*']) should copy entire directory and preserve empty directories. That means that cp-file should be able to copy a blank directory (without included files).

[schnittstabil]

@pgilad It would be the easiest to support this feature within cp-file, but that is out of the scope of cp-file: cp-file can be compared with fs.rename, fs.symlink or fs.mkdir.

[schnittstabil]

@conradz, @pgilad: I think a recursive option would make more sense:

• cpy(['./**/*'], …): copy all files under .
• cpy(['.'], …, {recursive: true}, …): copy the whole directory

@sindresorhus, @kevva: What do you think?

[schnittstabil]

Or, even better:

• cpy(['./**/*'], …): copy all files and folders under .
• cpy(['./**/*'], …, {nodir: true }, …): copy only files
• cpy(['./**/*/'], …): copy the directory structure (w/o files)

[sindresorhus]

cpy(['./*//'], …): copy the directory structure (w/o files)

I don't like how a trailing / can completely change the behaviour.

[schnittstabil]

@sindresorhus: cpy already handle trailing /, via globby, e.g:

> globby.sync('node_modules/globby/*/')
[ 'node_modules/globby/node_modules/' ]

My last suggestion is the same @conradz already suggested, which I hadn't thoroughly thought out:
if cp-file fails because src is a directory, cpy creates the appropriate dest directory.

But I do not know whether this makes sense:

The following would neither copy a single file nor throw an error:

cpy(['node_modules'], 'dist', …) // same as `mkdir dist/node_modules`

Comparing the behavior of cp, a --recursive option seems to offer a way out of this dilemma:

$ cp node_modules dist
cp: omitting directory 'node_modules'
$ echo $?
1

$ cp --recursive node_modules/ dist
$ echo $?
0

But I think it is not worth it. Especially in combination with globbing, --recursive may lead to problems, which are much too complicated to handle:

cpy(['**/node_modules'], …, {recursive: true}, …)
// apply cp-file by means of eachAsync to:
// 'node_modules',
// 'node_modules/globby/node_modules',
// …

[sindresorhus]

As a user it would make sense that cpy(['node_modules'], 'dist', …) actually copied the whole node_modules directory with files into dist.

I wonder how the behaviour of ncp compares.

[helmoski]

nodir is not currently an option for CLI

[schnittstabil]

But I think it is not worth it. Especially in combination with globbing, --recursive may lead to problems, which are much too complicated to handle…

Things have changed, today cpy and the underlying globby use Promises which simplifies many aspects of this problem.

@sindresorhus Hence, I would like to implement a recursive option for globby and use it within cpy (by default, no option).

[sindresorhus]

👍 Go for it :)

[schnittstabil]

It turns out, that a globby option is rather unattractive (sindresorhus/globby#24)

@sindresorhus If the following behavior is acceptable, then the things will become much easier:

$ tree 
.
└── src
    └── index.js

$ cpy --recursive 'src' '!**/*.js' 'dest'

$ tree 
.
├── dest
│   └── index.js
└── src
    └── index.js

I think that this is reasonable; it's similar to bash and cp: the patterns are evaluated before cp is called.

[sindresorhus]

I don't get it. In your example '!**/*.js' is moot. Did you mean to add more nested files to the src folder tree?

[schnittstabil]

I can think of two ways how negative patterns can have an effect in in conjunction with --recursive:

$ tree 
.
└── src
    └── index.js
    └── index.css

• Glob first:

cpy --recursive 'src' '!**/*.js' 'dest'
# equals to
cpy --recursive 'src' 'dest'

# => also copies 'src/index.js' to 'dest'

• --recursive changes globbing:

cpy --recursive 'src' '!**/*.js' 'dest'
# equals to
cpy 'src' 'src/index.css' 'dest'

# => does not copy 'src/index.js' to 'dest'

The first one is similar to bash and cp, but personally I would prefer the second one.

[danielweck]

Related issue: sindresorhus/cpy-cli#10 (comment)
=> usage of glob **/*.* vs. **/*, typically matches folder names (no filename extension)