How to Check If a Directory Is Tracked by Git

Introduction

In this lab, we will learn how to determine if a directory is being tracked by Git. We will explore the contents of a Git repository using the git ls-tree command to inspect the files and directories at a specific commit.

Furthermore, we will utilize the git status command to verify the current tracking status of files within our repository and understand how Git handles empty directories.

Skills Graph

Run git ls-tree for Directory

In this step, we will explore the contents of our Git repository using the git ls-tree command. This command allows us to view the contents of a tree object, which represents the state of a directory at a specific commit.

First, make sure you are in your my-time-machine directory:

cd ~/project/my-time-machine

Now, let's use git ls-tree to see the contents of the latest commit. We'll use HEAD to refer to the latest commit:

git ls-tree HEAD

You should see output similar to this:

100644 blob a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9	message.txt

Let's break down this output:

• 100644: This is the file mode, indicating it's a regular file.
• blob: This indicates the type of object. A blob object stores the content of a file.
• a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9: This is the unique identifier (SHA-1 hash) of the blob object that stores the content of message.txt. Your hash will be different.
• message.txt: This is the name of the file.

The git ls-tree command is useful for inspecting the contents of a specific commit without checking out the entire commit. It shows you the files and directories that were tracked by Git at that point in time.

Think of it like looking inside a specific time capsule (commit) to see exactly what files were included and what their unique fingerprints (blob hashes) were. This is a powerful way to understand the structure and content of your project's history.

Use git status to Verify Tracking

In the previous steps, we created a file and committed it to our Git repository. Now, let's use the git status command again to see the current state of our repository and confirm that our file is being tracked.

Make sure you are still in the ~/project/my-time-machine directory:

cd ~/project/my-time-machine

Now, run the git status command:

git status

You should see output similar to this:

On branch master
nothing to commit, working tree clean

This output tells us a few important things:

• On branch master: We are currently on the master branch, which is the main timeline of our project.
• nothing to commit, working tree clean: This is the key part. It means that there are no changes in our working directory that are not yet committed. Git is tracking all the files that are supposed to be tracked, and there are no new or modified files that need to be added or committed.

This is the desired state when you have finished making changes and committed them. It confirms that Git is aware of the current state of your project and that everything is up to date in your repository.

Comparing this output to the git status output we saw before creating and committing message.txt highlights the difference between an empty repository, a repository with untracked files, and a clean repository with tracked files.

Understanding git status is crucial because it's your main tool for knowing what's happening in your repository and what actions you need to take (like adding or committing files).

Test Empty Directories

In this step, we will explore how Git handles empty directories. This is a common point of confusion for beginners, as Git behaves differently with directories compared to files.

First, make sure you are in your ~/project/my-time-machine directory:

cd ~/project/my-time-machine

Now, let's create a new, empty directory inside our project:

mkdir empty-folder

We have created the directory. Now, let's check the status of our repository using git status:

git status

You should see output similar to this:

On branch master
nothing to commit, working tree clean

Notice that Git does not report empty-folder as an untracked directory. This is because Git tracks file content, not directories themselves. An empty directory has no content to track.

This is an important concept in Git. If you need to include an empty directory in your repository, the common workaround is to place a dummy file inside it. A common practice is to create a file named .gitkeep (though the name doesn't matter, it's just a convention).

Let's create a .gitkeep file inside empty-folder:

touch empty-folder/.gitkeep

Now, let's check the git status again:

git status

This time, you should see:

On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
	untracked files present (use "git add" to track)

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	empty-folder/

Now Git sees the empty-folder/ because it contains a file (.gitkeep) that can be tracked.

This demonstrates that Git tracks the presence of files within directories, rather than the directories themselves. To include a directory in your repository's history, it must contain at least one tracked file.

Summary

In this lab, we learned how to check if a directory and its contents are tracked by Git. We used the git ls-tree HEAD command to inspect the contents of the latest commit, understanding that it displays tracked files and their associated blob objects and hashes. This command provides a snapshot of the repository's state at a specific commit.

We also utilized the git status command to verify the current tracking status of files within the repository, confirming that committed files are indeed tracked by Git. Finally, we explored how Git handles empty directories, discovering that Git does not track empty directories directly but rather tracks files within them.