Recently, we were working on a project that had committed in the source code a configuration file. That configuration file had hard-coded the production system values, so we had to modify them to the development system values before using it.
To avoid committing the configuration file with the development parameters by accident, we instructed git
to ignore any changes that were made to it using the following command.
git update-index --assume-unchanged <file>;
By doing so, git
assumed that the file was always unchanged and it never showed up in the git status
results nor was staged when git add .
was used etc.
After we were done with development (and whenever we needed to pull
the branch for changes or checkout
another branch) we removed the file from the list of ignored files using the following command.
git update-index --no-assume-unchanged <file>;
Using this command, git
would start again to monitor changes to the file and merge
it or update
it or push
it when needed as it would normally do for any file not included in the .gitignore
file. The best part of this trick is that you do not have to update the .gitignore
file to achieve the task of ignoring a file.
More information
git update-index
modifies the index or directory cache. Each file mentioned is updated into the index and any unmerged or needs updating state is cleared.
--[no-]assume-unchanged
When these flags are specified, the object names recorded for the paths are not updated. Instead, these options set and unset the “assume unchanged” bit for the paths. When the “assume unchanged” bit is on, Git stops checking the working tree files for possible modifications, so you need to manually unset the bit to tell Git when you change the working tree file. This is sometimes helpful when working with a big project on a filesystem that has very slow lstat(2) system call (e.g. cifs).
This option can be also used as a coarse file-level mechanism to ignore uncommitted changes in tracked files (akin to what .gitignore does for untracked files). Git will fail (gracefully) in case it needs to modify this file in the index e.g. when merging in a commit; thus, in case the assumed-untracked file is changed upstream, you will need to handle the situation manually.
From: man git-update-index
Bonus
In case you are wondering on how to see which files are currently ignored in your local repository copy by the git update-index --assume-unchanged <file>;
command, you can use the following code:
git ls-files -v | grep -e '^[[:lower:]]';
git ls-files -v
will print out all objects that git
knows and the -v
parameter will print all flags associated with them. The files that are ignored because of the
git update-index --assume-unchanged <file>;
command will be printed each one on a different line that starts with a lower case character
. So, to get all files that are ignored by the git update-index --assume-unchanged <file>;
command, we need to grep
the results of git ls-files -v
for lines that start with a lower case.
git-ls-files
shows information about files in the index and the working tree.
It merges the file listing in the directory cache index with the actual working directory list, and shows different combinations of the two.
-v
Similar to -t
(below), but use lowercase letters for files that are marked as assume unchanged (see git-update-index(1)).
-t
This feature is semi-deprecated. For scripting purpose, git-status(1)–porcelain and git-diff-files(1)–name-status are almost always superior alternatives, and users should look at git-status(1)–short or git-diff(1)–name-status for more user-friendly alternatives.
This option identifies the file status with the following tags (followed by a space) at the start of each line:
An additional interesting parameter for git ls-files
is
-i, --ignored
Shows only ignored files in the output. When showing files in the index, it prints only those matched by an exclude pattern. When showing “other” files, it shows only those matched by an exclude pattern.
--exclude-standard
Add the standard Git exclusions: .git/info/exclude
, .gitignore
in each directory, and the user’s global exclusion file.
From: man git-ls-files
Examples for git ls-files -i, –ignored and –exclude-standard
# Show files in the index that are ignored because of patterns in .gitignore git ls-files --ignored --exclude-from=.gitignore; # Show other (i.e. untracked) files that are ignored because of patterns in .gitignore git ls-files --ignored --other --exclude-from=.gitignore; # Show files in the index that are ignored because of patterns in any of the standard git exclusions. git ls-files --ignored --exclude-standard; # Show other (i.e. untracked) files that are ignored because of patterns in any of the standard git exclusions. git ls-files --ignored --exclude-standard --other;
This post is also available in: Greek