A production-grade Git implementation written in Rust.

Ferris-Git is a complete Git implementation built from scratch in Rust. It provides both a library and a command-line interface for version control operations. This project demonstrates advanced Rust programming concepts including:

• Content-addressable storage with SHA-1 hashing
• Binary file format parsing (index files, pack files)
• Delta compression algorithms
• Tree data structures for directory representation
• Reference management and symbolic links

• Core Git Commands: init, add, commit, log, status, diff, branch, checkout, cat-file, hash-object
• Object Storage: Full implementation of Git's object model (blobs, trees, commits, tags)
• Index Management: Binary index file parsing and writing
• Reference Handling: Branch and tag management, symbolic references
• Delta Compression: Pack file support with copy/insert delta encoding
• Configuration: Git config file parsing and management
• Gitignore Support: Pattern matching for ignored files
• Colored Output: Rich terminal output with progress bars
• Shell Completions: Auto-generated completions for bash, zsh, fish, and PowerShell

# Clone the repository
git clone https://github.com/yourusername/ferris-git.git
cd ferris-git

# Build and install
cargo install --path .

cargo install ferris-git

# Initialize in current directory
ferris-git init

# Initialize with custom branch name
ferris-git init -b main

# Initialize in a specific directory
ferris-git init my-project

# Add a single file
ferris-git add README.md

# Add multiple files
ferris-git add src/*.rs

# Add all files in a directory
ferris-git add src/

# Add all changes (dry run)
ferris-git add -n .

# Commit with a message
ferris-git commit -m "Initial commit"

# Commit with verbose output
ferris-git -v commit -m "Add new feature"

# Full status
ferris-git status

# Short format
ferris-git status -s

# Porcelain format (for scripts)
ferris-git status --porcelain

# Full log
ferris-git log

# One-line format
ferris-git log --oneline

# Limit number of commits
ferris-git log -n 5

# With decorations (branch/tag names)
ferris-git log --decorate

# Working directory changes
ferris-git diff

# Staged changes
ferris-git diff --cached

# Name only
ferris-git diff --name-only

# With context
ferris-git diff -U5

# List branches
ferris-git branch

# Create a branch
ferris-git branch feature-x

# Delete a branch
ferris-git branch -d feature-x

# Verbose listing (shows commit info)
ferris-git branch -v

# Switch to a branch
ferris-git checkout main

# Create and switch to a new branch
ferris-git checkout -b feature-y

# Checkout a specific commit (detached HEAD)
ferris-git checkout abc1234

# Show object type
ferris-git cat-file -t HEAD

# Show object size
ferris-git cat-file -s HEAD

# Pretty-print object contents
ferris-git cat-file -p HEAD

# Compute hash without storing
ferris-git hash-object file.txt

# Compute hash and store in object database
ferris-git hash-object -w file.txt

# Hash from stdin
echo "content" | ferris-git hash-object --stdin

# Bash
ferris-git completions bash > /etc/bash_completion.d/ferris-git

# Zsh
ferris-git completions zsh > ~/.zsh/completions/_ferris-git

# Fish
ferris-git completions fish > ~/.config/fish/completions/ferris-git.fish

# PowerShell
ferris-git completions powershell > ferris-git.ps1

Ferris-Git can also be used as a library in your Rust projects:

use ferris_git::{Repository, Result};

fn main() -> Result<()> {
    // Initialize a new repository
    let repo = Repository::init("my-project")?;

    // Or open an existing one
    let repo = Repository::open(".")?;

    // Get current branch
    if let Some(branch) = repo.current_branch()? {
        println!("On branch: {}", branch);
    }

    // Stage a file
    repo.stage_file(std::path::Path::new("README.md"))?;

    // Create a commit
    let oid = repo.commit("Initial commit")?;
    println!("Created commit: {}", oid);

    // List branches
    for branch in repo.list_branches()? {
        println!("Branch: {}", branch);
    }

    Ok(())
}

ferris-git/
├── src/
│   ├── lib.rs           # Library entry point
│   ├── main.rs          # CLI entry point
│   ├── error.rs         # Error types
│   ├── config.rs        # Configuration handling
│   ├── repository.rs    # Repository operations
│   ├── utils.rs         # Utility functions
│   ├── commands/        # CLI command implementations
│   │   ├── init.rs
│   │   ├── add.rs
│   │   ├── commit.rs
│   │   ├── log.rs
│   │   ├── status.rs
│   │   ├── diff.rs
│   │   ├── branch.rs
│   │   ├── checkout.rs
│   │   ├── cat_file.rs
│   │   └── hash_object.rs
│   ├── objects/         # Git objects
│   │   ├── mod.rs
│   │   ├── oid.rs       # Object ID (SHA-1)
│   │   ├── blob.rs      # Blob objects
│   │   ├── tree.rs      # Tree objects
│   │   ├── commit.rs    # Commit objects
│   │   ├── tag.rs       # Tag objects
│   │   └── store.rs     # Object storage
│   ├── index/           # Index (staging area)
│   │   ├── mod.rs
│   │   └── entry.rs
│   ├── refs/            # References
│   │   └── mod.rs
│   └── pack/            # Pack files
│       ├── mod.rs
│       └── delta.rs     # Delta compression
└── tests/
    └── integration_tests.rs

Objects are stored using content-addressable storage:

1. Compute SHA-1 hash of "type size\0content"
2. Compress using zlib
3. Store in .git/objects/ab/cdef... (first 2 chars as directory)

The index file uses Git's binary format:

• 12-byte header: signature ("DIRC"), version (2), entry count
• Sorted entries with: timestamps, mode, SHA-1, flags, path
• 20-byte SHA-1 checksum

Pack files use copy/insert deltas:

• Copy instruction: Copy N bytes from offset O in source
• Insert instruction: Insert N literal bytes
• Variable-length encoding for sizes and offsets

# Run all tests
cargo test

# Run with output
cargo test -- --nocapture

# Run specific test
cargo test test_init

# Run integration tests only
cargo test --test integration_tests

Performance is comparable to Git for common operations on small to medium repositories:

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

This project is licensed under the MIT License - see the LICENSE file for details.

• The Git project for its excellent documentation
• The Rust community for amazing libraries like clap, thiserror, and sha1
• "Pro Git" book by Scott Chacon and Ben Straub
• "Building Git" by James Coglan

• Remote operations (fetch, push, pull)
• Merge and rebase
• Stash support
• Submodules
• Worktrees
• Git hooks
• Sparse checkout
• Partial clone