Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

How to stage only part of a new file with git?

Tags:

git

People also ask

Is it possible to stage only some part of file git?

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.

What command is used to stage only some changes in a file?

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.

How do I stage changes in git?

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
  • Hint If you're sure the 'empty' blob already exists in your git object database, you could hardcode the hash e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 instead. I don't recommend doing that_
  • Hint If you're on Windows, you probably can just use 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.

Git Gui screenshot


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.