git-actor

read and write a signature that uniquely identifies an actor within a git repository

git-hash

types to represent hash digests to identify git objects.
used to abstract over different kinds of hashes, like SHA1 and the upcoming SHA256
API documentation
- Some examples

git-chunk

decode the chunk file table of contents and provide convenient API
write the table of contents

git-object

decode (zero-copy) borrowed objects
- commit
  - parse the title, body, and provide a title summary.
  - parse trailers
- tree
encode owned objects
- commit
- tree
- tag
  - name validation
transform borrowed to owned objects
API documentation
- Some examples

git-pack

packs
- traverse pack index
- 'object' abstraction
  - decode (zero copy)
  - verify checksum
- simple and fast pack traversal
  - fast pack traversal works with ref-deltas
- decode
  - full objects
  - deltified objects
- decode
  - decode a pack from Read input
    - Add support for zlib-ng for 20% faster decompression performance
    - Read to Iterator of entries
      - read as is, verify hash, and restore partial packs
  - create index from pack alone (much faster than git)
    - resolve 'thin' packs
- encode
  - Add support for zlib-ng for 2.5x compression performance
  - objects to entries iterator
    - input objects as-is
    - pack only changed objects as derived from input
    - base object compression
    - delta compression
      - respect the delta=false attribute
    - create 'thin' pack, i.e. deltas that are based on objects the other side has.
    - parallel implementation that scales perfectly
  - entries to pack data iterator
  - write index along with the new pack
- verify pack with statistics
  - brute force - less memory
  - indexed - optimal speed, but more memory
- advanced
  - Multi-Pack index file (MIDX)
    - read
    - write
    - verify
  - 'bitmap' file
  - special handling for networked packs
  - detect and retry packed object reading
API documentation
- Some examples

git-odb

loose object store
- traverse
- read
  - into memory
  - streaming
  - verify checksum
- streaming write for blobs
- buffer write for small in-memory objects/non-blobs to bring IO down to open-read-close == 3 syscalls
dynamic store
- auto-refresh of on-disk state
- handles alternates
- multi-pack indices
- perfect scaling with cores
- support for pack caches, object caches and MRU for best per-thread performance.
- prefix/short-id lookup
- object replacements (git replace)
sink
- write objects and obtain id
alternates
- resolve links between object databases
- safe with cycles and recursive configurations
- multi-line with comments and quotes
promisor
- It's vague, but these seems to be like index files allowing to fetch objects from a server on demand.
API documentation
- Some examples

git-diff

Check out the performance discussion as well.

tree
- changes needed to obtain other tree
- case-insensitive comparisons
- rename and copy tracking
- readily available caching for 4x+ speedups
patches
- There are various ways to generate a patch from two blobs.
- any
diffing, merging, working with hunks of data
find differences between various states, i.e. index, working tree, commit-tree
Parallel stat calls to check/update objects in index
API documentation
- Examples

git-traverse

Check out the performance discussion as well.

trees
- nested traversal
commits
- ancestor graph traversal similar to git revlog
API documentation
- Examples

tree

git-url

As documented here: https://www.git-scm.com/docs/git-clone#_git_urls
parse
- ssh URLs and SCP like syntax
- file, git, and SSH
- paths (OS paths, without need for UTF-8)
username expansion for ssh and git urls
convert URL to string
API documentation
- Some examples

git-protocol

abstract over protocol versions to allow delegates to deal only with a single way of doing things
credentials
- via git-credentials
- via pure Rust implementation if no git is installed
fetch & clone
- detailed progress
- control credentials provider to fill, approve and reject
- command: ls-ref
  - parse V1 refs as provided during handshake
  - parse V2 refs
  - handle empty refs, AKA PKT-LINE(zero-id SP "capabilities^{}" NUL capability-list)
- initialize and validate command arguments and features sanely
- abort early for ls-remote capabilities
- packfile negotiation
  - delegate can support for all fetch features, including shallow, deepen, etc.
  - receive parsed shallow refs
push
API documentation
- Some examples

git-packetline

PKT-Line
encode
decode (zero-copy)
error line
V2 additions
side-band mode
Read from packet line with (optional) progress support via sidebands
Write with built-in packet line encoding
API documentation
- Some examples

git-transport

No matter what we do here, timeouts must be supported to prevent hanging forever and to make interrupts destructor-safe.
client
- general purpose connect(…) for clients
  - file:// launches service application
  - ssh:// launches service application in a remote shell using ssh
  - git:// establishes a tcp connection to a git daemon
  - http(s):// establishes connections to web server
  - pass context for scheme specific configuration, like timeouts
