Shell Programming and Scripting

We both needed something before we replied to this thread. I noticed that you hadn't included -type f and then posted a fix that had its own problems. And fixed it, and fixed it again, and fixed it again in a period of about 10 minutes. And, unfortunately, I can't use lack of coffee as an excuse. (I have a caffeine allergy, so I never drink coffee.)

And, I don't think:

Code:

cd /path/to/sourcedir
find . -type d  -exec mkdir -p /path/to/targetdir{} \;
find . -type f ! -name "*.[wW][mM][vV]" -exec cp {} /path/to/targetdir +

does what you were thinking either. The first find does copy the directory hierarchy under sourcedir to targetdir, but the second find still copies all of the non-.wmv files to the targetdir directory; not to their corresponding places in the newly created hierarchy. And, find -exec command + can only be used when there is no more than one {} in the command, and, if there is one, it has to be the last operand in that command.

The OP's desired destination for the copied files seems ambiguous to me. I don't know if the intent is to duplicate the file hierarchy or if the intent is to flatten the file hierarchy into the single directory named as targetdir.

If the intention is to flatten the hierarchy, I still believe:

Code:

cd /path/to/sourcedir
find . -type f ! -name "*.[wW][mM][vV]" -exec cp {} /path/to/targetdir \;

is sufficient.

The the intention is to preserve the hierarchy, I believe we would need something like:

Code:

cd /path/to/sourcedir
find . -type d  -exec mkdir -p /path/to/targetdir{} \;
find . -type f ! -name "*.[wW][mM][vV]" -exec cp {} /path/to/targetdir{} \;

I believe this could be combined into a single find command to avoid walking the tree twice, but with the thousands of invocations of cp the additional complexity might overshadow any performance gain:

Code:

cd /path/to/sourcedir
find . \( -type d  -exec mkdir -p /path/to/targetdir{} \; \) -o \
       \( -type f ! -name '*.[wW][mM][vV]' -exec cp {} /path/to/targetdir{} \; \)

Are we having fun yet???

Like i can't in this case. Somehow this thread is bringing up the worst in us both. You are right in your assessment

Alas, this is not the case either, because "{}" can only be used once in a command.

Yes, we do. Here is my next suggestion. By now i am quite sure it will not do what i want, neither do what the thread-o/p wants and most probably be forbidden by law.

Code:

cd /path/to/sourcedir
find . -type d -exec mkdir -p /path/to/targetdir{} \;
find . -type f ! -name "*.[Ww][Mm][Vv]" -exec FNAME={} ; cp "$FNAME" "/path/to/targetdir$FNAME" \;

Aren't we a happy lot?

bakunin

On systems without GNU-tar I'd be tempted to use cpio.

Code:

cd /path/to/sourcedir
find . -depth ! -name "*.[Ww][Mm][Vv]" |  cpio -pdm /path/to/target

Why not? It appears to work.

My man on find says From that I would take it that supporting multipe {} could be a GNU extension.

With -exec ... +, {} is only required to be replaced by the current pathname if it is the last argument before the + and only if it is a separate argument.

With -exec ... \;, {} is required to be replaced by the current pathname every time it appears as a separate argument. As an extension to the standards, many implementations replace {} with the current pathname no matter where it occurs in an argument (beginning, middle, end of an argument as well as when it is a stand-alone argument). The standards say the behavior is unspecified if {} appears anywhere other than as a stand-alone argument.

On OS/X, the command:

Code:

find . -type f ! -name "*.[wW][mM][vV]" -exec cp {} /path/to/targetdir/{} \;

works, but (obviously) it isn't portable.

True! find ... | cpio -pd ... would perhaps be the most portable and elegant solution to this. What a shame i haven't even thought of that. Thanks for reminding me that there are alternatives to tar.

bakunin