commit 8d1d9811164bc7930416f81a520d4353f483e85f Author: caelum0x Date: Mon Aug 24 20:43:50 2026 +0300 feat(rit+rithub): rit (rust git core, 35 tests) + rithub (forge scaffold) under railyard/apps diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..4e73dc7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +target/ +*.db +.env diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 0000000..1a4f567 --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,418 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "anstream" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d" +dependencies = [ + "anstyle", + "anstyle-parse", + "anstyle-query", + "anstyle-wincon", + "colorchoice", + "is_terminal_polyfill", + "utf8parse", +] + +[[package]] +name = "anstyle" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" + +[[package]] +name = "anstyle-parse" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e" +dependencies = [ + "utf8parse", +] + +[[package]] +name = "anstyle-query" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "anstyle-wincon" +version = "3.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d" +dependencies = [ + "anstyle", + "once_cell_polyfill", + "windows-sys", +] + +[[package]] +name = "anyhow" +version = "1.0.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" + +[[package]] +name = "bitflags" +version = "2.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da" + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "clap" +version = "4.6.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "473c7e07f409a8d772161724aa8db6a765a2532a70f9667eeb7b49d3d02fbdca" +dependencies = [ + "clap_builder", + "clap_derive", +] + +[[package]] +name = "clap_builder" +version = "4.6.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b48fea5a88e9ae728a2dcbedbfc0e730f7d60da42e1cb049a83c9fb8b789889" +dependencies = [ + "anstream", + "anstyle", + "clap_lex", + "strsim", +] + +[[package]] +name = "clap_derive" +version = "4.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d012d2b9d65aca7f18f4d9878a045bc17899bba951561ba5ec3c2ba1eed9a061" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "clap_lex" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9" + +[[package]] +name = "colorchoice" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570" + +[[package]] +name = "cpufeatures" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" +dependencies = [ + "libc", +] + +[[package]] +name = "crc32fast" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8498c871161e1742aaa9d52551b2d6ebdd4c3d45a3be423e3728f33b955be550" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "crypto-common" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" +dependencies = [ + "generic-array", + "typenum", +] + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer", + "crypto-common", +] + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys", +] + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "flate2" +version = "1.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c" +dependencies = [ + "crc32fast", + "miniz_oxide", +] + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", +] + +[[package]] +name = "getrandom" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099" +dependencies = [ + "cfg-if", + "libc", + "r-efi", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "is_terminal_polyfill" +version = "1.70.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695" + +[[package]] +name = "libc" +version = "0.2.189" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2" + +[[package]] +name = "linux-raw-sys" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" + +[[package]] +name = "miniz_oxide" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", + "simd-adler32", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "once_cell_polyfill" +version = "1.70.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe" + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + +[[package]] +name = "rit" +version = "0.1.0" +dependencies = [ + "anyhow", + "clap", + "flate2", + "sha1", + "tempfile", + "thiserror", +] + +[[package]] +name = "rustix" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys", + "windows-sys", +] + +[[package]] +name = "sha1" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + +[[package]] +name = "simd-adler32" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea" + +[[package]] +name = "strsim" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" + +[[package]] +name = "syn" +version = "3.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6275cddf4610d1775e6d1fe9469b2e77d0f39fd98fb7450901b821e0c53649f" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "tempfile" +version = "3.27.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" +dependencies = [ + "fastrand", + "getrandom", + "once_cell", + "rustix", + "windows-sys", +] + +[[package]] +name = "thiserror" +version = "2.0.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "typenum" +version = "1.20.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20" + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "utf8parse" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..a41be48 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,28 @@ +[package] +name = "rit" +version = "0.1.0" +edition = "2021" +license = "MIT" +description = "Library-first Rust implementation of the Git loose-object model: read, write, verify, and traverse standard Git repositories" +rust-version = "1.74" + +# Standalone by design: never join a parent Cargo workspace. +[workspace] + +[lib] +name = "rit" +path = "src/lib.rs" + +[[bin]] +name = "rit" +path = "src/main.rs" + +[dependencies] +anyhow = "1" +clap = { version = "4", features = ["derive"] } +flate2 = "1" +sha1 = "0.10" +thiserror = "2" + +[dev-dependencies] +tempfile = "3" diff --git a/PLAN.md b/PLAN.md new file mode 100644 index 0000000..3b892d5 --- /dev/null +++ b/PLAN.md @@ -0,0 +1,222 @@ +# Rust Git Forge Product and Architecture Plan + +Last revised: 23 August 2026 +Tracking issue: `videogen-zyo` + +## Decision record + +This is a production open-source systems product, not GitGram and not a +hackathon implementation. The neutral working name is **Rust Git Forge** until +brand, crate, and package-name checks are complete. + +The product has two layers: + +1. A library-first Rust implementation of Git repositories and the Git wire + protocol, compatible with existing Git repositories and clients. +2. A self-hostable collaboration forge built on that implementation, including + repositories, organizations, permissions, issues, pull requests, review, + protected branches, webhooks, releases, and audit logs. + +GitGram remains a mostly TypeScript social product. It turns repositories into +Instagram-like accounts with posts, reels, stories, media publishing, +followers, and feeds. GitGram does not own object storage, refs, packfiles, the +Git protocol, pull-request truth, or repository permissions. It integrates with +GitHub and, later, Rust Git Forge through public authenticated APIs and webhooks. + +AITimeMachine captures and restores AI coding workflows. It may attach its +checkpoints to Git commits, but it does not implement or replace Git. + +## Initial customer and promise + +The initial user is an engineer or small team that needs a trustworthy local +Git implementation with readable internals and strong compatibility evidence. +The first production promise is narrower than a complete GitHub replacement: +users can inspect, create, verify, exchange, and recover standard Git +repositories without corrupting data. + +The forge becomes a supported product only after the core passes +interoperability, crash-recovery, parser-fuzzing, and concurrent-ref tests. + +## Compatibility scope + +The core implementation must cover: + +- loose blobs, trees, commits, annotated tags, object verification, and object + traversal; +- SHA-1 repository compatibility with collision detection, plus an explicit + path to Git's SHA-256 repository format; +- refs, symbolic refs, packed refs, reflogs, atomic compare-and-swap updates, + and lock recovery; +- index formats, worktrees, ignore rules, status, add, restore, and commit; +- revision parsing, graph walks, merge bases, diffs, rename heuristics, and + conflict representation; +- pack indexes, packfiles, delta resolution, reachability, negotiation, and + quarantine of received objects; +- smart protocol v2 over HTTP and SSH for clone, fetch, and push; +- three-way merge, rebase, cherry-pick, revert, and deterministic conflict + handling. + +Submodules, sparse checkout, partial clone, large-file storage, replace refs, +notes, and advanced maintenance enter the compatibility matrix explicitly. None +is silently claimed before its test suite passes. + +## Rust workspace architecture + +```text +crates/ + git-object object IDs, parsing, validation, canonical serialization + git-odb loose and packed object databases, quarantine, alternates + git-refs refs, reflogs, transactions, locks + git-index index formats and extensions + git-worktree checkout, status, ignore rules, filesystem safety + git-revision revision syntax, graph traversal, reachability + git-diff text and binary diff, rename detection + git-merge merge bases, strategies, conflicts, sequencer + git-pack pack/index parsing, deltas, negotiation inputs + git-protocol protocol v2, upload-pack, receive-pack transports + git-cli compatibility-oriented command-line interface + forge-domain users, organizations, repositories, issues, reviews + forge-store metadata persistence and repository coordination + forge-http browser/API and smart-HTTP server + forge-ssh SSH command gateway and key authorization + forge-jobs durable maintenance, hooks, webhooks, notifications +``` + +Shared crates cannot depend on the forge UI or a specific database. Parsing and +storage APIs expose bounded streams rather than assuming objects or packs fit in +memory. Platform-specific filesystem behavior stays behind explicit adapters +and platform tests. + +## Forge architecture + +The first forge is a single-node, self-hosted service: + +- repositories and packfiles on a durable local filesystem; +- PostgreSQL for users, organizations, permissions, issues, reviews, jobs, and + immutable audit events; +- an SSH service for Git transport and an HTTP service for API, browser, and + smart HTTP; +- a transactional job outbox for webhooks, email, repository maintenance, and + indexing; +- filesystem snapshots plus PostgreSQL backups with a tested coordinated + restore procedure. + +SQLite may support desktop or single-user mode, but it does not imply safe +multi-node repository coordination. Multi-node storage, geo replication, +packages, runners, Actions-compatible CI, and large-file storage require later +designs with separate threat and cost reviews. + +Cloudflare Workers are not the Git execution or storage plane. Large pack +streams, SSH, repository filesystem semantics, and long-running maintenance +need a local process or conventional server. Cloudflare may serve static project +documentation and, after measurement, proxy ordinary browser/API traffic. R2 is +only a future cold-object or backup option under the shared account budget. + +## Security contract + +Repository data is adversarial input. The product must defend against: + +- malformed object, index, pack, bitmap, commit-graph, and protocol data; +- path traversal, case-folding collisions, NTFS/HFS hazards, unsafe symlinks, + and checkout outside the worktree; +- decompression bombs, delta chains, integer overflow, unbounded graph walks, + resource exhaustion, and archive bombs; +- SHA-1 collision attacks and object-ID confusion between hash formats; +- ref races, lock theft, non-fast-forward policy bypass, hook injection, and + partially received pushes; +- cross-tenant authorization errors, leaked deploy keys or tokens, forged + webhooks, and unsafe HTML or Markdown rendering. + +Incoming pushes remain quarantined until object verification, connectivity, +authorization, policy, and size checks pass. Ref changes use atomic +transactions. The forge supports scoped tokens, SSH key fingerprints, +phishing-resistant operator MFA, protected branches, signed commit and tag +verification, secret redaction, security logs, and auditable administrative +actions. + +## Verification strategy + +Production claims require retained evidence from: + +- differential tests that run equivalent operations through Rust Git Forge and + the reference Git CLI, then compare repository state and command semantics; +- interoperability matrices across supported Git versions, operating systems, + filesystem behaviors, HTTP servers, and SSH clients; +- property tests for serialization, graph traversal, deltas, refs, and index + round trips; +- coverage-guided fuzzing for every untrusted parser and protocol state machine; +- Git project fixtures where licensing and harness boundaries permit; +- fault injection around writes, fsync, locks, process death, partial network + reads, interrupted clone/fetch/push, and coordinated restore; +- concurrency tests for ref updates, simultaneous pushes, garbage collection, + and read/write isolation; +- independent security review before exposing public repository hosting. + +Every compatibility claim is tied to a named test. A failing repository fixture +remains a release blocker or a documented unsupported capability. + +## Release sequence + +### Stage 0: specification and harness + +Publish the compatibility matrix, threat model, repository fixtures, +differential harness, fuzz targets, performance budgets, and +corruption-recovery rules. + +### Stage 1: read-only repository core + +Ship object inspection, `cat-file`, `ls-tree`, log traversal, refs, pack reads, +and `fsck`. Opening hostile repositories cannot write outside the repository or +consume unbounded resources. + +### Stage 2: local authoring + +Ship init, status, add, diff, commit, branch, checkout/restore, tag, reflog, and +garbage-safe object writes. Pass crash tests for every state-changing command. + +### Stage 3: exchange + +Ship protocol v2 clone, fetch, and push over HTTP and SSH. Prove quarantine, +atomic refs, authentication, authorization, interrupted transfer recovery, and +interop with the reference Git client and server. + +### Stage 4: history editing + +Ship merge, rebase, cherry-pick, revert, conflict continuation/abort, and +recovery. Preserve user work during failures and match documented Git behavior. + +### Stage 5: single-node forge + +Ship accounts, organizations, repository permissions, issues, pull requests, +review, branch protection, webhooks, releases, operator tools, backups, restore, +export, deletion, abuse handling, and upgrade/rollback procedures. + +### Stage 6: public production + +Onboard outside repositories only after security review, capacity tests, +restore drills, support procedures, privacy/terms, observability, incident +response, and an upgrade from the previous release all pass. Multi-node and CI +features remain separate approvals. + +## Non-goals for the first public release + +- replacing every Git command at once; +- claiming GitHub parity; +- running arbitrary CI jobs; +- hosting unbounded public binary releases or package registries; +- coupling repository correctness to GitGram feeds; +- storing primary repositories in browser storage, R2, or a Worker runtime; +- inventing a new incompatible wire protocol before Git interoperability works. + +## Pre-code gate + +Before implementation: + +1. approve the project name, license, governance, supported platforms, and MSRV; +2. freeze the Stage 1 compatibility matrix and threat model; +3. select reference Git versions and reusable fixtures after license review; +4. decide whether existing Rust Git crates are comparison subjects, + dependencies, or clean-room references; +5. define benchmark repositories and memory, CPU, disk, and network budgets; +6. approve the single-node data and backup contract without using Cloudflare as + the repository execution plane. diff --git a/README.md b/README.md new file mode 100644 index 0000000..f936b42 --- /dev/null +++ b/README.md @@ -0,0 +1,13 @@ +# rit — rust git + +A from-scratch, **library-first** Rust implementation of the Git **loose-object model** — +the `git` equivalent. Byte-for-byte compatible with real Git (interop-tested against `git` 2.50). + +- Object model: loose blobs/trees/commits/tags (read + write), git-exact SHA-1, canonical framing. +- ODB (zlib, atomic writes, SHA-1 verification on read), refs (HEAD/loose/packed/symbolic). +- `rit` CLI: `hash-object`, `cat-file`, `ls-tree`, `log`. +- 35 tests incl. real-git interop (our OIDs == `git hash-object`; `git fsck` accepts what we write). + +The collaboration **forge** built on this core lives in [`../rithub`](../rithub) (the GitHub equivalent). + +Deferred per the design gate: packfiles/delta, index/worktree, wire protocol v2, merge/rebase, SHA-256. diff --git a/src/blob.rs b/src/blob.rs new file mode 100644 index 0000000..14c3548 --- /dev/null +++ b/src/blob.rs @@ -0,0 +1,31 @@ +//! Blob objects: opaque file contents. Git applies no interpretation, so a blob +//! is simply its bytes; the payload *is* the data. + +/// A blob object. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Blob { + /// Raw file contents. + pub data: Vec, +} + +impl Blob { + /// Wrap raw bytes as a blob. + pub fn new(data: Vec) -> Self { + Self { data } + } + + /// The contents as a lossy UTF-8 string, for display. + pub fn as_str_lossy(&self) -> std::borrow::Cow<'_, str> { + String::from_utf8_lossy(&self.data) + } + + /// Byte length of the blob. + pub fn len(&self) -> usize { + self.data.len() + } + + /// Whether the blob is empty. + pub fn is_empty(&self) -> bool { + self.data.is_empty() + } +} diff --git a/src/commit.rs b/src/commit.rs new file mode 100644 index 0000000..94eab99 --- /dev/null +++ b/src/commit.rs @@ -0,0 +1,173 @@ +//! Commit objects: a snapshot (`tree`) plus ancestry (`parent`), authorship, +//! and a message. +//! +//! Payload layout: +//! +//! ```text +//! tree <40-hex>\n +//! parent <40-hex>\n (zero or more, in order) +//! author \n +//! committer \n +//! [extra headers...]\n +//! \n +//! +//! ``` + +use crate::error::{ForgeError, Result}; +use crate::headers::{self, Header}; +use crate::oid::ObjectId; +use crate::signature::Signature; + +/// A parsed commit object. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Commit { + /// The snapshot this commit points at. + pub tree: ObjectId, + /// Parent commits, in stored order (empty for a root commit). + pub parents: Vec, + /// Who wrote the change. + pub author: Signature, + /// Who recorded it. + pub committer: Signature, + /// Any other headers (e.g. `encoding`, `gpgsig`), preserved in order so + /// re-serialization is byte-identical to Git's output. + pub extra_headers: Vec
, + /// The commit message body. + pub message: Vec, +} + +impl Commit { + /// Parse a commit payload, failing closed on missing required headers. + pub fn parse(payload: &[u8]) -> Result { + let block = headers::parse(payload, "commit")?; + + let mut tree = None; + let mut parents = Vec::new(); + let mut author = None; + let mut committer = None; + let mut extra_headers = Vec::new(); + + for h in block.headers { + match h.key.as_str() { + "tree" => { + let hex = std::str::from_utf8(&h.value) + .map_err(|_| ForgeError::malformed("commit", "tree oid not ASCII"))?; + tree = Some(ObjectId::from_hex(hex)?); + } + "parent" => { + let hex = std::str::from_utf8(&h.value) + .map_err(|_| ForgeError::malformed("commit", "parent oid not ASCII"))?; + parents.push(ObjectId::from_hex(hex)?); + } + "author" => { + let v = std::str::from_utf8(&h.value) + .map_err(|_| ForgeError::malformed("commit", "author not UTF-8"))?; + author = Some(Signature::parse(v, "commit")?); + } + "committer" => { + let v = std::str::from_utf8(&h.value) + .map_err(|_| ForgeError::malformed("commit", "committer not UTF-8"))?; + committer = Some(Signature::parse(v, "commit")?); + } + _ => extra_headers.push(h), + } + } + + Ok(Self { + tree: tree.ok_or_else(|| ForgeError::malformed("commit", "missing tree header"))?, + parents, + author: author + .ok_or_else(|| ForgeError::malformed("commit", "missing author header"))?, + committer: committer + .ok_or_else(|| ForgeError::malformed("commit", "missing committer header"))?, + extra_headers, + message: block.message, + }) + } + + /// Serialize back to the exact on-disk payload. + /// + /// Header order (tree, parents, author, committer, extras) matches Git, so + /// for objects Git wrote this reproduces their bytes and thus their oid. + pub fn serialize(&self) -> Vec { + let mut out = Vec::new(); + push_header(&mut out, "tree", self.tree.to_hex().as_bytes()); + for p in &self.parents { + push_header(&mut out, "parent", p.to_hex().as_bytes()); + } + push_header(&mut out, "author", self.author.to_raw().as_bytes()); + push_header(&mut out, "committer", self.committer.to_raw().as_bytes()); + for h in &self.extra_headers { + push_header(&mut out, &h.key, &h.value); + } + out.push(b'\n'); + out.extend_from_slice(&self.message); + out + } + + /// The message as a lossy UTF-8 string. + pub fn message_str(&self) -> std::borrow::Cow<'_, str> { + String::from_utf8_lossy(&self.message) + } + + /// The first line of the message (the summary). + pub fn summary(&self) -> String { + self.message_str().lines().next().unwrap_or("").to_string() + } +} + +/// Append one `key value\n` header, restoring continuation-line spacing. +fn push_header(out: &mut Vec, key: &str, value: &[u8]) { + out.extend_from_slice(key.as_bytes()); + out.push(b' '); + out.extend_from_slice(&headers::serialize_value(value)); + out.push(b'\n'); +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn parse_serialize_roundtrips() { + let payload = concat!( + "tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904\n", + "parent e69de29bb2d1d6434b8b29ae775ad8c2e48c5391\n", + "author Alice 1700000000 +0000\n", + "committer Alice 1700000000 +0000\n", + "\n", + "initial commit\n", + ) + .as_bytes() + .to_vec(); + + let commit = Commit::parse(&payload).unwrap(); + assert_eq!(commit.parents.len(), 1); + assert_eq!(commit.author.name, "Alice"); + assert_eq!(commit.summary(), "initial commit"); + // byte-exact round trip is the property that keeps oids stable + assert_eq!(commit.serialize(), payload); + } + + #[test] + fn root_commit_has_no_parents() { + let payload = concat!( + "tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904\n", + "author Alice 1700000000 +0000\n", + "committer Alice 1700000000 +0000\n", + "\n", + "root\n", + ) + .as_bytes() + .to_vec(); + let commit = Commit::parse(&payload).unwrap(); + assert!(commit.parents.is_empty()); + assert_eq!(commit.serialize(), payload); + } + + #[test] + fn rejects_missing_tree() { + let payload = b"author Alice 1 +0000\ncommitter Alice 1 +0000\n\nx\n"; + assert!(Commit::parse(payload).is_err()); + } +} diff --git a/src/error.rs b/src/error.rs new file mode 100644 index 0000000..0c27a73 --- /dev/null +++ b/src/error.rs @@ -0,0 +1,76 @@ +//! Stable error model for the Git core. +//! +//! Repository data is adversarial input (see PLAN "Security contract"): every +//! parser fails **closed** — it returns a typed [`ForgeError`] rather than +//! panicking on malformed objects, truncated headers, or corrupt compression. + +use thiserror::Error; + +/// Crate-wide result alias. +pub type Result = std::result::Result; + +/// The stable error enum for the Git object core. +#[derive(Debug, Error)] +pub enum ForgeError { + /// Underlying filesystem / IO failure. + #[error("io error: {0}")] + Io(#[from] std::io::Error), + + /// No `.git` directory was found while discovering a repository. + #[error("not a git repository (or any parent): {0}")] + NotARepository(String), + + /// An object's on-disk bytes could not be parsed (bad header, truncated + /// payload, declared length mismatch, non-UTF-8 header, etc.). + #[error("malformed {kind} object: {reason}")] + MalformedObject { + /// The object kind being parsed (or "loose" before the type is known). + kind: &'static str, + /// Human-readable reason. + reason: String, + }, + + /// A requested object does not exist in the loose object database. + #[error("object not found: {0}")] + ObjectNotFound(String), + + /// Content verification failed: the SHA-1 of the stored bytes did not match + /// the object id it was looked up under. Signals repository corruption. + #[error("object {looked_up} is corrupt: content hashes to {computed}")] + HashMismatch { + /// The oid the object was requested by. + looked_up: String, + /// The oid actually computed from its bytes. + computed: String, + }, + + /// A hex object id was the wrong length or contained non-hex characters. + #[error("invalid object id: {0}")] + InvalidOid(String), + + /// A ref/revision could not be resolved to an object id. + #[error("cannot resolve reference: {0}")] + InvalidRef(String), + + /// An abbreviated object id prefix matched more than one object. + #[error("ambiguous object id prefix: {0}")] + AmbiguousPrefix(String), + + /// The object header named a type that is not blob/tree/commit/tag. + #[error("unknown object type: {0}")] + UnknownType(String), + + /// zlib decompression of a loose object failed or exceeded the size cap. + #[error("decompression failed: {0}")] + Decompress(String), +} + +impl ForgeError { + /// Convenience constructor for a malformed-object error. + pub fn malformed(kind: &'static str, reason: impl Into) -> Self { + ForgeError::MalformedObject { + kind, + reason: reason.into(), + } + } +} diff --git a/src/headers.rs b/src/headers.rs new file mode 100644 index 0000000..f49a202 --- /dev/null +++ b/src/headers.rs @@ -0,0 +1,113 @@ +//! Shared header-block parsing for commit and tag objects. +//! +//! Both commit and tag payloads share a layout: a block of `key value` header +//! lines, a single blank line, then a free-form message. A header value may +//! span multiple lines — continuation lines begin with a single space (this is +//! how Git stores multi-line `gpgsig` values). We preserve the exact value +//! bytes (with embedded newlines) so re-serialization is byte-identical. + +use crate::error::{ForgeError, Result}; + +/// One header line: an ASCII key and its raw value bytes. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Header { + /// The header keyword (e.g. `tree`, `parent`, `author`, `gpgsig`). + pub key: String, + /// The value bytes; multi-line values keep embedded `\n` separators. + pub value: Vec, +} + +/// The result of splitting a commit/tag payload. +pub struct HeaderBlock { + /// Ordered header lines. + pub headers: Vec
, + /// The message body (everything after the blank separator line). + pub message: Vec, +} + +/// Split a payload into ordered headers and the message body. +pub fn parse(payload: &[u8], kind: &'static str) -> Result { + // Header block ends at the first blank line ("\n\n"). + let (header_section, message) = match find_double_newline(payload) { + Some(idx) => (&payload[..idx], payload[idx + 2..].to_vec()), + // Some objects (a header-only tag) may have no message; then the whole + // payload up to a trailing newline is headers. + None => (payload, Vec::new()), + }; + + let mut headers: Vec
= Vec::new(); + for line in split_lines(header_section) { + if line.first() == Some(&b' ') { + // Continuation of the previous header value. + let last = headers.last_mut().ok_or_else(|| { + ForgeError::malformed(kind, "continuation line with no preceding header") + })?; + last.value.push(b'\n'); + last.value.extend_from_slice(&line[1..]); + } else { + let space = line.iter().position(|&b| b == b' ').ok_or_else(|| { + ForgeError::malformed(kind, "header line missing space separator") + })?; + let key = std::str::from_utf8(&line[..space]) + .map_err(|_| ForgeError::malformed(kind, "header key is not ASCII"))? + .to_string(); + headers.push(Header { + key, + value: line[space + 1..].to_vec(), + }); + } + } + + Ok(HeaderBlock { headers, message }) +} + +/// Re-emit a header value, restoring the leading space on continuation lines. +pub fn serialize_value(value: &[u8]) -> Vec { + let mut out = Vec::with_capacity(value.len()); + for (i, &b) in value.iter().enumerate() { + out.push(b); + if b == b'\n' && i + 1 < value.len() { + out.push(b' '); + } + } + out +} + +/// Locate the first `\n\n` in a byte slice. +fn find_double_newline(data: &[u8]) -> Option { + data.windows(2).position(|w| w == b"\n\n") +} + +/// Split a header section into lines, dropping the line terminators. +fn split_lines(section: &[u8]) -> Vec<&[u8]> { + if section.is_empty() { + return Vec::new(); + } + section.split(|&b| b == b'\n').collect() +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn parses_simple_headers_and_message() { + let payload = b"tree abc\nparent def\n\nhello world\n"; + let block = parse(payload, "commit").unwrap(); + assert_eq!(block.headers.len(), 2); + assert_eq!(block.headers[0].key, "tree"); + assert_eq!(block.headers[0].value, b"abc"); + assert_eq!(block.message, b"hello world\n"); + } + + #[test] + fn parses_continuation_lines() { + let payload = b"gpgsig line1\n line2\n line3\n\nmsg\n"; + let block = parse(payload, "commit").unwrap(); + assert_eq!(block.headers.len(), 1); + assert_eq!(block.headers[0].key, "gpgsig"); + assert_eq!(block.headers[0].value, b"line1\nline2\nline3"); + // round-trips back to the on-disk continuation form + assert_eq!(serialize_value(&block.headers[0].value), b"line1\n line2\n line3"); + } +} diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..09decc9 --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,57 @@ +//! # rithub (core slice) +//! +//! A library-first Rust implementation of the **Git loose-object model**: read, +//! write, verify, and traverse standard Git repositories without corrupting +//! data. This crate is the narrow first promise from `PLAN.md` — the +//! collaboration *forge* (issues, pull requests, permissions, webhooks, wire +//! protocol) is deliberately **deferred** until this core passes interop, +//! crash-recovery, and fuzz testing. +//! +//! ## What is implemented +//! +//! - [`object`] — object types, canonical `" \0"` framing, +//! SHA-1 object ids (byte-identical to real Git), and loose parsing. +//! - [`blob`], [`tree`], [`commit`], [`tag`] — read **and** write the four +//! loose object kinds with byte-exact serialization. +//! - [`odb`] — the loose object database under `.git/objects/xx/...` with zlib +//! compression and read-time SHA-1 verification. +//! - [`refs`] — `HEAD`, loose refs, symbolic refs, and `packed-refs`. +//! - [`repo`] — the porcelain-ish [`Repository`] API: `hash-object`, `cat-file`, +//! `rev-parse`, tree/commit traversal, and `log`. +//! +//! ## Compatibility +//! +//! Real-git interop is proven in `tests/interop.rs`: object ids computed here +//! are asserted identical to `git hash-object`, and repositories created by real +//! `git` are read back with this crate. +//! +//! ## Deferred (per PLAN) +//! +//! Packfiles/delta resolution, the index/worktree, the smart wire protocol, +//! merge/rebase, SHA-256 repositories, SHA-1 collision detection (sha1dc), and +//! the entire forge layer are out of scope for this slice. + +pub mod blob; +pub mod commit; +pub mod error; +pub mod headers; +pub mod object; +pub mod odb; +pub mod oid; +pub mod refs; +pub mod repo; +pub mod signature; +pub mod tag; +pub mod tree; + +pub use blob::Blob; +pub use commit::Commit; +pub use error::{ForgeError, Result}; +pub use object::{hash_content, parse_loose, Object, ObjectType}; +pub use odb::Odb; +pub use oid::ObjectId; +pub use refs::{RefTarget, Refs}; +pub use repo::Repository; +pub use signature::Signature; +pub use tag::Tag; +pub use tree::{Tree, TreeEntry}; diff --git a/src/main.rs b/src/main.rs new file mode 100644 index 0000000..712f4e4 --- /dev/null +++ b/src/main.rs @@ -0,0 +1,225 @@ +//! `rgf` — a small, compatibility-oriented CLI over the rithub core. +//! +//! Runnable proof of the library: `hash-object`, `cat-file`, `ls-tree`, and +//! `log`, operating on real `.git` repositories. + +use std::io::{Read, Write}; +use std::path::PathBuf; + +use anyhow::{bail, Context, Result}; +use clap::{Args, Parser, Subcommand}; +use rit::object::Object; +use rit::{ObjectType, Repository}; + +#[derive(Parser)] +#[command( + name = "rgf", + version, + about = "rithub: inspect and create Git objects (loose-object core slice)" +)] +struct Cli { + /// Repository path to operate on (its `.git` is discovered by walking up). + #[arg(short = 'C', long, default_value = ".", global = true)] + repo: PathBuf, + + #[command(subcommand)] + command: Command, +} + +#[derive(Subcommand)] +enum Command { + /// Compute an object id (and optionally write the object). Like `git hash-object`. + HashObject(HashObjectArgs), + /// Print an object's type or pretty content. Like `git cat-file`. + CatFile(CatFileArgs), + /// List the entries of a tree. Like `git ls-tree`. + LsTree(LsTreeArgs), + /// Show commit history from a revision (default HEAD). Like `git log`. + Log(LogArgs), +} + +#[derive(Args)] +struct HashObjectArgs { + /// Object type to hash as. + #[arg(short = 't', long = "type", default_value = "blob")] + object_type: String, + /// Write the object into the object database. + #[arg(short = 'w')] + write: bool, + /// Read the content from stdin instead of a file. + #[arg(long)] + stdin: bool, + /// Path to the file to hash (unless `--stdin`). + file: Option, +} + +#[derive(Args)] +struct CatFileArgs { + /// Show the object type. + #[arg(short = 't', group = "mode")] + show_type: bool, + /// Pretty-print the object content. + #[arg(short = 'p', group = "mode")] + pretty: bool, + /// The revision / object to read (oid, ref, or HEAD). + object: String, +} + +#[derive(Args)] +struct LsTreeArgs { + /// A revision resolving to a tree or a commit (whose tree is listed). + #[arg(default_value = "HEAD")] + rev: String, +} + +#[derive(Args)] +struct LogArgs { + /// Revision to start from. + #[arg(default_value = "HEAD")] + rev: String, + /// Maximum number of commits to show. + #[arg(short = 'n', long)] + max: Option, +} + +fn main() { + if let Err(err) = run() { + eprintln!("rgf: {err:#}"); + std::process::exit(1); + } +} + +fn run() -> Result<()> { + let cli = Cli::parse(); + match &cli.command { + Command::HashObject(args) => cmd_hash_object(&cli, args), + Command::CatFile(args) => cmd_cat_file(&cli, args), + Command::LsTree(args) => cmd_ls_tree(&cli, args), + Command::Log(args) => cmd_log(&cli, args), + } +} + +fn cmd_hash_object(cli: &Cli, args: &HashObjectArgs) -> Result<()> { + let obj_type = ObjectType::parse(&args.object_type) + .with_context(|| format!("invalid object type {:?}", args.object_type))?; + + let data = if args.stdin { + let mut buf = Vec::new(); + std::io::stdin() + .read_to_end(&mut buf) + .context("reading stdin")?; + buf + } else { + let file = args + .file + .as_ref() + .context("provide a file path or use --stdin")?; + std::fs::read(file).with_context(|| format!("reading {}", file.display()))? + }; + + // Writing requires a real repo; hashing-only does not. + let oid = if args.write { + let repo = Repository::discover(&cli.repo) + .with_context(|| format!("opening repo at {}", cli.repo.display()))?; + repo.hash_object(obj_type, &data, true)? + } else { + rit::hash_content(obj_type, &data).0 + }; + println!("{oid}"); + Ok(()) +} + +fn cmd_cat_file(cli: &Cli, args: &CatFileArgs) -> Result<()> { + if !args.show_type && !args.pretty { + bail!("specify -t (type) or -p (pretty-print)"); + } + let repo = Repository::discover(&cli.repo) + .with_context(|| format!("opening repo at {}", cli.repo.display()))?; + let oid = repo.resolve(&args.object)?; + + if args.show_type { + println!("{}", repo.object_type(&oid)?); + return Ok(()); + } + + // pretty-print + match repo.read_object(&oid)? { + Object::Blob(b) => { + std::io::stdout().write_all(&b.data)?; + } + Object::Tree(t) => { + let mut out = std::io::stdout().lock(); + for e in &t.entries { + writeln!( + out, + "{} {} {}\t{}", + e.display_mode(), + e.kind(), + e.oid, + e.name_str() + )?; + } + } + Object::Commit(c) => { + std::io::stdout().write_all(&c.serialize())?; + } + Object::Tag(t) => { + std::io::stdout().write_all(&t.serialize())?; + } + } + Ok(()) +} + +fn cmd_ls_tree(cli: &Cli, args: &LsTreeArgs) -> Result<()> { + let repo = Repository::discover(&cli.repo) + .with_context(|| format!("opening repo at {}", cli.repo.display()))?; + let oid = repo.resolve(&args.rev)?; + + // Accept either a tree oid or a commit (list its tree). + let tree = match repo.read_object(&oid)? { + Object::Tree(t) => t, + Object::Commit(c) => repo.tree(&c.tree)?, + Object::Tag(_) => { + let commit = repo.peel_to_commit(oid)?; + repo.tree(&commit.tree)? + } + Object::Blob(_) => bail!("{oid} is a blob, not a tree"), + }; + + let mut out = std::io::stdout().lock(); + for e in &tree.entries { + writeln!( + out, + "{} {} {}\t{}", + e.display_mode(), + e.kind(), + e.oid, + e.name_str() + )?; + } + Ok(()) +} + +fn cmd_log(cli: &Cli, args: &LogArgs) -> Result<()> { + let repo = Repository::discover(&cli.repo) + .with_context(|| format!("opening repo at {}", cli.repo.display()))?; + let start = repo.resolve(&args.rev)?; + let history = repo.log(start)?; + + let mut out = std::io::stdout().lock(); + for (oid, commit) in history.iter().take(args.max.unwrap_or(usize::MAX)) { + writeln!(out, "commit {oid}")?; + writeln!( + out, + "Author: {} <{}>", + commit.author.name, commit.author.email + )?; + writeln!(out, "Date: {} {}", commit.author.time, commit.author.tz)?; + writeln!(out)?; + for line in commit.message_str().lines() { + writeln!(out, " {line}")?; + } + writeln!(out)?; + } + Ok(()) +} diff --git a/src/object.rs b/src/object.rs new file mode 100644 index 0000000..49c9afe --- /dev/null +++ b/src/object.rs @@ -0,0 +1,208 @@ +//! Core object model: types, canonical serialization, SHA-1 hashing, and the +//! loose-object framing shared by every Git object. +//! +//! Every Git object is `" \0"`, and its identity is the +//! SHA-1 of *those exact bytes*. Getting this framing byte-for-byte right is +//! what makes our object ids identical to real Git's. + +use crate::blob::Blob; +use crate::commit::Commit; +use crate::error::{ForgeError, Result}; +use crate::oid::{ObjectId, OID_LEN}; +use crate::tag::Tag; +use crate::tree::Tree; +use sha1::{Digest, Sha1}; + +/// The four object kinds in the loose-object model. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ObjectType { + /// File contents. + Blob, + /// Directory listing. + Tree, + /// A history node. + Commit, + /// An annotated tag. + Tag, +} + +impl ObjectType { + /// The keyword used in the object header and by `cat-file -t`. + pub const fn as_str(&self) -> &'static str { + match self { + ObjectType::Blob => "blob", + ObjectType::Tree => "tree", + ObjectType::Commit => "commit", + ObjectType::Tag => "tag", + } + } + + /// Parse a header keyword. + pub fn parse(s: &str) -> Result { + match s { + "blob" => Ok(ObjectType::Blob), + "tree" => Ok(ObjectType::Tree), + "commit" => Ok(ObjectType::Commit), + "tag" => Ok(ObjectType::Tag), + other => Err(ForgeError::UnknownType(other.to_string())), + } + } +} + +impl std::fmt::Display for ObjectType { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(self.as_str()) + } +} + +/// Maximum size we will decompress for a single loose object (a fail-closed +/// guard against decompression bombs — see PLAN "Security contract"). 512 MiB +/// is far above any realistic loose object. +pub const MAX_OBJECT_SIZE: u64 = 512 * 1024 * 1024; + +/// Build the loose-object bytes for a payload and return `(oid, full_bytes)`. +/// +/// `full_bytes` is the *uncompressed* `" \0"` framing whose +/// SHA-1 is the object id. This is the single source of truth for hashing. +pub fn hash_content(obj_type: ObjectType, payload: &[u8]) -> (ObjectId, Vec) { + let header = format!("{} {}\0", obj_type.as_str(), payload.len()); + let mut full = Vec::with_capacity(header.len() + payload.len()); + full.extend_from_slice(header.as_bytes()); + full.extend_from_slice(payload); + + let mut hasher = Sha1::new(); + hasher.update(&full); + let digest = hasher.finalize(); + + let mut bytes = [0u8; OID_LEN]; + bytes.copy_from_slice(&digest); + (ObjectId::from_bytes(bytes), full) +} + +/// Split an uncompressed loose object into its type and payload. +/// +/// Fails closed if the header is missing, non-numeric, or if the declared +/// length disagrees with the actual payload length (a corruption signal). +pub fn parse_loose(full: &[u8]) -> Result<(ObjectType, &[u8])> { + let nul = full + .iter() + .position(|&b| b == 0) + .ok_or_else(|| ForgeError::malformed("loose", "no NUL terminating the header"))?; + let header = &full[..nul]; + + let space = header + .iter() + .position(|&b| b == b' ') + .ok_or_else(|| ForgeError::malformed("loose", "no space in header"))?; + let type_str = std::str::from_utf8(&header[..space]) + .map_err(|_| ForgeError::malformed("loose", "type is not ASCII"))?; + let len_str = std::str::from_utf8(&header[space + 1..]) + .map_err(|_| ForgeError::malformed("loose", "length is not ASCII"))?; + + let obj_type = ObjectType::parse(type_str)?; + let declared: usize = len_str + .parse() + .map_err(|_| ForgeError::malformed("loose", "length is not a number"))?; + + let payload = &full[nul + 1..]; + if payload.len() != declared { + return Err(ForgeError::malformed( + "loose", + format!( + "declared length {declared} but payload is {} bytes", + payload.len() + ), + )); + } + Ok((obj_type, payload)) +} + +/// A fully parsed Git object. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum Object { + /// A blob. + Blob(Blob), + /// A tree. + Tree(Tree), + /// A commit. + Commit(Commit), + /// An annotated tag. + Tag(Tag), +} + +impl Object { + /// Parse a typed object from its payload. + pub fn parse(obj_type: ObjectType, payload: &[u8]) -> Result { + Ok(match obj_type { + ObjectType::Blob => Object::Blob(Blob::new(payload.to_vec())), + ObjectType::Tree => Object::Tree(Tree::parse(payload)?), + ObjectType::Commit => Object::Commit(Commit::parse(payload)?), + ObjectType::Tag => Object::Tag(Tag::parse(payload)?), + }) + } + + /// This object's type. + pub fn object_type(&self) -> ObjectType { + match self { + Object::Blob(_) => ObjectType::Blob, + Object::Tree(_) => ObjectType::Tree, + Object::Commit(_) => ObjectType::Commit, + Object::Tag(_) => ObjectType::Tag, + } + } + + /// The canonical payload bytes (round-trips Git's serialization). + pub fn serialize_payload(&self) -> Vec { + match self { + Object::Blob(b) => b.data.clone(), + Object::Tree(t) => t.serialize(), + Object::Commit(c) => c.serialize(), + Object::Tag(t) => t.serialize(), + } + } + + /// The object id this object hashes to. + pub fn id(&self) -> ObjectId { + hash_content(self.object_type(), &self.serialize_payload()).0 + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn empty_blob_matches_git_constant() { + // Every Git repo agrees on the empty blob oid. + let (id, _) = hash_content(ObjectType::Blob, b""); + assert_eq!(id.to_hex(), "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"); + } + + #[test] + fn hello_blob_matches_known_git_oid() { + // `printf 'hello\n' | git hash-object --stdin` -> this oid. + let (id, _) = hash_content(ObjectType::Blob, b"hello\n"); + assert_eq!(id.to_hex(), "ce013625030ba8dba906f756967f9e9ca394464a"); + } + + #[test] + fn loose_framing_roundtrips() { + let (_, full) = hash_content(ObjectType::Blob, b"payload"); + let (ty, payload) = parse_loose(&full).unwrap(); + assert_eq!(ty, ObjectType::Blob); + assert_eq!(payload, b"payload"); + } + + #[test] + fn rejects_length_mismatch() { + let mut full = b"blob 99\0short".to_vec(); + assert!(parse_loose(&full).is_err()); + full = b"blob\0nolen".to_vec(); + assert!(parse_loose(&full).is_err()); + } + + #[test] + fn rejects_unknown_type() { + assert!(parse_loose(b"widget 3\0abc").is_err()); + } +} diff --git a/src/odb.rs b/src/odb.rs new file mode 100644 index 0000000..0fd5b6d --- /dev/null +++ b/src/odb.rs @@ -0,0 +1,232 @@ +//! The loose object database: read, write, and verify objects stored under +//! `.git/objects/xx/<38-hex>` in zlib-compressed loose format. +//! +//! Reads **always verify** that the decompressed bytes hash back to the oid +//! they were requested under — corruption is surfaced as an error, never +//! silently returned (PLAN: "inspect ... without corrupting data"). + +use crate::error::{ForgeError, Result}; +use crate::object::{self, Object, ObjectType, MAX_OBJECT_SIZE}; +use crate::oid::ObjectId; +use flate2::read::ZlibDecoder; +use flate2::write::ZlibEncoder; +use flate2::Compression; +use std::io::{Read, Write}; +use std::path::{Path, PathBuf}; +use std::time::{SystemTime, UNIX_EPOCH}; + +/// A loose object database rooted at a `.git/objects` directory. +pub struct Odb { + objects_dir: PathBuf, +} + +impl Odb { + /// Open the object database inside a `.git` directory. + pub fn new(git_dir: &Path) -> Self { + Self { + objects_dir: git_dir.join("objects"), + } + } + + /// The on-disk path for an object (`objects/xx/`). + pub fn loose_path(&self, oid: &ObjectId) -> PathBuf { + self.objects_dir + .join(oid.dir_prefix()) + .join(oid.file_suffix()) + } + + /// Whether an object exists on disk. + pub fn contains(&self, oid: &ObjectId) -> bool { + self.loose_path(oid).exists() + } + + /// Write a payload as a loose object and return its oid. + /// + /// Idempotent: if the object already exists it is left untouched (its oid is + /// content-addressed, so identical content is identical bytes). The write is + /// atomic — bytes land in a temp file, are fsync'd, then renamed into place. + pub fn write(&self, obj_type: ObjectType, payload: &[u8]) -> Result { + let (oid, full) = object::hash_content(obj_type, payload); + let final_path = self.loose_path(&oid); + if final_path.exists() { + return Ok(oid); + } + + let dir = final_path + .parent() + .expect("loose path always has a parent directory"); + std::fs::create_dir_all(dir)?; + + let compressed = zlib_compress(&full)?; + + // Atomic publish: write to a unique temp file, flush + fsync, rename. + let tmp_path = self.temp_path(dir); + { + let mut file = std::fs::File::create(&tmp_path)?; + file.write_all(&compressed)?; + file.sync_all()?; + } + // rename is atomic within a filesystem; if it fails, clean up the temp. + if let Err(e) = std::fs::rename(&tmp_path, &final_path) { + let _ = std::fs::remove_file(&tmp_path); + return Err(e.into()); + } + Ok(oid) + } + + /// Read an object's raw type and payload, verifying its SHA-1. + pub fn read_raw(&self, oid: &ObjectId) -> Result<(ObjectType, Vec)> { + let path = self.loose_path(oid); + let compressed = std::fs::read(&path) + .map_err(|_| ForgeError::ObjectNotFound(oid.to_hex()))?; + let full = zlib_decompress(&compressed)?; + + // Verify integrity before trusting the bytes. + let computed = { + use sha1::{Digest, Sha1}; + let mut h = Sha1::new(); + h.update(&full); + let d = h.finalize(); + let mut b = [0u8; 20]; + b.copy_from_slice(&d); + ObjectId::from_bytes(b) + }; + if &computed != oid { + return Err(ForgeError::HashMismatch { + looked_up: oid.to_hex(), + computed: computed.to_hex(), + }); + } + + let (obj_type, payload) = object::parse_loose(&full)?; + Ok((obj_type, payload.to_vec())) + } + + /// Read and fully parse an object. + pub fn read(&self, oid: &ObjectId) -> Result { + let (obj_type, payload) = self.read_raw(oid)?; + Object::parse(obj_type, &payload) + } + + /// Read only an object's type (`cat-file -t`). + pub fn object_type(&self, oid: &ObjectId) -> Result { + Ok(self.read_raw(oid)?.0) + } + + /// Resolve an abbreviated hex prefix (>= 4 chars) to a unique full oid. + pub fn resolve_prefix(&self, prefix: &str) -> Result { + if prefix.len() < 4 || prefix.len() > 40 { + return Err(ForgeError::InvalidOid(format!( + "prefix must be 4-40 hex chars: {prefix:?}" + ))); + } + let (dir_part, file_part) = prefix.split_at(2.min(prefix.len())); + let subdir = self.objects_dir.join(dir_part); + let mut matches: Vec = Vec::new(); + if let Ok(read_dir) = std::fs::read_dir(&subdir) { + for entry in read_dir.flatten() { + let name = entry.file_name().to_string_lossy().to_string(); + let full_hex = format!("{dir_part}{name}"); + if full_hex.starts_with(prefix) { + if let Ok(oid) = ObjectId::from_hex(&full_hex) { + matches.push(oid); + } + } + } + } + let _ = file_part; + match matches.len() { + 0 => Err(ForgeError::ObjectNotFound(prefix.to_string())), + 1 => Ok(matches[0]), + _ => Err(ForgeError::AmbiguousPrefix(prefix.to_string())), + } + } + + /// Build a unique temporary file path inside `dir` (no extra deps). + fn temp_path(&self, dir: &Path) -> PathBuf { + let nanos = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_nanos()) + .unwrap_or(0); + let pid = std::process::id(); + dir.join(format!(".rgf-tmp-{pid}-{nanos}")) + } +} + +/// Compress bytes with zlib (the format Git uses for loose objects). +fn zlib_compress(data: &[u8]) -> Result> { + let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default()); + encoder.write_all(data)?; + encoder + .finish() + .map_err(|e| ForgeError::Decompress(format!("compression failed: {e}"))) +} + +/// Decompress a zlib stream, guarding against decompression bombs. +fn zlib_decompress(data: &[u8]) -> Result> { + let decoder = ZlibDecoder::new(data); + let mut limited = decoder.take(MAX_OBJECT_SIZE + 1); + let mut out = Vec::new(); + limited + .read_to_end(&mut out) + .map_err(|e| ForgeError::Decompress(e.to_string()))?; + if out.len() as u64 > MAX_OBJECT_SIZE { + return Err(ForgeError::Decompress(format!( + "object exceeds {MAX_OBJECT_SIZE} byte cap" + ))); + } + Ok(out) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::object::Object; + + fn temp_git_dir() -> tempfile::TempDir { + let dir = tempfile::tempdir().unwrap(); + std::fs::create_dir_all(dir.path().join("objects")).unwrap(); + dir + } + + #[test] + fn write_then_read_roundtrips_blob() { + let dir = temp_git_dir(); + let odb = Odb::new(dir.path()); + let oid = odb.write(ObjectType::Blob, b"hello odb\n").unwrap(); + assert!(odb.contains(&oid)); + match odb.read(&oid).unwrap() { + Object::Blob(b) => assert_eq!(b.data, b"hello odb\n"), + other => panic!("expected blob, got {other:?}"), + } + } + + #[test] + fn write_is_idempotent() { + let dir = temp_git_dir(); + let odb = Odb::new(dir.path()); + let a = odb.write(ObjectType::Blob, b"same").unwrap(); + let b = odb.write(ObjectType::Blob, b"same").unwrap(); + assert_eq!(a, b); + } + + #[test] + fn detects_corruption() { + let dir = temp_git_dir(); + let odb = Odb::new(dir.path()); + let oid = odb.write(ObjectType::Blob, b"trust me").unwrap(); + // Corrupt the stored bytes. + let path = odb.loose_path(&oid); + std::fs::write(&path, b"not even zlib").unwrap(); + assert!(odb.read_raw(&oid).is_err()); + } + + #[test] + fn resolve_prefix_finds_unique() { + let dir = temp_git_dir(); + let odb = Odb::new(dir.path()); + let oid = odb.write(ObjectType::Blob, b"prefix me\n").unwrap(); + let short = &oid.to_hex()[..8]; + assert_eq!(odb.resolve_prefix(short).unwrap(), oid); + } +} diff --git a/src/oid.rs b/src/oid.rs new file mode 100644 index 0000000..6798eec --- /dev/null +++ b/src/oid.rs @@ -0,0 +1,118 @@ +//! Git object identifiers. +//! +//! An [`ObjectId`] is a 20-byte SHA-1 digest — the same identity Git assigns to +//! every object. The hex form is the familiar 40-character string printed by +//! `git rev-parse`. + +use crate::error::{ForgeError, Result}; +use std::fmt; + +/// Number of raw bytes in a SHA-1 object id. +pub const OID_LEN: usize = 20; +/// Number of hex characters in a SHA-1 object id. +pub const OID_HEX_LEN: usize = OID_LEN * 2; + +/// A 20-byte SHA-1 Git object identifier. +#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub struct ObjectId([u8; OID_LEN]); + +impl ObjectId { + /// Wrap 20 raw digest bytes. + pub const fn from_bytes(bytes: [u8; OID_LEN]) -> Self { + Self(bytes) + } + + /// Borrow the raw digest bytes (used when serializing tree entries). + pub const fn as_bytes(&self) -> &[u8; OID_LEN] { + &self.0 + } + + /// Parse a full 40-character lowercase/uppercase hex string. + pub fn from_hex(s: &str) -> Result { + let s = s.trim(); + if s.len() != OID_HEX_LEN { + return Err(ForgeError::InvalidOid(format!( + "expected {OID_HEX_LEN} hex chars, got {}", + s.len() + ))); + } + let mut bytes = [0u8; OID_LEN]; + let raw = s.as_bytes(); + for (i, byte) in bytes.iter_mut().enumerate() { + let hi = hex_val(raw[i * 2]) + .ok_or_else(|| ForgeError::InvalidOid(format!("non-hex character in {s:?}")))?; + let lo = hex_val(raw[i * 2 + 1]) + .ok_or_else(|| ForgeError::InvalidOid(format!("non-hex character in {s:?}")))?; + *byte = (hi << 4) | lo; + } + Ok(Self(bytes)) + } + + /// Render the lowercase 40-character hex form. + pub fn to_hex(&self) -> String { + const HEX: &[u8; 16] = b"0123456789abcdef"; + let mut out = String::with_capacity(OID_HEX_LEN); + for &b in &self.0 { + out.push(HEX[(b >> 4) as usize] as char); + out.push(HEX[(b & 0x0f) as usize] as char); + } + out + } + + /// The two-character sharded subdirectory (`objects/xx/...`). + pub fn dir_prefix(&self) -> String { + self.to_hex()[..2].to_string() + } + + /// The remaining 38 hex characters (`objects/xx/`). + pub fn file_suffix(&self) -> String { + self.to_hex()[2..].to_string() + } +} + +impl fmt::Display for ObjectId { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(&self.to_hex()) + } +} + +impl fmt::Debug for ObjectId { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "ObjectId({})", self.to_hex()) + } +} + +/// Map an ASCII hex digit to its numeric value, or `None` if not hex. +fn hex_val(c: u8) -> Option { + match c { + b'0'..=b'9' => Some(c - b'0'), + b'a'..=b'f' => Some(c - b'a' + 10), + b'A'..=b'F' => Some(c - b'A' + 10), + _ => None, + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn hex_roundtrips() { + let hex = "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"; + let oid = ObjectId::from_hex(hex).unwrap(); + assert_eq!(oid.to_hex(), hex); + assert_eq!(oid.dir_prefix(), "e6"); + assert_eq!(oid.file_suffix(), "9de29bb2d1d6434b8b29ae775ad8c2e48c5391"); + } + + #[test] + fn rejects_bad_length() { + assert!(ObjectId::from_hex("abc").is_err()); + } + + #[test] + fn rejects_non_hex() { + let bad = "z69de29bb2d1d6434b8b29ae775ad8c2e48c5391"; + assert!(ObjectId::from_hex(bad).is_err()); + } +} diff --git a/src/refs.rs b/src/refs.rs new file mode 100644 index 0000000..341d4e7 --- /dev/null +++ b/src/refs.rs @@ -0,0 +1,198 @@ +//! References: `HEAD`, loose refs under `.git/refs/`, and `.git/packed-refs`. +//! +//! Supports symbolic refs (`ref: refs/heads/main`), direct oids, and the +//! standard shorthand resolution order Git uses (`main` -> +//! `refs/heads/main`, etc.). Enough to answer "what commit is HEAD?". + +use crate::error::{ForgeError, Result}; +use crate::oid::ObjectId; +use std::collections::HashMap; +use std::path::{Path, PathBuf}; + +/// A resolved-one-step reference value. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum RefTarget { + /// A symbolic ref pointing at another ref name. + Symbolic(String), + /// A direct object id. + Direct(ObjectId), +} + +/// Ref storage for one repository. +pub struct Refs { + git_dir: PathBuf, +} + +/// Guard against symbolic-ref cycles. +const MAX_REF_DEPTH: usize = 10; + +impl Refs { + /// Create ref access rooted at a `.git` directory. + pub fn new(git_dir: &Path) -> Self { + Self { + git_dir: git_dir.to_path_buf(), + } + } + + /// Read and interpret `.git/HEAD`. + pub fn read_head(&self) -> Result { + let raw = std::fs::read_to_string(self.git_dir.join("HEAD")) + .map_err(|_| ForgeError::InvalidRef("HEAD is unreadable".into()))?; + parse_ref_content(raw.trim()) + } + + /// Resolve `HEAD` all the way to an object id. + pub fn resolve_head(&self) -> Result { + match self.read_head()? { + RefTarget::Direct(oid) => Ok(oid), + RefTarget::Symbolic(name) => self.resolve(&name), + } + } + + /// Resolve a ref name (full or shorthand) to an object id. + pub fn resolve(&self, name: &str) -> Result { + self.resolve_depth(name, 0) + } + + fn resolve_depth(&self, name: &str, depth: usize) -> Result { + if depth > MAX_REF_DEPTH { + return Err(ForgeError::InvalidRef(format!( + "symbolic ref chain too deep at {name}" + ))); + } + if name == "HEAD" { + return self.resolve_head(); + } + for candidate in self.candidate_paths(name) { + if let Some(target) = self.read_loose_ref(&candidate)? { + return match target { + RefTarget::Direct(oid) => Ok(oid), + RefTarget::Symbolic(next) => self.resolve_depth(&next, depth + 1), + }; + } + } + // Fall back to packed-refs, keyed by full ref name. + let packed = self.read_packed_refs()?; + for candidate in self.candidate_names(name) { + if let Some(oid) = packed.get(&candidate) { + return Ok(*oid); + } + } + Err(ForgeError::InvalidRef(name.to_string())) + } + + /// List all loose ref names and their resolved oids (used by `log` and + /// for listing). Packed refs are merged in, loose winning on conflict. + pub fn list(&self) -> Result> { + let mut out: HashMap = self.read_packed_refs()?; + let refs_root = self.git_dir.join("refs"); + collect_loose(&refs_root, &refs_root, &mut out)?; + let mut v: Vec<(String, ObjectId)> = out.into_iter().collect(); + v.sort_by(|a, b| a.0.cmp(&b.0)); + Ok(v) + } + + /// Read one loose ref file, if present, one step (no recursion). + fn read_loose_ref(&self, refname: &str) -> Result> { + let path = self.git_dir.join(refname); + match std::fs::read_to_string(&path) { + Ok(raw) => Ok(Some(parse_ref_content(raw.trim())?)), + Err(_) => Ok(None), + } + } + + /// Parse `.git/packed-refs` into a name -> oid map (peel lines ignored). + fn read_packed_refs(&self) -> Result> { + let path = self.git_dir.join("packed-refs"); + let mut map = HashMap::new(); + let raw = match std::fs::read_to_string(&path) { + Ok(r) => r, + Err(_) => return Ok(map), // absent packed-refs is normal + }; + for line in raw.lines() { + if line.starts_with('#') || line.starts_with('^') || line.trim().is_empty() { + continue; + } + if let Some((oid_hex, name)) = line.split_once(' ') { + if let Ok(oid) = ObjectId::from_hex(oid_hex) { + map.insert(name.trim().to_string(), oid); + } + } + } + Ok(map) + } + + /// Candidate loose-ref *paths* (relative to `.git`) for a shorthand name. + fn candidate_paths(&self, name: &str) -> Vec { + self.candidate_names(name) + } + + /// Standard Git ref resolution order for a shorthand. + fn candidate_names(&self, name: &str) -> Vec { + if name.starts_with("refs/") { + return vec![name.to_string()]; + } + vec![ + name.to_string(), + format!("refs/{name}"), + format!("refs/tags/{name}"), + format!("refs/heads/{name}"), + format!("refs/remotes/{name}"), + format!("refs/remotes/{name}/HEAD"), + ] + } +} + +/// Interpret raw ref file / HEAD content. +fn parse_ref_content(content: &str) -> Result { + if let Some(target) = content.strip_prefix("ref:") { + Ok(RefTarget::Symbolic(target.trim().to_string())) + } else { + Ok(RefTarget::Direct(ObjectId::from_hex(content)?)) + } +} + +/// Recursively collect loose refs under `dir`, keyed by full ref name. +fn collect_loose( + root: &Path, + dir: &Path, + out: &mut HashMap, +) -> Result<()> { + let read_dir = match std::fs::read_dir(dir) { + Ok(rd) => rd, + Err(_) => return Ok(()), + }; + for entry in read_dir.flatten() { + let path = entry.path(); + if path.is_dir() { + collect_loose(root, &path, out)?; + } else if let Ok(raw) = std::fs::read_to_string(&path) { + // Build "refs/..." name relative to the .git dir. + if let Ok(rel) = path.strip_prefix(root.parent().unwrap_or(root)) { + let name = rel.to_string_lossy().replace('\\', "/"); + if let Ok(RefTarget::Direct(oid)) = parse_ref_content(raw.trim()) { + out.insert(name, oid); + } + } + } + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn parses_symbolic_head() { + let t = parse_ref_content("ref: refs/heads/main").unwrap(); + assert_eq!(t, RefTarget::Symbolic("refs/heads/main".into())); + } + + #[test] + fn parses_detached_head() { + let hex = "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"; + let t = parse_ref_content(hex).unwrap(); + assert_eq!(t, RefTarget::Direct(ObjectId::from_hex(hex).unwrap())); + } +} diff --git a/src/repo.rs b/src/repo.rs new file mode 100644 index 0000000..c68579a --- /dev/null +++ b/src/repo.rs @@ -0,0 +1,222 @@ +//! The porcelain-ish repository API — the layer that proves the PLAN's first +//! promise: "inspect, create, verify ... standard Git repositories without +//! corrupting data." +//! +//! [`Repository`] ties the object database and refs together and exposes the +//! equivalents of `hash-object -w`, `cat-file -p/-t`, `rev-parse`, `ls-tree`, +//! and `log`. + +use crate::blob::Blob; +use crate::commit::Commit; +use crate::error::{ForgeError, Result}; +use crate::object::{Object, ObjectType}; +use crate::odb::Odb; +use crate::oid::ObjectId; +use crate::refs::Refs; +use crate::tree::Tree; +use std::collections::HashSet; +use std::path::{Path, PathBuf}; + +/// An opened Git repository (loose-object scope). +pub struct Repository { + git_dir: PathBuf, + odb: Odb, + refs: Refs, +} + +impl Repository { + /// Open a repository given its `.git` directory directly. + pub fn open_git_dir(git_dir: impl AsRef) -> Result { + let git_dir = git_dir.as_ref().to_path_buf(); + if !git_dir.join("objects").is_dir() { + return Err(ForgeError::NotARepository(git_dir.display().to_string())); + } + let odb = Odb::new(&git_dir); + let refs = Refs::new(&git_dir); + Ok(Self { + git_dir, + odb, + refs, + }) + } + + /// Discover a repository by walking up from `start` looking for `.git`. + pub fn discover(start: impl AsRef) -> Result { + let start = start.as_ref(); + let mut cur: Option<&Path> = Some(start); + while let Some(dir) = cur { + let candidate = dir.join(".git"); + if candidate.is_dir() { + return Self::open_git_dir(candidate); + } + // Also accept being handed a `.git` dir itself. + if dir.file_name().map(|n| n == ".git").unwrap_or(false) && dir.join("objects").is_dir() + { + return Self::open_git_dir(dir); + } + cur = dir.parent(); + } + Err(ForgeError::NotARepository(start.display().to_string())) + } + + /// The `.git` directory path. + pub fn git_dir(&self) -> &Path { + &self.git_dir + } + + /// Borrow the object database. + pub fn odb(&self) -> &Odb { + &self.odb + } + + /// Borrow ref access. + pub fn refs(&self) -> &Refs { + &self.refs + } + + // --- object plumbing -------------------------------------------------- + + /// `git hash-object [-w]`: hash `data` as `obj_type`, optionally writing it. + pub fn hash_object(&self, obj_type: ObjectType, data: &[u8], write: bool) -> Result { + if write { + self.odb.write(obj_type, data) + } else { + Ok(crate::object::hash_content(obj_type, data).0) + } + } + + /// `git cat-file `: read and parse an object. + pub fn read_object(&self, oid: &ObjectId) -> Result { + self.odb.read(oid) + } + + /// `git cat-file -t `: an object's type. + pub fn object_type(&self, oid: &ObjectId) -> Result { + self.odb.object_type(oid) + } + + /// Read an object expected to be a blob. + pub fn blob(&self, oid: &ObjectId) -> Result { + match self.odb.read(oid)? { + Object::Blob(b) => Ok(b), + other => Err(type_error(oid, "blob", other)), + } + } + + /// Read an object expected to be a tree. + pub fn tree(&self, oid: &ObjectId) -> Result { + match self.odb.read(oid)? { + Object::Tree(t) => Ok(t), + other => Err(type_error(oid, "tree", other)), + } + } + + /// Read an object expected to be a commit. + pub fn commit(&self, oid: &ObjectId) -> Result { + match self.odb.read(oid)? { + Object::Commit(c) => Ok(c), + other => Err(type_error(oid, "commit", other)), + } + } + + /// Verify that a stored object is not corrupt (its bytes hash to its oid). + /// `read_raw` performs the check; this exposes it as a boolean. + pub fn verify(&self, oid: &ObjectId) -> Result { + match self.odb.read_raw(oid) { + Ok(_) => Ok(true), + Err(ForgeError::HashMismatch { .. }) => Ok(false), + Err(e) => Err(e), + } + } + + // --- refs / revisions ------------------------------------------------- + + /// The commit `HEAD` points at. + pub fn head(&self) -> Result { + self.refs.resolve_head() + } + + /// Read the commit `HEAD` currently points at. + pub fn head_commit(&self) -> Result { + let oid = self.head()?; + self.peel_to_commit(oid) + } + + /// Read the tree of the `HEAD` commit. + pub fn head_tree(&self) -> Result { + let commit = self.head_commit()?; + self.tree(&commit.tree) + } + + /// Resolve a revision string: `HEAD`, a ref name, a full 40-hex oid, or an + /// unambiguous abbreviated oid prefix. + pub fn resolve(&self, rev: &str) -> Result { + let rev = rev.trim(); + // Full oid? + if rev.len() == 40 { + if let Ok(oid) = ObjectId::from_hex(rev) { + return Ok(oid); + } + } + // Ref (HEAD, branch, tag, remote)? + if let Ok(oid) = self.refs.resolve(rev) { + return Ok(oid); + } + // Abbreviated oid? + if rev.len() >= 4 && rev.len() < 40 && rev.chars().all(|c| c.is_ascii_hexdigit()) { + return self.odb.resolve_prefix(rev); + } + Err(ForgeError::InvalidRef(rev.to_string())) + } + + /// If `oid` is an annotated tag, follow it to the commit it references; + /// otherwise require `oid` to already be a commit. + pub fn peel_to_commit(&self, oid: ObjectId) -> Result { + let mut current = oid; + for _ in 0..10 { + match self.odb.read(¤t)? { + Object::Commit(c) => return Ok(c), + Object::Tag(t) => current = t.object, + other => return Err(type_error(¤t, "commit", other)), + } + } + Err(ForgeError::InvalidRef(format!( + "{oid} does not peel to a commit" + ))) + } + + /// `git log`: walk history from `start`, newest first by committer time. + /// + /// Bounded by a visited set so cycles or malicious graphs cannot loop + /// forever (PLAN "Security contract": no unbounded graph walks). + pub fn log(&self, start: ObjectId) -> Result> { + let mut seen: HashSet = HashSet::new(); + let mut stack: Vec = vec![start]; + let mut out: Vec<(ObjectId, Commit)> = Vec::new(); + + while let Some(oid) = stack.pop() { + if !seen.insert(oid) { + continue; + } + let commit = self.peel_to_commit(oid)?; + for parent in &commit.parents { + if !seen.contains(parent) { + stack.push(*parent); + } + } + out.push((oid, commit)); + } + + // Newest first; committer time is a stable, Git-visible ordering. + out.sort_by(|a, b| b.1.committer.time.cmp(&a.1.committer.time)); + Ok(out) + } +} + +/// Build a helpful "wrong type" error. +fn type_error(oid: &ObjectId, expected: &'static str, got: Object) -> ForgeError { + ForgeError::malformed( + "object", + format!("{oid} is a {}, expected {expected}", got.object_type()), + ) +} diff --git a/src/signature.rs b/src/signature.rs new file mode 100644 index 0000000..39f8de7 --- /dev/null +++ b/src/signature.rs @@ -0,0 +1,102 @@ +//! Author / committer / tagger signatures. +//! +//! A Git signature line looks like: +//! +//! ```text +//! Alice Example 1700000000 +0100 +//! ``` +//! +//! We keep the exact `raw` value so re-serialization is byte-identical to what +//! Git wrote, while also exposing parsed `name` / `email` / `time` for the API. + +use crate::error::{ForgeError, Result}; + +/// A parsed Git identity + timestamp. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Signature { + /// The exact bytes after the `author `/`committer `/`tagger ` prefix. + /// Preserved verbatim so serialization round-trips Git output exactly. + pub raw: String, + /// Display name (everything before the ` <`). + pub name: String, + /// Email address (between `<` and `>`). + pub email: String, + /// Unix timestamp in seconds. + pub time: i64, + /// Timezone offset token, e.g. `+0100`. + pub tz: String, +} + +impl Signature { + /// Parse a signature value (the text after the header keyword). + /// + /// Fails closed on a missing email or timestamp rather than guessing. + pub fn parse(value: &str, kind: &'static str) -> Result { + let lt = value + .find('<') + .ok_or_else(|| ForgeError::malformed(kind, "signature missing '<' in email"))?; + let gt = value + .find('>') + .ok_or_else(|| ForgeError::malformed(kind, "signature missing '>' in email"))?; + if gt < lt { + return Err(ForgeError::malformed(kind, "signature '>' precedes '<'")); + } + + let name = value[..lt].trim().to_string(); + let email = value[lt + 1..gt].to_string(); + let rest = value[gt + 1..].trim(); + + // rest is " ". Both are optional in some hand-written + // objects, but Git always writes them, so we require them. + let mut parts = rest.split_whitespace(); + let time = parts + .next() + .ok_or_else(|| ForgeError::malformed(kind, "signature missing timestamp"))? + .parse::() + .map_err(|_| ForgeError::malformed(kind, "signature timestamp is not an integer"))?; + let tz = parts + .next() + .ok_or_else(|| ForgeError::malformed(kind, "signature missing timezone"))? + .to_string(); + + Ok(Self { + raw: value.to_string(), + name, + email, + time, + tz, + }) + } + + /// The exact on-disk value (round-trips Git output). + pub fn to_raw(&self) -> &str { + &self.raw + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn parses_standard_signature() { + let sig = Signature::parse("Alice Example 1700000000 +0100", "commit") + .unwrap(); + assert_eq!(sig.name, "Alice Example"); + assert_eq!(sig.email, "alice@example.com"); + assert_eq!(sig.time, 1700000000); + assert_eq!(sig.tz, "+0100"); + // raw preserved for byte-exact re-serialization + assert_eq!(sig.to_raw(), "Alice Example 1700000000 +0100"); + } + + #[test] + fn rejects_missing_email() { + assert!(Signature::parse("Alice 1700000000 +0100", "commit").is_err()); + } + + #[test] + fn rejects_missing_timestamp() { + assert!(Signature::parse("Alice ", "commit").is_err()); + } +} diff --git a/src/tag.rs b/src/tag.rs new file mode 100644 index 0000000..ef50940 --- /dev/null +++ b/src/tag.rs @@ -0,0 +1,147 @@ +//! Annotated tag objects. +//! +//! Payload layout: +//! +//! ```text +//! object <40-hex>\n +//! type \n +//! tag \n +//! tagger \n +//! \n +//! +//! ``` + +use crate::error::{ForgeError, Result}; +use crate::headers::{self, Header}; +use crate::object::ObjectType; +use crate::oid::ObjectId; +use crate::signature::Signature; + +/// A parsed annotated tag. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Tag { + /// The tagged object's id. + pub object: ObjectId, + /// The tagged object's type. + pub object_type: ObjectType, + /// The tag name (e.g. `v1.0.0`). + pub tag: String, + /// The tagger identity (Git always writes one; lightweight tags are refs, + /// not tag objects, so this is expected to be present). + pub tagger: Option, + /// Any other headers, preserved in order for byte-exact serialization. + pub extra_headers: Vec
, + /// The tag message body. + pub message: Vec, +} + +impl Tag { + /// Parse a tag payload, failing closed on missing required headers. + pub fn parse(payload: &[u8]) -> Result { + let block = headers::parse(payload, "tag")?; + + let mut object = None; + let mut object_type = None; + let mut tag = None; + let mut tagger = None; + let mut extra_headers = Vec::new(); + + for h in block.headers { + match h.key.as_str() { + "object" => { + let hex = std::str::from_utf8(&h.value) + .map_err(|_| ForgeError::malformed("tag", "object oid not ASCII"))?; + object = Some(ObjectId::from_hex(hex)?); + } + "type" => { + let s = std::str::from_utf8(&h.value) + .map_err(|_| ForgeError::malformed("tag", "type not ASCII"))?; + object_type = Some(ObjectType::parse(s)?); + } + "tag" => { + tag = Some( + std::str::from_utf8(&h.value) + .map_err(|_| ForgeError::malformed("tag", "tag name not UTF-8"))? + .to_string(), + ); + } + "tagger" => { + let v = std::str::from_utf8(&h.value) + .map_err(|_| ForgeError::malformed("tag", "tagger not UTF-8"))?; + tagger = Some(Signature::parse(v, "tag")?); + } + _ => extra_headers.push(h), + } + } + + Ok(Self { + object: object.ok_or_else(|| ForgeError::malformed("tag", "missing object header"))?, + object_type: object_type + .ok_or_else(|| ForgeError::malformed("tag", "missing type header"))?, + tag: tag.ok_or_else(|| ForgeError::malformed("tag", "missing tag header"))?, + tagger, + extra_headers, + message: block.message, + }) + } + + /// Serialize back to the exact on-disk payload. + pub fn serialize(&self) -> Vec { + let mut out = Vec::new(); + push_header(&mut out, "object", self.object.to_hex().as_bytes()); + push_header(&mut out, "type", self.object_type.as_str().as_bytes()); + push_header(&mut out, "tag", self.tag.as_bytes()); + if let Some(tagger) = &self.tagger { + push_header(&mut out, "tagger", tagger.to_raw().as_bytes()); + } + for h in &self.extra_headers { + push_header(&mut out, &h.key, &h.value); + } + out.push(b'\n'); + out.extend_from_slice(&self.message); + out + } + + /// The message as a lossy UTF-8 string. + pub fn message_str(&self) -> std::borrow::Cow<'_, str> { + String::from_utf8_lossy(&self.message) + } +} + +fn push_header(out: &mut Vec, key: &str, value: &[u8]) { + out.extend_from_slice(key.as_bytes()); + out.push(b' '); + out.extend_from_slice(&headers::serialize_value(value)); + out.push(b'\n'); +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn parse_serialize_roundtrips() { + let payload = concat!( + "object e69de29bb2d1d6434b8b29ae775ad8c2e48c5391\n", + "type commit\n", + "tag v1.0.0\n", + "tagger Alice 1700000000 +0000\n", + "\n", + "release one\n", + ) + .as_bytes() + .to_vec(); + + let tag = Tag::parse(&payload).unwrap(); + assert_eq!(tag.tag, "v1.0.0"); + assert_eq!(tag.object_type, ObjectType::Commit); + assert!(tag.tagger.is_some()); + assert_eq!(tag.serialize(), payload); + } + + #[test] + fn rejects_missing_object() { + let payload = b"type commit\ntag v1\ntagger A 1 +0000\n\nmsg\n"; + assert!(Tag::parse(payload).is_err()); + } +} diff --git a/src/tree.rs b/src/tree.rs new file mode 100644 index 0000000..5585840 --- /dev/null +++ b/src/tree.rs @@ -0,0 +1,208 @@ +//! Tree objects: the directory listings of a Git repository. +//! +//! On-disk payload format is a concatenation of entries, each: +//! +//! ```text +//! \0<20-byte-oid> +//! ``` +//! +//! `mode` is octal ASCII with no fixed width (Git stores `40000` for a +//! sub-tree, not `040000`), `name` is raw path-component bytes, and the oid is +//! 20 raw bytes (not hex). + +use crate::error::{ForgeError, Result}; +use crate::oid::{ObjectId, OID_LEN}; + +/// A single entry (child) of a tree. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct TreeEntry { + /// Mode string exactly as stored (e.g. `100644`, `100755`, `40000`). + pub mode: String, + /// Entry name (a single path component), preserved as raw bytes because + /// Git does not require paths to be valid UTF-8. + pub name: Vec, + /// The child object id (blob for files, tree for directories). + pub oid: ObjectId, +} + +impl TreeEntry { + /// The entry name as a lossy UTF-8 string, for display. + pub fn name_str(&self) -> std::borrow::Cow<'_, str> { + String::from_utf8_lossy(&self.name) + } + + /// The human `git cat-file`-style kind derived from the mode. + pub fn kind(&self) -> &'static str { + match self.mode.as_str() { + "40000" | "040000" => "tree", + "160000" => "commit", // gitlink / submodule + _ => "blob", + } + } + + /// The mode left-padded to 6 digits, matching `git cat-file -p` output + /// (Git prints `040000` for trees even though it stores `40000`). + pub fn display_mode(&self) -> String { + format!("{:0>6}", self.mode) + } +} + +/// A parsed tree object. +#[derive(Clone, Debug, PartialEq, Eq, Default)] +pub struct Tree { + /// Entries in stored order (Git stores them sorted). + pub entries: Vec, +} + +impl Tree { + /// Parse a tree payload into entries, failing closed on truncation. + pub fn parse(payload: &[u8]) -> Result { + let mut entries = Vec::new(); + let mut pos = 0; + while pos < payload.len() { + // mode: bytes up to the space + let space = payload[pos..] + .iter() + .position(|&b| b == b' ') + .ok_or_else(|| ForgeError::malformed("tree", "entry missing space after mode"))?; + let mode = std::str::from_utf8(&payload[pos..pos + space]) + .map_err(|_| ForgeError::malformed("tree", "mode is not ASCII"))? + .to_string(); + pos += space + 1; + + // name: bytes up to the NUL + let nul = payload[pos..] + .iter() + .position(|&b| b == 0) + .ok_or_else(|| ForgeError::malformed("tree", "entry missing NUL after name"))?; + let name = payload[pos..pos + nul].to_vec(); + if name.is_empty() { + return Err(ForgeError::malformed("tree", "entry has empty name")); + } + pos += nul + 1; + + // oid: exactly 20 raw bytes + if pos + OID_LEN > payload.len() { + return Err(ForgeError::malformed("tree", "truncated entry oid")); + } + let mut raw = [0u8; OID_LEN]; + raw.copy_from_slice(&payload[pos..pos + OID_LEN]); + pos += OID_LEN; + + entries.push(TreeEntry { + mode, + name, + oid: ObjectId::from_bytes(raw), + }); + } + Ok(Self { entries }) + } + + /// Serialize back to the exact on-disk payload (round-trips Git output). + pub fn serialize(&self) -> Vec { + let mut out = Vec::new(); + for e in &self.entries { + out.extend_from_slice(e.mode.as_bytes()); + out.push(b' '); + out.extend_from_slice(&e.name); + out.push(0); + out.extend_from_slice(e.oid.as_bytes()); + } + out + } + + /// Find an entry by exact name. + pub fn entry(&self, name: &[u8]) -> Option<&TreeEntry> { + self.entries.iter().find(|e| e.name == name) + } + + /// Sort entries into Git's canonical order. + /// + /// Git orders tree entries by name, but compares as though every tree + /// entry's name had a trailing `/`. This is what makes `write-tree` + /// deterministic and hash-stable. + pub fn canonicalize(&mut self) { + self.entries.sort_by(git_name_cmp); + } +} + +/// Compare two entries using Git's tree-sort rule (trees sort as `name/`). +fn git_name_cmp(a: &TreeEntry, b: &TreeEntry) -> std::cmp::Ordering { + let a_key = sort_key(a); + let b_key = sort_key(b); + a_key.cmp(&b_key) +} + +fn sort_key(e: &TreeEntry) -> Vec { + let mut key = e.name.clone(); + if e.kind() == "tree" { + key.push(b'/'); + } + key +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::object; + + fn oid(hex: &str) -> ObjectId { + ObjectId::from_hex(hex).unwrap() + } + + #[test] + fn parse_serialize_roundtrips() { + let entries = vec![ + TreeEntry { + mode: "100644".into(), + name: b"a.txt".to_vec(), + oid: oid("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), + }, + TreeEntry { + mode: "40000".into(), + name: b"sub".to_vec(), + oid: oid("4b825dc642cb6eb9a060e54bf8d69288fbee4904"), + }, + ]; + let tree = Tree { entries }; + let payload = tree.serialize(); + let reparsed = Tree::parse(&payload).unwrap(); + assert_eq!(tree, reparsed); + } + + #[test] + fn empty_tree_matches_known_oid() { + // The canonical empty tree oid every Git repo shares. + let payload = Tree::default().serialize(); + let (id, _) = object::hash_content(object::ObjectType::Tree, &payload); + assert_eq!(id.to_hex(), "4b825dc642cb6eb9a060e54bf8d69288fbee4904"); + } + + #[test] + fn rejects_truncated_oid() { + let bad = b"100644 a.txt\0short".to_vec(); + assert!(Tree::parse(&bad).is_err()); + } + + #[test] + fn canonicalize_sorts_trees_as_slashed() { + let mut tree = Tree { + entries: vec![ + TreeEntry { + mode: "100644".into(), + name: b"foo".to_vec(), + oid: oid("e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"), + }, + TreeEntry { + mode: "40000".into(), + name: b"foo".to_vec(), + oid: oid("4b825dc642cb6eb9a060e54bf8d69288fbee4904"), + }, + ], + }; + tree.canonicalize(); + // "foo" (blob) sorts before "foo/" (tree) + assert_eq!(tree.entries[0].kind(), "blob"); + assert_eq!(tree.entries[1].kind(), "tree"); + } +} diff --git a/tests/interop.rs b/tests/interop.rs new file mode 100644 index 0000000..1c4540d --- /dev/null +++ b/tests/interop.rs @@ -0,0 +1,292 @@ +//! Real-git interoperability tests — the whole point of this slice. +//! +//! These shell out to the installed `git` binary and assert that: +//! 1. object ids we compute are byte-identical to `git hash-object`; +//! 2. a repository authored by real `git` is read back correctly by us; +//! 3. objects we write are readable by real `git` (`cat-file`), and +//! 4. our serialization reproduces git's exact bytes (round-trip via oid). +//! +//! Requires `git` on PATH (the task environment has it). + +use std::path::Path; +use std::process::Command; + +use rit::object::{hash_content, Object}; +use rit::{ObjectType, Repository}; +use tempfile::TempDir; + +/// Run `git` with args in `cwd`, returning trimmed stdout; panics on failure. +fn git(cwd: &Path, args: &[&str]) -> String { + let output = Command::new("git") + .args(args) + .current_dir(cwd) + .output() + .expect("git must be installed and on PATH"); + assert!( + output.status.success(), + "git {args:?} failed: {}", + String::from_utf8_lossy(&output.stderr) + ); + String::from_utf8(output.stdout).unwrap().trim().to_string() +} + +/// Run `git` returning raw (untrimmed) stdout bytes. +fn git_bytes(cwd: &Path, args: &[&str]) -> Vec { + let output = Command::new("git") + .args(args) + .current_dir(cwd) + .output() + .expect("git must be installed and on PATH"); + assert!( + output.status.success(), + "git {args:?} failed: {}", + String::from_utf8_lossy(&output.stderr) + ); + output.stdout +} + +/// Create an initialized repo with deterministic identity + a first commit. +fn init_repo_with_commit() -> TempDir { + let dir = tempfile::tempdir().unwrap(); + let p = dir.path(); + git(p, &["init", "-q", "-b", "main"]); + git(p, &["config", "user.name", "Forge Tester"]); + git(p, &["config", "user.email", "forge@example.com"]); + git(p, &["config", "commit.gpgsign", "false"]); + + std::fs::write(p.join("hello.txt"), b"Hello, Forge!\n").unwrap(); + std::fs::create_dir(p.join("sub")).unwrap(); + std::fs::write(p.join("sub").join("nested.txt"), b"nested content\n").unwrap(); + git(p, &["add", "."]); + // Fixed dates so commits are reproducible. + let env_commit = [ + "-c", + "user.name=Forge Tester", + "-c", + "user.email=forge@example.com", + ]; + let mut args = vec!["commit", "-q", "-m", "initial commit"]; + // prepend the -c overrides + let mut full: Vec<&str> = env_commit.to_vec(); + full.append(&mut args); + git(p, &full); + dir +} + +#[test] +fn blob_oid_matches_git_hash_object() { + let dir = tempfile::tempdir().unwrap(); + let contents: &[&[u8]] = &[b"hello world\n", b"", b"no trailing newline", b"\x00\x01\x02binary"]; + + for (i, content) in contents.iter().enumerate() { + let file = dir.path().join(format!("f{i}.bin")); + std::fs::write(&file, content).unwrap(); + + let git_oid = git(dir.path(), &["hash-object", file.to_str().unwrap()]); + let ours = hash_content(ObjectType::Blob, content).0.to_hex(); + + assert_eq!( + ours, git_oid, + "blob oid mismatch for content #{i} ({content:?})" + ); + } +} + +#[test] +fn reads_repo_authored_by_real_git() { + let dir = init_repo_with_commit(); + let p = dir.path(); + + let repo = Repository::discover(p).unwrap(); + + // HEAD oid matches `git rev-parse HEAD`. + let head = repo.head().unwrap(); + assert_eq!(head.to_hex(), git(p, &["rev-parse", "HEAD"])); + + // The HEAD commit's tree matches `git rev-parse HEAD^{tree}`. + let commit = repo.head_commit().unwrap(); + assert_eq!(commit.tree.to_hex(), git(p, &["rev-parse", "HEAD^{tree}"])); + + // Parsed metadata is correct. + assert_eq!(commit.author.name, "Forge Tester"); + assert_eq!(commit.author.email, "forge@example.com"); + assert_eq!(commit.summary(), "initial commit"); + assert!(commit.parents.is_empty(), "first commit has no parents"); + + // The tree lists hello.txt with the same blob oid git reports. + let tree = repo.tree(&commit.tree).unwrap(); + let entry = tree.entry(b"hello.txt").expect("hello.txt in tree"); + assert_eq!(entry.oid.to_hex(), git(p, &["rev-parse", "HEAD:hello.txt"])); + assert_eq!(entry.display_mode(), "100644"); + + // And the blob content round-trips. + let blob = repo.blob(&entry.oid).unwrap(); + assert_eq!(blob.data, b"Hello, Forge!\n"); + + // Sub-tree is reachable and its nested blob matches git. + let sub = tree.entry(b"sub").expect("sub dir in tree"); + assert_eq!(sub.kind(), "tree"); + let subtree = repo.tree(&sub.oid).unwrap(); + let nested = subtree.entry(b"nested.txt").expect("nested.txt"); + assert_eq!( + nested.oid.to_hex(), + git(p, &["rev-parse", "HEAD:sub/nested.txt"]) + ); +} + +#[test] +fn objects_we_write_are_readable_by_real_git() { + let dir = init_repo_with_commit(); + let p = dir.path(); + let repo = Repository::discover(p).unwrap(); + + // Write a blob with OUR code. + let content = b"round trip through our writer\n"; + let oid = repo.hash_object(ObjectType::Blob, content, true).unwrap(); + + // Real git can read its type and content. + assert_eq!(git(p, &["cat-file", "-t", &oid.to_hex()]), "blob"); + assert_eq!(git_bytes(p, &["cat-file", "-p", &oid.to_hex()]), content); + + // And git's own oid for the same content agrees with ours. + let git_oid = { + let f = p.join("rt.txt"); + std::fs::write(&f, content).unwrap(); + git(p, &["hash-object", f.to_str().unwrap()]) + }; + assert_eq!(oid.to_hex(), git_oid); + + // fsck is clean: nothing we wrote corrupts the repo. + let fsck = git(p, &["fsck", "--strict"]); + assert!( + !fsck.to_lowercase().contains("error"), + "git fsck reported problems: {fsck}" + ); +} + +#[test] +fn our_serialization_reproduces_git_bytes_exactly() { + // If our parse+serialize is byte-exact, re-hashing git's objects with our + // code must reproduce git's oids. + let dir = init_repo_with_commit(); + let p = dir.path(); + let repo = Repository::discover(p).unwrap(); + + let head = repo.head().unwrap(); + + // Commit: parse then re-serialize then re-hash -> same oid. + match repo.read_object(&head).unwrap() { + Object::Commit(c) => { + let (id, _) = hash_content(ObjectType::Commit, &c.serialize()); + assert_eq!(id, head, "commit re-serialization is not byte-exact"); + } + other => panic!("HEAD should be a commit, got {other:?}"), + } + + // Tree: same property. + let tree_oid = repo.head_commit().unwrap().tree; + let tree = repo.tree(&tree_oid).unwrap(); + let (id, _) = hash_content(ObjectType::Tree, &tree.serialize()); + assert_eq!(id, tree_oid, "tree re-serialization is not byte-exact"); +} + +#[test] +fn reads_annotated_tag_from_real_git() { + let dir = init_repo_with_commit(); + let p = dir.path(); + git( + p, + &[ + "-c", + "user.name=Forge Tester", + "-c", + "user.email=forge@example.com", + "tag", + "-a", + "v1.0.0", + "-m", + "first release", + ], + ); + + let repo = Repository::discover(p).unwrap(); + let tag_oid = repo.resolve("v1.0.0").unwrap(); + match repo.read_object(&tag_oid).unwrap() { + Object::Tag(t) => { + assert_eq!(t.tag, "v1.0.0"); + assert_eq!(t.object_type, ObjectType::Commit); + assert_eq!(t.object, repo.head().unwrap()); + assert!(t.message_str().contains("first release")); + // byte-exact: re-hash reproduces git's tag oid + let (id, _) = hash_content(ObjectType::Tag, &t.serialize()); + assert_eq!(id, tag_oid, "tag re-serialization is not byte-exact"); + } + other => panic!("expected annotated tag, got {other:?}"), + } + + // Peeling the tag reaches the commit. + let commit = repo.peel_to_commit(tag_oid).unwrap(); + assert_eq!(commit.summary(), "initial commit"); +} + +#[test] +fn log_walks_multi_commit_history() { + let dir = init_repo_with_commit(); + let p = dir.path(); + let overrides = [ + "-c", + "user.name=Forge Tester", + "-c", + "user.email=forge@example.com", + ]; + + // second commit + std::fs::write(p.join("second.txt"), b"second\n").unwrap(); + git(p, &["add", "."]); + let mut a: Vec<&str> = overrides.to_vec(); + a.extend_from_slice(&["commit", "-q", "-m", "second commit"]); + git(p, &a); + + // third commit + std::fs::write(p.join("third.txt"), b"third\n").unwrap(); + git(p, &["add", "."]); + let mut b: Vec<&str> = overrides.to_vec(); + b.extend_from_slice(&["commit", "-q", "-m", "third commit"]); + git(p, &b); + + let repo = Repository::discover(p).unwrap(); + let head = repo.head().unwrap(); + let history = repo.log(head).unwrap(); + + assert_eq!(history.len(), 3, "expected 3 commits"); + // Compare our ordered oids against `git rev-list HEAD`. + let git_list: Vec = git(p, &["rev-list", "HEAD"]) + .lines() + .map(str::to_string) + .collect(); + let ours: Vec = history.iter().map(|(oid, _)| oid.to_hex()).collect(); + assert_eq!(ours, git_list, "log order/content differs from git rev-list"); + assert_eq!(history[0].1.summary(), "third commit"); +} + +#[test] +fn corrupt_object_is_rejected_not_panicked() { + let dir = init_repo_with_commit(); + let p = dir.path(); + let repo = Repository::discover(p).unwrap(); + let head = repo.head().unwrap(); + + // Overwrite the loose object with garbage and confirm we error, not panic. + // Git stores loose objects read-only (0444), so make it writable first. + let path = repo.odb().loose_path(&head); + if path.exists() { + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o644)).unwrap(); + } + std::fs::write(&path, b"totally not a git object").unwrap(); + let result = repo.read_object(&head); + assert!(result.is_err(), "corrupt object must be rejected"); + } +}