Gitlite internal working

`gitlite init`

gitlite init initialtes a repository depending on the number of arguments passed to it.

If no arguments are given, gitlite is initialized in the same directory
If one argument is given, a directory in the name of the argument given is created and gitlite is initialized in that directory

The main putpose of gitlite init is to store the version control information / metadata for efficiency.

The structure of repository is as follows

.gitlite
├── index
├── /objects
└── /refs
    ├── HEAD
    └── /heads
        └── main
.gitignore

When gitlite init command is invoked, a new directory named .gitlite is created, thus initializing gitlite. If gitlite is already initialized in the directory, gitlite init re-initializes repository in the givendirectory.

Purposes of different files and directories inside the .gitlite directory are as follows:

index file acts like a staging area to keep a track of the changes in the working directory.
/objects is used to store the SHA-1 hashes of commit objects and working tree
/refs is used to store branch related infromation
- /heads stores files for different branches that hold the SHA-1 hash of that branchs’ commit. main is the default branch here.
- HEAD serves as a reference to the current branch

Usage

$ gitlite init

OR

$ gitlite init <directory-name>

`gitlite add`

gitlite add is used to stage files and directories to commit them. Depending on the number of files or directories name given as arguments, they will be staged.

If argument given is a file, that file will be staged
If argument given is a directory, all files in that directory will be staged
If multiple file names or directory names are given as arguments, all the them will be staged

Information related to the staged files are stored as bytes in the index file. The TreeItemobject stored in this index file is structure as follows:

filename: name of the file being staged
hash: SHA-1 hash of the file being staged
filetype : enum (Blob or Tree) representing what’s being staged is a file or a directory

Each time gitlite add <file-name> is invoked, the exisiting TreeItems in the index file are read and updated according to the new files to be staged.

Usage

$ gitlite add <file-name>

OR

$ gitlite add <directory-name>

OR

$ gitlite add <file-name-1> <file-name-2> <directory-name-1> <file-name-3>...

`gitlite status`

gitlite status is used to view the status of the staging area. It shows if the files in the root directory of the repository are staged , modified or untracked . The meaning of the statuses above are as follows

staged files : files that are added to the staging area and are ready to be comitted
modified files : files in the staging area that are modifed
untracked files : files that are not in the staging area

A simple comparison is made between the files in the root directory to the staging areas and the previously committed working trees to identify their statuses.

Usage

$ gitlite status

Note: This command does not accept arguments.

`gitlite commit`

gitlite commit creates a snapshot of all the files that are staged, storing crucial metadata like timestamps, commit messages, tree hashes and hash of the parent commit.

Information related to the commit are stored as CommitObject bytes in the /objects directory. The structure of CommitObject is as follows:

timestamp: Date and time when the commit is being made
commit message: A short message to say what the commit is regaring
tree hash: SHA-1 working tree fiiles that were staged
parent hash : SHA-1 hash of the parent commit (None for initial commit)

Following are the arguments accepted by git commit:

-m: Commit message
-a / --amend : Amend to previous commit

Usage

To create a new commit

$ gitlite commit -m <commit-message>

Amend to previous commit

$ gitlite commit -a <new-commit-message>

`gitlite branch`

gitlite branch is used view and modify different branches in a repository. Each branch points to a particular commit object that act as the latest commit of that branch. The SHA-1 hash of this commit is stored as bytes in a file named after the branch’s name under the .gitlite/refs/heads directory.

The HEAD file consists of a reference to the current branch file (main serves as a default branch)

A typical branch file looks as follows

.gitlite
└── /refs
    ├── HEAD
		    ref: refs/heads/main
    └── /heads
        └── main
	        <commit-hash-of-latest-commit-as-bytes>
        └── develop
        <commit-hash-of-latest-commit-as-bytes>
        └── release-1.0
        <commit-hash-of-latest-commit-as-bytes>

Following are the arguments accepted by git branch:

branch-name: Create new branch
-m: Rename current branch
-d: Delete a branch (other than current branch)

Usage

View all branches

$ gitlite branch

Create a branch

$ gitlite branch <branch-name>

Rename a branch

$ gitlite branch -m <new-branch-name>

OR

$ gitlite branch -m <old-branch-name> <new-branch-name>

Delete a branch (other than current branch)

$ gitlite branch -d <branch-name>

`gitlite checkout`

gitlite checkout is used switch between different branches in a repository. Behind the scenes, the reference in the HEAD file is changed in order to point the branch file that needs to be checkout out to.

Following are the arguments accepted by git checkout:

branch-name: Checkout to an existing branch
-b: Create new branch and checkout to that branch

Usage

Checkout to an existing branch

$ gitlite checkout <branch-name>

Create a new branch and checkout

$ gitlite checkout -b <new-branch-name>

`gitlite log`

gitlite log is used to view the commit history of a particular branch. All the commits of the given branch are traced back to the point where the parent commit hash is None and the information such as the commit hash, timestamp and the commit message of each commit are displayed.

Following are the arguments accepted by git log:

branch-name: Commit history of a particular branch
When no argument is passed, commit history of current branch is shown

Usage

Commit log of a particular branch

$ gitlite log <branch-name>

Commit history of current branch

$ gitlite log

Conclusion

This project aims to provide a simplified, educational implementation of core Git concepts, focusing on staging, committing, and branching. Feel free to checkout the source code at

https://github.com/nithin-sudarsan

Star ⭐️ this repo if you find it interesting or to show support!

Hold on