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-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-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.

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
manage multiple worktrees
deal with exclude specifications, like .gitignore and other exclude files.

git-revision

find specifications for revisions (like git name-rev)
parse specifications into revisions (like git rev-parse)

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