🥮 mooncakes.io
    Sign in

    git

    Pure MoonBit Git implementation

    git
    packfile
    protocol
    Download zip
    Author
    Version
    0.2.0
    License
    Apache-2.0
    Repository
    Last updated
    8 months ago
    Downloads
    58

    Dependencies

    #mizchi/moonbit_template

    FileSystem

    source
    pub(open) trait FileSystem {
      mkdir_p(Self, String) -> Unit raise GitError
      write_file(Self, String, Bytes) -> Unit raise GitError
      write_string(Self, String, String) -> Unit raise GitError
      remove_file(Self, String) -> Unit raise GitError
      remove_dir(Self, String) -> Unit raise GitError
    }

    HttpClient

    source
    pub(open) trait HttpClient {
      get(Self, String, Map[String, String]) -> (HttpResponse, Bytes) raise GitError
      post(Self, String, Bytes, Map[String, String]) -> (HttpResponse, Bytes) raise GitError
    }

    HTTP client trait for abstracting HTTP operations Implementations:
    • Native: Uses @http package (real HTTP)
    • WASM/JS: Uses browser fetch API
    • Test: Mock implementation for testing

    RepoFileSystem

    source
    pub(open) trait RepoFileSystem {
      read_file(Self, String) -> Bytes raise GitError
      readdir(Self, String) -> Array[String] raise GitError
      is_dir(Self, String) -> Bool
      is_file(Self, String) -> Bool
    }

    Read-only filesystem abstraction for loading git objects

    GitError

    source
    pub(all) suberror GitError {
      InvalidObject(String)
      HashMismatch(String, String)
      PackfileError(String)
      ProtocolError(String)
      IoError(String)
    }

    Git operation errors
    impl Eq for GitError
    impl Show for GitError

    Commit

    source
    pub struct Commit {
      tree : ObjectId
      parents : Array[ObjectId]
      author : String
      author_time : Int64
      author_tz : String
      committer : String
      commit_time : Int64
      committer_tz : String
      message : String
    }

    Git commit object

    Commit::new

    source
    fn Commit::new(tree : ObjectId, parents : Array[ObjectId], author : String, author_time : Int64, author_tz : String, committer : String, commit_time : Int64, committer_tz : String, message : String) -> Commit

    CommitInfo

    source
    pub struct CommitInfo {
      tree : ObjectId
      parents : Array[ObjectId]
    }

    FilterSpec

    source
    pub(all) enum FilterSpec {
      NoFilter
      BlobNone
      BlobLimit(Int64)
      TreeDepth(Int)
    }

    Filter specification for partial clone

    FilterSpec::is_partial

    source
    fn FilterSpec::is_partial(self : FilterSpec) -> Bool

    FilterSpec::to_string

    source
    fn FilterSpec::to_string(self : FilterSpec) -> String

    HttpResponse

    source
    pub struct HttpResponse {
      code : Int
      headers : Map[String, String]
    }

    HttpResponse::new

    source
    fn HttpResponse::new(code : Int) -> HttpResponse

    HttpResponse::with_headers

    source
    fn HttpResponse::with_headers(code : Int, headers : Map[String, String]) -> HttpResponse

    LsRefsResult

    source
    pub struct LsRefsResult {
      refs : Array[(ObjectId, String)]
      symrefs : Map[String, String]
    }

    MockHttpClient

    source
    pub struct MockHttpClient {
      responses : Map[String, (Int, Bytes)]
    }

    Mock HTTP client for testing

    MockHttpClient::add_response

    source
    fn MockHttpClient::add_response(self : MockHttpClient, url : String, code : Int, body : Bytes) -> Unit

    MockHttpClient::new

    source

    NativeHttpClient

    source
    pub struct NativeHttpClient {
      dummy : Int
    }

    NativeHttpClient::new

    source

    ObjectId

    source
    pub struct ObjectId {
      bytes : FixedArray[Byte]
    }

    SHA-1 object identifier (20 bytes)
    impl Eq for ObjectId
    impl Hash for ObjectId
    impl Show for ObjectId

    ObjectId::from_bytes

    source
    fn ObjectId::from_bytes(data : Bytes) -> ObjectId raise GitError

    Create ObjectId from Bytes (must be exactly 20 bytes)

    ObjectId::from_bytes_at

    source
    fn ObjectId::from_bytes_at(data : Bytes, offset : Int) -> ObjectId

    Create ObjectId from Bytes at offset (for parsing packed data)

    ObjectId::from_hex

    source
    fn ObjectId::from_hex(hex : String) -> ObjectId raise GitError

    ObjectId::new

    source
    fn ObjectId::new(bytes : FixedArray[Byte]) -> ObjectId

    ObjectId::to_bytes

    source
    fn ObjectId::to_bytes(self : ObjectId) -> Bytes

    Convert ObjectId to Bytes (20 bytes) - zero-copy when possible

    ObjectId::to_hex

    source
    fn ObjectId::to_hex(self : ObjectId) -> String

    ObjectId::zero

    source
    fn ObjectId::zero() -> ObjectId

    ObjectStore

    source
    pub struct ObjectStore {
      objects : Map[String, PackObject]
    }

    ObjectStore::add_objects

    source
    fn ObjectStore::add_objects(self : ObjectStore, objects : Array[PackObject]) -> Unit

    ObjectStore::contains

    source
    fn ObjectStore::contains(self : ObjectStore, id : ObjectId) -> Bool

    ObjectStore::from_pack

    source
    fn ObjectStore::from_pack(objects : Array[PackObject]) -> ObjectStore

    ObjectStore::get

    source
    fn ObjectStore::get(self : ObjectStore, id : ObjectId) -> PackObject?

    ObjectStore::new

    source

    ObjectType

    source
    pub(all) enum ObjectType {
      Blob
      Tree
      Commit
      Tag
    }

    Git object types
    impl Eq for ObjectType
    impl Show for ObjectType

    ObjectType::to_packfile_type

    source
    fn ObjectType::to_packfile_type(self : ObjectType) -> Int

    ObjectType::to_string

    source
    fn ObjectType::to_string(self : ObjectType) -> String

    PackDeltaMode

    source
    pub(all) enum PackDeltaMode {
      NoDelta
      RefDelta
      OfsDelta
    }

    Delta encoding mode for packfile generation

    PackObject

    source
    pub struct PackObject {
      obj_type : ObjectType
      data : Bytes
      id : ObjectId
      offset : Int
      crc32 : UInt
    }

    A Git object ready for packing

    PackObject::new

    source
    fn PackObject::new(obj_type : ObjectType, data : Bytes) -> PackObject

    PackObject::with_metadata

    source
    fn PackObject::with_metadata(obj_type : ObjectType, data : Bytes, id : ObjectId, offset : Int, crc32 : UInt) -> PackObject

    ProtocolVersion

    source
    pub(all) enum ProtocolVersion {
      V0
      V2
    }

    PushRequest

    source
    pub struct PushRequest {
      old_id : ObjectId
      new_id : ObjectId
      refname : String
      packfile : Bytes
    }

    Git push request data

    PushRequest::new

    source
    fn PushRequest::new(old_id : ObjectId, new_id : ObjectId, refname : String, packfile : Bytes) -> PushRequest

    Remote

    source
    pub struct Remote {
      url : String
    }

    Remote repository URL

    Remote::info_refs_url

    source
    fn Remote::info_refs_url(self : Remote) -> String

    Build URL for git-receive-pack info/refs

    Remote::new

    source
    fn Remote::new(url : String) -> Remote

    Remote::receive_pack_url

    source
    fn Remote::receive_pack_url(self : Remote) -> String

    Build URL for git-receive-pack

    RemoteKind

    source
    pub(all) enum RemoteKind {
      Http
      Ssh
      File
    }

    impl Eq for RemoteKind

    RemoteSpec

    source
    pub struct RemoteSpec {
      kind : RemoteKind
      raw : String
      host : String?
      path : String
      base_url : String?
    }

    Sha1State

    source
    pub struct Sha1State {
      h : FixedArray[Int]
      block : FixedArray[Byte]
      w : FixedArray[Int]
      block_len : Int
      total_len : Int64
    }

    Incremental SHA-1 state

    Sha1State::finish

    source
    fn Sha1State::finish(self : Sha1State) -> ObjectId

    Sha1State::new

    source
    fn Sha1State::new() -> Sha1State

    Sha1State::reset

    source
    fn Sha1State::reset(self : Sha1State) -> Unit

    Sha1State::update

    source
    fn Sha1State::update(self : Sha1State, data : Bytes) -> Unit

    Sha1State::update_byte

    source
    fn Sha1State::update_byte(self : Sha1State, b : Byte) -> Unit

    Sha1State::update_slice

    source
    fn Sha1State::update_slice(self : Sha1State, data : Bytes, offset : Int, len : Int) -> Unit

    Sha1State::update_string

    source
    fn Sha1State::update_string(self : Sha1State, s : String) -> Unit

    TestFs

    source
    pub struct TestFs {
      files : Map[String, Bytes]
      dirs : Map[String, Bool]
    }

    TestFs::exists

    source
    fn TestFs::exists(self : TestFs, path : String) -> Bool

    TestFs::is_dir

    source
    fn TestFs::is_dir(self : TestFs, path : String) -> Bool

    TestFs::is_file

    source
    fn TestFs::is_file(self : TestFs, path : String) -> Bool

    TestFs::mkdir_p

    source
    fn TestFs::mkdir_p(self : TestFs, path : String) -> Unit

    TestFs::new

    source
    fn TestFs::new() -> TestFs

    TestFs::read_file

    source
    fn TestFs::read_file(self : TestFs, path : String) -> Bytes raise GitError

    TestFs::read_string

    source
    fn TestFs::read_string(self : TestFs, path : String) -> String raise GitError

    TestFs::readdir

    source
    fn TestFs::readdir(self : TestFs, path : String) -> Array[String] raise GitError

    TestFs::remove_dir

    source
    fn TestFs::remove_dir(self : TestFs, path : String) -> Unit raise GitError

    TestFs::remove_file

    source
    fn TestFs::remove_file(self : TestFs, path : String) -> Unit raise GitError

    TestFs::write_file

    source
    fn TestFs::write_file(self : TestFs, path : String, content : Bytes) -> Unit

    TestFs::write_string

    source
    fn TestFs::write_string(self : TestFs, path : String, content : String) -> Unit

    TreeEntry

    source
    pub struct TreeEntry {
      mode : String
      name : String
      id : ObjectId
    }

    Tree entry in a Git tree object

    TreeEntry::new

    source
    fn TreeEntry::new(mode : String, name : String, id : ObjectId) -> TreeEntry

    apply_delta

    source
    fn apply_delta(base : Bytes, delta : Bytes) -> Bytes raise GitError

    build_fetch_request_v0

    source
    fn build_fetch_request_v0(agent : String, wants : Array[ObjectId], advertised : Array[String]) -> Bytes

    build_fetch_request_v2

    source
    fn build_fetch_request_v2(agent : String, wants : Array[ObjectId], depth : Int, filter? : FilterSpec) -> Bytes

    Build a fetch request for protocol v2.
    • depth > 0: shallow clone with that depth
    • filter: partial clone filter specification

    build_ls_refs_request

    source
    fn build_ls_refs_request(agent : String, prefixes : Array[String]) -> Bytes

    build_pack_index

    source
    fn build_pack_index(pack : Bytes) -> Bytes raise GitError

    Build a pack index (v2) from packfile bytes.

    build_pack_index_from_objects

    source
    fn build_pack_index_from_objects(pack : Bytes, objects : Array[PackObject]) -> Bytes raise GitError

    Build a pack index (v2) from packfile bytes and parsed objects. Uses cached metadata (id, offset, crc32) from PackObject when available.

    build_receive_pack_body

    source
    fn build_receive_pack_body(req : PushRequest) -> Bytes

    Build the request body for git-receive-pack

    build_ref_update

    source
    fn build_ref_update(old_id : ObjectId, new_id : ObjectId, refname : String, capabilities : String) -> String

    Build a ref update command for git-receive-pack Format: {old_sha} {new_sha} {refname}\0{capabilities}\n

    build_ref_update_simple

    source
    fn build_ref_update_simple(old_id : ObjectId, new_id : ObjectId, refname : String) -> String

    Build a ref update command (without capabilities)

    checkout_commit

    source
    fn checkout_commit(store : ObjectStore, commit_id : ObjectId) -> Map[String, Bytes] raise GitError

    checkout_commit_to_fs

    source
    fn checkout_commit_to_fs(store : ObjectStore, commit_id : ObjectId, fs : &FileSystem, root : String) -> Unit raise GitError

    Materialize commit files into a filesystem under root.

    clone_http

    source
    async fn clone_http(remote : String, prefer_v2 : Bool, depth? : Int, filter? : FilterSpec) -> (Array[(ObjectId, String)], Array[PackObject]) raise GitError

    clone_http_to_fs

    source
    async fn clone_http_to_fs(remote : String, prefer_v2 : Bool, fs : &FileSystem, root : String, depth? : Int, filter? : FilterSpec) -> Array[(ObjectId, String)] raise GitError

    Clone and checkout into filesystem under root.
    • depth > 0: shallow clone with that depth
    • filter: partial clone filter (e.g., FilterSpec::BlobNone)

    clone_process

    source
    async fn clone_process(remote : String, prefer_v2 : Bool) -> (Array[(ObjectId, String)], Array[PackObject]) raise GitError

    clone_process_to_fs

    source
    async fn clone_process_to_fs(remote : String, prefer_v2 : Bool, fs : &FileSystem, root : String) -> Array[(ObjectId, String)] raise GitError

    Clone and checkout into filesystem under root.

    clone_remote

    source
    async fn clone_remote(remote : String, prefer_v2 : Bool) -> (Array[(ObjectId, String)], Array[PackObject]) raise GitError

    clone_remote_to_fs

    source
    async fn clone_remote_to_fs(remote : String, prefer_v2 : Bool, fs : &FileSystem, root : String) -> Array[(ObjectId, String)] raise GitError

    clone_to_fs_with_http

    source
    async fn clone_to_fs_with_http(remote : String, prefer_v2 : Bool, depth : Int, filter : FilterSpec, fs : &FileSystem, root : String, http_get : async (String, Map[String, String]) -> (HttpResponse, Bytes) raise GitError, http_post : async (String, Bytes, Map[String, String]) -> (HttpResponse, Bytes) raise GitError) -> Array[(ObjectId, String)] raise GitError

    Clone and checkout into filesystem using provided HTTP client.
    • depth > 0: shallow clone with that depth
    • filter: partial clone filter (if BlobNone, skip checkout)

    clone_with_http

    source
    async fn clone_with_http(remote : String, prefer_v2 : Bool, depth : Int, filter : FilterSpec, http_get : async (String, Map[String, String]) -> (HttpResponse, Bytes) raise GitError, http_post : async (String, Bytes, Map[String, String]) -> (HttpResponse, Bytes) raise GitError) -> (Array[(ObjectId, String)], Array[PackObject]) raise GitError

    Clone using provided HTTP client.
    • depth > 0: shallow clone with that depth
    • filter: partial clone filter

    crc32_range

    source
    fn crc32_range(data : Bytes, start : Int, end : Int) -> UInt raise GitError

    create_blob

    source
    fn create_blob(content : Bytes) -> (ObjectId, Bytes)

    Create a blob object from content

    create_blob_packfile

    source
    fn create_blob_packfile(content : Bytes) -> Bytes

    Create a packfile containing a single blob

    create_blob_string

    source
    fn create_blob_string(content : String) -> (ObjectId, Bytes)

    Create a blob from string content

    create_commit

    source
    fn create_commit(commit : Commit) -> (ObjectId, Bytes)

    Create a commit object

    create_commit_packfile

    source
    fn create_commit_packfile(blob_content : Bytes, filename : String, commit : Commit) -> (ObjectId, Bytes)

    Create a packfile with blob, tree, and commit

    create_object

    source
    fn create_object(obj_type : ObjectType, content : Bytes) -> (ObjectId, Bytes)

    Create a Git object and return its ID and compressed data Format: {type} {size}\0{content} -> SHA-1 -> zlib compress

    create_packfile

    source
    fn create_packfile(objects : Array[PackObject]) -> Bytes

    Create a packfile from a list of objects Format: [PACK] 4 bytes magic [version] 4 bytes (big-endian, always 2) [object count] 4 bytes (big-endian) [...objects...] variable [SHA-1 trailer] 20 bytes

    create_packfile_with_delta

    source
    fn create_packfile_with_delta(objects : Array[PackObject], delta_mode : PackDeltaMode) -> Bytes

    Create a packfile from a list of objects with a chosen delta mode

    create_packfile_with_delta_stats

    source
    fn create_packfile_with_delta_stats(objects : Array[PackObject], delta_mode : PackDeltaMode) -> (Bytes, Int)

    Create a packfile with delta statistics (delta object count)

    create_tree

    source
    fn create_tree(entries : Array[TreeEntry]) -> (ObjectId, Bytes)

    Create a tree object from entries Entries must be sorted by name

    decode_type_and_size_at

    source
    fn decode_type_and_size_at(data : Bytes, start : Int) -> (Int, Int, Int) raise GitError

    Decode packfile object header and return (type_id, size, next_offset).

    detect_protocol_version

    source
    fn detect_protocol_version(data : Bytes) -> ProtocolVersion raise GitError

    discover_receive_refs_http

    source
    async fn discover_receive_refs_http(remote : Remote) -> Array[(ObjectId, String)] raise GitError

    Fetch receive-pack refs via smart HTTP (native)

    discover_refs

    source
    async fn discover_refs(remote : Remote) -> (Array[(ObjectId, String)], Array[String]) raise GitError

    Discover refs and capabilities from remote (native)

    discover_refs_with_http

    source
    async fn discover_refs_with_http(remote : Remote, http_get : async (String, Map[String, String]) -> (HttpResponse, Bytes) raise GitError) -> (Array[(ObjectId, String)], Array[String]) raise GitError

    Discover refs using provided HTTP client functions

    discover_upload_refs

    source
    async fn discover_upload_refs(remote : String, prefer_v2 : Bool) -> (Array[(ObjectId, String)], Array[String], ProtocolVersion, Map[String, String]) raise GitError

    discover_upload_refs_http

    source
    async fn discover_upload_refs_http(remote : String, prefer_v2 : Bool) -> (Array[(ObjectId, String)], Array[String], ProtocolVersion, Map[String, String]) raise GitError

    discover_upload_refs_process

    source
    async fn discover_upload_refs_process(remote : String, prefer_v2 : Bool) -> (Array[(ObjectId, String)], Array[String], ProtocolVersion, Map[String, String]) raise GitError

    discover_upload_refs_with_http

    source
    async fn discover_upload_refs_with_http(remote : String, prefer_v2 : Bool, http_get : async (String, Map[String, String]) -> (HttpResponse, Bytes) raise GitError, http_post : async (String, Bytes, Map[String, String]) -> (HttpResponse, Bytes) raise GitError) -> (Array[(ObjectId, String)], Array[String], ProtocolVersion, Map[String, String]) raise GitError

    Discover upload refs using provided HTTP client

    encode_type_and_size

    source
    fn encode_type_and_size(obj_type : Int, size : Int, result : Array[Byte]) -> Unit

    Encode type and size in Git's variable-length format

    extract_capabilities

    source
    fn extract_capabilities(data : Bytes) -> Array[String]

    Extract capabilities from refs response

    extract_pack_from_v0_response

    source
    fn extract_pack_from_v0_response(data : Bytes) -> Bytes raise GitError

    extract_pack_from_v2_response

    source
    fn extract_pack_from_v2_response(data : Bytes) -> Bytes raise GitError

    fetch_objects

    source
    async fn fetch_objects(remote : String, wants : Array[ObjectId], prefer_v2 : Bool) -> Array[PackObject] raise GitError

    fetch_objects_http

    source
    async fn fetch_objects_http(remote : String, wants : Array[ObjectId], prefer_v2 : Bool, depth? : Int, filter? : FilterSpec) -> Array[PackObject] raise GitError

    fetch_objects_process

    source
    async fn fetch_objects_process(remote : String, wants : Array[ObjectId], prefer_v2 : Bool) -> Array[PackObject] raise GitError

    fetch_objects_with_http

    source
    async fn fetch_objects_with_http(remote : String, wants : Array[ObjectId], prefer_v2 : Bool, depth : Int, filter : FilterSpec, http_get : async (String, Map[String, String]) -> (HttpResponse, Bytes) raise GitError, http_post : async (String, Bytes, Map[String, String]) -> (HttpResponse, Bytes) raise GitError) -> Array[PackObject] raise GitError

    Fetch objects using provided HTTP client.
    • depth > 0: shallow clone with that depth
    • filter: partial clone filter

    fetch_pack

    source
    async fn fetch_pack(remote : String, wants : Array[ObjectId], prefer_v2 : Bool) -> Bytes raise GitError

    fetch_pack_http

    source
    async fn fetch_pack_http(remote : String, wants : Array[ObjectId], prefer_v2 : Bool, depth? : Int, filter? : FilterSpec) -> Bytes raise GitError

    fetch_pack_process

    source
    async fn fetch_pack_process(remote : String, wants : Array[ObjectId], prefer_v2 : Bool) -> Bytes raise GitError

    fetch_pack_with_http

    source
    async fn fetch_pack_with_http(remote : String, wants : Array[ObjectId], prefer_v2 : Bool, depth : Int, filter : FilterSpec, http_get : async (String, Map[String, String]) -> (HttpResponse, Bytes) raise GitError, http_post : async (String, Bytes, Map[String, String]) -> (HttpResponse, Bytes) raise GitError) -> Bytes raise GitError

    Fetch pack using provided HTTP client.
    • depth > 0: shallow clone with that depth (v2 only)
    • filter: partial clone filter (v2 only)

    generate_commit_packfile

    source
    fn generate_commit_packfile() -> (ObjectId, Bytes)

    generate_test_packfile

    source
    fn generate_test_packfile() -> Bytes

    hash_blob

    source
    fn hash_blob(content : Bytes) -> ObjectId

    Hash a blob without creating the compressed object - optimized with incremental SHA1

    hash_blob_string

    source
    fn hash_blob_string(content : String) -> ObjectId

    Hash a blob from string - optimized with incremental SHA1

    hash_object_content

    source
    fn hash_object_content(obj_type : ObjectType, content : Bytes) -> ObjectId

    Hash object content (without compression) - optimized with incremental SHA1

    hex_dump

    source
    fn hex_dump(data : Bytes) -> String

    Print packfile as hex dump for debugging

    materialize_clone_to_fs

    source
    fn materialize_clone_to_fs(store : ObjectStore, commit_id : ObjectId, refname : String, remote_url : String, fs : &FileSystem, root : String) -> Unit raise GitError

    native_http_get

    source
    async fn native_http_get(url : String, headers : Map[String, String]) -> (HttpResponse, Bytes) raise GitError

    native_http_post

    source
    async fn native_http_post(url : String, body : Bytes, headers : Map[String, String]) -> (HttpResponse, Bytes) raise GitError

    packfile_type_to_object_type

    source
    fn packfile_type_to_object_type(type_id : Int) -> ObjectType raise GitError

    Convert packfile type id to ObjectType.

    parse_commit

    source
    fn parse_commit(content : Bytes) -> CommitInfo raise GitError

    parse_ls_refs_response

    source
    fn parse_ls_refs_response(data : Bytes) -> LsRefsResult raise GitError

    parse_packfile

    source
    fn parse_packfile(data : Bytes) -> Array[PackObject] raise GitError

    Parse a packfile into objects.

    parse_packfile_stream

    source
    fn parse_packfile_stream(data : Bytes, emit : (PackObject) -> Unit) -> Unit raise GitError

    Parse a packfile and emit resolved objects (order not guaranteed).

    parse_packfile_stream_with_bases

    source
    fn parse_packfile_stream_with_bases(data : Bytes, bases : Array[PackObject], emit : (PackObject) -> Unit) -> Unit raise GitError

    Parse a packfile with base objects and emit resolved objects.

    parse_packfile_with_bases

    source
    fn parse_packfile_with_bases(data : Bytes, bases : Array[PackObject]) -> Array[PackObject] raise GitError

    Parse a packfile with preloaded base objects (for thin packs).

    parse_receive_pack_response

    source
    fn parse_receive_pack_response(data : Bytes) -> Result[String, GitError]

    Parse receive-pack response

    parse_refs

    source
    fn parse_refs(data : Bytes) -> Array[(ObjectId, String)] raise GitError

    Parse refs from git-receive-pack response Format: {sha} {refname}\0{capabilities}\n (for first line) {sha} {refname}\n (for subsequent lines)

    parse_remote

    source
    fn parse_remote(remote : String) -> RemoteSpec

    parse_sideband

    source
    fn parse_sideband(data : Bytes) -> (Int, Bytes)

    Parse side-band data

    parse_tree

    source
    fn parse_tree(content : Bytes) -> Array[TreeEntry] raise GitError

    parse_v0_advertised_caps

    source
    fn parse_v0_advertised_caps(data : Bytes) -> Array[String] raise GitError

    parse_v2_advertised_caps

    source
    fn parse_v2_advertised_caps(data : Bytes) -> Array[String] raise GitError

    pktline_decode

    source
    fn pktline_decode(data : Bytes) -> Array[(Bytes, Bool)] raise GitError

    Decode pkt-lines from bytes Returns array of (data, is_flush)

    pktline_delim

    source
    fn pktline_delim() -> Bytes

    Delimiter packet (0001)

    pktline_encode

    source
    fn pktline_encode(data : String) -> Bytes

    Encode a single pkt-line Format: {4-hex-length}{payload} Length includes the 4-byte header

    pktline_encode_bytes

    source
    fn pktline_encode_bytes(data : Bytes) -> Bytes

    Encode pkt-line from bytes

    pktline_flush

    source
    fn pktline_flush() -> Bytes

    Flush packet (0000)

    push

    source
    async fn push(remote : Remote, req : PushRequest) -> String raise GitError

    Push a packfile to remote repository (native)

    push_file

    source
    async fn push_file(remote : Remote, content : Bytes, filename : String, message : String, author : String, timestamp : Int64, parent : ObjectId?) -> ObjectId raise GitError

    Push a single file as a new commit (native)

    push_with_http

    source
    async fn push_with_http(remote : Remote, req : PushRequest, http_get : async (String, Map[String, String]) -> (HttpResponse, Bytes) raise GitError, http_post : async (String, Bytes, Map[String, String]) -> (HttpResponse, Bytes) raise GitError) -> String raise GitError

    Push using provided HTTP client functions

    read_ofs_delta_offset

    source
    fn read_ofs_delta_offset(data : Bytes, start : Int) -> (Int, Int) raise GitError

    read_ref_delta_id

    source
    fn read_ref_delta_id(data : Bytes, start : Int) -> (String, Int) raise GitError

    select_default_ref

    source
    fn select_default_ref(refs : Array[(ObjectId, String)], symrefs : Map[String, String]) -> (String, ObjectId)?

    select_default_wants

    source
    fn select_default_wants(refs : Array[(ObjectId, String)], symrefs : Map[String, String]) -> Array[ObjectId]

    sha1

    source
    fn sha1(data : Bytes) -> ObjectId

    Compute SHA-1 hash of data

    sha1_array

    source
    fn sha1_array(data : Array[Byte]) -> ObjectId

    Compute SHA-1 hash of data from Array

    sha1_array_prefix

    source
    fn sha1_array_prefix(data : Array[Byte], len : Int) -> ObjectId

    Compute SHA-1 hash of Array prefix (first len bytes).

    sha1_prefix

    source
    fn sha1_prefix(data : Bytes, len : Int) -> ObjectId

    Compute SHA-1 hash of data prefix (first len bytes).

    upload_pack_info_refs

    source
    async fn upload_pack_info_refs(remote : String, prefer_v2 : Bool) -> Bytes raise GitError

    upload_pack_info_refs_http

    source
    async fn upload_pack_info_refs_http(remote : String, prefer_v2 : Bool) -> Bytes raise GitError

    upload_pack_info_refs_process

    source
    async fn upload_pack_info_refs_process(remote : String, prefer_v2 : Bool) -> Bytes raise GitError

    upload_pack_info_refs_with_http

    source
    async fn upload_pack_info_refs_with_http(remote : String, prefer_v2 : Bool, http_get : async (String, Map[String, String]) -> (HttpResponse, Bytes) raise GitError) -> Bytes raise GitError

    Fetch info/refs using provided HTTP client

    upload_pack_request

    source
    async fn upload_pack_request(remote : String, body : Bytes, prefer_v2 : Bool) -> Bytes raise GitError

    upload_pack_request_http

    source
    async fn upload_pack_request_http(remote : String, body : Bytes, prefer_v2 : Bool) -> Bytes raise GitError

    upload_pack_request_process

    source
    async fn upload_pack_request_process(remote : String, body : Bytes, prefer_v2 : Bool) -> Bytes raise GitError

    upload_pack_request_with_http

    source
    async fn upload_pack_request_with_http(remote : String, body : Bytes, prefer_v2 : Bool, http_post : async (String, Bytes, Map[String, String]) -> (HttpResponse, Bytes) raise GitError) -> Bytes raise GitError

    Send upload-pack request using provided HTTP client

    write_git_metadata

    source
    fn write_git_metadata(store : ObjectStore, commit_id : ObjectId, refname : String, remote_url : String, fs : &FileSystem, root : String) -> Unit raise GitError

    write_pack_index

    source
    fn write_pack_index(fs : &FileSystem, idx_path : String, pack : Bytes) -> Unit raise GitError

    Write a pack index to the filesystem.

    write_pack_index_from_objects

    source
    fn write_pack_index_from_objects(fs : &FileSystem, idx_path : String, pack : Bytes, objects : Array[PackObject]) -> Unit raise GitError

    Write a pack index using pre-parsed objects.

    write_pack_index_from_objects_versioned

    source
    fn write_pack_index_from_objects_versioned(fs : &FileSystem, idx_path : String, pack : Bytes, objects : Array[PackObject], version : Int) -> Unit raise GitError

    Write a pack index using pre-parsed objects with specific version.

    write_packfile_with_index

    source
    fn write_packfile_with_index(fs : &FileSystem, git_dir : String, pack : Bytes, objects : Array[PackObject]) -> Unit raise GitError

    Write a packfile and its index under .git/objects/pack.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io