Staging PatchesIt's also possible for Git to stage certain parts of files and not the rest. For example, if you make two changes to your simplegit. rb file and want to stage one of them and not the other, doing so is very easy in Git.
git add -p is basically "git add partial (or patch)" Patch mode allows you to stage parts of a changed file, instead of the entire file. This allows you to make concise, well-crafted commits that make for an easier to read history.
First, you edit your files in the working directory. When you're ready to save a copy of the current state of the project, you stage changes with git add . After you're happy with the staged snapshot, you commit it to the project history with git commit .
Whoa, all that update-index
and hash-object
business seems overly complicated. How about this instead:
git add -N new_file
git add -i # or 'git add -p' if you prefer
From git help add
:
-N, --intent-to-add
Record only the fact that the path will be added later. An entry
for the path is placed in the index with no content. This is useful
for, among other things, showing the unstaged content of such files
with git diff and committing them with git commit -a.
git update-index --add --cacheinfo 100644 $(git hash-object -w /dev/null) newfile
git add --interactive newfile
Simple demo:
mkdir /tmp/demo
cd /tmp/demo
git init .
echo hello > newfile
git update-index --add --cacheinfo 100644 $(git hash-object -w /dev/null) newfile
e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
instead. I don't recommend doing that_NUL:
instead of /dev/null
. Otherwise, use something like echo -n '' | git hash-object --stdin -w
Now the index will contain newfile
as the empty blob, and the empty blob has been entered into the object database if it didn't exist yet:
$ find .git/objects/ -type f
.git/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391
$ git status
# On branch master
#
# Initial commit
#
# Changes to be committed:
# (use "git rm --cached <file>..." to unstage)
#
# new file: newfile
#
# Changed but not updated:
# (use "git add <file>..." to update what will be committed)
# (use "git checkout -- <file>..." to discard changes in working directory)
#
# modified: newfile
#
$ git diff
diff --git a/newfile b/newfile
index e69de29..ce01362 100644
--- a/newfile
+++ b/newfile
@@ -0,0 +1 @@
+hello
This should be precisely what you want. May I also recommend the vim fugitive plugin for very intelligent index management (see Better git add -p?)
The easiest way to do this (and imho interactive staging in general) is git gui
. It comes bundled with git and should work on almost all platforms that are supported by git.
Simply run git gui
and a gui will open that allows staging and unstaging hunks and even single lines of tracked and untracked files.
Edit: this doesn't seem to be working now. I'm sure it was before (on git 1.7.1). In case it doesn't work, I suggest staging /dev/null
as sehe suggests above:
git update-index --add --cacheinfo 100644 $(git hash-object -w /dev/null) newfile
If you're on Windows (without /dev/null
) then you can replace it with the path to an empty file.
Original answer
You want
git add -p # (or --patch)
This adds untracked files for me. From the man page:
Interactively choose hunks of patch between the index and the work tree and add them to the index. This gives the user a chance to review the difference before adding modified contents to the index.
This effectively runs add --interactive, but bypasses the initial command menu and directly jumps to the patch subcommand. See “Interactive mode” for details.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With