I'm looking for a way to 'hide' minor changes made to a few files in Git, such that they will not show up in git status until a different change is made to those files.
Example: I have a java file where the only change made is the removal of an unused import (a contributor forgot to run an organize imports before committing). Now I have removed that import and the change (obviously) shows up in git. Since I have no other change to make to that file, I don't really like committing the file as part of another (unrelated) change or committing this change stand-alone. Sure, I could revert the change and only applying it whenever I will have to make changes to that file, but I could "risk" forgetting it.
Does a command exists for such a task? It would work somewhat like the assume-unchanged command but in a not permanent way.
What would be the proper way to resolve this if no such command is available?
Thanks in advance.
In my use case (developing using an edited config file on my personal machine, running on another machine with the unchanged config), this was the solution for me:
start ignoring changes to a file:
git update-index --assume-unchanged path/to/file
keep tracking again:
git update-index --no-assume-unchanged path/to/file
Just don't add the trivial changes.
It's good practice to carefully review the things that you add before committing.
You can even ignore some changes in a file while adding others, using
git add -p.
This is even easier if you use gitx (R).
Keep your changes that are not ready in a separate branch. git rebase this branch atop new changes in the main history as necessary.
Be it development in progress, temporary things, even things that are never to be included in the main project history -- the same process works equally well.
If/when the changes of the branch are ready to be included in the main history; merge it in. If not, keep them in the separate branch and continue rebasing.
(side note: git merge --no-ff may be of use to create a merge-commit even if a fast-forward merge is possible -- depending on the rules of your project, this may be preferable)
There are multiple ways [although may not be clean and neat and would require your attention]
- Add the file in concern to
.gitignore in your repo so that it doesn't show up for commit. Be careful to remove this from .gitignore when you are ready to commit the file
- Ensure you do not 'stage' the file while committing rest of your changes. You may want to write a wrapper over
git which will ensure commands like git commit -a or git add . run on all except the file under question. Another alternative would be to use git gui or git citool where you can visually ensure your file isn't in 'staged' area and hence never gets committed
- Another way would be to commit all your 'committable' changes and then
git stash save your only working file. Later when you are ready to change the file, you can git stash pop and continue working and committing.
Hope that helps :)
