www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Copying and moving directories

reply Chris <wendlec tcd.ie> writes:
In `std.file`, I haven't found a function that allows me to move 
or at least copy directories, as in `mv dir /toDir`. Do I have to 
go the awkward way over `rename` or something?
Feb 16
next sibling parent reply Adam D. Ruppe <destructionator gmail.com> writes:
On Thursday, 16 February 2017 at 16:38:51 UTC, Chris wrote:
 In `std.file`, I haven't found a function that allows me to 
 move or at least copy directories, as in `mv dir /toDir`. Do I 
 have to go the awkward way over `rename` or something?
Have you already tried just renaming the directory?
Feb 16
parent reply Chris <wendlec tcd.ie> writes:
On Thursday, 16 February 2017 at 16:41:48 UTC, Adam D. Ruppe 
wrote:
 On Thursday, 16 February 2017 at 16:38:51 UTC, Chris wrote:
 In `std.file`, I haven't found a function that allows me to 
 move or at least copy directories, as in `mv dir /toDir`. Do I 
 have to go the awkward way over `rename` or something?
Have you already tried just renaming the directory?
Yes, but that's a bit awkward. It'd be handier to have a function like `mv(dir, toDir)`.
Feb 16
parent reply Jonathan M Davis via Digitalmars-d-learn writes:
On Thursday, February 16, 2017 16:47:05 Chris via Digitalmars-d-learn wrote:
 On Thursday, 16 February 2017 at 16:41:48 UTC, Adam D. Ruppe

 wrote:
 On Thursday, 16 February 2017 at 16:38:51 UTC, Chris wrote:
 In `std.file`, I haven't found a function that allows me to
 move or at least copy directories, as in `mv dir /toDir`. Do I
 have to go the awkward way over `rename` or something?
Have you already tried just renaming the directory?
Yes, but that's a bit awkward. It'd be handier to have a function like `mv(dir, toDir)`.
Well, there's zero difference between renaming the file or directory and moving it. It's simply a difference in name. rename actually comes from POSIX, where rename is used in C code, and mv is used in the shell. So, I guess that you can blame POSIX. But there really isn't any reason to have a mv or move function in addition to rename. If you want mv instead, just alias rename to mv. However, I would point out that rename has the problem (at least on *nix - not sure about Windows) that it can't move across filesystem boundaries. I think that at some point, an alternative which did work across filesystem boundaries was proposed, and that may have been called move. It's not currently in Phobos though. - Jonathan M Davis
Feb 16
next sibling parent reply Kagamin <spam here.lot> writes:
On Thursday, 16 February 2017 at 17:06:30 UTC, Jonathan M Davis 
wrote:
 Well, there's zero difference between renaming the file or 
 directory and moving it. It's simply a difference in name.
Isn't there a difference? I though move("/path/dir1","dir2") moves folder to current directory and changes its name to dir2 rename("/path/dir1","dir2") leaves folder where it was and only changes its name to dir2
Feb 17
parent Jonathan M Davis via Digitalmars-d-learn writes:
On Friday, February 17, 2017 08:48:03 Kagamin via Digitalmars-d-learn wrote:
 On Thursday, 16 February 2017 at 17:06:30 UTC, Jonathan M Davis

 wrote:
 Well, there's zero difference between renaming the file or
 directory and moving it. It's simply a difference in name.
Isn't there a difference? I though move("/path/dir1","dir2") moves folder to current directory and changes its name to dir2 rename("/path/dir1","dir2") leaves folder where it was and only changes its name to dir2
No, rename does change the whole path, just like mv would. If you want to just change the last part of the path, then you need to supply the entire path again but just change the last part. e.g. this passes: import std.file; void main() { scope(exit) if("a".exists) rmdirRecurse("a"); scope(exit) if("c".exists) rmdirRecurse("c"); mkdirRecurse("a/b"); assert("a".exists); assert(!"c".exists); assert("a/b".exists); assert(!"a/c".exists); rename("a/b", "c"); assert("a".exists); assert("c".exists); assert(!"a/b".exists); assert(!"a/c".exists); } Maybe there's another language that declares a move function and a rename function like you describe, but POSIX has rename for C and mv for shell, and both of them change the whole path, and on POSIX systems, D has just wrapped the POSIX rename function, so its behavior is the same. http://www.unix.com/man-page/FreeBSD/2/rename/ https://linux.die.net/man/2/rename - Jonathan M Davis
Feb 17
prev sibling parent reply Chris <wendlec tcd.ie> writes:
On Thursday, 16 February 2017 at 17:06:30 UTC, Jonathan M Davis 
wrote:
 Well, there's zero difference between renaming the file or 
 directory and moving it. It's simply a difference in name. 
 rename actually comes from POSIX, where rename is used in C 
 code, and mv is used in the shell. So, I guess that you can 
 blame POSIX. But there really isn't any reason to have a mv or 
 move function in addition to rename.
