Skip to content

Latest commit

 

History

History
235 lines (215 loc) · 7.77 KB

TODO.md

File metadata and controls

235 lines (215 loc) · 7.77 KB

To outline what should be done in each command or method of the Repository class, let's go through the common Git commands and repository methods. Below is a high-level explanation of each method's tasks, step-by-step, which can serve as a "to-do" list for implementation:

1. init()

  • Purpose: Initializes a new Git repository.
  • To-Do:
    • Create a new .git directory.
    • Create subdirectories like objects, refs, heads.
    • Initialize the HEAD file pointing to refs/heads/master.
    • Create an empty index file (.git/index).

2. add(filePath: string)

  • Purpose: Adds a file to the staging area (index).
  • To-Do:
    • Read the file's content and calculate its hash using SHA-1.
    • Store the file content in the objects folder (as a blob object).
    • Update the index file with the file’s path, permissions, and hash.
    • Manage file modes (executable, regular files).
    • Ensure that the index file is updated with the new entry.

3. commit(message: string)

  • Purpose: Records changes to the repository.
  • To-Do:
    • Read the index and gather all staged files.
    • Create a tree object based on the file structure.
    • Create a commit object with the tree hash, parent commit hash (if any), author information, and commit message.
    • Write the commit object to the objects folder.
    • Update the HEAD to point to the new commit hash.

4. log()

  • Purpose: Shows the commit history.
  • To-Do:
    • Read the HEAD to get the latest commit.
    • Recursively walk through the parent commits.
    • For each commit, display the author, timestamp, and commit message.

5. status()

  • Purpose: Displays the working directory and staging area status.
  • To-Do:
    • Compare the current working directory with the index to find any changes.
    • List files that have been modified, added, or deleted.
    • Check for files that are staged for commit.
    • Display untracked files that aren’t yet in the index.

6. checkout(commitHash: string)

  • Purpose: Switches to a specific commit, branch, or file.
  • To-Do:
    • Look up the commit object by hash.
    • Extract the tree object associated with the commit.
    • Update the working directory to reflect the state of the specified commit.
    • Update the HEAD to point to the specified commit or branch.

7. branch(branchName: string)

  • Purpose: Creates a new branch.
  • To-Do:
    • Create a new reference under refs/heads/ that points to the current commit.
    • Ensure the HEAD stays where it is unless explicitly moved (e.g., by checkout).

8. merge(branchName: string)

  • Purpose: Merges the specified branch into the current branch.
  • To-Do:
    • Retrieve the latest commit on the current branch and the branch to be merged.
    • Find the common ancestor of both branches.
    • Merge the changes by applying the differences from the common ancestor.
    • Handle conflicts if both branches have modified the same file.
    • Create a merge commit.

9. tag(tagName: string)

  • Purpose: Tags a commit.
  • To-Do:
    • Create a tag object that references a specific commit.
    • Store the tag information in the refs/tags/ directory.
    • Optional: Create an annotated tag with a message, author, and date.

10. diff()

  • Purpose: Shows changes between commits, working tree, and index.
  • To-Do:
    • Compare the index with the current working directory to show unstaged changes.
    • Compare the index with the last commit to show staged changes.
    • Optionally, compare two commits for historical differences.

11. reset(commitHash: string)

  • Purpose: Resets the current branch to a specific commit.
  • To-Do:
    • Update HEAD to point to the given commit.
    • Update the index to match the tree of the specified commit.
    • Optionally, update the working directory to match the commit.

12. revert(commitHash: string)

  • Purpose: Creates a new commit that undoes the changes introduced by a previous commit.
  • To-Do:
    • Find the commit object by its hash.
    • Apply an inverse patch to undo the changes in that commit.
    • Create a new commit with the reverted changes.

13. clone(repoUrl: string)

  • Purpose: Clones a repository from a remote location.
  • To-Do:
    • Download the remote repository's contents (this can be as simple as copying .git contents for local repositories).
    • Set up the local repository with references to the remote repository.
    • Initialize tracking branches.

14. fetch(remoteUrl: string)

  • Purpose: Fetches updates from a remote repository.
  • To-Do:
    • Connect to the remote repository and download the latest objects and references.
    • Update the local references (e.g., refs/remotes/origin/master).

15. push(remoteUrl: string)

  • Purpose: Pushes local changes to a remote repository.
  • To-Do:
    • Authenticate with the remote repository.
    • Compare local references with remote ones to see what needs to be pushed.
    • Send the commit objects, trees, and blobs that aren’t already on the remote.
    • Update the remote references to point to the pushed commits.

General Notes:

  • Error Handling: Each method should handle errors (e.g., missing files, invalid paths, permission errors) gracefully.
  • File Operations: The FileAdapter (or any future file handling module) should be used for all reading and writing operations to keep file operations consistent and modular.
  • Logging: For debugging and tracking purposes, consider adding logs or print statements to show when significant actions are performed (e.g., file written, index updated, etc.).
  • Compression/Decompression: For object storage, use Git's compression mechanism (zlib) when writing objects to the objects directory.

This high-level overview should help you define the structure and behavior of each method in the Repository class. If you'd like further clarification on any specific method, feel free to ask!

+---------------+ | Repository | +---------------+ | - name | | - description | | - commits | | | | +------------+ | | init() | | | add() | | | commit() | | | log() | | | checkout() | | +------------+ +---------------+ | | v +---------------+ | Commit | +---------------+ | - id | | - parent | | - author | | - timestamp | | - message | | | | +------------+ | | Commit() | | | getParent() | | | getAuthor() | | | getTimestamp() | | | getMessage() | | +------------+ +---------------+ | | v +---------------+ | Tree | +---------------+ | - id | | - entries | | | | +------------+ | | Tree() | | | addEntry() | | | getEntries() | | +------------+ +---------------+ | | v +---------------+ | Entry | +---------------+ | - name | | - mode | | - hash | | | | +------------+ | | Entry() | | | getName() | | | getMode() | | | getHash() | | +------------+ +---------------+ | | v +---------------+ | Blob | +---------------+ | - id | | - data | | | | +------------+ | | Blob() | | | getData() | | +------------+ +---------------+ | | v +---------------+ | Index | +---------------+ | - entries | | | | +------------+ | | Index() | | | addEntry() | | | getEntries() | | +------------+ +---------------+ | | v +---------------+ | Workspace | +---------------+ | - files | | | | +------------+ | | Workspace() | | | addFile() | | | getFile() | | +------------+ +---------------+