How to move directory into a directory with the same name?

Question

I have a directory foo with several files:

.
└── foo
    ├── a.txt
    └── b.txt

and I want to move it into a directory with the same name:

.
└── foo
    └── foo
        ├── a.txt
        └── b.txt

I'm currently creating a temporary directory bar, move foo into bar and rename bar to foo afterwards:

mkdir bar
mv foo bar
mv bar foo

But this feels a little cumbersome and I have to pick a name for bar that's not already taken.

Is there a more elegant or straight-forward way to achieve this? I'm on macOS if that matters.

Answer 1

To safely create a temporary directory in the current directory, with a name that is not already taken, you can use mktemp -d like so:

tmpdir=$(mktemp -d "$PWD"/tmp.XXXXXXXX)   # using ./tmp.XXXXXXXX would work too

The mktemp -d command will create a directory at the given path, with the X-es at the end of the pathname replaced by random alphanumeric characters. It will return the pathname of the directory that was created, and we store this value in tmpdir.¹

This tmpdir variable could then be used when following the same procedure that you are already doing, with bar replaced by "$tmpdir":

mv foo "$tmpdir"
mv "$tmpdir" foo
unset tmpdir

The unset tmpdir at the end just removes the variable.

---

¹ _{Usually, one should be able to set the TMPDIR environment variable to a directory path where one wants to create temporary files or directories with mktemp, but the utility on macOS seems to work subtly differently with regards to this than the same utility on other BSD systems, and will create the directory in a totally different location. The above would however work on macOS. Using the slightly more convenient tmpdir=$(TMPDIR=$PWD mktemp -d) or even tmpdir=$(TMPDIR=. mktemp -d) would only be an issue on macOS if the default temporary directory was on another partition and the foo directory contained a lot of data (i.e. it would be slow).}

Answer 2

On macOS, you can install the rename command (a Perl script) using Homebrew:

brew install rename

Then using the -p (a la mkdir) to have it make any necessary directories, and -A to add a prefix:

