19

Can git commit empty versions of some files? The case in point is that I need new (untracked), non-empty files to first be added and committed as empty files, so as to mark their contents as being new and to be reviewed (the full, untracked file should not be added to the index; git diff should show the newly added contents by comparing the file to its committed empty version).

There is git add -N file…, which puts file with an empty content in the index, but this only says that file will be added, and git commit complains that the file has not been added. The thing is that the current, non-empty version is not what has to be added, but only an empty version of the new file.

Is there a way to do this?

PS: This question is asked in the context of a program that automatically adds files to a git repository (my program follows what code students write). Uncommitted code is code that I have yet to approve. Thus, the state in which a program created by a student starts should be the empty state, even though my program just found a new, non-empty program in their home directory; this is handled by automatically committing a new, empty version of any new student program file in a git repository. Thus, new code lines that they write appear as being newly added contents, compared to the last committed git revision.

Improve this question
10
  • 1
    I honestly don't understand your problem. touch empty-file && git add empty-file && git commit works for me. Commented Nov 20, 2010 at 10:09
  • git diff works perfectly fine for a newly created file. If you diff a state when the file didn't exist with a diff when it has content, you will see all lines added, the exact same diff as diffing against an empty file. (Only the modelines are different.) Commented Nov 20, 2010 at 15:38
  • 1
    @joschi: The problem is that I have many new, non-empty files. Using Sven's approach #1 is more cumbersome that using his neat git-plumbing approach. Commented Nov 21, 2010 at 8:00
  • @Jefromi: The point is that there should not be any "state"/version where the file "has content" (only a version where the file is empty). New, non-empty files should thus not be committed, because this is a way for me, as a teacher, to mark student code as not having yet been approved. Commented Nov 21, 2010 at 8:03
  • @EOL: But then, until approval, the code is untracked! Scary! You could use committing to mark submission of the code, then mark approval by amending with a signed-off-by-line, or commit it to a "submitted" branch, then cherry-pick or merge it to an "approved" branch... Commented Nov 21, 2010 at 13:31

2 Answers 2

Reset to default
37

To be honest, I do not really understand what this is useful for. I would try to fix the review process instead of messing up the history. But if you really want to do this, here are several ways how:

  1. The pragmatic approach:

    mv file out-of-way
touch file
git add file
mv out-of-way file

  2. The porcelain approach:

    git add -N file
git add -p file

    ... and just answer "no" when asked whether the single hunk should be added. (Apparently this does not work anymore in 2019.)

  3. The plumbing approach:

    First, make sure an empty object exists in the object database:

    git hash-object -w --stdin < /dev/null

    This will return the SHA1 of an empty blob (which is e69de29bb2d1d6434b8b29ae775ad8c2e48c5391). You have to create this object only once. Now you can create empty files in the index by

    git update-index --add --cacheinfo 0644 e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 file
Improve this answer
Sign up to request clarification or add additional context in comments.

11 Comments

@Sven: Thank you so much! The plumbing approach is perfect for me: its is easily automatized, and to the point (the second guessing of why I would need this is not so relevant, though :) ). This is useful for following what new code my students add to their home directory by using git diff on my local copies of their programs. Code that I have not yet approved should not be committed, but keep appearing as newly added lines (compared to an empty file) as long as it is not committed (i.e. approved).
@EOL: You could also easily automate touch, add, then copy.
@EOL: Sorry for sounding unkind -- just wanted to point out that I do not recommend to actually do what I explained in this answer. I think the approaches Jefromi suggests in the comments to your question provide more flexible (and more reliable) workflows.
@EOL: I was referring to the workflows Jefromi described in the comments to your question, e.g. have separate branches commited and accepted. This would be one way to "fix the review process" instead of "messing up the history".
The porcelain approach doesn't seem to work here: git commit says file: not added yet error: Error building trees, and a similar error from git stash. The plumbing approach does work.
|
-2

Automatically add all empty files and folders

Force add all files

$ git add -Af

You can automatically add a .gitignore file in every empty folder.

$ find $PATH_TO_REPOSITORY -type d ! -path "*.git*" -empty -exec cp .gitignore '{}'/ \;

You can automatically add a .gitkeep file in every empty folder.

$ find $PATH_TO_REPOSITORY -type d ! -path "*.git*" -empty -exec touch '{}'/.gitkeep \;
Improve this answer

1 Comment

Hi Nathan. The question specifically asks about "non-empty" files. Are you sure this is not just a generic copy-paste answer?

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.