- git://
  - V1 handshake
    - send values + receive data with sidebands
    - ~~support for receiving 'shallow' refs in case the remote repository is shallow itself (I presume)~~
      - Since V2 doesn't seem to support that, let's skip this until there is an actual need. No completionist :D
  - V2 handshake
    - send command request, receive response with sideband support
- http(s)://
  - set identity for basic authentication
  - V1 handshake
    - send values + receive data with sidebands
  - V2 handshake
    - send command request, receive response with sideband support
  - ~~'dumb'~~ - we opt out using this protocol seems too slow to be useful, unless it downloads entire packs for clones?
- authentication failures are communicated by io::ErrorKind::PermissionDenied, allowing other layers to retry with authentication
server
- general purpose accept(…) for servers
API documentation
- Some examples

git-attributes

parse git-ignore files (aka git-attributes without the attributes or negation)
parse git-attributes files
create an attributes stack, ideally one that includes 'ignored' status from .gitignore files.
- support for built-in binary macro for -text -diff -merge

git-quote

ansi-c
- quote
- unquote

git-mailmap

parsing
lookup and mapping of author names

git-path

transformations to and from bytes
conversions between different platforms
virtual canonicalization for more concise paths via absolutize()
more flexible canonicalization with symlink resolution for paths which are partially virtual via realpath()
spec
- parse
- check for match

git-pathspec

parse
check for match

git-note

A mechanism to associate metadata with any object, and keep revisions of it using git itself.

CRUD for git notes

git-discover

check if a git directory is a git repository
find a git repository by searching upward
- define ceilings that should not be surpassed
- prevent crossing file-systems (non-windows only)
handle linked worktrees
a way to handle safe.directory
- note that it's less critical to support it as gitoxide allows access but prevents untrusted configuration to become effective.

git-date

parse git dates

git-credentials

launch git credentials helpers with a given action

git-filter

Provide base-implementations for dealing with smudge and clean filters as well as filter processes, facilitating their development.

clean filter base
smudge filter base
filter process base

git-sec

Provides a trust model to share across gitoxide crates. It helps configuring how to interact with external processes, among other things.

integrations
- git-config
- git-repository

git-rebase

obtain rebase status
drive a rebase operation

git-sequencer

Handle human-aided operations which cannot be completed in one command invocation.

git-lfs

Implement git large file support using the process protocol and make it flexible enough to handle a variety of cases. Make it the best-performing implementation and the most convenient one.

git-glob

parse pattern
a type for pattern matching of paths and non-paths, optionally case-insensitively.

git-worktree

handle the working tree/checkout
- checkout an index of files, executables and symlinks just as fast as git
  - forbid symlinks in directories
  - handle submodules
  - handle sparse directories
  - handle sparse index
  - linear scaling with multi-threading up to IO saturation
- supported attributes to affect working tree and index contents
  - eol
  - working-tree-encoding
  - …more
- filtering
  - text
  - ident
  - filter processes
  - single-invocation clean/smudge filters
access to all .gitignore/exclude information
access to all attributes information

git-revision

describe() (similar to git name-rev)
parse specifications
- parsing and navigation
- full date parsing support (depends on git-date)
- revision ranges

git-submodule

CRUD for submodules
try to handle with all the nifty interactions and be a little more comfortable than what git offers, lay a foundation for smarter git submodules.

git-bitmap

A plumbing crate with shared functionality regarding EWAH compressed bitmaps, as well as other kinds of bitmap implementations.

EWAH
- Array type to read and write bits
  - execute closure for each true bit
- decode on-disk representation
- encode on-disk representation

git-index

The git staging area.

read
- V2 - the default, including long-paths support
- V3 - extended flags
- V4 - delta-compression for paths
- optional threading
  - concurrent loading of index extensions
  - threaded entry reading
- extensions
  - TREE for speeding up tree generation
  - REUC resolving undo
  - UNTR untracked cache
  - FSMN file system monitor cache V1 and V2
  - 'link' base indices to take information from, split index
  - 'sdir' sparse directory entries - marker
- verification of entries and extensions as well as checksum
stat update
- optional threaded stat based on thread_cost (aka preload)
handling of .gitignore and system file exclude configuration
handle potential races
maintain extensions when altering the cache
- TREE for speeding up tree generation
- REUC resolving undo
- UNTR untracked cache
- FSMN file system monitor cache V1 and V2
- EOIE end of index entry
- IEOT index entry offset table
- 'link' base indices to take information from, split index
- 'sdir' sparse directory entries
additional support
- non-sparse
- sparse (search for sparse index here)
add and remove entries
API documentation
- Some examples

git-commitgraph

read-only access
- Graph lookup of commit information to obtain timestamps, generation and parents, and extra edges
- Bloom filter index
- Bloom filter data
create and update graphs and graph files
API documentation
- Some examples

git-tempfile

See its README.md.

git-lock