% mkdir -p foo/bar; touch foo/{a,b}.txt foo/bar/c.txt
% rename -p -A foo/ foo/*
% tree foo
foo
└── foo
    ├── a.txt
    ├── b.txt
    └── bar
        └── c.txt

Run with -n to show changes without renaming (dry-run):

% rename -p -A foo/ foo/* -n
'foo/a.txt' would be renamed to 'foo/foo/a.txt'
'foo/b.txt' would be renamed to 'foo/foo/b.txt'
'foo/bar' would be renamed to 'foo/foo/bar'

If you have dot files, so that a simple * won't pick them up, then use other methods with rename:

• With bash, (mis)use GLOBIGNORE to get * to match dot files:

  $ GLOBIGNORE=.; rename -p -A foo/ foo/* -n
  'foo/.baz' would be renamed to 'foo/foo/.baz'
  'foo/a.txt' would be renamed to 'foo/foo/a.txt'
  'foo/b.txt' would be renamed to 'foo/foo/b.txt'
  'foo/bar' would be renamed to 'foo/foo/bar'
  

• Or use find with -print0 and rename with -0:

  % find foo -mindepth 1 -maxdepth 1 -print0 | rename -0 -p -A foo/ -n
  Reading filenames from STDIN
  Splitting on NUL bytes
  'foo/b.txt' would be renamed to 'foo/foo/b.txt'
  'foo/a.txt' would be renamed to 'foo/foo/a.txt'
  'foo/bar' would be renamed to 'foo/foo/bar'
  'foo/.baz' would be renamed to 'foo/foo/.baz'
  

Answer 3

As long as the contents are not sufficient to exceed the maximum parameter limits, (and you don't mind an "acceptable" error message) then it doesn't need to be any more complicated than this:

mkdir foo/foo
mv foo/* foo/foo

Amendment to handle hidden files:

mkdir foo/foo
mv foo/{.,}* foo/foo

Answer 4

I suggest the other way around. Don't move the directory, but only its content:

.
└── foo
    ├── a.txt
    └── b.txt

mkdir foo/foo

.
└── foo
    ├── foo
    ├── a.txt
    └── b.txt

cd foo
mv $(ls | grep -v '^foo$') foo
cd -

.
└── foo
    └── foo
        ├── a.txt
        └── b.txt

If you have bash, you can also do

shopt -s extglob
cd foo
mv !(foo) foo
cd -

(as described here) to avoid running ls and grep.

The advantage of this solution is that it's really simple.

Disadvantages (as pointed out in the comments):

• Cannot handle hidden files (ls -A fixes it, but not ls -a)
• Cannot handle filenames containing spaces (can be fixed by quotes: mv "$(ls | grep -v '^foo$')" foo
• Cannot handle filenames containing newlines and other special characters

Most disadvantages can be addressed by using some bash trick, but if one must handle crazy filenames, it's better to use more robust approach, as described in other answers.

Answer 5

You've pretty much nailed it already. You could pick a different name for the transient directory, such as the target name with the current date/time in nanoseconds and our PID as a composite suffix, but this still presupposes the directory doesn't already exist:

dir=foo                         # The directory we want to nest
now=$(date +'%s_%N')            # Seconds and nanoseconds
mkdir "$dir.$now.$$"            # Create a transient directory
mv -f "$dir" "$dir.$now.$$/"    # Move our directory inside transient directory
mv -f "$dir.$now.$$" "$dir"     # Rename the transient directory to the name with which we started

If you want a guaranteed robust solution, I would loop around the mkdir until it was successful

now=$(date +'%s_%N')
while ! mkdir -m700 "$dir.$now.$$" 2>/dev/null
do
    sleep 0.$$
    now=$(date +'%s_%N')
done

Answer 6

mkdir foo/foo && mv foo/!(foo) foo/foo

You need to cd into the directory where the source folder (foo) is.

Then run the command above. It will create a folder called of the same name and move the contents of the parent foo into the child foo directory (except the child directory, hence the ! designation).

If the child foo directory already exists you can ignore the first part and just run the mv command:

mv foo/!(foo) foo/foo

In MacOS you may need to set the extglob option:

shopt -s extglob

Answer 7

In addition to the suggestions above, you might want to checkout rsync. Before I even start, always remember to use the --dry-run option with rsync before running it without it. The --dry-run will tell you what would happen in real life.

rsync has many options that can not only help copy/move files, but also speed up the process. Here is one way to get your job done. The --remove-source-filesoption deletes files from the source after the move process (which is actually a copy followed by a delete). Notice that the rsync command first reads the contents of foo, creates the directory foo within the existing directory called foo, then starts the copy process. It ends with deleting the source files in foo. Caution: Pay particular attention to the slashes for the directory names.

There are other considerations as many have pointed above (like symlinks), but a man rsync will help you pick the options that you need. A note here: Since you have asked for a solution for files, this will work. This will not remove empty directories that will be left behind. I am not aware of a way to do so without an additional step, so if anyone can add to this, thanks in advance!

mkdir foo
cd foo
touch aaa bbb ccc ddd
cd ..
rsync -av --remove-source-files foo foo/

a = archive mode

v = verbose

Answer 8

Simply don't touch foo and you don't have issues with identical names. Instead, create a directory with the same name inside it and move everything there. Use the $_ trick for that and && to make it a one-liner:

cd foo && mkdir $_ && mv * $_

This will throw a harmless error (mv: rename foo to foo/foo: Invalid argument) that you can ignore.

Advantage over other answers: You only need to type the directory name once, so you can't make mistakes with typos.

---

you can mix this with other answers for even better effect:

• mv {.,}* $_ will take care of hidden files (at the cost of more errors that you can also ignore)
• mv ./!(foo) will avoid the error message, but only if you set shopt -s extglob

Answer 9

This is actually deceptively simple and I'm shocked nobody else has offered this answer yet, so here I go Using the following for example...

$ mkdir foo
$ mkdir bar
$ mkdir ./bar/foo
$ touch ./bar/foo/file1 && touch ./bar/foo/file2 && touch ./bar/foo/file3
$ ls ./
bar/ foo/
$ ls ./bar/foo
file1 file2 file3

Now comes the magic part

$ mv ./bar/foo ./foo/
$ ls ./foo/
foo/
$ ls ./foo/foo/
file1 file2 file3

Now why does this work? I can't give you the most precise answer as I'm just a neophyte - but I understand it comes down to how trailing / characters are treated on folders.

Look closely at that mv command

$ mv ./bar/foo ./foo/

Notice how the target folder of files is specified without a trailing /, while the destination sharing the target folder's name has been specified using a trailing /'. This is your magic ticket, and can bite you in the ass if you aren't paying attention.

I'm sorry I can't offer a more elaborate answer than that at present, but perhaps someone more fluently knowledgeable will take the liberty of editing my answer.

In any event, this would seem to be the most simple and straightforward solution, with a single use of the ls command and no creation of intermediary folders.

Hope it works for you, cheers!