Convert a Git working directory to a bare-like repository?

Question

Our development environment uses multiple repositories as part of an overall build system. The build dynamically adapts depending on which repositories you have checked out: if you don't need to build a particular component, just don't clone it.

However, once you have cloned a component, removing it from the build is problematic:

• You can delete the files in the working directory, but git status will show uncommitted changes
• You can delete the repository, at the expense of re-cloning when you need it again
• You can move the repository, but your multi-repo tools might "helpfully" re-clone

Is there a better way to remove the working directory's files? Something akin to hg co null or p4 sync ...#none?

Answer 1

After finding similar questions that didn't quite do what I want, this article provided the answer: create an empty branch.

git checkout --orphan empty
git rm -rf .
git commit --allow-empty -m "An empty working directory"

Of course, ensure you've committed any important files to your repo first. I've called this branch empty, but you can give it any name via the checkout command.

Once set up, you can switch to any branch to get your files back:

git checkout master

When you need to "remove" the working directory, commit your changes, then run:

git checkout empty

This removes all tracked files. If you also need to remove untracked files and directories, follow this up with:

git clean -fdx

Answer 2

git clean can be used with various arguments to remove items that aren't checked in and committed, and sounds like a much better option than anything you came up with above. Creating a new branch seems completely counter intuitive as does committing false changes that erase things just to be restored separately.

For many of my own CI build scripts I do use something like this to make sure the build area is 100% pristine to what git has for it: git clean -f -x -d

However upon further reading, the confusing nature of your problem becomes slightly more evident. It sounds like you have multiple seperate repositories in a common folder and your 'build' process separately uses them all for various things.

I could come up with two obvious ways to address the problem:
1. Subtree merging : Create a repo/branch whose sole purpose is for you to subtree merge the desired versions of other repos in together so that you have a repeatable build
2. Use symlinks to the repos in your 'build' directory so that you can blow away symlinks to repo's that you don't want taking part in a given build without blowing away the repo's existence only to be recloned later.

Answer 3

You can use the --assume-unchanged feature:

git ls-files big-unused-component | xargs git update-index --assume-unchanged

Then, you can remove your files:

rm -rf big-unused-component

The first command lists all the tracked files in the big-unused-component directory, and then update-index --assume-unchanged sets the "assume this file is unchanged" bit in the Git index. Then, when you remove that whole directory, Git doesn't consider that a change.

To undo the effect of the previous command, repeat it with --no-assume-unchanged. The git ls-files -v command can show you which files have been ignored in this way.