- read and write a signature that uniquely identifies an actor within a git repository
- 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
- decode the chunk file table of contents and provide convenient API
- write the table of contents
- decode (zero-copy) borrowed objects
- commit
- parse the title, body, and provide a title summary.
- parse trailers
- tree
- commit
- encode owned objects
- commit
- tree
- tag
- transform borrowed to owned objects
- API documentation
- Some examples
- packs
- traverse pack index
- 'object' abstraction
- decode (zero copy)
- verify checksum
- simple and fast pack traversal
- decode
- full objects
- deltified objects
- decode
- decode a pack from
Read
input- Add support for zlib-ng for 20% faster decompression performance
-
Read
toIterator
of entries- read as is, verify hash, and restore partial packs
- create index from pack alone (much faster than git)
- resolve 'thin' packs
- decode a pack from
- 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
- respect the
- 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
- Multi-Pack index file (MIDX)
- API documentation
- Some examples
- 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, with optional listing of ambiguous objects.
- 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
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
Check out the performance discussion as well.
- trees
- nested traversal
- commits
- ancestor graph traversal similar to
git revlog
- ancestor graph traversal similar to
- API documentation
- Examples
- tree
- 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
- 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
- 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
- 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
- V1 handshake
- 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
- general purpose
- server
- general purpose
accept(…)
for servers
- general purpose
- API documentation
- Some examples
- 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
- support for built-in
- ansi-c
- quote
- unquote
- parsing
- lookup and mapping of author names
- 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
- parse
- check for match
A mechanism to associate metadata with any object, and keep revisions of it using git itself.
- CRUD for git notes
- 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.
- note that it's less critical to support it as
- parse git dates
- serialize
Time
- launch git credentials helpers with a given action
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
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
- obtain rebase status
- drive a rebase operation
Handle human-aided operations which cannot be completed in one command invocation.
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.
- parse pattern
- a type for pattern matching of paths and non-paths, optionally case-insensitively.
- 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
-
- checkout an index of files, executables and symlinks just as fast as git
- access to all .gitignore/exclude information
- access to all attributes information
-
describe()
(similar togit name-rev
) - parse specifications
- parsing and navigation
- full date parsing support (depends on
git-date
) - revision ranges
- 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.
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
- execute closure for each
- decode on-disk representation
- encode on-disk representation
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)
- optional threaded
- 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
- 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
See its README.md.
See its README.md.
- read
- zero-copy parsing with event emission
- decode value
- boolean
- integer
- color
- ANSI code output for terminal colors
- path (incl. resolution)
- date
- [permission][https://github.com/git/git/blob/71a8fab31b70c417e8f5b5f716581f89955a7082/setup.c#L1526:L1526]
- include
- includeIf
-
gitdir
,gitdir/i
, andonbranch
-
hasconfig
-
- access values and sections by name and sub-section
- edit configuration in memory, non-destructively
- cross-platform newline handling
- write files back for lossless round-trips.
- keep comments and whitespace, and only change lines that are affected by actual changes, to allow truly non-destructive editing
- cascaded loading of various configuration files into one
- load from environment variables
- load from well-known sources for global configuration
- load repository configuration with all known sources
- API documentation
- Some examples
- utilities for applications to make long running operations interruptible gracefully and to support timeouts in servers.
- handle
core.repositoryFormatVersion
and extensions - support for unicode-precomposition of command-line arguments (needs explicit use in parent application)
- Repository
- discovery
- option to not cross file systems (default)
- handle git-common-dir
- support for
GIT_CEILING_DIRECTORIES
environment variable - handle other non-discovery modes and provide control over environment variable usage required in applications
- rev-parse
- deviation
@
actually stands forHEAD
, whereasgit
resolves it to the object pointed to byHEAD
without making theHEAD
ref available for lookups.
- unsupported
- regex
- deviation
- instantiation
- access to refs and objects
- traverse
- commit graphs
- make git-notes accessible
- tree entries
- diffs/changes
- tree with working tree
- tree with index
- initialize
- Proper configuration depending on platform (e.g. ignorecase, filemode, …)
- Id
- short hashes with detection of ambiguity.
- Commit
-
describe()
like functionality - create new commit from tree
-
- Objects
- lookup
- peel to object kind
- create signed commits and tags
- trees
- lookup path
- references
- peel to end
- ref-log access
- clone from remote
- shallow
- execute hooks
- refs
- run transaction hooks and handle special repository states like quarantine
- support for different backends like
files
andreftable
- main or linked worktree
- add files with
.gitignore
handling - checkout with conversions like clean + smudge as in
.gitattributes
- diff index with working tree
- sparse checkout support
- read per-worktree config if
extensions.worktreeConfig
is enabled. - index
- tree from index
- index from tree
- add files with
- worktrees
- open a repository with worktrees
- read locked state
- obtain 'prunable' information
- proper handling of worktree related refs
- create, move, remove, and repair
- open a repository with worktrees
- config
- read the primitive types
boolean
,integer
,string
- read and interpolate trusted paths
- low-level API for more elaborate access to all details of
git-config
files - a way to make changes to individual configuration files
- read the primitive types
- remotes with push and pull
- mailmap
- object replacements (
git replace
) - configuration
- merging
- stashing
- Use Commit Graph to speed up certain queries
- subtree
- interactive rebase status/manipulation
- submodules
- discovery
- API documentation
- Some examples
- create a bundle from an archive
- respect
export-ignore
andexport-subst
- respect
- extract a branch from a bundle into a repository
- API documentation
- Some examples
- validate ref names
- validate tag names
- Prepare code for arrival of longer hashes like Sha256. It's part of the V2 proposal but should work for loose refs as well.
- Stores
- disable transactions during quarantine
- namespaces
- a server-side feature to transparently isolate refs in a single shared repository, allowing all forks to live in the same condensed repository.
- loose file
- ref validation
- find single ref by name
- special handling of
FETCH_HEAD
andMERGE_HEAD
- iterate refs with optional prefix
- worktree support
- support multiple bases and classify refs
- support for ref iteration merging common and private refs seamlessly.
- avoid packing refs which are worktree private
symbolic ref support, using symbolic links- This is a legacy feature which is not in use anymore.
- transactions
- delete, create or update single ref or multiple refs while handling the reflog
- set any valid ref value (not just object ids)
- reflog changes can be entirely disabled (i.e. for bare repos)
- rename or copy references
- transparent handling of packed-refs during deletion
- writing loose refs into packed-refs and optionally delete them
- initial transaction optimization (a faster way to create clones with a lot of refs)
- log
- forward iteration
- backward iteration
- expire
- ref
- peel to id
- packed
- find single ref by name
- iterate refs with optional prefix
- handle unsorted packed refs and those without a header
- reftable,
- API documentation
- Some examples
- io-pipe feature toggle
- a unix like pipeline for bytes
- parallel feature toggle
- When on…
in_parallel
join
- When off all functions execute serially
- When on…
- fast-sha1
- provides a faster SHA1 implementation using CPU intrinsics
- API documentation
- a terminal user interface seeking to replace and improve on
tig
- Can display complex history in novel ways to make them graspable. Maybe this post can be an inspiration.
A re-implementation of a minimal tig
like UI that aims to be fast and to the point.