You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 

10 KiB

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

  • decode (zero-copy) borrowed objects
    • commit
    • tree
    • tag
  • encode owned objects
    • commit
    • tree
    • tag
  • transform borrowed to owned objects
  • API documentation
    • Some examples

git-odb

  • loose objects
    • 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
  • 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 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
          • 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
    • verify pack with statistics
      • brute force - less memory
      • indexed - faster, but more memory
    • advanced
  • API documentation
    • Some examples
  • sink
    • write objects and obtain id
  • alternates
    • database that act as link to other known git ODBs on disk
    • safe with cycles and recursive configurations
    • multi-line with comments and quotes
  • multi-odb
    • an ODB for object lookup from multiple lower level ODB at once
  • promisor
    • It's vague, but these seems to be like index files allowing to fetch objects from a server on demand.

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

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

  • read and write a git-index file
  • 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-config

  • read
    • line-wise parsing with decent error messages
    • decode value
      • boolean
      • integer
      • color
      • path (incl. resolution)
      • include
      • includeIf
  • write
    • keep comments and whitespace, and only change lines that are affected by actual changes, to allow truly non-destructive editing
  • Config type which integrates multiple files into one interface to support system, user and repository levels for config files
  • API documentation
    • Some examples

git-repository

  • initialize
    • Proper configuration depending on platform (e.g. ignorecase, filemode, …)
  • All mutations are multi-process safe and this is tested and configurable (i.e. abort or wait if lock is encountered)
  • Signed commits and tags
  • clone
    • shallow
    • namespaces support
  • sparse checkout support
  • execute hooks
  • .gitignore handling
  • checkout/stage conversions clean + smudge as in .gitattributes
  • rev-parsing and ref history
  • worktree
  • remotes with push and pull
  • configuration
  • merging
  • stashing
  • Use Commit Graph to speed up certain queries
  • API documentation
    • Some examples

git-bundle

  • create a bundle from an archive
  • extract a branch from a bundle into a repository
  • API documentation
    • Some examples

git-ref

git-features

  • interrupt-handler feature toggle
    • Interruption for computations when receiving SIGTERM and SIGINT
    • can be entirely didsabled with the disable-interrupts feature toggle
  • io-pipe feature toggle
    • a unix like pipeline for bytes
  • parallel feature toggle
    • When on…
      • in_parallel
      • join
    • When off all functions execute serially
  • fast-sha1
    • provides a faster SHA1 implementation using CPU intrinsics
  • API documentation

git-tui

  • a terminal user interface seeking to replace and improve on tig