`mv` or `move` would be more intuitive. I actually looked for names similar to the operations available in the shell (cp/copy, mv/move). It took me a few minutes to realize I had to use `rename` (which is poorly documented). But it is counter-intuitive. When you use a GUI, `rename` doesn't change the location. `rename` is a bit "techy", you have to go "wait a minute, when you think about it, rename should do the same". But that's not good enough for a library function. One of D's slogans is `simple things should be simple`, so moving a file should be `move(dir, toDir)`. Seriously, you don't want to spend much time on stuff like that.
 If you want mv instead, just alias rename to mv.

 However, I would point out that rename has the problem (at 
 least on *nix - not sure about Windows) that it can't move 
 across filesystem boundaries. I think that at some point, an 
 alternative which did work across filesystem boundaries was 
 proposed, and that may have been called move. It's not 
 currently in Phobos though.

 - Jonathan M Davis
That is actually a bit of a problem. First, I might want to store backup files on a different device. Second, loads of applications need this nowadays to interact with MP3 players, ebook readers etc.
Feb 17
parent reply Jonathan M Davis via Digitalmars-d-learn writes:
On Friday, February 17, 2017 11:00:30 Chris via Digitalmars-d-learn wrote:
 On Thursday, 16 February 2017 at 17:06:30 UTC, Jonathan M Davis

 wrote:
 Well, there's zero difference between renaming the file or
 directory and moving it. It's simply a difference in name.
 rename actually comes from POSIX, where rename is used in C
 code, and mv is used in the shell. So, I guess that you can
 blame POSIX. But there really isn't any reason to have a mv or
 move function in addition to rename.
`mv` or `move` would be more intuitive. I actually looked for names similar to the operations available in the shell (cp/copy, mv/move). It took me a few minutes to realize I had to use `rename` (which is poorly documented). But it is counter-intuitive. When you use a GUI, `rename` doesn't change the location. `rename` is a bit "techy", you have to go "wait a minute, when you think about it, rename should do the same". But that's not good enough for a library function. One of D's slogans is `simple things should be simple`, so moving a file should be `move(dir, toDir)`. Seriously, you don't want to spend much time on stuff like that.
Well, there's a _long_ history of it being called rename on POSIX systems, and since the D function is a simple wrapper around rename, it makes sense that it's called rename, much as I agree that the name isn't the best for anyone not familiar with the C function. Regardless, changing it now would break code, and at this point, we pretty much never rename public symbols in Phobos just to improve their names.
 If you want mv instead, just alias rename to mv.

 However, I would point out that rename has the problem (at
 least on *nix - not sure about Windows) that it can't move
 across filesystem boundaries. I think that at some point, an
 alternative which did work across filesystem boundaries was
 proposed, and that may have been called move. It's not
 currently in Phobos though.
That is actually a bit of a problem. First, I might want to store backup files on a different device. Second, loads of applications need this nowadays to interact with MP3 players, ebook readers etc.
Yes, it is a problem, but we would have to implement our own function to do it, because the underlying system calls don't support moving files across filesystem boundaries. At that point, what you're fundamentally doing is copying the file or directory and then deleting the original. It's not actually possible to simply move files across filesystem boundaries (which is why the system call works the way it does). Any language or library which supports moving across file system boundaries implemented its own solution rather than simply using a system call. And we probably should add some sort of move function to std.file that works more like mv (leaving rename to wrap the system call and act like someone familiar with the POSIX function would expect while providing a more user-friendly - but somewhat less efficient - function for moving files from anywhere to anywhere), but thus far, no one has added such a function to Phobos. We don't even have one that copies recursively (there's a PR in limbo for that one, but there were issues with the implementation and disagreement on how it should work - I basically wanted it to act like cp - which the PR doesn't - whereas others thought that that was a terrible idea). So, while what std.file has is nice and cross-platform and more pleasant than dealing with the underlying system calls even when you don't care about being cross-platform, it could definitely use some work to make some aspects of it more user-friendly. Most of what is there are fairly thin wrappers around systems calls. Sadly, my workaround has generally been to use std.process to use cp or mv, but there are also plenty of cases where I would have had to do that anyway, because I needed sudo (which AFAIK can't be done without the shell - though I'd love to learn how if it is). - Jonathan M Davis
Feb 17
parent Chris <wendlec tcd.ie> writes:
On Friday, 17 February 2017 at 11:40:35 UTC, Jonathan M Davis 
wrote:
 Well, there's a _long_ history of it being called rename on 
 POSIX systems, and since the D function is a simple wrapper 
 around rename, it makes sense that it's called rename, much as 
 I agree that the name isn't the best for anyone not familiar 
 with the C function. Regardless, changing it now would break 
 code, and at this point, we pretty much never rename public 
 symbols in Phobos just to improve their names.
Nobody wants to rename `rename` :-) But an additional `move` function would be nice.
 [...]
I agree. std.file needs more work.
Feb 17
prev sibling parent Daniel =?UTF-8?B?S296w6Fr?= via Digitalmars-d-learn writes:
V Thu, 16 Feb 2017 16:38:51 +0000
Chris via Digitalmars-d-learn <digitalmars-d-learn puremagic.com>
napsáno:

 In `std.file`, I haven't found a function that allows me to move 
 or at least copy directories, as in `mv dir /toDir`. Do I have to 
 go the awkward way over `rename` or something?
http://forum.dlang.org/post/uzoxwrxsgeazugqohusp forum.dlang.org
Feb 16