CS61B Gitlet Design

Gitlet Design Document

Name: Kai Huang

Classes and Data Structures

Commit

Represents a commit in gitlet. A series of commits can be seen as a linked list.

Fields

1. private String message The message of this Commit.
2. private long timestamp Time at which a commit was created. Assigned by the constructor.
3. private String parent The parent commit of a commit object.
4. private String secondParent The second parent if merge.
5. public TreeMap<String, String> reference References to blobs.

---

Main

This is the entry point to our program. It takes in arguments from the command line and based on the command (the first element of the args array) calls the corresponding command in Repository which will actually execute the logic of the command. It also validates the arguments based on the command to ensure that enough and appropriate arguments were passed in.

Fields

This class has no fields and hence no associated state: it simply validates arguments and defers the execution to the Repository class.

---

Repository

Fields

Local

1. public static File CWD = new File(System.getProperty("user.dir")) Current working directory
2. public static final File currentCWD = new File(System.getProperty("user.dir")) A CWD that never change.
3. public static File GITLET_DIR = join(CWD, ".gitlet") .gitlet directory.
4. public static File Stage_DIR = join(GITLET_DIR, "stage", "addition") The stage for addition directory.
5. public static File Removal_DIR = join(GITLET_DIR, "stage", "removal") The stage for removal directory.
6. public static File Commit_DIR = join(GITLET_DIR, "commit") The commit directory.
7. public static File Blob_DIR = join(GITLET_DIR, "blob") The blob directory.
8. public static File Head_DIR = join(GITLET_DIR, "refs", "heads") The head directory.
9. public static File Remote_DIR = join(GITLET_DIR, "refs", "remote") The remote directory.
10. public static File Config_DIR = join(GITLET_DIR, "config") Record remote repository information: name and url.
11. public static File HEAD = join(GITLET_DIR, "HEAD") Store branch name in HEAD.
12. public static HashSet<String> gitIgnore = new HashSet<>(Set.of(".gitignore", "delete_gitletDir.sh", "Makefile", "gitlet-design.md", "pom.xml")) The gitIgnore file.

Remote

1. public static File remoteCWD
2. public static File remoteGITLET_DIR If need, remoteGITLET_DIR will be new File(readContentsAsString(join(Config_DIR, remoteName))).
3. public static File remoteCommit_DIR
4. public static File remoteBlob_DIR
5. public static File remoteHead_DIR
6. public static final String remoteSeparator = "#" Replace “/“ with “#” because filename can’t contain “/“, e.g. replace “R1/master” with “R1#master”.

---

Utils

This class contains helpful utility methods to read/write objects or String contents from/to files, as well as reporting errors when they occur.

Fields

Only some private fields to aid in the magic.

---

HelpMethod

The help methods to help achieve functions in Repository class.

Fields

No fields.

Algorithms

init

1. Check if GITLET_DIR exists. If exist, error.
2. Local directories and file make.
3. Make initial commit.
   1. new instance ,serialize and sha1.
   2. Write to Commit_DIR, filename: sha1-hash, content: serialization.
   3. Write “master” in HEAD, write sha1-hash in Commit_DIR/master

add

…

Persistence

The directory structure looks like this:

CWD                          <==== The current working directory
└── .gitlet                      <==== All persistant data is stored within here
    ├── stage                   
        ├── addition
            ├── a.txt                <==== Content: hash in blob
            └── ...
        └── removal
            ├── b.txt
            └── ...      
    ├── commit
            ├── 6d675d...            <==== Content: Serialized commit
            └── ...      
    ├── blob
            ├── cdf006...            <==== Content: Real content in xx.txt
            └── ...         
    ├── refs                    
        ├── heads
            ├── master               <==== Content: sha1-hash
            ├── ...
            ├── R1#master
            └── ...            
        └── remote    
            ├── R1
            	├── master               <==== Content: sha1-hash
            	└── ...
            └── ...
    ├── config
    	├── R1                       <==== Content: .gitlet url in remote repository
    	└── ...	
    └── HEAD			         <==== Where the head branch is stored (a file)

The Repository will set up all persistence.

Other

Super helpful commands in real Git

1. git hash-object <File> //show the hash of the file
2. git cat-file -p <sha-1 hash> //deserialize
3. git ls-files -s //Lists the status of all the files in the current Git repository and displays the metadata for those files. Specifically, it lists the files in the staging area and their related information.

Key sentences from a video

git add

Create a blob containing the content of the file.

git commit

1. Write the commit’s content to the working copy.
2. Write the commit’s content to the Index.
3. Point HEAD at the thing that was checked out.

A commit is a set of changes.

git merge

1. Generate the diff that combines the changes made by the receiver and giver.
2. Apply the diff to the working copy.
3. Apply the diff to the Index.
4. Commit the updated Index.
5. Point HEAD at the new commit.

when conflict:

1. Generate the diff that combines the changes made by the receiver and giver.
2. Apply the diff to the working copy.
3. Apply the diff to the Index.
4. The user resolves the conflicts in the working copy.
5. The user resolves the conflicts in the Index.
6. The user commits the merge.

git fetch

1. Find the tip commit on the branch being fetched from the remote repository.
2. Copy to the fetching repository the tip commit and the objects it depends on.
3. Point the ref for the remote branch at the fetched commit.
4. Point FETCH_HEAD at the fetched commit.

git pull

git fetch + git merge FETCH_HEAD

git clone

1. Create the directory for the new repository.
2. Move into the clone’s directory.
3. Initialize the clone’s directory as a Git repository.
4. Check out the branch that was checked out on the repository being cloned.
5. Pull the branch that was checked out on the repository being cloned.

git clone [ ] [ ] --bare A bare repository: You push to it and you pull from it but you never commit to it directly.

git push

1. Copy the pushed branch’s tip commit and the objects it depends on to the remote directory.
2. Point the pushed branch on the remote to the tip commit.

To be improved

1. Use ppt to draw .gitlet file structure, merge cases, tesing cases.

References

1. Git from the inside out - video

2. Git from the inside out - essay

3. GITLET.js

4. Project 2: Gitlet FAQ