From 52261defa67c2af55b61b1a881fb101284931b9a Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Thu, 2 Apr 2026 06:57:35 +0000 Subject: README: `next` branch refactor --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 990d46bd..6ef61139 100644 --- a/README.md +++ b/README.md @@ -7,6 +7,7 @@ Furgit is a low‐level Git library in Go. ## Status +* **A refactor is pending on the `next` branch.** * Years or decades away from stable * Absolutely no guarantees * Do not use in production -- cgit v1.3.1-10-gc9f91 From df1f2fb3daa1acd25c88510f259d5535fb482126 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Sun, 5 Apr 2026 07:38:52 +0000 Subject: README, etc.: Add hjgit mirror --- CONTRIBUTING.md | 8 -------- README.md | 17 ++++++++--------- 2 files changed, 8 insertions(+), 17 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 1f5019b0..9341afd8 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -2,14 +2,6 @@ Refer to the README for community spaces. -## Repos and mirrors - -* [Codeberg](https://codeberg.org/lindenii/furgit) -* [SourceHut mirror](https://git.sr.ht/~runxiyu/furgit) -* [tangled mirror](https://tangled.org/@runxiyu.tngl.sh/furgit) -* [GitHub mirror](https://github.com/runxiyu/furgit) -* [git.runxiyu.org mirror](https://git.runxiyu.org/furgit.git//) - ## Reporting bugs Bug reports ideally include a reproduction recipe: a Go program which starts diff --git a/README.md b/README.md index 6ef61139..dd435c95 100644 --- a/README.md +++ b/README.md @@ -52,13 +52,12 @@ acceptance by the Designated Proxy of any subsequent version of the GNU Affero General Public License shall permanently authorize the use of that accepted version for this Program. -## Alternatives - -Not endorsements. - -* [github.com/go-git/go-git](https://github.com/go-git/go-git) (by far the most mature) -* [github.com/driusan/dgit](https://github.com/driusan/dgit) -* [github.com/Nivl/git-go](https://github.com/Nivl/git-go) -* [github.com/unkn0wn-root/git-go.git](https://github.com/unkn0wn-root/git-go.git) -* [github.com/speedata/gogit](https://github.com/speedata/gogit) +## Repos and mirrors + +* [Codeberg](https://codeberg.org/lindenii/furgit) +* [SourceHut mirror](https://git.sr.ht/~runxiyu/furgit) +* [hjgit mirror](https://hjgit.org/runxiyu/furgit/HEAD/info.html) +* [tangled mirror](https://tangled.org/@runxiyu.tngl.sh/furgit) +* [GitHub mirror](https://github.com/runxiyu/furgit) +* [git.runxiyu.org mirror](https://git.runxiyu.org/furgit.git//) -- cgit v1.3.1-10-gc9f91 From 7ca4818e21ea760daa0f579ce24fb84ed7163cbf Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Sun, 26 Apr 2026 23:02:07 +0000 Subject: research: dynamic packfiles do not need abbreviated hashes --- research/dynamic_packfiles.txt | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/research/dynamic_packfiles.txt b/research/dynamic_packfiles.txt index e6671521..e4fe7e54 100644 --- a/research/dynamic_packfiles.txt +++ b/research/dynamic_packfiles.txt @@ -171,3 +171,9 @@ https://github.com/inkandswitch/darn https://www.youtube.com/watch?v=nk4nefmguZk https://crates.io/crates/iroh-blobs https://crates.io/crates/bao-tree + + +Actually, who cares about abbreviated hashes? +Clients. Clients only. +It will be a separate interface satisfied by "normal repos" +but not satisfied by our store. Good enough. -- cgit v1.3.1-10-gc9f91 From 676d0e6766e9af0574485dfac9a5d8ddf933ab03 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Sun, 17 May 2026 14:45:40 +0000 Subject: object: Serialize -> Bytes --- commitquery/queries_is_ancestor_unit_test.go | 4 ++-- commitquery/queries_merge_bases_unit_test.go | 4 ++-- object/blob/serialize.go | 10 +++++----- object/blob/serialize_test.go | 4 ++-- object/commit/serialize.go | 10 +++++----- object/commit/serialize_test.go | 4 ++-- object/object.go | 4 ++-- object/tag/serialize.go | 10 +++++----- object/tag/serialize_test.go | 4 ++-- object/tree/serialize.go | 10 +++++----- object/tree/serialize_test.go | 4 ++-- reachability/unit_test.go | 4 ++-- 12 files changed, 36 insertions(+), 36 deletions(-) diff --git a/commitquery/queries_is_ancestor_unit_test.go b/commitquery/queries_is_ancestor_unit_test.go index 002c49ae..75a4b00c 100644 --- a/commitquery/queries_is_ancestor_unit_test.go +++ b/commitquery/queries_is_ancestor_unit_test.go @@ -42,9 +42,9 @@ func ancestorTagBody(target objectid.ObjectID, targetType objecttype.Type) []byt func mustSerializeAncestorTree(tb testing.TB, tree *objecttree.Tree) []byte { tb.Helper() - body, err := tree.SerializeWithoutHeader() + body, err := tree.BytesWithoutHeader() if err != nil { - tb.Fatalf("SerializeWithoutHeader: %v", err) + tb.Fatalf("BytesWithoutHeader: %v", err) } return body diff --git a/commitquery/queries_merge_bases_unit_test.go b/commitquery/queries_merge_bases_unit_test.go index 3e302536..3772f882 100644 --- a/commitquery/queries_merge_bases_unit_test.go +++ b/commitquery/queries_merge_bases_unit_test.go @@ -60,9 +60,9 @@ func containsID(set map[objectid.ObjectID]struct{}, id objectid.ObjectID) bool { func mustSerializeTree(tb testing.TB, tree *tree.Tree) []byte { tb.Helper() - body, err := tree.SerializeWithoutHeader() + body, err := tree.BytesWithoutHeader() if err != nil { - tb.Fatalf("SerializeWithoutHeader: %v", err) + tb.Fatalf("BytesWithoutHeader: %v", err) } return body diff --git a/object/blob/serialize.go b/object/blob/serialize.go index 80cce8dc..5594b200 100644 --- a/object/blob/serialize.go +++ b/object/blob/serialize.go @@ -7,14 +7,14 @@ import ( objecttype "codeberg.org/lindenii/furgit/object/type" ) -// SerializeWithoutHeader renders the raw blob body bytes. -func (blob *Blob) SerializeWithoutHeader() ([]byte, error) { +// BytesWithoutHeader renders the raw blob body bytes. +func (blob *Blob) BytesWithoutHeader() ([]byte, error) { return append([]byte(nil), blob.Data...), nil } -// SerializeWithHeader renders the raw object (header + body). -func (blob *Blob) SerializeWithHeader() ([]byte, error) { - body, err := blob.SerializeWithoutHeader() +// BytesWithHeader renders the raw object (header + body). +func (blob *Blob) BytesWithHeader() ([]byte, error) { + body, err := blob.BytesWithoutHeader() if err != nil { return nil, err } diff --git a/object/blob/serialize_test.go b/object/blob/serialize_test.go index 4292abad..99725eaf 100644 --- a/object/blob/serialize_test.go +++ b/object/blob/serialize_test.go @@ -17,9 +17,9 @@ func TestBlobSerialize(t *testing.T) { obj := &blob.Blob{Data: body} - rawObj, err := obj.SerializeWithHeader() + rawObj, err := obj.BytesWithHeader() if err != nil { - t.Fatalf("SerializeWithHeader: %v", err) + t.Fatalf("BytesWithHeader: %v", err) } gotID := algo.Sum(rawObj) diff --git a/object/commit/serialize.go b/object/commit/serialize.go index 3f141550..0642d656 100644 --- a/object/commit/serialize.go +++ b/object/commit/serialize.go @@ -9,8 +9,8 @@ import ( objecttype "codeberg.org/lindenii/furgit/object/type" ) -// SerializeWithoutHeader renders the raw commit body bytes. -func (commit *Commit) SerializeWithoutHeader() ([]byte, error) { +// BytesWithoutHeader renders the raw commit body bytes. +func (commit *Commit) BytesWithoutHeader() ([]byte, error) { var buf bytes.Buffer if commit.Tree.Algorithm().Size() == 0 { @@ -64,9 +64,9 @@ func (commit *Commit) SerializeWithoutHeader() ([]byte, error) { return buf.Bytes(), nil } -// SerializeWithHeader renders the raw object (header + body). -func (commit *Commit) SerializeWithHeader() ([]byte, error) { - body, err := commit.SerializeWithoutHeader() +// BytesWithHeader renders the raw object (header + body). +func (commit *Commit) BytesWithHeader() ([]byte, error) { + body, err := commit.BytesWithoutHeader() if err != nil { return nil, err } diff --git a/object/commit/serialize_test.go b/object/commit/serialize_test.go index e58a8078..6a3486cd 100644 --- a/object/commit/serialize_test.go +++ b/object/commit/serialize_test.go @@ -21,9 +21,9 @@ func TestCommitSerialize(t *testing.T) { t.Fatalf("ParseCommit: %v", err) } - rawObj, err := parsed.SerializeWithHeader() + rawObj, err := parsed.BytesWithHeader() if err != nil { - t.Fatalf("SerializeWithHeader: %v", err) + t.Fatalf("BytesWithHeader: %v", err) } gotID := algo.Sum(rawObj) diff --git a/object/object.go b/object/object.go index d1b1bc4f..2021a3de 100644 --- a/object/object.go +++ b/object/object.go @@ -5,6 +5,6 @@ import objecttype "codeberg.org/lindenii/furgit/object/type" // Object is a Git object. type Object interface { ObjectType() objecttype.Type - SerializeWithoutHeader() ([]byte, error) - SerializeWithHeader() ([]byte, error) + BytesWithoutHeader() ([]byte, error) + BytesWithHeader() ([]byte, error) } diff --git a/object/tag/serialize.go b/object/tag/serialize.go index 4f9d6664..43fad522 100644 --- a/object/tag/serialize.go +++ b/object/tag/serialize.go @@ -9,8 +9,8 @@ import ( objecttype "codeberg.org/lindenii/furgit/object/type" ) -// SerializeWithoutHeader renders the raw tag body bytes. -func (tag *Tag) SerializeWithoutHeader() ([]byte, error) { +// BytesWithoutHeader renders the raw tag body bytes. +func (tag *Tag) BytesWithoutHeader() ([]byte, error) { if tag.Target.Algorithm().Size() == 0 { return nil, errors.New("object: tag: missing target id") } @@ -48,9 +48,9 @@ func (tag *Tag) SerializeWithoutHeader() ([]byte, error) { return buf.Bytes(), nil } -// SerializeWithHeader renders the raw object (header + body). -func (tag *Tag) SerializeWithHeader() ([]byte, error) { - body, err := tag.SerializeWithoutHeader() +// BytesWithHeader renders the raw object (header + body). +func (tag *Tag) BytesWithHeader() ([]byte, error) { + body, err := tag.BytesWithoutHeader() if err != nil { return nil, err } diff --git a/object/tag/serialize_test.go b/object/tag/serialize_test.go index a1311c39..3a87e5ad 100644 --- a/object/tag/serialize_test.go +++ b/object/tag/serialize_test.go @@ -22,9 +22,9 @@ func TestTagSerialize(t *testing.T) { t.Fatalf("ParseTag: %v", err) } - rawObj, err := parsed.SerializeWithHeader() + rawObj, err := parsed.BytesWithHeader() if err != nil { - t.Fatalf("SerializeWithHeader: %v", err) + t.Fatalf("BytesWithHeader: %v", err) } gotID := algo.Sum(rawObj) diff --git a/object/tree/serialize.go b/object/tree/serialize.go index 69deacda..922cd145 100644 --- a/object/tree/serialize.go +++ b/object/tree/serialize.go @@ -8,8 +8,8 @@ import ( objecttype "codeberg.org/lindenii/furgit/object/type" ) -// SerializeWithoutHeader renders the raw tree body bytes. -func (tree *Tree) SerializeWithoutHeader() ([]byte, error) { +// BytesWithoutHeader renders the raw tree body bytes. +func (tree *Tree) BytesWithoutHeader() ([]byte, error) { var bodyLen int for _, entry := range tree.Entries { @@ -35,9 +35,9 @@ func (tree *Tree) SerializeWithoutHeader() ([]byte, error) { return body, nil } -// SerializeWithHeader renders the raw object (header + body). -func (tree *Tree) SerializeWithHeader() ([]byte, error) { - body, err := tree.SerializeWithoutHeader() +// BytesWithHeader renders the raw object (header + body). +func (tree *Tree) BytesWithHeader() ([]byte, error) { + body, err := tree.BytesWithoutHeader() if err != nil { return nil, err } diff --git a/object/tree/serialize_test.go b/object/tree/serialize_test.go index 9c9a2f1c..f7bc64b6 100644 --- a/object/tree/serialize_test.go +++ b/object/tree/serialize_test.go @@ -60,9 +60,9 @@ func TestTreeSerialize(t *testing.T) { wantTreeID := testRepo.Mktree(t, buildGitMktreeInput(obj.Entries)) - rawObj, err := obj.SerializeWithHeader() + rawObj, err := obj.BytesWithHeader() if err != nil { - t.Fatalf("SerializeWithHeader: %v", err) + t.Fatalf("BytesWithHeader: %v", err) } gotTreeID := algo.Sum(rawObj) diff --git a/reachability/unit_test.go b/reachability/unit_test.go index 1f761108..5be7f6fb 100644 --- a/reachability/unit_test.go +++ b/reachability/unit_test.go @@ -415,9 +415,9 @@ func TestWalkInvalidDomainReturnsPlainError(t *testing.T) { func mustSerializeTree(tb testing.TB, tree *tree.Tree) []byte { tb.Helper() - body, err := tree.SerializeWithoutHeader() + body, err := tree.BytesWithoutHeader() if err != nil { - tb.Fatalf("SerializeWithoutHeader: %v", err) + tb.Fatalf("BytesWithoutHeader: %v", err) } return body -- cgit v1.3.1-10-gc9f91 From f741f09fc8a114009abb65070395c44e4bc0e4f2 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Wed, 20 May 2026 16:24:57 +0000 Subject: ref/store: List should not be backend-defined --- ref/store/reading.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ref/store/reading.go b/ref/store/reading.go index a9e2ad49..bf610d9b 100644 --- a/ref/store/reading.go +++ b/ref/store/reading.go @@ -28,6 +28,8 @@ type Reader interface { // List returns references matching pattern. // // The exact pattern language is backend-defined. + // This is not good, and I should fix this soon. + // Also, this should be an iter.Seq[ref.Ref] instead. // // Labels: Life-Parent. List(pattern string) ([]ref.Ref, error) -- cgit v1.3.1-10-gc9f91 From 5d68b08dcd50c65e6e67239ca1ee8b25786d4559 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Wed, 20 May 2026 16:27:38 +0000 Subject: ref/store: More bikeshedding --- ref/store/errors.go | 1 + ref/store/update_errors.go | 3 +++ 2 files changed, 4 insertions(+) diff --git a/ref/store/errors.go b/ref/store/errors.go index 45583440..3b2b15b3 100644 --- a/ref/store/errors.go +++ b/ref/store/errors.go @@ -4,4 +4,5 @@ import "errors" // ErrReferenceNotFound indicates that a reference does not exist in a backend. // TODO: Interface error? Just like object not found in objectstore. +// I'm not sure if I want this as a sentinel. var ErrReferenceNotFound = errors.New("refstore: reference not found") diff --git a/ref/store/update_errors.go b/ref/store/update_errors.go index f05f37d2..d3580439 100644 --- a/ref/store/update_errors.go +++ b/ref/store/update_errors.go @@ -62,6 +62,9 @@ func (err *CreateExistsError) Error() string { // IncorrectOldValueError indicates that one operation's expected old value did // not match the current reference value. +// +// TODO: All of these errors should be redesigned. +// Strings are not appropriate here. type IncorrectOldValueError struct { Actual string Expected string -- cgit v1.3.1-10-gc9f91 From 7e1f61e1e6ce9c09fef68be6818d4c7162b54fa8 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Wed, 20 May 2026 16:52:22 +0000 Subject: reachability: CheckConnected should get a strict option --- reachability/connected.go | 9 +++++---- reachability/integration_test.go | 1 + reachability/unit_test.go | 2 +- 3 files changed, 7 insertions(+), 5 deletions(-) diff --git a/reachability/connected.go b/reachability/connected.go index 96211079..655c40b9 100644 --- a/reachability/connected.go +++ b/reachability/connected.go @@ -6,12 +6,13 @@ import objectid "codeberg.org/lindenii/furgit/object/id" // selected domain) can be fully traversed without missing-object/type/parse // errors, excluding subgraphs rooted at haves. // -// Even with commit-graph acceleration available, each visited commit is -// still validated against the object store. -func (r *Reachability) CheckConnected(domain Domain, haves, wants map[objectid.ObjectID]struct{}) error { +// With commit-graph acceleration available, +// each visited commit is validated against the object store +// iff struct is set to true. +func (r *Reachability) CheckConnected(domain Domain, haves, wants map[objectid.ObjectID]struct{}, strict bool) error { walk := r.Walk(domain, haves, wants) - walk.strict = true + walk.strict = strict for range walk.Seq() { } diff --git a/reachability/integration_test.go b/reachability/integration_test.go index 20d9e3f7..2df938aa 100644 --- a/reachability/integration_test.go +++ b/reachability/integration_test.go @@ -183,6 +183,7 @@ func TestCheckConnectedMissingObject(t *testing.T) { reachability.DomainObjects, nil, map[objectid.ObjectID]struct{}{commitID: {}}, + false, ) if err == nil { t.Fatal("expected error") diff --git a/reachability/unit_test.go b/reachability/unit_test.go index 5be7f6fb..469c79ff 100644 --- a/reachability/unit_test.go +++ b/reachability/unit_test.go @@ -380,7 +380,7 @@ func TestCheckConnectedReturnsConcreteMissingObject(t *testing.T) { r := reachability.New(objectfetch.New(store), nil) - err = r.CheckConnected(reachability.DomainCommits, nil, map[objectid.ObjectID]struct{}{commit: {}}) + err = r.CheckConnected(reachability.DomainCommits, nil, map[objectid.ObjectID]struct{}{commit: {}}, false) if err == nil { t.Fatal("expected error") } -- cgit v1.3.1-10-gc9f91 From 33103e13b34d3f40fae507d657fc1750c66c3b8c Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Wed, 20 May 2026 17:12:31 +0000 Subject: object/tag: Rename Target to TargetID --- cmd/show-object/print.go | 2 +- object/fetch/peel_to_blob.go | 2 +- object/fetch/peel_to_blob_id.go | 2 +- object/fetch/peel_to_commit.go | 2 +- object/fetch/peel_to_commit_id.go | 2 +- object/fetch/peel_to_tree.go | 2 +- object/fetch/peel_to_tree_id.go | 2 +- object/tag/parse.go | 2 +- object/tag/parse_test.go | 4 ++-- object/tag/serialize.go | 4 ++-- object/tag/tag.go | 2 +- reachability/walk_expand_commits.go | 2 +- reachability/walk_expand_objects.go | 2 +- repository/traversal_test.go | 2 +- 14 files changed, 16 insertions(+), 16 deletions(-) diff --git a/cmd/show-object/print.go b/cmd/show-object/print.go index 75484f73..fcd6494f 100644 --- a/cmd/show-object/print.go +++ b/cmd/show-object/print.go @@ -58,7 +58,7 @@ func printStored(s *stored.Stored[object.Object]) { targetTy = fmt.Sprintf("type %d", tag.TargetType) } - fmt.Fprintf(&b, "target: %s (%s)\n", tag.Target, targetTy) + fmt.Fprintf(&b, "target: %s (%s)\n", tag.TargetID, targetTy) fmt.Fprintf(&b, "name: %s\n", tag.Name) if tag.Tagger != nil { diff --git a/object/fetch/peel_to_blob.go b/object/fetch/peel_to_blob.go index adf86495..121bb70b 100644 --- a/object/fetch/peel_to_blob.go +++ b/object/fetch/peel_to_blob.go @@ -23,7 +23,7 @@ func (r *Fetcher) PeelToBlob(id objectid.ObjectID) (*stored.Stored[*blob.Blob], case *blob.Blob: return stored.New(id, parsed), nil case *tag.Tag: - id = parsed.Target + id = parsed.TargetID default: return nil, &giterrors.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: objecttype.TypeBlob} } diff --git a/object/fetch/peel_to_blob_id.go b/object/fetch/peel_to_blob_id.go index 7a43b4cc..82f23c91 100644 --- a/object/fetch/peel_to_blob_id.go +++ b/object/fetch/peel_to_blob_id.go @@ -23,7 +23,7 @@ func (r *Fetcher) PeelToBlobID(id objectid.ObjectID) (objectid.ObjectID, error) return objectid.ObjectID{}, err } - id = tag.Object().Target + id = tag.Object().TargetID case objecttype.TypeInvalid, objecttype.TypeCommit, objecttype.TypeTree, diff --git a/object/fetch/peel_to_commit.go b/object/fetch/peel_to_commit.go index e5fdce2b..569ea7a8 100644 --- a/object/fetch/peel_to_commit.go +++ b/object/fetch/peel_to_commit.go @@ -23,7 +23,7 @@ func (r *Fetcher) PeelToCommit(id objectid.ObjectID) (*stored.Stored[*commit.Com case *commit.Commit: return stored.New(id, parsed), nil case *tag.Tag: - id = parsed.Target + id = parsed.TargetID default: return nil, &giterrors.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: objecttype.TypeCommit} } diff --git a/object/fetch/peel_to_commit_id.go b/object/fetch/peel_to_commit_id.go index 7b58bdea..9d7fdbc9 100644 --- a/object/fetch/peel_to_commit_id.go +++ b/object/fetch/peel_to_commit_id.go @@ -23,7 +23,7 @@ func (r *Fetcher) PeelToCommitID(id objectid.ObjectID) (objectid.ObjectID, error return objectid.ObjectID{}, err } - id = tag.Object().Target + id = tag.Object().TargetID case objecttype.TypeInvalid, objecttype.TypeTree, objecttype.TypeBlob, diff --git a/object/fetch/peel_to_tree.go b/object/fetch/peel_to_tree.go index adc87e6b..8898746b 100644 --- a/object/fetch/peel_to_tree.go +++ b/object/fetch/peel_to_tree.go @@ -27,7 +27,7 @@ func (r *Fetcher) PeelToTree(id objectid.ObjectID) (*stored.Stored[*tree.Tree], case *commit.Commit: return r.ExactTree(parsed.Tree) case *tag.Tag: - id = parsed.Target + id = parsed.TargetID default: return nil, &giterrors.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: objecttype.TypeTree} } diff --git a/object/fetch/peel_to_tree_id.go b/object/fetch/peel_to_tree_id.go index 4c9bdac9..8482d28e 100644 --- a/object/fetch/peel_to_tree_id.go +++ b/object/fetch/peel_to_tree_id.go @@ -31,7 +31,7 @@ func (r *Fetcher) PeelToTreeID(id objectid.ObjectID) (objectid.ObjectID, error) return objectid.ObjectID{}, err } - id = tag.Object().Target + id = tag.Object().TargetID case objecttype.TypeInvalid, objecttype.TypeBlob, objecttype.TypeFuture, diff --git a/object/tag/parse.go b/object/tag/parse.go index 92fa0d8b..2876ec6d 100644 --- a/object/tag/parse.go +++ b/object/tag/parse.go @@ -42,7 +42,7 @@ func Parse(body []byte, algo objectid.Algorithm) (*Tag, error) { return nil, fmt.Errorf("object: tag: object: %w", err) } - t.Target = id + t.TargetID = id haveTarget = true case "type": ty, ok := objecttype.Parse(string(value)) diff --git a/object/tag/parse_test.go b/object/tag/parse_test.go index 293350ed..18f38aaa 100644 --- a/object/tag/parse_test.go +++ b/object/tag/parse_test.go @@ -24,8 +24,8 @@ func TestTagParseFromGit(t *testing.T) { t.Fatalf("ParseTag: %v", err) } - if parsed.Target != commitID { - t.Fatalf("tag target mismatch: got %s want %s", parsed.Target, commitID) + if parsed.TargetID != commitID { + t.Fatalf("tag target mismatch: got %s want %s", parsed.TargetID, commitID) } if parsed.TargetType != objecttype.TypeCommit { diff --git a/object/tag/serialize.go b/object/tag/serialize.go index 43fad522..301984cc 100644 --- a/object/tag/serialize.go +++ b/object/tag/serialize.go @@ -11,12 +11,12 @@ import ( // BytesWithoutHeader renders the raw tag body bytes. func (tag *Tag) BytesWithoutHeader() ([]byte, error) { - if tag.Target.Algorithm().Size() == 0 { + if tag.TargetID.Algorithm().Size() == 0 { return nil, errors.New("object: tag: missing target id") } var buf bytes.Buffer - fmt.Fprintf(&buf, "object %s\n", tag.Target.String()) + fmt.Fprintf(&buf, "object %s\n", tag.TargetID.String()) tyName, ok := tag.TargetType.Name() if !ok { diff --git a/object/tag/tag.go b/object/tag/tag.go index e01f8ac9..4fcc88b0 100644 --- a/object/tag/tag.go +++ b/object/tag/tag.go @@ -16,7 +16,7 @@ import ( // // Labels: MT-Unsafe. type Tag struct { - Target objectid.ObjectID + TargetID objectid.ObjectID TargetType objecttype.Type Name []byte Tagger *objectsignature.Signature diff --git a/reachability/walk_expand_commits.go b/reachability/walk_expand_commits.go index eaeb4e72..c612ddf1 100644 --- a/reachability/walk_expand_commits.go +++ b/reachability/walk_expand_commits.go @@ -50,7 +50,7 @@ func (walk *Walk) expandCommits(item walkItem) ([]walkItem, error) { return nil, err } - return []walkItem{{id: tag.Object().Target, want: objecttype.TypeInvalid}}, nil + return []walkItem{{id: tag.Object().TargetID, want: objecttype.TypeInvalid}}, nil case objecttype.TypeTree, objecttype.TypeBlob, objecttype.TypeInvalid, objecttype.TypeFuture, objecttype.TypeOfsDelta, objecttype.TypeRefDelta: return nil, &errors.ObjectTypeError{OID: item.id, Got: ty, Want: objecttype.TypeCommit} diff --git a/reachability/walk_expand_objects.go b/reachability/walk_expand_objects.go index 8b479021..8f0e1d02 100644 --- a/reachability/walk_expand_objects.go +++ b/reachability/walk_expand_objects.go @@ -60,7 +60,7 @@ func (walk *Walk) expandObjects(item walkItem) ([]walkItem, error) { return nil, err } - return []walkItem{{id: tag.Object().Target, want: tag.Object().TargetType}}, nil + return []walkItem{{id: tag.Object().TargetID, want: tag.Object().TargetType}}, nil case objecttype.TypeInvalid, objecttype.TypeFuture, objecttype.TypeOfsDelta, objecttype.TypeRefDelta: return nil, &errors.ObjectTypeError{OID: item.id, Got: ty, Want: item.want} } diff --git a/repository/traversal_test.go b/repository/traversal_test.go index 99a8faaf..5f75eb5b 100644 --- a/repository/traversal_test.go +++ b/repository/traversal_test.go @@ -199,7 +199,7 @@ func traverseReachableIter(repo *repository.Repository, root objectid.ObjectID) stack = append(stack, entry.ID) } case *tag.Tag: - stack = append(stack, obj.Target) + stack = append(stack, obj.TargetID) case *blob.Blob: default: // Unknown parsed object variants are treated as leaves. -- cgit v1.3.1-10-gc9f91 From 5a441a6becbee3d114eb6245b8cd1830d3a8dbd7 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Wed, 20 May 2026 17:56:44 +0000 Subject: research: That note on object IDs is a bit confusing Just read security considerations instead. --- research/packfile_bloom.txt | 7 ------- 1 file changed, 7 deletions(-) diff --git a/research/packfile_bloom.txt b/research/packfile_bloom.txt index 6f7dccf2..e8f996cf 100644 --- a/research/packfile_bloom.txt +++ b/research/packfile_bloom.txt @@ -30,13 +30,6 @@ are as follows: 4. A lookup thus reads one 64-octet bucket and checks whether all required bits are set. -Note on Object IDs ------------------- - -Git object IDs are cryptographic hashes (e.g., currently either SHA-256 -or SHA-1), and are thus uniformly distributed in non-pathological scenarios. -See also the "Security considerations" section. - Definitions ----------- -- cgit v1.3.1-10-gc9f91 From 295e8ba5bbb09dd32b2dad1b9285c0032c4e299a Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Wed, 20 May 2026 18:02:16 +0000 Subject: research: Probably no XOR filters. --- research/packfile_bloom.txt | 2 -- 1 file changed, 2 deletions(-) diff --git a/research/packfile_bloom.txt b/research/packfile_bloom.txt index e8f996cf..63acafbe 100644 --- a/research/packfile_bloom.txt +++ b/research/packfile_bloom.txt @@ -131,5 +131,3 @@ TODOs * What are the sizes? * What are the false positive rates? * How are benchmarks? - -* Switch to XOR filters since those are immutable sets anyway. -- cgit v1.3.1-10-gc9f91 From b21910a94367434c5a923050d7f874df3b57406d Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Fri, 22 May 2026 16:04:59 +0000 Subject: object/store/packed: Delta cache should not need copying --- object/store/packed/internal/reading/delta_cache.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/object/store/packed/internal/reading/delta_cache.go b/object/store/packed/internal/reading/delta_cache.go index 4259eb81..04bd3ff3 100644 --- a/object/store/packed/internal/reading/delta_cache.go +++ b/object/store/packed/internal/reading/delta_cache.go @@ -44,14 +44,14 @@ func (cache *deltaCache) get(key deltaBaseKey) (objecttype.Type, []byte, bool) { return objecttype.TypeInvalid, nil, false } - return value.ty, append([]byte(nil), value.content...), true + return value.ty, value.content, true } // add stores a cloned base object value. func (cache *deltaCache) add(key deltaBaseKey, ty objecttype.Type, content []byte) { cache.lru.Add(key, deltaBaseValue{ ty: ty, - content: append([]byte(nil), content...), + content: content, }) } -- cgit v1.3.1-10-gc9f91 From 4e14637a5dae4d0bc91175e5e2f1411034a5a566 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Sun, 24 May 2026 08:21:42 +0000 Subject: README: Use the master branch's badge --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index dd435c95..4d50e665 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Furgit -[![builds.sr.ht status](https://builds.sr.ht/~runxiyu/furgit.svg)](https://builds.sr.ht/~runxiyu/furgit) +[![builds.sr.ht status](https://builds.sr.ht/~runxiyu/furgit/commits/master.svg)](https://builds.sr.ht/~runxiyu/furgit/commits/master) [![Go Reference](https://pkg.go.dev/badge/codeberg.org/lindenii/furgit.svg)](https://pkg.go.dev/codeberg.org/lindenii/furgit) Furgit is a low‐level Git library in Go. -- cgit v1.3.1-10-gc9f91 From 794aa2f848423e17a7a0540dc6a71960252fa721 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Sun, 24 May 2026 11:22:57 +0000 Subject: reachability: Fix documentation typo --- reachability/connected.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/reachability/connected.go b/reachability/connected.go index 655c40b9..692d8501 100644 --- a/reachability/connected.go +++ b/reachability/connected.go @@ -8,7 +8,7 @@ import objectid "codeberg.org/lindenii/furgit/object/id" // // With commit-graph acceleration available, // each visited commit is validated against the object store -// iff struct is set to true. +// iff strict is set to true. func (r *Reachability) CheckConnected(domain Domain, haves, wants map[objectid.ObjectID]struct{}, strict bool) error { walk := r.Walk(domain, haves, wants) -- cgit v1.3.1-10-gc9f91 From f0ca4fe7a2d6011600fd218ae185f20592573610 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Sun, 24 May 2026 11:29:15 +0000 Subject: README: Update --- README.md | 20 +++++--------------- 1 file changed, 5 insertions(+), 15 deletions(-) diff --git a/README.md b/README.md index 4d50e665..a61ccef0 100644 --- a/README.md +++ b/README.md @@ -3,23 +3,13 @@ [![builds.sr.ht status](https://builds.sr.ht/~runxiyu/furgit/commits/master.svg)](https://builds.sr.ht/~runxiyu/furgit/commits/master) [![Go Reference](https://pkg.go.dev/badge/codeberg.org/lindenii/furgit.svg)](https://pkg.go.dev/codeberg.org/lindenii/furgit) -Furgit is a low‐level Git library in Go. +A low‐level Git library in Go. ## Status * **A refactor is pending on the `next` branch.** -* Years or decades away from stable -* Absolutely no guarantees -* Do not use in production -* Mature alternative: [go-git](https://github.com/go-git/go-git) -* Will use [Semantic Versioning 2.0.0](https://semver.org/spec/v2.0.0.html) starting at 1.0.0 - -## Goals - -* General‐purpose Git plumbing library for UNIX‐like systems -* Aim for extremely clear and modular architecture -* Then aim for high performance -* Expect familiarity with Git internals +* Early development, not suitable for production. +* A mature alternative is [go-git](https://github.com/go-git/go-git). ## Community @@ -28,7 +18,7 @@ Furgit is a low‐level Git library in Go. * [#lindenii](https://web.libera.chat/#lindenii) on [Libera.Chat](https://libera.chat) -See the CONTRIBUTING document for bug reports and patch submissions. +See also `CONTRIBUTING.md`. ## Acknowledgements @@ -60,4 +50,4 @@ version for this Program. * [tangled mirror](https://tangled.org/@runxiyu.tngl.sh/furgit) * [GitHub mirror](https://github.com/runxiyu/furgit) * [git.runxiyu.org mirror](https://git.runxiyu.org/furgit.git//) - +* [cgit.space mirror](https://cgit.space/~runxiyu/furgit.git/) -- cgit v1.3.1-10-gc9f91 From 947bf81a33c6e4e5d21c8b36f9317fe00b84f6ae Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Sun, 24 May 2026 13:41:34 +0000 Subject: ref/store/memory: Simple memory-backed ref store --- TODO | 3 + ref/store/memory/batch.go | 195 +++++++++++++++++++ ref/store/memory/doc.go | 2 + ref/store/memory/read.go | 125 ++++++++++++ ref/store/memory/ref.go | 45 +++++ ref/store/memory/store.go | 42 +++++ ref/store/memory/store_test.go | 282 +++++++++++++++++++++++++++ ref/store/memory/transaction.go | 97 ++++++++++ ref/store/memory/update.go | 409 ++++++++++++++++++++++++++++++++++++++++ 9 files changed, 1200 insertions(+) create mode 100644 ref/store/memory/batch.go create mode 100644 ref/store/memory/doc.go create mode 100644 ref/store/memory/read.go create mode 100644 ref/store/memory/ref.go create mode 100644 ref/store/memory/store.go create mode 100644 ref/store/memory/store_test.go create mode 100644 ref/store/memory/transaction.go create mode 100644 ref/store/memory/update.go diff --git a/TODO b/TODO index 540b9055..567eac69 100644 --- a/TODO +++ b/TODO @@ -22,6 +22,9 @@ Missing operations that tangled needs Unstructured ones ================= +* See if the space-trimming behavior on symbolic ref storage is correct again +* Ref namespace yaks to shave + * Receive-pack hook shape redesign; separate post-ref and post-ingest hook types. * Completely redo error handling. diff --git a/ref/store/memory/batch.go b/ref/store/memory/batch.go new file mode 100644 index 00000000..df3d554d --- /dev/null +++ b/ref/store/memory/batch.go @@ -0,0 +1,195 @@ +package memory + +import ( + objectid "codeberg.org/lindenii/furgit/object/id" + refstore "codeberg.org/lindenii/furgit/ref/store" +) + +// Batch stages in-memory updates for one subset commit. +type Batch struct { + store *Store + ops []queuedUpdate +} + +var _ refstore.Batch = (*Batch)(nil) + +// BeginBatch creates one new in-memory batch. +// +//nolint:ireturn +func (store *Store) BeginBatch() (refstore.Batch, error) { + return &Batch{ + store: store, + ops: make([]queuedUpdate, 0, 8), + }, nil +} + +// Create queues a detached reference creation. +func (batch *Batch) Create(name string, newID objectid.ObjectID) error { + return batch.queue(queuedUpdate{name: name, kind: updateCreate, newID: newID}) +} + +// Update queues a detached reference update. +func (batch *Batch) Update(name string, newID, oldID objectid.ObjectID) error { + return batch.queue(queuedUpdate{name: name, kind: updateReplace, newID: newID, oldID: oldID}) +} + +// Delete queues a detached reference deletion. +func (batch *Batch) Delete(name string, oldID objectid.ObjectID) error { + return batch.queue(queuedUpdate{name: name, kind: updateDelete, oldID: oldID}) +} + +// Verify queues a detached reference verification. +func (batch *Batch) Verify(name string, oldID objectid.ObjectID) error { + return batch.queue(queuedUpdate{name: name, kind: updateVerify, oldID: oldID}) +} + +// CreateSymbolic queues a symbolic reference creation. +func (batch *Batch) CreateSymbolic(name, newTarget string) error { + return batch.queue(queuedUpdate{name: name, kind: updateCreateSymbolic, newTarget: newTarget}) +} + +// UpdateSymbolic queues a symbolic reference update. +func (batch *Batch) UpdateSymbolic(name, newTarget, oldTarget string) error { + return batch.queue(queuedUpdate{name: name, kind: updateReplaceSymbolic, newTarget: newTarget, oldTarget: oldTarget}) +} + +// DeleteSymbolic queues a symbolic reference deletion. +func (batch *Batch) DeleteSymbolic(name, oldTarget string) error { + return batch.queue(queuedUpdate{name: name, kind: updateDeleteSymbolic, oldTarget: oldTarget}) +} + +// VerifySymbolic queues a symbolic reference verification. +func (batch *Batch) VerifySymbolic(name, oldTarget string) error { + return batch.queue(queuedUpdate{name: name, kind: updateVerifySymbolic, oldTarget: oldTarget}) +} + +// Apply validates queued operations, +// drops rejected operations, +// and applies the remaining compatible set. +// Concurrent readers observe +// either the pre-Apply state +// or the post-Apply state. +func (batch *Batch) Apply() ([]refstore.BatchResult, error) { + results := make([]refstore.BatchResult, len(batch.ops)) + remainingIdx := make([]int, 0, len(batch.ops)) + remainingOps := make([]queuedUpdate, 0, len(batch.ops)) + seenTargets := make(map[string]struct{}, len(batch.ops)) + + batch.store.mu.Lock() + defer batch.store.mu.Unlock() + + for i, op := range batch.ops { + results[i].Name = op.name + + target, err := resolveQueuedUpdateTarget(batch.store.refs, op) + if err != nil { + if isBatchRejected(err) { + results[i].Status = refstore.BatchStatusRejected + results[i].Error = batchResultError(err) + + continue + } + + results[i].Status = refstore.BatchStatusFatal + results[i].Error = batchResultError(err) + + for j := i + 1; j < len(results); j++ { + results[j].Name = batch.ops[j].name + results[j].Status = refstore.BatchStatusNotAttempted + results[j].Error = batchResultError(err) + } + + return results, err + } + + if _, exists := seenTargets[target.name]; exists { + results[i].Status = refstore.BatchStatusRejected + results[i].Error = &refstore.DuplicateUpdateError{} + + continue + } + + seenTargets[target.name] = struct{}{} + + remainingIdx = append(remainingIdx, i) + remainingOps = append(remainingOps, op) + } + + for len(remainingOps) > 0 { + prepared, err := prepareUpdates(batch.store.refs, remainingOps) + if err == nil { + next := cloneRefs(batch.store.refs) + applyPreparedUpdates(next, prepared) + batch.store.refs = next + + for _, idx := range remainingIdx { + results[idx].Status = refstore.BatchStatusApplied + } + + return results, nil + } + + if !isBatchRejected(err) { + fatalName := batchResultName(err) + fatalMarked := false + + for i, idx := range remainingIdx { + if !fatalMarked && remainingOps[i].name == fatalName && fatalName != "" { + results[idx].Status = refstore.BatchStatusFatal + results[idx].Error = batchResultError(err) + fatalMarked = true + + continue + } + + results[idx].Status = refstore.BatchStatusNotAttempted + results[idx].Error = batchResultError(err) + } + + return results, err + } + + name := batchResultName(err) + rejectedAt := -1 + + for i, op := range remainingOps { + if op.name == name { + rejectedAt = i + + break + } + } + + if rejectedAt < 0 { + for _, idx := range remainingIdx { + results[idx].Status = refstore.BatchStatusNotAttempted + results[idx].Error = batchResultError(err) + } + + return results, err + } + + results[remainingIdx[rejectedAt]].Status = refstore.BatchStatusRejected + results[remainingIdx[rejectedAt]].Error = batchResultError(err) + remainingIdx = append(remainingIdx[:rejectedAt], remainingIdx[rejectedAt+1:]...) + remainingOps = append(remainingOps[:rejectedAt], remainingOps[rejectedAt+1:]...) + } + + return results, nil +} + +// Abort abandons the batch. +func (batch *Batch) Abort() error { + return nil +} + +func (batch *Batch) queue(op queuedUpdate) error { + err := validateQueuedUpdate(op) + if err != nil { + return err + } + + batch.ops = append(batch.ops, op) + + return nil +} diff --git a/ref/store/memory/doc.go b/ref/store/memory/doc.go new file mode 100644 index 00000000..3a2072a0 --- /dev/null +++ b/ref/store/memory/doc.go @@ -0,0 +1,2 @@ +// Package memory provides an in-memory reference store. +package memory diff --git a/ref/store/memory/read.go b/ref/store/memory/read.go new file mode 100644 index 00000000..5f8095bb --- /dev/null +++ b/ref/store/memory/read.go @@ -0,0 +1,125 @@ +package memory + +import ( + "fmt" + "path" + "slices" + "strings" + + "codeberg.org/lindenii/furgit/ref" + refstore "codeberg.org/lindenii/furgit/ref/store" +) + +// Resolve resolves one reference name +// from the in-memory namespace. +func (store *Store) Resolve(name string) (ref.Ref, error) { //nolint:ireturn + store.mu.RLock() + defer store.mu.RUnlock() + + return publicRef(name, store.refs[name]) +} + +// ResolveToDetached resolves symbolic references +// through the in-memory namespace +// until one detached reference is reached. +func (store *Store) ResolveToDetached(name string) (ref.Detached, error) { + store.mu.RLock() + defer store.mu.RUnlock() + + return store.resolveToDetachedLocked(name) +} + +// List lists references from the in-memory namespace. +func (store *Store) List(pattern string) ([]ref.Ref, error) { + matchAll := pattern == "" + if !matchAll { + _, err := path.Match(pattern, "HEAD") + if err != nil { + return nil, err + } + } + + store.mu.RLock() + defer store.mu.RUnlock() + + names := make([]string, 0, len(store.refs)) + for name := range store.refs { + if !matchAll { + matched, err := path.Match(pattern, name) + if err != nil { + return nil, err + } + + if !matched { + continue + } + } + + names = append(names, name) + } + + slices.Sort(names) + + refs := make([]ref.Ref, 0, len(names)) + for _, name := range names { + resolved, err := publicRef(name, store.refs[name]) + if err != nil { + return nil, err + } + + refs = append(refs, resolved) + } + + return refs, nil +} + +func (store *Store) resolveToDetachedLocked(name string) (ref.Detached, error) { + cur := name + seen := make(map[string]struct{}) + + for { + if _, ok := seen[cur]; ok { + return ref.Detached{}, fmt.Errorf("refstore/memory: symbolic reference cycle at %q", cur) + } + + seen[cur] = struct{}{} + + resolved, err := publicRef(cur, store.refs[cur]) + if err != nil { + return ref.Detached{}, err + } + + switch resolved := resolved.(type) { + case ref.Detached: + return resolved, nil + case ref.Symbolic: + target := strings.TrimSpace(resolved.Target) + if target == "" { + return ref.Detached{}, fmt.Errorf("refstore/memory: symbolic reference %q has empty target", resolved.Name()) + } + + cur = target + default: + return ref.Detached{}, fmt.Errorf("refstore/memory: unsupported reference type %T", resolved) + } + } +} + +func publicRef(name string, stored storedRef) (ref.Ref, error) { //nolint:ireturn + switch stored.kind { + case storedDetached: + detached := ref.Detached{RefName: name, ID: stored.id} + if stored.peeled != nil { + peeled := *stored.peeled + detached.Peeled = &peeled + } + + return detached, nil + case storedSymbolic: + return ref.Symbolic{RefName: name, Target: stored.target}, nil + case storedMissing: + return nil, refstore.ErrReferenceNotFound + default: + return nil, fmt.Errorf("refstore/memory: unsupported stored reference kind %d", stored.kind) + } +} diff --git a/ref/store/memory/ref.go b/ref/store/memory/ref.go new file mode 100644 index 00000000..67d9268f --- /dev/null +++ b/ref/store/memory/ref.go @@ -0,0 +1,45 @@ +package memory + +import objectid "codeberg.org/lindenii/furgit/object/id" + +// Because the public one includes the ref's name/identity. + +type storedKind uint8 + +const ( + storedMissing storedKind = iota + storedDetached + storedSymbolic +) + +// Missing is obviously not the best design +// but it does make it easier to operate on internally. +// Might make a tagged union wrapper, though... +// Or might just make a wrapper struct that has an "ok" bool. + +type storedRef struct { + kind storedKind + id objectid.ObjectID + target string + peeled *objectid.ObjectID +} + +func cloneStoredRef(stored storedRef) storedRef { + if stored.peeled == nil { + return stored + } + + peeled := *stored.peeled + stored.peeled = &peeled + + return stored +} + +func cloneRefs(refs map[string]storedRef) map[string]storedRef { + cloned := make(map[string]storedRef, len(refs)) + for name, stored := range refs { + cloned[name] = cloneStoredRef(stored) + } + + return cloned +} diff --git a/ref/store/memory/store.go b/ref/store/memory/store.go new file mode 100644 index 00000000..d77f72e2 --- /dev/null +++ b/ref/store/memory/store.go @@ -0,0 +1,42 @@ +package memory + +import ( + "sync" + + objectid "codeberg.org/lindenii/furgit/object/id" + refstore "codeberg.org/lindenii/furgit/ref/store" +) + +// Store reads and writes one in-memory Git reference namespace. +// +// Labels: Close-Caller. +type Store struct { + mu sync.RWMutex + algo objectid.Algorithm + refs map[string]storedRef +} + +var ( + _ refstore.Reader = (*Store)(nil) + _ refstore.Transactioner = (*Store)(nil) + _ refstore.Batcher = (*Store)(nil) +) + +// New builds one empty in-memory reference store for one object format. +func New(algo objectid.Algorithm) (*Store, error) { + if algo.Size() == 0 { + return nil, objectid.ErrInvalidAlgorithm + } + + return &Store{ + algo: algo, + refs: make(map[string]storedRef), + }, nil +} + +// Close closes the in-memory reference store. +// +// Labels: MT-Unsafe. +func (store *Store) Close() error { + return nil +} diff --git a/ref/store/memory/store_test.go b/ref/store/memory/store_test.go new file mode 100644 index 00000000..d8735805 --- /dev/null +++ b/ref/store/memory/store_test.go @@ -0,0 +1,282 @@ +package memory_test + +import ( + "errors" + "testing" + + "codeberg.org/lindenii/furgit/internal/testgit" + objectid "codeberg.org/lindenii/furgit/object/id" + "codeberg.org/lindenii/furgit/ref" + refstore "codeberg.org/lindenii/furgit/ref/store" + "codeberg.org/lindenii/furgit/ref/store/memory" +) + +// Unlike the public ResolveToDetached, +// this one does not resolve symbolic refs. +func resolveDetached(t *testing.T, store *memory.Store, name string) ref.Detached { + t.Helper() + + resolved, err := store.Resolve(name) + if err != nil { + t.Fatalf("Resolve(%q): %v", name, err) + } + + detached, ok := resolved.(ref.Detached) + if !ok { + t.Fatalf("Resolve(%q) = %T, want ref.Detached", name, resolved) + } + + return detached +} + +func TestReadListAndResolveSymbolic(t *testing.T) { + t.Parallel() + + //nolint:thelper + testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { + t.Parallel() + + store, err := memory.New(algo) + if err != nil { + t.Fatalf("memory.New: %v", err) + } + + mainID := algo.Sum([]byte("main")) + tx, err := store.BeginTransaction() + if err != nil { + t.Fatalf("BeginTransaction: %v", err) + } + + err = tx.Create("refs/heads/main", mainID) + if err != nil { + t.Fatalf("Create(main): %v", err) + } + + err = tx.CreateSymbolic("HEAD", "refs/heads/main") + if err != nil { + t.Fatalf("CreateSymbolic(HEAD): %v", err) + } + + err = tx.Commit() + if err != nil { + t.Fatalf("Commit seed refs: %v", err) + } + + head, err := store.Resolve("HEAD") + if err != nil { + t.Fatalf("Resolve(HEAD): %v", err) + } + + symbolic, ok := head.(ref.Symbolic) + if !ok { + t.Fatalf("Resolve(HEAD) = %T, want ref.Symbolic", head) + } + + if symbolic.Target != "refs/heads/main" { + t.Fatalf("HEAD target = %q, want refs/heads/main", symbolic.Target) + } + + detached, err := store.ResolveToDetached("HEAD") + if err != nil { + t.Fatalf("ResolveToDetached(HEAD): %v", err) + } + + if detached.ID != mainID { + t.Fatalf("ResolveToDetached(HEAD) ID = %v, want %v", detached.ID, mainID) + } + + listed, err := store.List("") + if err != nil { + t.Fatalf("List: %v", err) + } + + if len(listed) != 2 || listed[0].Name() != "HEAD" || listed[1].Name() != "refs/heads/main" { + t.Fatalf("List names = %v, want [HEAD refs/heads/main]", listed) + } + }) +} + +func TestTransactionRejectLeavesStoreUnchanged(t *testing.T) { + t.Parallel() + + //nolint:thelper + testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { + t.Parallel() + + store, err := memory.New(algo) + if err != nil { + t.Fatalf("memory.New: %v", err) + } + + mainID := algo.Sum([]byte("main")) + devID := algo.Sum([]byte("dev")) + nextID := algo.Sum([]byte("next")) + wrongOld := algo.Sum([]byte("wrong")) + + tx, err := store.BeginTransaction() + if err != nil { + t.Fatalf("BeginTransaction: %v", err) + } + + err = tx.Create("refs/heads/main", mainID) + if err != nil { + t.Fatalf("Create(main): %v", err) + } + + err = tx.Create("refs/heads/dev", devID) + if err != nil { + t.Fatalf("Create(dev): %v", err) + } + + err = tx.Commit() + if err != nil { + t.Fatalf("Commit seed refs: %v", err) + } + + tx, err = store.BeginTransaction() + if err != nil { + t.Fatalf("BeginTransaction: %v", err) + } + + err = tx.Update("refs/heads/main", nextID, mainID) + if err != nil { + t.Fatalf("Update(main): %v", err) + } + + err = tx.Update("refs/heads/dev", nextID, wrongOld) + if err != nil { + t.Fatalf("Update(dev): %v", err) + } + + err = tx.Commit() + if err == nil { + t.Fatalf("Commit succeeded, want incorrect old value error") + } + + var oldValueErr *refstore.IncorrectOldValueError + if !errors.As(err, &oldValueErr) { + t.Fatalf("Commit error = %T %v, want IncorrectOldValueError", err, err) + } + + if got := resolveDetached(t, store, "refs/heads/main").ID; got != mainID { + t.Fatalf("main after rejected transaction = %v, want %v", got, mainID) + } + + if got := resolveDetached(t, store, "refs/heads/dev").ID; got != devID { + t.Fatalf("dev after rejected transaction = %v, want %v", got, devID) + } + }) +} + +func TestBatchRejectsDuplicateResolvedTargetAndAppliesRemainder(t *testing.T) { + t.Parallel() + + //nolint:thelper + testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { + t.Parallel() + + store, err := memory.New(algo) + if err != nil { + t.Fatalf("memory.New: %v", err) + } + + mainID := algo.Sum([]byte("main")) + devID := algo.Sum([]byte("dev")) + nextMainID := algo.Sum([]byte("next-main")) + nextDevID := algo.Sum([]byte("next-dev")) + aliasID := algo.Sum([]byte("alias")) + + tx, err := store.BeginTransaction() + if err != nil { + t.Fatalf("BeginTransaction: %v", err) + } + + err = tx.Create("refs/heads/main", mainID) + if err != nil { + t.Fatalf("Create(main): %v", err) + } + + err = tx.Create("refs/heads/dev", devID) + if err != nil { + t.Fatalf("Create(dev): %v", err) + } + + err = tx.CreateSymbolic("refs/heads/alias", "refs/heads/main") + if err != nil { + t.Fatalf("CreateSymbolic(alias): %v", err) + } + + err = tx.Commit() + if err != nil { + t.Fatalf("Commit seed refs: %v", err) + } + + batch, err := store.BeginBatch() + if err != nil { + t.Fatalf("BeginBatch: %v", err) + } + + err = batch.Update("refs/heads/main", nextMainID, mainID) + if err != nil { + t.Fatalf("Update(main): %v", err) + } + + err = batch.Update("refs/heads/alias", aliasID, mainID) + if err != nil { + t.Fatalf("Update(alias): %v", err) + } + + err = batch.Update("refs/heads/dev", nextDevID, devID) + if err != nil { + t.Fatalf("Update(dev): %v", err) + } + + results, err := batch.Apply() + if err != nil { + t.Fatalf("Apply: %v", err) + } + + if len(results) != 3 { + t.Fatalf("len(results) = %d, want 3", len(results)) + } + + if results[0].Status != refstore.BatchStatusApplied { + t.Fatalf("results[0].Status = %v, want applied", results[0].Status) + } + + if results[1].Status != refstore.BatchStatusRejected { + t.Fatalf("results[1].Status = %v, want rejected", results[1].Status) + } + + var duplicateErr *refstore.DuplicateUpdateError + if !errors.As(results[1].Error, &duplicateErr) { + t.Fatalf("results[1].Error = %T %v, want DuplicateUpdateError", results[1].Error, results[1].Error) + } + + if results[2].Status != refstore.BatchStatusApplied { + t.Fatalf("results[2].Status = %v, want applied", results[2].Status) + } + + if got := resolveDetached(t, store, "refs/heads/main").ID; got != nextMainID { + t.Fatalf("main after batch = %v, want %v", got, nextMainID) + } + + if got := resolveDetached(t, store, "refs/heads/dev").ID; got != nextDevID { + t.Fatalf("dev after batch = %v, want %v", got, nextDevID) + } + + resolved, err := store.Resolve("refs/heads/alias") + if err != nil { + t.Fatalf("Resolve(alias): %v", err) + } + + symbolic, ok := resolved.(ref.Symbolic) + if !ok { + t.Fatalf("Resolve(alias) = %T, want ref.Symbolic", resolved) + } + + if symbolic.Target != "refs/heads/main" { + t.Fatalf("alias target = %q, want refs/heads/main", symbolic.Target) + } + }) +} diff --git a/ref/store/memory/transaction.go b/ref/store/memory/transaction.go new file mode 100644 index 00000000..81ae01ef --- /dev/null +++ b/ref/store/memory/transaction.go @@ -0,0 +1,97 @@ +package memory + +import ( + objectid "codeberg.org/lindenii/furgit/object/id" + refstore "codeberg.org/lindenii/furgit/ref/store" +) + +// Transaction stages in-memory updates for one atomic commit. +type Transaction struct { + store *Store + ops []queuedUpdate +} + +var _ refstore.Transaction = (*Transaction)(nil) + +// BeginTransaction creates one new in-memory transaction. +// +//nolint:ireturn +func (store *Store) BeginTransaction() (refstore.Transaction, error) { + return &Transaction{ + store: store, + ops: make([]queuedUpdate, 0, 8), + }, nil +} + +// Create queues a detached reference creation. +func (tx *Transaction) Create(name string, newID objectid.ObjectID) error { + return tx.queue(queuedUpdate{name: name, kind: updateCreate, newID: newID}) +} + +// Update queues a detached reference update. +func (tx *Transaction) Update(name string, newID, oldID objectid.ObjectID) error { + return tx.queue(queuedUpdate{name: name, kind: updateReplace, newID: newID, oldID: oldID}) +} + +// Delete queues a detached reference deletion. +func (tx *Transaction) Delete(name string, oldID objectid.ObjectID) error { + return tx.queue(queuedUpdate{name: name, kind: updateDelete, oldID: oldID}) +} + +// Verify queues a detached reference verification. +func (tx *Transaction) Verify(name string, oldID objectid.ObjectID) error { + return tx.queue(queuedUpdate{name: name, kind: updateVerify, oldID: oldID}) +} + +// CreateSymbolic queues a symbolic reference creation. +func (tx *Transaction) CreateSymbolic(name, newTarget string) error { + return tx.queue(queuedUpdate{name: name, kind: updateCreateSymbolic, newTarget: newTarget}) +} + +// UpdateSymbolic queues a symbolic reference update. +func (tx *Transaction) UpdateSymbolic(name, newTarget, oldTarget string) error { + return tx.queue(queuedUpdate{name: name, kind: updateReplaceSymbolic, newTarget: newTarget, oldTarget: oldTarget}) +} + +// DeleteSymbolic queues a symbolic reference deletion. +func (tx *Transaction) DeleteSymbolic(name, oldTarget string) error { + return tx.queue(queuedUpdate{name: name, kind: updateDeleteSymbolic, oldTarget: oldTarget}) +} + +// VerifySymbolic queues a symbolic reference verification. +func (tx *Transaction) VerifySymbolic(name, oldTarget string) error { + return tx.queue(queuedUpdate{name: name, kind: updateVerifySymbolic, oldTarget: oldTarget}) +} + +// Commit validates and applies the queued updates atomically. +func (tx *Transaction) Commit() error { + tx.store.mu.Lock() + defer tx.store.mu.Unlock() + + prepared, err := prepareUpdates(tx.store.refs, tx.ops) + if err != nil { + return err + } + + next := cloneRefs(tx.store.refs) + applyPreparedUpdates(next, prepared) + tx.store.refs = next + + return nil +} + +// Abort abandons the transaction. +func (tx *Transaction) Abort() error { + return nil +} + +func (tx *Transaction) queue(op queuedUpdate) error { + err := validateQueuedUpdate(op) + if err != nil { + return err + } + + tx.ops = append(tx.ops, op) + + return nil +} diff --git a/ref/store/memory/update.go b/ref/store/memory/update.go new file mode 100644 index 00000000..78a7ca2d --- /dev/null +++ b/ref/store/memory/update.go @@ -0,0 +1,409 @@ +package memory + +import ( + "errors" + "fmt" + "strings" + + objectid "codeberg.org/lindenii/furgit/object/id" + refname "codeberg.org/lindenii/furgit/ref/name" + refstore "codeberg.org/lindenii/furgit/ref/store" +) + +type updateKind uint8 + +const ( + updateCreate updateKind = iota + updateReplace + updateDelete + updateVerify + updateCreateSymbolic + updateReplaceSymbolic + updateDeleteSymbolic + updateVerifySymbolic +) + +type queuedUpdate struct { + name string + kind updateKind + newID objectid.ObjectID + oldID objectid.ObjectID + newTarget string + oldTarget string +} + +type resolvedUpdateTarget struct { + name string + ref storedRef +} + +type preparedUpdate struct { + op queuedUpdate + target resolvedUpdateTarget +} + +type updateContextError struct { + name string + err error +} + +func (err *updateContextError) Error() string { + return fmt.Sprintf("refstore/memory: update %q: %v", err.name, err.err) +} + +func (err *updateContextError) Unwrap() error { + if err == nil { + return nil + } + + return err.err +} + +func wrapUpdateError(name string, err error) error { + if err == nil || name == "" { + return err + } + + return &updateContextError{name: name, err: err} +} + +func validateQueuedUpdate(op queuedUpdate) error { + if op.name == "" { + return wrapUpdateError(op.name, &refstore.InvalidNameError{Err: fmt.Errorf("empty reference name")}) + } + + switch op.kind { + case updateCreate, updateReplace: + err := refname.ValidateUpdateName(op.name, true) + if err != nil { + return wrapUpdateError(op.name, &refstore.InvalidNameError{Err: err}) + } + + if op.newID.Algorithm().Size() == 0 { + return wrapUpdateError(op.name, &refstore.InvalidValueError{Err: objectid.ErrInvalidAlgorithm}) + } + case updateDelete, updateVerify: + err := refname.ValidateUpdateName(op.name, false) + if err != nil { + return wrapUpdateError(op.name, &refstore.InvalidNameError{Err: err}) + } + + if op.oldID.Algorithm().Size() == 0 { + return wrapUpdateError(op.name, &refstore.InvalidValueError{Err: objectid.ErrInvalidAlgorithm}) + } + case updateCreateSymbolic, updateReplaceSymbolic: + err := refname.ValidateUpdateName(op.name, true) + if err != nil { + return wrapUpdateError(op.name, &refstore.InvalidNameError{Err: err}) + } + + if strings.TrimSpace(op.newTarget) == "" { + return wrapUpdateError(op.name, &refstore.InvalidValueError{Err: fmt.Errorf("empty symbolic target")}) + } + + err = refname.ValidateSymbolicTarget(op.name, strings.TrimSpace(op.newTarget)) + if err != nil { + return wrapUpdateError(op.name, &refstore.InvalidValueError{Err: err}) + } + case updateDeleteSymbolic, updateVerifySymbolic: + err := refname.ValidateUpdateName(op.name, false) + if err != nil { + return wrapUpdateError(op.name, &refstore.InvalidNameError{Err: err}) + } + default: + return fmt.Errorf("refstore/memory: unsupported update operation %d", op.kind) + } + + if op.kind == updateReplaceSymbolic || op.kind == updateDeleteSymbolic || op.kind == updateVerifySymbolic { + if strings.TrimSpace(op.oldTarget) == "" { + return wrapUpdateError(op.name, &refstore.InvalidValueError{Err: fmt.Errorf("empty symbolic old target")}) + } + } + + return nil +} + +func prepareUpdates(refs map[string]storedRef, ops []queuedUpdate) ([]preparedUpdate, error) { + prepared, err := resolvePreparedUpdates(refs, ops) + if err != nil { + return prepared, err + } + + deleted, written := collectPreparedWrites(prepared) + existing := collectVisibleNames(refs) + + for _, name := range written { + err = verifyRefnameAvailable(name, existing, written, deleted) + if err != nil { + return prepared, err + } + } + + err = verifyPreparedUpdates(refs, prepared) + if err != nil { + return prepared, err + } + + return prepared, nil +} + +func resolvePreparedUpdates(refs map[string]storedRef, ops []queuedUpdate) ([]preparedUpdate, error) { + prepared := make([]preparedUpdate, 0, len(ops)) + targets := make(map[string]struct{}, len(ops)) + + for _, op := range ops { + target, err := resolveQueuedUpdateTarget(refs, op) + if err != nil { + return prepared, err + } + + if _, exists := targets[target.name]; exists { + return prepared, wrapUpdateError(op.name, &refstore.DuplicateUpdateError{}) + } + + targets[target.name] = struct{}{} + prepared = append(prepared, preparedUpdate{op: op, target: target}) + } + + return prepared, nil +} + +func resolveQueuedUpdateTarget(refs map[string]storedRef, op queuedUpdate) (resolvedUpdateTarget, error) { + switch op.kind { + case updateCreate: + return resolveOrdinaryTarget(refs, op.name, true) + case updateReplace, updateDelete, updateVerify: + return resolveOrdinaryTarget(refs, op.name, false) + case updateCreateSymbolic, updateReplaceSymbolic, updateDeleteSymbolic, updateVerifySymbolic: + return resolvedUpdateTarget{name: op.name, ref: directRead(refs, op.name)}, nil + default: + return resolvedUpdateTarget{}, fmt.Errorf("refstore/memory: unsupported update operation %d", op.kind) + } +} + +func resolveOrdinaryTarget(refs map[string]storedRef, name string, allowMissing bool) (resolvedUpdateTarget, error) { + cur := name + seen := make(map[string]struct{}) + + for { + if _, ok := seen[cur]; ok { + return resolvedUpdateTarget{}, fmt.Errorf("refstore/memory: symbolic reference cycle at %q", cur) + } + + seen[cur] = struct{}{} + + refState := directRead(refs, cur) + switch refState.kind { + case storedMissing: + if !allowMissing { + return resolvedUpdateTarget{}, wrapUpdateError(name, refstore.ErrReferenceNotFound) + } + + return resolvedUpdateTarget{name: cur, ref: refState}, nil + case storedDetached: + return resolvedUpdateTarget{name: cur, ref: refState}, nil + case storedSymbolic: + target := strings.TrimSpace(refState.target) + if target == "" { + return resolvedUpdateTarget{}, wrapUpdateError(name, &refstore.InvalidValueError{ + Err: fmt.Errorf("symbolic reference has empty target"), + }) + } + + cur = target + default: + return resolvedUpdateTarget{}, fmt.Errorf("refstore/memory: unsupported stored reference kind %d", refState.kind) + } + } +} + +func directRead(refs map[string]storedRef, name string) storedRef { + stored, ok := refs[name] + if !ok { + return storedRef{kind: storedMissing} + } + + return cloneStoredRef(stored) +} + +func collectPreparedWrites(prepared []preparedUpdate) (deleted map[string]struct{}, written []string) { + deleted = make(map[string]struct{}) + written = make([]string, 0, len(prepared)) + + for _, item := range prepared { + switch item.op.kind { + case updateDelete, updateDeleteSymbolic: + deleted[item.target.name] = struct{}{} + case updateCreate, updateReplace, updateCreateSymbolic, updateReplaceSymbolic: + written = append(written, item.target.name) + case updateVerify, updateVerifySymbolic: + } + } + + return deleted, written +} + +func collectVisibleNames(refs map[string]storedRef) map[string]struct{} { + names := make(map[string]struct{}, len(refs)) + for name := range refs { + names[name] = struct{}{} + } + + return names +} + +func verifyRefnameAvailable(name string, existing map[string]struct{}, writes []string, deleted map[string]struct{}) error { + for existingName := range existing { + if existingName == name { + continue + } + + if _, skip := deleted[existingName]; skip { + continue + } + + if refnamesConflict(name, existingName) { + return wrapUpdateError(name, &refstore.NameConflictError{Other: existingName}) + } + } + + for _, other := range writes { + if other == name { + continue + } + + if refnamesConflict(name, other) { + return wrapUpdateError(name, &refstore.NameConflictError{Other: other}) + } + } + + return nil +} + +func refnamesConflict(left, right string) bool { + return left == right || + strings.HasPrefix(left, right+"/") || + strings.HasPrefix(right, left+"/") +} + +func verifyPreparedUpdates(refs map[string]storedRef, prepared []preparedUpdate) error { + for i := range prepared { + item := &prepared[i] + item.target.ref = directRead(refs, item.target.name) + + err := verifyPreparedUpdateCurrent(*item) + if err != nil { + return err + } + } + + return nil +} + +func verifyPreparedUpdateCurrent(item preparedUpdate) error { + switch item.op.kind { + case updateCreate: + if item.target.ref.kind != storedMissing { + return wrapUpdateError(item.op.name, &refstore.CreateExistsError{}) + } + + return nil + case updateReplace, updateDelete, updateVerify: + if item.target.ref.kind == storedMissing { + return wrapUpdateError(item.op.name, refstore.ErrReferenceNotFound) + } + + if item.target.ref.kind != storedDetached { + return wrapUpdateError(item.op.name, &refstore.ExpectedDetachedError{}) + } + + if item.target.ref.id != item.op.oldID { + return wrapUpdateError(item.op.name, &refstore.IncorrectOldValueError{ + Actual: item.target.ref.id.String(), + Expected: item.op.oldID.String(), + }) + } + + return nil + case updateCreateSymbolic: + if item.target.ref.kind != storedMissing { + return wrapUpdateError(item.op.name, &refstore.CreateExistsError{}) + } + + return nil + case updateReplaceSymbolic, updateDeleteSymbolic, updateVerifySymbolic: + if item.target.ref.kind == storedMissing { + return wrapUpdateError(item.op.name, refstore.ErrReferenceNotFound) + } + + if item.target.ref.kind != storedSymbolic { + return wrapUpdateError(item.op.name, &refstore.ExpectedSymbolicError{}) + } + + if strings.TrimSpace(item.target.ref.target) != strings.TrimSpace(item.op.oldTarget) { + return wrapUpdateError(item.op.name, &refstore.IncorrectOldValueError{ + Actual: strings.TrimSpace(item.target.ref.target), + Expected: strings.TrimSpace(item.op.oldTarget), + }) + } + + return nil + } + + return nil +} + +func applyPreparedUpdates(refs map[string]storedRef, prepared []preparedUpdate) { + for _, item := range prepared { + switch item.op.kind { + case updateCreate, updateReplace: + refs[item.target.name] = storedRef{kind: storedDetached, id: item.op.newID} + case updateCreateSymbolic, updateReplaceSymbolic: + refs[item.target.name] = storedRef{kind: storedSymbolic, target: strings.TrimSpace(item.op.newTarget)} + case updateDelete, updateDeleteSymbolic: + delete(refs, item.target.name) + case updateVerify, updateVerifySymbolic: + } + } +} + +func isBatchRejected(err error) bool { + _, invalidName := errors.AsType[*refstore.InvalidNameError](err) + _, invalidValue := errors.AsType[*refstore.InvalidValueError](err) + _, duplicateUpdate := errors.AsType[*refstore.DuplicateUpdateError](err) + _, createExists := errors.AsType[*refstore.CreateExistsError](err) + _, incorrectOldValue := errors.AsType[*refstore.IncorrectOldValueError](err) + _, expectedDetached := errors.AsType[*refstore.ExpectedDetachedError](err) + _, expectedSymbolic := errors.AsType[*refstore.ExpectedSymbolicError](err) + _, nameConflict := errors.AsType[*refstore.NameConflictError](err) + + return errors.Is(err, refstore.ErrReferenceNotFound) || + invalidName || + invalidValue || + duplicateUpdate || + createExists || + incorrectOldValue || + expectedDetached || + expectedSymbolic || + nameConflict +} + +func batchResultError(err error) error { + updateErr, ok := errors.AsType[*updateContextError](err) + if ok { + return updateErr.err + } + + return err +} + +func batchResultName(err error) string { + updateErr, ok := errors.AsType[*updateContextError](err) + if !ok { + return "" + } + + return updateErr.name +} + +// TODO: these really shouldn't be used in the batched path, really... -- cgit v1.3.1-10-gc9f91 From b6915fbdb1c4343b91be29dabf1bc8861c506e27 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Mon, 25 May 2026 04:52:46 +0000 Subject: ref/store/memory: Fix whitespace --- ref/store/memory/store_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/ref/store/memory/store_test.go b/ref/store/memory/store_test.go index d8735805..b9705770 100644 --- a/ref/store/memory/store_test.go +++ b/ref/store/memory/store_test.go @@ -42,6 +42,7 @@ func TestReadListAndResolveSymbolic(t *testing.T) { } mainID := algo.Sum([]byte("main")) + tx, err := store.BeginTransaction() if err != nil { t.Fatalf("BeginTransaction: %v", err) -- cgit v1.3.1-10-gc9f91 From 82b5a3b23d42013c45b0bf77d04b8c77fe342f4a Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Wed, 27 May 2026 03:46:41 +0000 Subject: repository: Object->&Store, Refs->RefStore --- cmd/receivepack9418/conn.go | 4 +- cmd/show-object/resolve.go | 2 +- internal/testgit/repo_open_object_store.go | 2 +- network/receivepack/int_test.go | 96 +++++++++++----------- object/fetch/treefs_test.go | 2 +- object/store/packed/internal/ingest/ingest_test.go | 2 +- repository/objects.go | 6 +- repository/refs.go | 8 +- repository/refs_test.go | 8 +- repository/traversal_test.go | 2 +- repository/write_loose_test.go | 12 +-- 11 files changed, 72 insertions(+), 72 deletions(-) diff --git a/cmd/receivepack9418/conn.go b/cmd/receivepack9418/conn.go index 755cf022..008a8a45 100644 --- a/cmd/receivepack9418/conn.go +++ b/cmd/receivepack9418/conn.go @@ -57,8 +57,8 @@ func (srv *server) handleConn(conn net.Conn) { opts := receivepack.Options{ GitProtocol: gitProtocol, Algorithm: srv.repo.Algorithm(), - Refs: srv.repo.Refs(), - ExistingObjects: srv.repo.Objects(), + Refs: srv.repo.RefStore(), + ExistingObjects: srv.repo.ObjectStore(), ObjectIngress: objectIngress, } diff --git a/cmd/show-object/resolve.go b/cmd/show-object/resolve.go index eaf2c102..22afe70c 100644 --- a/cmd/show-object/resolve.go +++ b/cmd/show-object/resolve.go @@ -13,7 +13,7 @@ func resolveInput(repo *repository.Repository, input string) (objectid.ObjectID, return id, nil } - resolved, err := repo.Refs().ResolveToDetached(input) + resolved, err := repo.RefStore().ResolveToDetached(input) if err != nil { return objectid.ObjectID{}, err } diff --git a/internal/testgit/repo_open_object_store.go b/internal/testgit/repo_open_object_store.go index 42dc370c..256ee54a 100644 --- a/internal/testgit/repo_open_object_store.go +++ b/internal/testgit/repo_open_object_store.go @@ -25,5 +25,5 @@ func (testRepo *TestRepo) OpenObjectStore(tb testing.TB) objectstore.Reader { _ = repo.Close() }) - return repo.Objects() + return repo.ObjectStore() } diff --git a/network/receivepack/int_test.go b/network/receivepack/int_test.go index 352bbe7b..2440f9c8 100644 --- a/network/receivepack/int_test.go +++ b/network/receivepack/int_test.go @@ -47,8 +47,8 @@ func TestReceivePackDeleteOnlyAtomicDeleteSucceeds(t *testing.T) { err := receivepack.ReceivePack(context.Background(), &output, strings.NewReader(input.String()), receivepack.Options{ GitProtocol: "", Algorithm: algo, - Refs: repo.Refs(), - ExistingObjects: repo.Objects(), + Refs: repo.RefStore(), + ExistingObjects: repo.ObjectStore(), }) if err != nil { t.Fatalf("ReceivePack: %v", err) @@ -59,7 +59,7 @@ func TestReceivePackDeleteOnlyAtomicDeleteSucceeds(t *testing.T) { t.Fatalf("unexpected receive-pack output %q", got) } - _, err = repo.Refs().Resolve("refs/heads/main") + _, err = repo.RefStore().Resolve("refs/heads/main") if err == nil { t.Fatal("refs/heads/main still exists after delete push") } @@ -97,8 +97,8 @@ func TestReceivePackDeleteOnlyNonAtomicAppliesIndependentDeletes(t *testing.T) { err := receivepack.ReceivePack(context.Background(), &output, strings.NewReader(input.String()), receivepack.Options{ GitProtocol: "", Algorithm: algo, - Refs: repo.Refs(), - ExistingObjects: repo.Objects(), + Refs: repo.RefStore(), + ExistingObjects: repo.ObjectStore(), }) if err != nil { t.Fatalf("ReceivePack: %v", err) @@ -109,12 +109,12 @@ func TestReceivePackDeleteOnlyNonAtomicAppliesIndependentDeletes(t *testing.T) { t.Fatalf("unexpected receive-pack output %q", got) } - _, err = repo.Refs().Resolve("refs/heads/main") + _, err = repo.RefStore().Resolve("refs/heads/main") if err != nil { t.Fatalf("Resolve(main): %v", err) } - _, err = repo.Refs().Resolve("refs/heads/topic") + _, err = repo.RefStore().Resolve("refs/heads/topic") if err == nil { t.Fatal("refs/heads/topic still exists after successful delete") } @@ -152,8 +152,8 @@ func TestReceivePackDeleteOnlyAtomicFailureLeavesAllRefsUntouched(t *testing.T) err := receivepack.ReceivePack(context.Background(), &output, strings.NewReader(input.String()), receivepack.Options{ GitProtocol: "", Algorithm: algo, - Refs: repo.Refs(), - ExistingObjects: repo.Objects(), + Refs: repo.RefStore(), + ExistingObjects: repo.ObjectStore(), }) if err != nil { t.Fatalf("ReceivePack: %v", err) @@ -164,12 +164,12 @@ func TestReceivePackDeleteOnlyAtomicFailureLeavesAllRefsUntouched(t *testing.T) t.Fatalf("unexpected receive-pack output %q", got) } - _, err = repo.Refs().Resolve("refs/heads/main") + _, err = repo.RefStore().Resolve("refs/heads/main") if err != nil { t.Fatalf("Resolve(main): %v", err) } - _, err = repo.Refs().Resolve("refs/heads/topic") + _, err = repo.RefStore().Resolve("refs/heads/topic") if err != nil { t.Fatalf("Resolve(topic): %v", err) } @@ -199,8 +199,8 @@ func TestReceivePackAdvertisesResolvedHEAD(t *testing.T) { err := receivepack.ReceivePack(context.Background(), &output, strings.NewReader(input.String()), receivepack.Options{ Algorithm: algo, - Refs: repo.Refs(), - ExistingObjects: repo.Objects(), + Refs: repo.RefStore(), + ExistingObjects: repo.ObjectStore(), }) if err != nil { t.Fatalf("ReceivePack: %v", err) @@ -252,8 +252,8 @@ func TestReceivePackWithoutReportStatusWritesNoStatusPayload(t *testing.T) { err := receivepack.ReceivePack(context.Background(), &output, strings.NewReader(input.String()), receivepack.Options{ Algorithm: algo, - Refs: repo.Refs(), - ExistingObjects: repo.Objects(), + Refs: repo.RefStore(), + ExistingObjects: repo.ObjectStore(), }) if err != nil { t.Fatalf("ReceivePack: %v", err) @@ -292,8 +292,8 @@ func testReceivePackProtocolFallback(t *testing.T, gitProtocol string) { err := receivepack.ReceivePack(context.Background(), &output, strings.NewReader(input.String()), receivepack.Options{ GitProtocol: gitProtocol, Algorithm: algo, - Refs: repo.Refs(), - ExistingObjects: repo.Objects(), + Refs: repo.RefStore(), + ExistingObjects: repo.ObjectStore(), }) if err != nil { t.Fatalf("ReceivePack: %v", err) @@ -330,8 +330,8 @@ func TestReceivePackPackRequestWithoutObjectIngressReportsNotConfigured(t *testi err := receivepack.ReceivePack(context.Background(), &output, strings.NewReader(input.String()), receivepack.Options{ Algorithm: algo, - Refs: repo.Refs(), - ExistingObjects: repo.Objects(), + Refs: repo.RefStore(), + ExistingObjects: repo.ObjectStore(), }) if err != nil { t.Fatalf("ReceivePack: %v", err) @@ -379,8 +379,8 @@ func TestReceivePackPackCreatePromotesObjectsAndUpdatesRef(t *testing.T) { io.MultiReader(strings.NewReader(input.String()), packStream), receivepack.Options{ Algorithm: algo, - Refs: repo.Refs(), - ExistingObjects: repo.Objects(), + Refs: repo.RefStore(), + ExistingObjects: repo.ObjectStore(), ObjectIngress: objectIngress, }, ) @@ -395,7 +395,7 @@ func TestReceivePackPackCreatePromotesObjectsAndUpdatesRef(t *testing.T) { reopened := receiver.OpenRepository(t) - resolved, err := reopened.Refs().ResolveToDetached("refs/heads/main") + resolved, err := reopened.RefStore().ResolveToDetached("refs/heads/main") if err != nil { t.Fatalf("ResolveToDetached(main): %v", err) } @@ -451,8 +451,8 @@ func TestReceivePackHookSeesQuarantinedObjectsAndCanRejectBeforePromotion(t *tes io.MultiReader(strings.NewReader(input.String()), packStream), receivepack.Options{ Algorithm: algo, - Refs: repo.Refs(), - ExistingObjects: repo.Objects(), + Refs: repo.RefStore(), + ExistingObjects: repo.ObjectStore(), ObjectIngress: objectIngress, Hook: func(ctx context.Context, req receivepack.HookRequest) ([]receivepack.UpdateDecision, error) { hookCalled = true @@ -491,7 +491,7 @@ func TestReceivePackHookSeesQuarantinedObjectsAndCanRejectBeforePromotion(t *tes t.Fatalf("unexpected receive-pack output %q", got) } - _, err = repo.Refs().Resolve("refs/heads/main") + _, err = repo.RefStore().Resolve("refs/heads/main") if err == nil { t.Fatal("refs/heads/main exists after hook rejection") } @@ -532,8 +532,8 @@ func TestReceivePackHookCanRejectSubsetOfNonAtomicDeleteOnlyPush(t *testing.T) { err := receivepack.ReceivePack(context.Background(), &output, strings.NewReader(input.String()), receivepack.Options{ Algorithm: algo, - Refs: repo.Refs(), - ExistingObjects: repo.Objects(), + Refs: repo.RefStore(), + ExistingObjects: repo.ObjectStore(), Hook: func(ctx context.Context, req receivepack.HookRequest) ([]receivepack.UpdateDecision, error) { return []receivepack.UpdateDecision{ {Accept: false, Message: "leave main alone"}, @@ -550,12 +550,12 @@ func TestReceivePackHookCanRejectSubsetOfNonAtomicDeleteOnlyPush(t *testing.T) { t.Fatalf("unexpected receive-pack output %q", got) } - _, err = repo.Refs().Resolve("refs/heads/main") + _, err = repo.RefStore().Resolve("refs/heads/main") if err != nil { t.Fatalf("Resolve(main): %v", err) } - _, err = repo.Refs().Resolve("refs/heads/topic") + _, err = repo.RefStore().Resolve("refs/heads/topic") if err == nil { t.Fatal("refs/heads/topic still exists after successful delete") } @@ -587,8 +587,8 @@ func TestReceivePackHookProgressUsesSideBand64K(t *testing.T) { err := receivepack.ReceivePack(context.Background(), &output, strings.NewReader(input.String()), receivepack.Options{ Algorithm: algo, - Refs: repo.Refs(), - ExistingObjects: repo.Objects(), + Refs: repo.RefStore(), + ExistingObjects: repo.ObjectStore(), Hook: func(ctx context.Context, req receivepack.HookRequest) ([]receivepack.UpdateDecision, error) { _, err := io.WriteString(req.IO.Progress, "hook says hello\n") if err != nil { @@ -684,8 +684,8 @@ func TestReceivePackPredefinedRejectForcePushHookRejectsNonFastForward(t *testin io.MultiReader(strings.NewReader(input.String()), packStream), receivepack.Options{ Algorithm: algo, - Refs: repo.Refs(), - ExistingObjects: repo.Objects(), + Refs: repo.RefStore(), + ExistingObjects: repo.ObjectStore(), ObjectIngress: objectIngress, Hook: receivepackhooks.RejectForcePush(), }, @@ -699,7 +699,7 @@ func TestReceivePackPredefinedRejectForcePushHookRejectsNonFastForward(t *testin t.Fatalf("unexpected receive-pack output %q", got) } - resolved, err := repo.Refs().ResolveToDetached("refs/heads/main") + resolved, err := repo.RefStore().ResolveToDetached("refs/heads/main") if err != nil { t.Fatalf("ResolveToDetached(main): %v", err) } @@ -735,8 +735,8 @@ func TestReceivePackReportStatusV2IncludesRefDetails(t *testing.T) { err := receivepack.ReceivePack(context.Background(), &output, strings.NewReader(input.String()), receivepack.Options{ Algorithm: algo, - Refs: repo.Refs(), - ExistingObjects: repo.Objects(), + Refs: repo.RefStore(), + ExistingObjects: repo.ObjectStore(), }) if err != nil { t.Fatalf("ReceivePack: %v", err) @@ -776,8 +776,8 @@ func TestReceivePackGitPushCreatesBranch(t *testing.T) { sender, receivepack.Options{ Algorithm: algo, - Refs: repo.Refs(), - ExistingObjects: repo.Objects(), + Refs: repo.RefStore(), + ExistingObjects: repo.ObjectStore(), ObjectIngress: objectIngress, }, "push", "--porcelain", "fd::3,4/test", "refs/heads/main:refs/heads/main", @@ -790,7 +790,7 @@ func TestReceivePackGitPushCreatesBranch(t *testing.T) { t.Fatalf("ReceivePack: %v", serverErr) } - resolved, err := receiver.OpenRepository(t).Refs().ResolveToDetached("refs/heads/main") + resolved, err := receiver.OpenRepository(t).RefStore().ResolveToDetached("refs/heads/main") if err != nil { t.Fatalf("ResolveToDetached(main): %v", err) } @@ -826,8 +826,8 @@ func TestReceivePackGitPushRefUpdateWithoutNewObjectsSucceeds(t *testing.T) { sender, receivepack.Options{ Algorithm: algo, - Refs: repo.Refs(), - ExistingObjects: repo.Objects(), + Refs: repo.RefStore(), + ExistingObjects: repo.ObjectStore(), ObjectIngress: objectIngress, }, "push", "--porcelain", "fd::3,4/test", "refs/heads/main:refs/heads/topic", @@ -840,7 +840,7 @@ func TestReceivePackGitPushRefUpdateWithoutNewObjectsSucceeds(t *testing.T) { t.Fatalf("ReceivePack: %v", serverErr) } - resolved, err := receiver.OpenRepository(t).Refs().ResolveToDetached("refs/heads/topic") + resolved, err := receiver.OpenRepository(t).RefStore().ResolveToDetached("refs/heads/topic") if err != nil { t.Fatalf("ResolveToDetached(topic): %v", err) } @@ -874,8 +874,8 @@ func TestReceivePackGitPushAtomicDelete(t *testing.T) { sender, receivepack.Options{ Algorithm: algo, - Refs: repo.Refs(), - ExistingObjects: repo.Objects(), + Refs: repo.RefStore(), + ExistingObjects: repo.ObjectStore(), }, "push", "--porcelain", "--atomic", "fd::3,4/test", ":refs/heads/main", ) @@ -887,7 +887,7 @@ func TestReceivePackGitPushAtomicDelete(t *testing.T) { t.Fatalf("ReceivePack: %v", serverErr) } - _, err := receiver.OpenRepository(t).Refs().Resolve("refs/heads/main") + _, err := receiver.OpenRepository(t).RefStore().Resolve("refs/heads/main") if err == nil { t.Fatal("refs/heads/main still exists after delete push") } @@ -922,8 +922,8 @@ func TestReceivePackGitPushRejectsForcedUpdateViaHook(t *testing.T) { sender, receivepack.Options{ Algorithm: algo, - Refs: repo.Refs(), - ExistingObjects: repo.Objects(), + Refs: repo.RefStore(), + ExistingObjects: repo.ObjectStore(), ObjectIngress: objectIngress, Hook: receivepackhooks.RejectForcePush(), }, @@ -941,7 +941,7 @@ func TestReceivePackGitPushRejectsForcedUpdateViaHook(t *testing.T) { t.Fatalf("git push output missing non-fast-forward message\nstdout=%s\nstderr=%s", stdout, stderr) } - resolved, err := receiver.OpenRepository(t).Refs().ResolveToDetached("refs/heads/main") + resolved, err := receiver.OpenRepository(t).RefStore().ResolveToDetached("refs/heads/main") if err != nil { t.Fatalf("ResolveToDetached(main): %v", err) } diff --git a/object/fetch/treefs_test.go b/object/fetch/treefs_test.go index ba5d4127..a4f28a01 100644 --- a/object/fetch/treefs_test.go +++ b/object/fetch/treefs_test.go @@ -41,7 +41,7 @@ func TestTreeFS(t *testing.T) { defer func() { _ = repo.Close() }() - fetcher := fetch.New(repo.Objects()) + fetcher := fetch.New(repo.ObjectStore()) treeFS, err := fetcher.TreeFS(commitID) if err != nil { diff --git a/object/store/packed/internal/ingest/ingest_test.go b/object/store/packed/internal/ingest/ingest_test.go index c99afe65..1631ec34 100644 --- a/object/store/packed/internal/ingest/ingest_test.go +++ b/object/store/packed/internal/ingest/ingest_test.go @@ -270,7 +270,7 @@ func TestIngestThinPackWithFixThin(t *testing.T) { result, err := ingest.WritePack(packRoot, algo, bytes.NewReader(thinPack), ingest.Options{ FixThin: true, WriteRev: true, - ThinBase: receiverRepo.Objects(), + ThinBase: receiverRepo.ObjectStore(), RequireTrailingEOF: true, }) if err != nil { diff --git a/repository/objects.go b/repository/objects.go index 2527363a..b1e975ee 100644 --- a/repository/objects.go +++ b/repository/objects.go @@ -81,9 +81,9 @@ func openObjectStore( return objects, objectsRoot, objectsPackRoot, objectsLoose, objectsPacked, nil } -// Objects returns the configured object store. +// ObjectStore returns the configured object store. // -// Use Objects for direct object-ID lookups, object headers, sizes, raw object +// Use ObjectStore for direct object-ID lookups, object headers, sizes, raw object // bytes, streamed object contents, object writes, pack ingestion, and // coordinated quarantines. Callers who want typed object values should usually // prefer [Repository.Fetcher]. @@ -91,7 +91,7 @@ func openObjectStore( // Labels: Life-Parent. // //nolint:ireturn -func (repo *Repository) Objects() interface { +func (repo *Repository) ObjectStore() interface { objectstore.Reader objectstore.Writer objectstore.Quarantiner diff --git a/repository/refs.go b/repository/refs.go index d66ae752..ab983baf 100644 --- a/repository/refs.go +++ b/repository/refs.go @@ -2,16 +2,16 @@ package repository import refstore "codeberg.org/lindenii/furgit/ref/store" -// Refs returns the configured ref store. +// RefStore returns the configured ref store. // -// Use Refs when starting from branch names, tags, HEAD, or other references. +// Use RefStore when starting from branch names, tags, HEAD, or other references. // A common pattern is to resolve a reference first and then pass the resulting -// object ID to [Repository.Fetcher] or [Repository.Objects]. +// object ID to [Repository.Fetcher] or [Repository.ObjectStore]. // // Labels: Life-Parent. // //nolint:ireturn -func (repo *Repository) Refs() interface { +func (repo *Repository) RefStore() interface { refstore.Reader refstore.Transactioner refstore.Batcher diff --git a/repository/refs_test.go b/repository/refs_test.go index d01dda19..cde0e94e 100644 --- a/repository/refs_test.go +++ b/repository/refs_test.go @@ -29,7 +29,7 @@ func TestOpenFilesRefFormat(t *testing.T) { t.Fatalf("Algorithm = %v, want %v", repo.Algorithm(), algo) } - headerType, headerSize, err := repo.Objects().ReadHeader(commitID) + headerType, headerSize, err := repo.ObjectStore().ReadHeader(commitID) if err != nil { t.Fatalf("ReadHeader(commit): %v", err) } @@ -42,7 +42,7 @@ func TestOpenFilesRefFormat(t *testing.T) { t.Fatalf("ReadHeader(commit) size = %d, want > 0", headerSize) } - resolved, err := repo.Refs().Resolve("refs/heads/main") + resolved, err := repo.RefStore().Resolve("refs/heads/main") if err != nil { t.Fatalf("Resolve(refs/heads/main): %v", err) } @@ -56,7 +56,7 @@ func TestOpenFilesRefFormat(t *testing.T) { t.Fatalf("Resolve(refs/heads/main) id = %s, want %s", detached.ID, commitID) } - head, err := repo.Refs().ResolveToDetached("HEAD") + head, err := repo.RefStore().ResolveToDetached("HEAD") if err != nil { t.Fatalf("ResolveToDetached(HEAD): %v", err) } @@ -102,7 +102,7 @@ func assertResolveToDetached(t *testing.T, repoHarness *testgit.TestRepo, name s repo := repoHarness.OpenRepository(t) - resolved, err := repo.Refs().ResolveToDetached(name) + resolved, err := repo.RefStore().ResolveToDetached(name) if err != nil { t.Fatalf("ResolveToDetached(%s): %v", name, err) } diff --git a/repository/traversal_test.go b/repository/traversal_test.go index 5f75eb5b..034119ac 100644 --- a/repository/traversal_test.go +++ b/repository/traversal_test.go @@ -147,7 +147,7 @@ func walkRepositoryFromRoot(t *testing.T, root *os.Root, label string) { defer func() { _ = repo.Close() }() - head, err := repo.Refs().ResolveToDetached("HEAD") + head, err := repo.RefStore().ResolveToDetached("HEAD") if err != nil { t.Fatalf("ResolveRefFully(HEAD): %v", err) } diff --git a/repository/write_loose_test.go b/repository/write_loose_test.go index d1fa479c..218a70cd 100644 --- a/repository/write_loose_test.go +++ b/repository/write_loose_test.go @@ -23,7 +23,7 @@ func TestWriteLooseBytesContent(t *testing.T) { content := []byte("write-loose-bytes-content\n") - gotID, err := repo.Objects().WriteBytesContent(objecttype.TypeBlob, content) + gotID, err := repo.ObjectStore().WriteBytesContent(objecttype.TypeBlob, content) if err != nil { t.Fatalf("WriteLooseBytesContent: %v", err) } @@ -33,7 +33,7 @@ func TestWriteLooseBytesContent(t *testing.T) { t.Fatalf("WriteLooseBytesContent id = %s, want %s", gotID, wantID) } - ty, gotContent, err := repo.Objects().ReadBytesContent(gotID) + ty, gotContent, err := repo.ObjectStore().ReadBytesContent(gotID) if err != nil { t.Fatalf("ReadStoredBytesContent: %v", err) } @@ -62,7 +62,7 @@ func TestWriteLooseReaderContent(t *testing.T) { content := []byte("write-loose-reader-content\n") - gotID, err := repo.Objects().WriteReaderContent(objecttype.TypeBlob, int64(len(content)), bytes.NewReader(content)) + gotID, err := repo.ObjectStore().WriteReaderContent(objecttype.TypeBlob, int64(len(content)), bytes.NewReader(content)) if err != nil { t.Fatalf("WriteLooseReaderContent: %v", err) } @@ -87,12 +87,12 @@ func TestWriteLooseFull(t *testing.T) { repo := repoHarness.OpenRepository(t) - raw, err := repo.Objects().ReadBytesFull(commitID) + raw, err := repo.ObjectStore().ReadBytesFull(commitID) if err != nil { t.Fatalf("ReadStoredBytesFull: %v", err) } - idFromBytes, err := repo.Objects().WriteBytesFull(raw) + idFromBytes, err := repo.ObjectStore().WriteBytesFull(raw) if err != nil { t.Fatalf("WriteLooseBytesFull: %v", err) } @@ -101,7 +101,7 @@ func TestWriteLooseFull(t *testing.T) { t.Fatalf("WriteLooseBytesFull id = %s, want %s", idFromBytes, commitID) } - idFromReader, err := repo.Objects().WriteReaderFull(bytes.NewReader(raw)) + idFromReader, err := repo.ObjectStore().WriteReaderFull(bytes.NewReader(raw)) if err != nil { t.Fatalf("WriteLooseReaderFull: %v", err) } -- cgit v1.3.1-10-gc9f91 From bbefa87ee46d8b1887ddf9e6e36518aeeb2e4725 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Wed, 27 May 2026 05:59:46 +0000 Subject: furgit: This should be called doc.go too --- doc.go | 71 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ furgit.go | 71 --------------------------------------------------------------- 2 files changed, 71 insertions(+), 71 deletions(-) create mode 100644 doc.go delete mode 100644 furgit.go diff --git a/doc.go b/doc.go new file mode 100644 index 00000000..60966584 --- /dev/null +++ b/doc.go @@ -0,0 +1,71 @@ +// Package furgit provides low-level Git operations. +// +// Furgit provides absolutely no guarantees on correctness, performance, +// API stability. In particular, before version 1.0.0, no attempt at +// API stability is made at all, and breaking changes may be introduced +// in patch-level releases. See also the warranty and liability disclaimers +// in the license. +// +// Git libraries often center on a repository type that owns objects, refs, +// worktree state, and configuration behind a single facade. Furgit inverts +// that: objects are plain values, stored objects are separate types that +// associate objects with their object IDs, object storage and ref storage +// are sets of narrow interfaces consisting only of things that are truly +// reasonable for all implementations to satisfy, and every higher-level +// operation, such as commit traversal, reachability analysis, and +// recursive peeling, is built over those interfaces. +// +// While the [codeberg.org/lindenii/furgit/repository] package is where +// most users should begin, it only exists as one convenient composition of +// those pieces for the standard on-disk repository layout. Nothing inside +// furgit should depend on it; extensions to furgit such as alterntaive +// object stores must not depend on it either. +// +// # Contract labels +// +// Many furgit APIs document concurrency, dependency ownership, value lifetime, +// and close behavior using short labels. +// These labels summarize the API contract, but they do not replace the full +// doc comment on a package, type, function, method, constant, or variable. +// +// When both a type and one of its methods specify labels, the method-level +// labels take precedence for that operation. +// +// Concurrency labels: +// +// - MT-Safe: safe for concurrent use. +// - MT-Unsafe: not safe for concurrent use without external synchronization. +// +// Dependency labels: +// +// - Deps-Owned: the receiver takes ownership of all supplied dependencies +// where ownership is a reasonable concept. +// - Deps-Borrowed: the value borrows supplied dependencies. Also Life-Parent +// in most cases, unless those dependencies are not retained past +// construction. +// - Deps-Mixed: some supplied dependencies are owned and others are borrowed. +// +// Lifetime labels: +// +// - Life-Independent: returned values remain valid independently of the +// parent or provider. +// - Life-Parent: returned values are only valid while the parent or provider +// remains valid. +// - Life-Call: returned values are only valid for the duration of the +// current call, callback, or hook invocation. +// +// Close labels: +// +// - Close-Caller: the caller must close the returned value. +// - Close-No: the caller must not close the returned value directly. +// - Close-Idem: repeated Close calls are safe. +// +// Mutation labels: +// +// - Mut-Never: returned values must not be mutated. +// +// Unless Close-Idem is specified, repeated Close calls are undefined behavior. +// +// Unless a doc comment explicitly states otherwise, these labels describe the +// API contract only. They do not imply any specific implementation strategy. +package furgit diff --git a/furgit.go b/furgit.go deleted file mode 100644 index 60966584..00000000 --- a/furgit.go +++ /dev/null @@ -1,71 +0,0 @@ -// Package furgit provides low-level Git operations. -// -// Furgit provides absolutely no guarantees on correctness, performance, -// API stability. In particular, before version 1.0.0, no attempt at -// API stability is made at all, and breaking changes may be introduced -// in patch-level releases. See also the warranty and liability disclaimers -// in the license. -// -// Git libraries often center on a repository type that owns objects, refs, -// worktree state, and configuration behind a single facade. Furgit inverts -// that: objects are plain values, stored objects are separate types that -// associate objects with their object IDs, object storage and ref storage -// are sets of narrow interfaces consisting only of things that are truly -// reasonable for all implementations to satisfy, and every higher-level -// operation, such as commit traversal, reachability analysis, and -// recursive peeling, is built over those interfaces. -// -// While the [codeberg.org/lindenii/furgit/repository] package is where -// most users should begin, it only exists as one convenient composition of -// those pieces for the standard on-disk repository layout. Nothing inside -// furgit should depend on it; extensions to furgit such as alterntaive -// object stores must not depend on it either. -// -// # Contract labels -// -// Many furgit APIs document concurrency, dependency ownership, value lifetime, -// and close behavior using short labels. -// These labels summarize the API contract, but they do not replace the full -// doc comment on a package, type, function, method, constant, or variable. -// -// When both a type and one of its methods specify labels, the method-level -// labels take precedence for that operation. -// -// Concurrency labels: -// -// - MT-Safe: safe for concurrent use. -// - MT-Unsafe: not safe for concurrent use without external synchronization. -// -// Dependency labels: -// -// - Deps-Owned: the receiver takes ownership of all supplied dependencies -// where ownership is a reasonable concept. -// - Deps-Borrowed: the value borrows supplied dependencies. Also Life-Parent -// in most cases, unless those dependencies are not retained past -// construction. -// - Deps-Mixed: some supplied dependencies are owned and others are borrowed. -// -// Lifetime labels: -// -// - Life-Independent: returned values remain valid independently of the -// parent or provider. -// - Life-Parent: returned values are only valid while the parent or provider -// remains valid. -// - Life-Call: returned values are only valid for the duration of the -// current call, callback, or hook invocation. -// -// Close labels: -// -// - Close-Caller: the caller must close the returned value. -// - Close-No: the caller must not close the returned value directly. -// - Close-Idem: repeated Close calls are safe. -// -// Mutation labels: -// -// - Mut-Never: returned values must not be mutated. -// -// Unless Close-Idem is specified, repeated Close calls are undefined behavior. -// -// Unless a doc comment explicitly states otherwise, these labels describe the -// API contract only. They do not imply any specific implementation strategy. -package furgit -- cgit v1.3.1-10-gc9f91 From ed21333863da2f3b29d6fdb3f2e51f7a22d075e7 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Wed, 27 May 2026 06:07:13 +0000 Subject: furgit: Use next's docs --- doc.go | 115 ++++++++++++++++++++++++++++++++++++++++------------------------- 1 file changed, 71 insertions(+), 44 deletions(-) diff --git a/doc.go b/doc.go index 60966584..f9aca881 100644 --- a/doc.go +++ b/doc.go @@ -1,35 +1,48 @@ -// Package furgit provides low-level Git operations. -// -// Furgit provides absolutely no guarantees on correctness, performance, -// API stability. In particular, before version 1.0.0, no attempt at -// API stability is made at all, and breaking changes may be introduced -// in patch-level releases. See also the warranty and liability disclaimers -// in the license. -// -// Git libraries often center on a repository type that owns objects, refs, -// worktree state, and configuration behind a single facade. Furgit inverts -// that: objects are plain values, stored objects are separate types that -// associate objects with their object IDs, object storage and ref storage -// are sets of narrow interfaces consisting only of things that are truly -// reasonable for all implementations to satisfy, and every higher-level -// operation, such as commit traversal, reachability analysis, and -// recursive peeling, is built over those interfaces. -// -// While the [codeberg.org/lindenii/furgit/repository] package is where -// most users should begin, it only exists as one convenient composition of -// those pieces for the standard on-disk repository layout. Nothing inside -// furgit should depend on it; extensions to furgit such as alterntaive -// object stores must not depend on it either. +// Package furgit provides low-level git operations. +// +// Furgit is an unfinished research project, +// and is not suitable for production. +// +// The architecture is rather deliberate +// and the parts that exist +// have been built carefully +// (to the best of our capability) +// and tested against git as the canonical oracle, etc. +// +// However, the API is not yet settled at all; +// we may revise interfaces and behaviour at any time, +// to incorporate findings from ongoing audits, +// including full rearchitectures. +// Consumers that depend on a 0.x version of furgit +// will need to revise their usages +// every few days or weeks. +// +// Therefore, you should probably not use furgit. +// Consider using [go-git], +// which is mature and has API stability promises, +// or simply use [os/exec] to upstream git, +// which is sufficient for many purposes. +// +// # Overall architecture +// +// Git libraries often center on a central repository type where all +// data structures and operations are hosted. +// Furgit inverts that: +// objects are plain values that do not provide access to the storer that loaded them, +// object storage and ref storage are sets of narrow interfaces +// that consist only of methods that are reasonable for all implementations, +// and every higher-level operation, +// such as commit traversal, reachability analysis, and recursive peeling, +// is built over those interfaces as independent subsystems. // // # Contract labels // -// Many furgit APIs document concurrency, dependency ownership, value lifetime, -// and close behavior using short labels. -// These labels summarize the API contract, but they do not replace the full -// doc comment on a package, type, function, method, constant, or variable. +// Many furgit APIs use short labels to document +// concurrency, dependency ownership, value lifetime, and other behavior. // -// When both a type and one of its methods specify labels, the method-level -// labels take precedence for that operation. +// When both a type and one of its methods +// specify conflicting labels, +// the method-label takes precedence. // // Concurrency labels: // @@ -40,32 +53,46 @@ // // - Deps-Owned: the receiver takes ownership of all supplied dependencies // where ownership is a reasonable concept. -// - Deps-Borrowed: the value borrows supplied dependencies. Also Life-Parent -// in most cases, unless those dependencies are not retained past -// construction. -// - Deps-Mixed: some supplied dependencies are owned and others are borrowed. +// - Deps-Borrowed: the value borrows supplied dependencies. +// Usually also labelled with Life-Parent +// unless those dependencies are not retained past construction. +// - Deps-Mixed: some are mixed while others are borrowed. +// The documentation should specify further. // // Lifetime labels: // -// - Life-Independent: returned values remain valid independently of the -// parent or provider. -// - Life-Parent: returned values are only valid while the parent or provider -// remains valid. -// - Life-Call: returned values are only valid for the duration of the -// current call, callback, or hook invocation. +// - Life-Independent: returned values remain valid +// independently of the parent or provider. +// - Life-Parent: returned values are only valid +// while the parent or provider remains valid. +// - Life-Call: returned values are only valid +// for the duration of the current call, callback, or hook invocation. // // Close labels: // // - Close-Caller: the caller must close the returned value. -// - Close-No: the caller must not close the returned value directly. -// - Close-Idem: repeated Close calls are safe. +// - Close-No: the caller must not close the returned value, +// even if the returned value has a Close method. +// +// Idempotency labels: +// +// - Idem-Yes: action is idempotent. +// - Idem-2UB: action is not idempotent; +// repeated use is undefined behavior. // // Mutation labels: // -// - Mut-Never: returned values must not be mutated. +// - Mut-No: returned values must not be mutated. +// +// These labels describe the API contract only, +// and do not imply any specific implementation strategy. // -// Unless Close-Idem is specified, repeated Close calls are undefined behavior. +// Concrete implementations of capability interfaces +// generally inherit the contract documented by the interfaces they satisfy. +// Implementation docs focus on additional guarantees +// and implementation-specific behavior, +// but users are advised not to rely on them +// in order to maintain the flexibility of switching implementations. // -// Unless a doc comment explicitly states otherwise, these labels describe the -// API contract only. They do not imply any specific implementation strategy. +// [go-git]: https://github.com/go-git/go-git package furgit -- cgit v1.3.1-10-gc9f91 From 8fbc00847e764db21a25c5be5500e09782e4a603 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Wed, 27 May 2026 06:07:55 +0000 Subject: README: Use next's --- README.md | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index a61ccef0..2f2175b6 100644 --- a/README.md +++ b/README.md @@ -3,13 +3,16 @@ [![builds.sr.ht status](https://builds.sr.ht/~runxiyu/furgit/commits/master.svg)](https://builds.sr.ht/~runxiyu/furgit/commits/master) [![Go Reference](https://pkg.go.dev/badge/codeberg.org/lindenii/furgit.svg)](https://pkg.go.dev/codeberg.org/lindenii/furgit) -A low‐level Git library in Go. +A low‐level Git plumbing library in Go. + +A refactor is pending on the `next` branch. ## Status -* **A refactor is pending on the `next` branch.** -* Early development, not suitable for production. -* A mature alternative is [go-git](https://github.com/go-git/go-git). +**You should *not* use furgit.** + +Furgit is an unfinished research project, +and has breaking API changes every few days. ## Community @@ -22,9 +25,9 @@ See also `CONTRIBUTING.md`. ## Acknowledgements -Partly inspired by [upstream Git](https://git-scm.com), +Partly inspired by [upstream git](https://git-scm.com), OpenBSD's [Game of Trees](https://gameoftrees.org), and -[9front Git](https://git.9front.org/plan9front/9front/HEAD/sys/src/cmd/git/f.html). +[9front git](https://git.9front.org/plan9front/9front/HEAD/sys/src/cmd/git/f.html). ## License @@ -47,7 +50,7 @@ version for this Program. * [Codeberg](https://codeberg.org/lindenii/furgit) * [SourceHut mirror](https://git.sr.ht/~runxiyu/furgit) * [hjgit mirror](https://hjgit.org/runxiyu/furgit/HEAD/info.html) -* [tangled mirror](https://tangled.org/@runxiyu.tngl.sh/furgit) -* [GitHub mirror](https://github.com/runxiyu/furgit) * [git.runxiyu.org mirror](https://git.runxiyu.org/furgit.git//) * [cgit.space mirror](https://cgit.space/~runxiyu/furgit.git/) +* [tangled mirror](https://tangled.org/@runxiyu.tngl.sh/furgit) +* [GitHub mirror](https://github.com/runxiyu/furgit) -- cgit v1.3.1-10-gc9f91 From c1122079bf6ebf1ef0db2ee5048e134c9ee9a850 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Wed, 27 May 2026 06:14:54 +0000 Subject: Switch package URLs to lindenii.org/go/furgit --- cmd/receivepack9418/conn.go | 8 ++++---- cmd/receivepack9418/errpkt.go | 2 +- cmd/receivepack9418/gitproto.go | 2 +- cmd/receivepack9418/run.go | 2 +- cmd/receivepack9418/server.go | 2 +- cmd/show-object/print.go | 12 ++++++------ cmd/show-object/resolve.go | 4 ++-- cmd/show-object/run.go | 2 +- commitquery/commit_data.go | 4 ++-- commitquery/node.go | 4 ++-- commitquery/node_compare.go | 2 +- commitquery/node_generation.go | 2 +- commitquery/node_id.go | 2 +- commitquery/node_new.go | 2 +- commitquery/parent_ref.go | 4 ++-- commitquery/queries.go | 4 ++-- commitquery/queries_is_ancestor.go | 2 +- commitquery/queries_is_ancestor_integration_test.go | 10 +++++----- commitquery/queries_is_ancestor_unit_test.go | 18 +++++++++--------- commitquery/queries_merge_base.go | 2 +- commitquery/queries_merge_bases.go | 2 +- commitquery/queries_merge_bases_integration_test.go | 8 ++++---- commitquery/queries_merge_bases_unit_test.go | 16 ++++++++-------- commitquery/queries_new.go | 4 ++-- commitquery/query.go | 6 +++--- commitquery/query_is_ancestor.go | 2 +- commitquery/query_load_by_oid.go | 2 +- commitquery/query_load_commit_at_graph_pos.go | 2 +- commitquery/query_merge_base.go | 2 +- commitquery/query_merge_bases.go | 2 +- commitquery/query_new.go | 6 +++--- commitquery/query_paint_down_to_common.go | 2 +- commitquery/query_resolve_commitish.go | 2 +- commitquery/query_resolve_graph_pos.go | 2 +- commitquery/query_resolve_oid.go | 2 +- config/config_test.go | 6 +++--- config/typed.go | 2 +- diff/lines/diff_test.go | 2 +- diff/trees/diff.go | 4 ++-- diff/trees/diff_recursive.go | 4 ++-- diff/trees/diff_test.go | 12 ++++++------ diff/trees/entry.go | 2 +- errors/missing.go | 2 +- errors/type.go | 4 ++-- format/commitgraph/bloom/key.go | 2 +- format/commitgraph/bloom/murmur.go | 2 +- format/commitgraph/bloom/settings.go | 2 +- format/commitgraph/read/bloom.go | 4 ++-- format/commitgraph/read/commitat.go | 4 ++-- format/commitgraph/read/commits.go | 2 +- format/commitgraph/read/edges.go | 4 ++-- format/commitgraph/read/errors.go | 2 +- format/commitgraph/read/generation.go | 4 ++-- format/commitgraph/read/hash.go | 2 +- format/commitgraph/read/iterators.go | 4 ++-- format/commitgraph/read/layer.go | 2 +- format/commitgraph/read/layer_lookup.go | 4 ++-- format/commitgraph/read/layer_open.go | 6 +++--- format/commitgraph/read/layer_parse.go | 8 ++++---- format/commitgraph/read/layer_pos.go | 2 +- format/commitgraph/read/lookup.go | 4 ++-- format/commitgraph/read/oidat.go | 4 ++-- format/commitgraph/read/open.go | 2 +- format/commitgraph/read/open_chain.go | 4 ++-- format/commitgraph/read/open_single.go | 4 ++-- format/commitgraph/read/parents.go | 2 +- format/commitgraph/read/position.go | 2 +- format/commitgraph/read/read_test.go | 10 +++++----- format/commitgraph/read/reader.go | 2 +- format/packfile/entry.go | 2 +- format/packfile/entry_header.go | 2 +- go.mod | 2 +- internal/adler32/adler32_amd64.go | 2 +- internal/adler32/bench_test.go | 2 +- internal/compress/flate/deflate.go | 2 +- internal/compress/flate/example_test.go | 2 +- internal/compress/flate/fast_encoder.go | 2 +- internal/compress/flate/fuzz_test.go | 2 +- internal/compress/flate/huffman_bit_writer.go | 2 +- internal/compress/flate/level1.go | 2 +- internal/compress/flate/matchlen_generic.go | 2 +- internal/compress/flate/stateless.go | 2 +- internal/compress/zlib/reader.go | 4 ++-- internal/compress/zlib/reader_reset.go | 6 +++--- internal/compress/zlib/reader_test.go | 2 +- internal/compress/zlib/writer.go | 2 +- internal/compress/zlib/writer_header.go | 4 ++-- internal/compress/zlib/writer_test.go | 2 +- internal/iolimit/capped_capture_writer_test.go | 2 +- internal/iolimit/expect_length_reader_test.go | 2 +- internal/lru/lru_test.go | 2 +- internal/priorityqueue/queue_test.go | 2 +- internal/progress/counters.go | 2 +- internal/progress/meter.go | 2 +- internal/progress/options.go | 2 +- internal/progress/render.go | 2 +- internal/progress/set.go | 2 +- internal/testgit/algorithms.go | 2 +- internal/testgit/repo.go | 2 +- internal/testgit/repo_cat_file.go | 2 +- internal/testgit/repo_commit_tree.go | 2 +- internal/testgit/repo_commit_tree_env.go | 2 +- internal/testgit/repo_from_fixture.go | 2 +- internal/testgit/repo_hash_object.go | 2 +- internal/testgit/repo_make_commit.go | 2 +- internal/testgit/repo_make_many_objects_history.go | 2 +- internal/testgit/repo_make_single_file_tree.go | 2 +- internal/testgit/repo_mktree.go | 2 +- internal/testgit/repo_new.go | 2 +- internal/testgit/repo_open_commit_graph.go | 2 +- internal/testgit/repo_open_object_store.go | 4 ++-- internal/testgit/repo_open_repository.go | 2 +- internal/testgit/repo_properties.go | 2 +- internal/testgit/repo_refs.go | 2 +- internal/testgit/repo_remove_loose_object.go | 2 +- internal/testgit/repo_rev_list.go | 2 +- internal/testgit/repo_rev_parse.go | 2 +- internal/testgit/repo_tag_annotated.go | 2 +- .../append_data_preserves_dst_on_error_test.go | 2 +- network/protocol/pktline/append_helpers_test.go | 2 +- .../pktline/chunk_writer_write_and_read_from_test.go | 2 +- .../pktline/decoder_data_control_and_0004_test.go | 2 +- .../protocol/pktline/decoder_invalid_0003_test.go | 2 +- network/protocol/pktline/decoder_peek_test.go | 2 +- .../decoder_rejects_over_maximum_length_test.go | 2 +- .../decoder_resync_after_over_max_data_test.go | 2 +- .../decoder_resync_after_over_wire_max_test.go | 2 +- .../protocol/pktline/decoder_unexpected_eof_test.go | 2 +- .../protocol/pktline/encode_length_header_test.go | 2 +- network/protocol/pktline/encoder.go | 2 +- .../encoder_buffered_flush_and_f_flush_test.go | 2 +- .../pktline/encoder_buffered_flush_behavior_test.go | 2 +- ...der_set_max_data_cannot_exceed_wire_limit_test.go | 2 +- .../protocol/pktline/encoder_writes_frames_test.go | 2 +- network/protocol/pktline/parse_length_header_test.go | 2 +- network/protocol/sideband64k/append.go | 2 +- network/protocol/sideband64k/append_helpers_test.go | 2 +- .../append_preserves_dst_on_error_test.go | 2 +- .../chunk_writer_write_and_read_from_test.go | 2 +- network/protocol/sideband64k/constants.go | 2 +- network/protocol/sideband64k/decoder.go | 2 +- .../decoder_data_control_and_keepalive_test.go | 2 +- .../sideband64k/decoder_invalid_band_test.go | 2 +- .../decoder_invalid_empty_payload_test.go | 2 +- .../sideband64k/decoder_malformed_pktline_test.go | 4 ++-- .../sideband64k/decoder_partial_read_test.go | 2 +- network/protocol/sideband64k/decoder_peek_test.go | 2 +- .../decoder_resync_after_over_max_data_test.go | 2 +- .../decoder_resync_after_over_wire_max_test.go | 4 ++-- .../sideband64k/decoder_unexpected_eof_test.go | 2 +- network/protocol/sideband64k/encoder.go | 4 ++-- .../encoder_buffered_flush_behavior_test.go | 2 +- .../sideband64k/encoder_partial_write_test.go | 2 +- ...der_set_max_data_cannot_exceed_wire_limit_test.go | 2 +- .../sideband64k/encoder_writes_frames_test.go | 2 +- network/protocol/v0v1/server/advertise_test.go | 6 +++--- network/protocol/v0v1/server/advertised_ref.go | 2 +- network/protocol/v0v1/server/frame.go | 2 +- network/protocol/v0v1/server/helpers_test.go | 2 +- .../protocol/v0v1/server/receivepack/capabilities.go | 2 +- .../protocol/v0v1/server/receivepack/helpers_test.go | 2 +- .../protocol/v0v1/server/receivepack/parse_test.go | 10 +++++----- .../v0v1/server/receivepack/report_status.go | 2 +- .../v0v1/server/receivepack/report_status_test.go | 12 ++++++------ network/protocol/v0v1/server/receivepack/session.go | 6 +++--- network/protocol/v0v1/server/receivepack/types.go | 2 +- network/protocol/v0v1/server/session.go | 8 ++++---- network/receivepack/advertise.go | 6 +++--- network/receivepack/commands.go | 4 ++-- network/receivepack/hook.go | 12 ++++++------ network/receivepack/hooks/chain.go | 2 +- network/receivepack/hooks/reject_force_push.go | 10 +++++----- network/receivepack/int_test.go | 20 ++++++++++---------- network/receivepack/options.go | 8 ++++---- network/receivepack/receivepack.go | 8 ++++---- network/receivepack/results.go | 4 ++-- network/receivepack/service/apply.go | 4 ++-- network/receivepack/service/command.go | 2 +- network/receivepack/service/command_result.go | 2 +- network/receivepack/service/execute.go | 4 ++-- network/receivepack/service/hook.go | 10 +++++----- network/receivepack/service/ingest_quarantine.go | 4 ++-- network/receivepack/service/options.go | 8 ++++---- network/receivepack/service/run_hook.go | 4 ++-- network/receivepack/service/service_test.go | 16 ++++++++-------- network/receivepack/service/update.go | 2 +- network/receivepack/version.go | 2 +- object/blob/parse_test.go | 6 +++--- object/blob/serialize.go | 4 ++-- object/blob/serialize_test.go | 6 +++--- object/blob/test.go | 2 +- object/commit/commit.go | 6 +++--- object/commit/parse.go | 4 ++-- object/commit/parse_test.go | 6 +++--- object/commit/serialize.go | 4 ++-- object/commit/serialize_test.go | 6 +++--- object/commit/type.go | 2 +- object/doc.go | 2 +- object/fetch/exact_blob.go | 10 +++++----- object/fetch/exact_blob_reader.go | 4 ++-- object/fetch/exact_commit.go | 10 +++++----- object/fetch/exact_object.go | 6 +++--- object/fetch/exact_reader.go | 6 +++--- object/fetch/exact_tag.go | 10 +++++----- object/fetch/exact_tree.go | 10 +++++----- object/fetch/fetcher.go | 2 +- object/fetch/header.go | 4 ++-- object/fetch/object_errors.go | 6 +++--- object/fetch/object_parse.go | 4 ++-- object/fetch/path.go | 4 ++-- object/fetch/peel_to_blob.go | 12 ++++++------ object/fetch/peel_to_blob_id.go | 6 +++--- object/fetch/peel_to_blob_reader.go | 2 +- object/fetch/peel_to_commit.go | 12 ++++++------ object/fetch/peel_to_commit_id.go | 6 +++--- object/fetch/peel_to_tree.go | 14 +++++++------- object/fetch/peel_to_tree_id.go | 6 +++--- object/fetch/size.go | 2 +- object/fetch/treefs.go | 4 ++-- object/fetch/treefs_entry.go | 4 ++-- object/fetch/treefs_info.go | 2 +- object/fetch/treefs_new.go | 2 +- object/fetch/treefs_open.go | 2 +- object/fetch/treefs_readfile.go | 2 +- object/fetch/treefs_test.go | 10 +++++----- object/header/append.go | 2 +- object/header/encode.go | 2 +- object/header/parse.go | 2 +- object/id/objectid_test.go | 2 +- object/object.go | 2 +- object/parse_with_header.go | 4 ++-- object/parse_without_header.go | 12 ++++++------ object/signature/parse.go | 2 +- object/signed/commit/commit.go | 2 +- object/signed/commit/integration_test.go | 6 +++--- object/signed/commit/parse.go | 2 +- object/signed/commit/signature_algorithms.go | 2 +- object/signed/commit/signature_append.go | 2 +- object/signed/commit/unit_test.go | 4 ++-- object/signed/doc.go | 4 ++-- object/signed/tag/integration_test.go | 6 +++--- object/signed/tag/parse.go | 2 +- object/signed/tag/signature_algorithms.go | 2 +- object/signed/tag/signature_append.go | 2 +- object/signed/tag/tag.go | 2 +- object/signed/tag/unit_test.go | 4 ++-- object/store/chain/bytes.go | 6 +++--- object/store/chain/chain.go | 2 +- object/store/chain/header.go | 6 +++--- object/store/chain/new.go | 2 +- object/store/chain/reader.go | 6 +++--- object/store/chain/size.go | 4 ++-- object/store/doc.go | 2 +- object/store/dual/dual.go | 2 +- object/store/dual/dual_test.go | 14 +++++++------- object/store/dual/new.go | 4 ++-- object/store/dual/quarantine.go | 8 ++++---- object/store/dual/quarantine_begin.go | 2 +- object/store/dual/reader.go | 4 ++-- object/store/dual/writer_object.go | 4 ++-- object/store/dual/writer_pack.go | 2 +- object/store/loose/helpers_test.go | 10 +++++----- object/store/loose/parse.go | 6 +++--- object/store/loose/paths.go | 4 ++-- object/store/loose/quarantine.go | 2 +- object/store/loose/quarantine_begin.go | 2 +- object/store/loose/quarantine_test.go | 8 ++++---- object/store/loose/read_bytes.go | 4 ++-- object/store/loose/read_header.go | 6 +++--- object/store/loose/read_reader.go | 8 ++++---- object/store/loose/read_size.go | 2 +- object/store/loose/read_test.go | 10 +++++----- object/store/loose/store.go | 2 +- object/store/loose/write_bytes.go | 4 ++-- object/store/loose/write_reader.go | 6 +++--- object/store/loose/write_test.go | 8 ++++---- object/store/loose/write_writer.go | 2 +- object/store/loose/write_writer_accept.go | 2 +- object/store/loose/write_writer_finalize.go | 2 +- object/store/memory/algorithm.go | 2 +- object/store/memory/object.go | 2 +- object/store/memory/read_bytes.go | 8 ++++---- object/store/memory/read_header.go | 6 +++--- object/store/memory/read_reader.go | 4 ++-- object/store/memory/read_size.go | 2 +- object/store/memory/store.go | 2 +- object/store/memory/write_bytes.go | 6 +++--- object/store/memory/write_reader.go | 6 +++--- object/store/memory/write_test.go | 10 +++++----- object/store/mix/bytes.go | 6 +++--- object/store/mix/header.go | 6 +++--- object/store/mix/mix.go | 2 +- object/store/mix/mru.go | 2 +- object/store/mix/new.go | 2 +- object/store/mix/reader.go | 6 +++--- object/store/mix/refresh.go | 2 +- object/store/mix/size.go | 4 ++-- object/store/packed/internal/ingest/cache.go | 4 ++-- object/store/packed/internal/ingest/delta_header.go | 2 +- object/store/packed/internal/ingest/drain.go | 8 ++++---- object/store/packed/internal/ingest/entry.go | 2 +- object/store/packed/internal/ingest/entry_header.go | 4 ++-- object/store/packed/internal/ingest/entry_prefix.go | 6 +++--- object/store/packed/internal/ingest/finalize.go | 2 +- object/store/packed/internal/ingest/hash.go | 6 +++--- object/store/packed/internal/ingest/header.go | 2 +- object/store/packed/internal/ingest/idx_write.go | 4 ++-- object/store/packed/internal/ingest/ingest_test.go | 6 +++--- object/store/packed/internal/ingest/options.go | 4 ++-- .../store/packed/internal/ingest/progress_write.go | 2 +- .../store/packed/internal/ingest/record_content.go | 2 +- object/store/packed/internal/ingest/record_delta.go | 4 ++-- .../store/packed/internal/ingest/record_inflate.go | 2 +- .../store/packed/internal/ingest/record_resolve.go | 2 +- object/store/packed/internal/ingest/records.go | 4 ++-- object/store/packed/internal/ingest/resolve_all.go | 2 +- object/store/packed/internal/ingest/result.go | 2 +- object/store/packed/internal/ingest/rev_write.go | 4 ++-- .../packed/internal/ingest/rewrite_header_trailer.go | 4 ++-- object/store/packed/internal/ingest/scan.go | 4 ++-- object/store/packed/internal/ingest/state.go | 2 +- object/store/packed/internal/ingest/thin_append.go | 6 +++--- object/store/packed/internal/ingest/thin_fix.go | 6 +++--- .../store/packed/internal/ingest/thin_unresolved.go | 4 ++-- object/store/packed/internal/ingest/write.go | 2 +- object/store/packed/internal/ingest/write_empty.go | 2 +- .../packed/internal/reading/delta_build_chain.go | 2 +- object/store/packed/internal/reading/delta_cache.go | 4 ++-- object/store/packed/internal/reading/delta_chain.go | 2 +- .../packed/internal/reading/delta_resolve_chain.go | 4 ++-- .../internal/reading/delta_resolve_chain_start.go | 2 +- .../packed/internal/reading/delta_resolve_content.go | 2 +- object/store/packed/internal/reading/delta_size.go | 2 +- .../store/packed/internal/reading/entry_inflate.go | 4 ++-- object/store/packed/internal/reading/entry_parse.go | 8 ++++---- object/store/packed/internal/reading/helpers_test.go | 10 +++++----- object/store/packed/internal/reading/idx.go | 2 +- object/store/packed/internal/reading/idx_lookup.go | 2 +- object/store/packed/internal/reading/idx_open.go | 4 ++-- object/store/packed/internal/reading/new.go | 2 +- object/store/packed/internal/reading/pack.go | 4 ++-- .../packed/internal/reading/pack_idx_checksum.go | 2 +- object/store/packed/internal/reading/read_bytes.go | 6 +++--- object/store/packed/internal/reading/read_header.go | 4 ++-- .../packed/internal/reading/read_header_resolve.go | 2 +- object/store/packed/internal/reading/read_reader.go | 8 ++++---- object/store/packed/internal/reading/read_size.go | 4 ++-- object/store/packed/internal/reading/read_test.go | 8 ++++---- object/store/packed/internal/reading/store.go | 4 ++-- object/store/packed/internal/reading/store_lookup.go | 4 ++-- object/store/packed/new.go | 4 ++-- object/store/packed/quarantine.go | 2 +- object/store/packed/quarantine_begin.go | 2 +- object/store/packed/quarantine_test.go | 10 +++++----- object/store/packed/reader.go | 8 ++++---- object/store/packed/store.go | 4 ++-- object/store/packed/writer.go | 4 ++-- object/store/reader.go | 4 ++-- object/store/writer_object.go | 4 ++-- object/store/writer_pack.go | 2 +- object/stored/id.go | 2 +- object/stored/new.go | 4 ++-- object/stored/stored.go | 4 ++-- object/tag/parse.go | 6 +++--- object/tag/parse_test.go | 8 ++++---- object/tag/serialize.go | 4 ++-- object/tag/serialize_test.go | 6 +++--- object/tag/tag.go | 8 ++++---- object/tag/type.go | 2 +- object/tree/entry.go | 2 +- object/tree/helpers_test.go | 4 ++-- object/tree/parse.go | 2 +- object/tree/parse_test.go | 6 +++--- object/tree/serialize.go | 4 ++-- object/tree/serialize_test.go | 6 +++--- object/tree/type.go | 2 +- reachability/connected.go | 2 +- reachability/integration_test.go | 10 +++++----- reachability/reachability.go | 4 ++-- reachability/unit_test.go | 16 ++++++++-------- reachability/walk.go | 2 +- reachability/walk_expand_commits.go | 4 ++-- reachability/walk_expand_commits_graph.go | 6 +++--- reachability/walk_expand_objects.go | 6 +++--- reachability/walk_item.go | 4 ++-- reachability/walk_seq.go | 2 +- reachability/walk_stack.go | 2 +- reachability/walk_verify.go | 6 +++--- ref/detached.go | 2 +- ref/name/refname_test.go | 2 +- ref/store/batch.go | 2 +- ref/store/chain/chain.go | 2 +- ref/store/chain/list.go | 2 +- ref/store/chain/new.go | 2 +- ref/store/chain/resolve.go | 4 ++-- ref/store/files/batch.go | 2 +- ref/store/files/batch_apply.go | 2 +- ref/store/files/batch_begin.go | 2 +- ref/store/files/batch_queue_ops.go | 2 +- ref/store/files/batch_rejection.go | 2 +- ref/store/files/batch_test.go | 6 +++--- ref/store/files/helpers_test.go | 6 +++--- ref/store/files/new.go | 2 +- ref/store/files/packed_delete_test.go | 6 +++--- ref/store/files/packed_parse.go | 4 ++-- ref/store/files/packed_read.go | 2 +- ref/store/files/packed_refs.go | 2 +- ref/store/files/read_list.go | 4 ++-- ref/store/files/read_loose.go | 6 +++--- ref/store/files/read_resolve.go | 4 ++-- ref/store/files/read_resolve_fully.go | 2 +- ref/store/files/resolve_list_test.go | 6 +++--- ref/store/files/root_loose_path.go | 2 +- ref/store/files/store.go | 4 ++-- ref/store/files/transaction.go | 2 +- ref/store/files/transaction_begin.go | 2 +- ref/store/files/transaction_dirs_test.go | 4 ++-- ref/store/files/transaction_names_test.go | 8 ++++---- ref/store/files/transaction_pseudoref_test.go | 6 +++--- ref/store/files/transaction_queue_ops.go | 2 +- ref/store/files/transaction_symbolic_test.go | 6 +++--- ref/store/files/transaction_update_test.go | 8 ++++---- ref/store/files/update_direct_read.go | 6 +++--- ref/store/files/update_direct_ref.go | 2 +- ref/store/files/update_operation_queue.go | 2 +- ref/store/files/update_prepare_resolve.go | 2 +- ref/store/files/update_resolve_target_ordinary.go | 2 +- ref/store/files/update_validate.go | 6 +++--- ref/store/files/update_verify_current.go | 2 +- ref/store/files/update_verify_refnames.go | 2 +- ref/store/files/worktree_test.go | 6 +++--- ref/store/memory/batch.go | 4 ++-- ref/store/memory/read.go | 4 ++-- ref/store/memory/ref.go | 2 +- ref/store/memory/store.go | 4 ++-- ref/store/memory/store_test.go | 10 +++++----- ref/store/memory/transaction.go | 4 ++-- ref/store/memory/update.go | 6 +++--- ref/store/reading.go | 2 +- ref/store/transaction.go | 2 +- repository/algorithm.go | 4 ++-- repository/commit_graph.go | 4 ++-- repository/commit_queries.go | 2 +- repository/config.go | 2 +- repository/fetcher.go | 2 +- repository/objects.go | 10 +++++----- repository/open.go | 6 +++--- repository/reachability.go | 2 +- repository/refs.go | 2 +- repository/refs_test.go | 8 ++++---- repository/refs_timeout.go | 2 +- repository/repository.go | 18 +++++++++--------- repository/stored_test.go | 6 +++--- repository/traversal_test.go | 14 +++++++------- repository/write_loose_test.go | 6 +++--- 455 files changed, 909 insertions(+), 909 deletions(-) diff --git a/cmd/receivepack9418/conn.go b/cmd/receivepack9418/conn.go index 008a8a45..f4c0a2e9 100644 --- a/cmd/receivepack9418/conn.go +++ b/cmd/receivepack9418/conn.go @@ -9,10 +9,10 @@ import ( "os" "strings" - "codeberg.org/lindenii/furgit/network/receivepack" - objectdual "codeberg.org/lindenii/furgit/object/store/dual" - objectloose "codeberg.org/lindenii/furgit/object/store/loose" - objectpacked "codeberg.org/lindenii/furgit/object/store/packed" + "lindenii.org/go/furgit/network/receivepack" + objectdual "lindenii.org/go/furgit/object/store/dual" + objectloose "lindenii.org/go/furgit/object/store/loose" + objectpacked "lindenii.org/go/furgit/object/store/packed" ) func (srv *server) handleConn(conn net.Conn) { diff --git a/cmd/receivepack9418/errpkt.go b/cmd/receivepack9418/errpkt.go index 743811aa..9234f76f 100644 --- a/cmd/receivepack9418/errpkt.go +++ b/cmd/receivepack9418/errpkt.go @@ -3,7 +3,7 @@ package main import ( "io" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func writeErrPkt(w io.Writer, message string) { diff --git a/cmd/receivepack9418/gitproto.go b/cmd/receivepack9418/gitproto.go index 28c192d4..1375f57c 100644 --- a/cmd/receivepack9418/gitproto.go +++ b/cmd/receivepack9418/gitproto.go @@ -4,7 +4,7 @@ import ( "fmt" "io" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func readGitProtoRequest(r io.Reader) (gitProtoRequest, error) { diff --git a/cmd/receivepack9418/run.go b/cmd/receivepack9418/run.go index 2932459d..a283dab4 100644 --- a/cmd/receivepack9418/run.go +++ b/cmd/receivepack9418/run.go @@ -8,7 +8,7 @@ import ( "net" "os" - "codeberg.org/lindenii/furgit/repository" + "lindenii.org/go/furgit/repository" ) func run(listenAddr, repoPath string) error { diff --git a/cmd/receivepack9418/server.go b/cmd/receivepack9418/server.go index 74793712..e1a6e062 100644 --- a/cmd/receivepack9418/server.go +++ b/cmd/receivepack9418/server.go @@ -3,7 +3,7 @@ package main import ( "os" - "codeberg.org/lindenii/furgit/repository" + "lindenii.org/go/furgit/repository" ) type server struct { diff --git a/cmd/show-object/print.go b/cmd/show-object/print.go index fcd6494f..315527b1 100644 --- a/cmd/show-object/print.go +++ b/cmd/show-object/print.go @@ -5,12 +5,12 @@ import ( "os" "strings" - "codeberg.org/lindenii/furgit/object" - "codeberg.org/lindenii/furgit/object/blob" - "codeberg.org/lindenii/furgit/object/commit" - "codeberg.org/lindenii/furgit/object/stored" - "codeberg.org/lindenii/furgit/object/tag" - "codeberg.org/lindenii/furgit/object/tree" + "lindenii.org/go/furgit/object" + "lindenii.org/go/furgit/object/blob" + "lindenii.org/go/furgit/object/commit" + "lindenii.org/go/furgit/object/stored" + "lindenii.org/go/furgit/object/tag" + "lindenii.org/go/furgit/object/tree" ) func printStored(s *stored.Stored[object.Object]) { diff --git a/cmd/show-object/resolve.go b/cmd/show-object/resolve.go index 22afe70c..cd1c6b78 100644 --- a/cmd/show-object/resolve.go +++ b/cmd/show-object/resolve.go @@ -3,8 +3,8 @@ package main import ( "strings" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/repository" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/repository" ) func resolveInput(repo *repository.Repository, input string) (objectid.ObjectID, error) { diff --git a/cmd/show-object/run.go b/cmd/show-object/run.go index f1a6fc6d..4a322f1f 100644 --- a/cmd/show-object/run.go +++ b/cmd/show-object/run.go @@ -4,7 +4,7 @@ import ( "fmt" "os" - "codeberg.org/lindenii/furgit/repository" + "lindenii.org/go/furgit/repository" ) func run(repoPath, name *string) error { diff --git a/commitquery/commit_data.go b/commitquery/commit_data.go index dff6a91c..75f7bbc6 100644 --- a/commitquery/commit_data.go +++ b/commitquery/commit_data.go @@ -1,8 +1,8 @@ package commitquery import ( - commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" - objectid "codeberg.org/lindenii/furgit/object/id" + commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" + objectid "lindenii.org/go/furgit/object/id" ) // commitData stores the metadata needed by commit-domain queries. diff --git a/commitquery/node.go b/commitquery/node.go index 7432a719..d0ab1f66 100644 --- a/commitquery/node.go +++ b/commitquery/node.go @@ -1,8 +1,8 @@ package commitquery import ( - commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" - objectid "codeberg.org/lindenii/furgit/object/id" + commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" + objectid "lindenii.org/go/furgit/object/id" ) // node stores one mutable commit traversal node. diff --git a/commitquery/node_compare.go b/commitquery/node_compare.go index cf072af2..512cd906 100644 --- a/commitquery/node_compare.go +++ b/commitquery/node_compare.go @@ -1,6 +1,6 @@ package commitquery -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // compare orders two internal nodes using merge-base queue ordering. func (query *query) compare(left, right nodeIndex) int { diff --git a/commitquery/node_generation.go b/commitquery/node_generation.go index 03283cf6..048d9f66 100644 --- a/commitquery/node_generation.go +++ b/commitquery/node_generation.go @@ -3,7 +3,7 @@ package commitquery import ( "math" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // effectiveGeneration returns one node's generation value. diff --git a/commitquery/node_id.go b/commitquery/node_id.go index 8ec0b126..6570e912 100644 --- a/commitquery/node_id.go +++ b/commitquery/node_id.go @@ -1,6 +1,6 @@ package commitquery -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // id returns one node's object ID. func (query *query) id(idx nodeIndex) objectid.ObjectID { diff --git a/commitquery/node_new.go b/commitquery/node_new.go index 14a35262..ccdb0687 100644 --- a/commitquery/node_new.go +++ b/commitquery/node_new.go @@ -1,6 +1,6 @@ package commitquery -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // newNode allocates one empty internal node. func (query *query) newNode(id objectid.ObjectID) nodeIndex { diff --git a/commitquery/parent_ref.go b/commitquery/parent_ref.go index 08d224df..a6371759 100644 --- a/commitquery/parent_ref.go +++ b/commitquery/parent_ref.go @@ -1,8 +1,8 @@ package commitquery import ( - commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" - objectid "codeberg.org/lindenii/furgit/object/id" + commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" + objectid "lindenii.org/go/furgit/object/id" ) // parentRef references one commit parent. diff --git a/commitquery/queries.go b/commitquery/queries.go index 33709783..17bcdb6d 100644 --- a/commitquery/queries.go +++ b/commitquery/queries.go @@ -3,8 +3,8 @@ package commitquery import ( "sync" - commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" - objectfetch "codeberg.org/lindenii/furgit/object/fetch" + commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" + objectfetch "lindenii.org/go/furgit/object/fetch" ) // Queries provides commit-domain queries over one object fetcher diff --git a/commitquery/queries_is_ancestor.go b/commitquery/queries_is_ancestor.go index e2c955c6..865ac8ed 100644 --- a/commitquery/queries_is_ancestor.go +++ b/commitquery/queries_is_ancestor.go @@ -1,6 +1,6 @@ package commitquery -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // IsAncestor reports whether ancestor is reachable from descendant through // commit parent edges. diff --git a/commitquery/queries_is_ancestor_integration_test.go b/commitquery/queries_is_ancestor_integration_test.go index 7e8886a9..19d9ffc3 100644 --- a/commitquery/queries_is_ancestor_integration_test.go +++ b/commitquery/queries_is_ancestor_integration_test.go @@ -4,11 +4,11 @@ import ( "errors" "testing" - "codeberg.org/lindenii/furgit/commitquery" - giterrors "codeberg.org/lindenii/furgit/errors" - "codeberg.org/lindenii/furgit/internal/testgit" - "codeberg.org/lindenii/furgit/object/fetch" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/commitquery" + giterrors "lindenii.org/go/furgit/errors" + "lindenii.org/go/furgit/internal/testgit" + "lindenii.org/go/furgit/object/fetch" + objectid "lindenii.org/go/furgit/object/id" ) func TestIsMatchesGitMergeBase(t *testing.T) { diff --git a/commitquery/queries_is_ancestor_unit_test.go b/commitquery/queries_is_ancestor_unit_test.go index 75a4b00c..edc0bf34 100644 --- a/commitquery/queries_is_ancestor_unit_test.go +++ b/commitquery/queries_is_ancestor_unit_test.go @@ -5,15 +5,15 @@ import ( "fmt" "testing" - giterrors "codeberg.org/lindenii/furgit/errors" - "codeberg.org/lindenii/furgit/internal/testgit" - "codeberg.org/lindenii/furgit/object/fetch" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/store/memory" - objecttree "codeberg.org/lindenii/furgit/object/tree" - objecttype "codeberg.org/lindenii/furgit/object/type" - - "codeberg.org/lindenii/furgit/commitquery" + giterrors "lindenii.org/go/furgit/errors" + "lindenii.org/go/furgit/internal/testgit" + "lindenii.org/go/furgit/object/fetch" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/store/memory" + objecttree "lindenii.org/go/furgit/object/tree" + objecttype "lindenii.org/go/furgit/object/type" + + "lindenii.org/go/furgit/commitquery" ) // ancestorCommitBody serializes one minimal commit body. diff --git a/commitquery/queries_merge_base.go b/commitquery/queries_merge_base.go index 28de7fe2..c512be3c 100644 --- a/commitquery/queries_merge_base.go +++ b/commitquery/queries_merge_base.go @@ -1,6 +1,6 @@ package commitquery -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // MergeBase reports one merge base between left and right, if any. func (queries *Queries) MergeBase(left, right objectid.ObjectID) (objectid.ObjectID, bool, error) { diff --git a/commitquery/queries_merge_bases.go b/commitquery/queries_merge_bases.go index 74c5054a..99a11e31 100644 --- a/commitquery/queries_merge_bases.go +++ b/commitquery/queries_merge_bases.go @@ -1,6 +1,6 @@ package commitquery -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // MergeBases reports all merge bases in Git's merge-base --all order. // diff --git a/commitquery/queries_merge_bases_integration_test.go b/commitquery/queries_merge_bases_integration_test.go index 4fdfdf16..c2ceb9eb 100644 --- a/commitquery/queries_merge_bases_integration_test.go +++ b/commitquery/queries_merge_bases_integration_test.go @@ -6,10 +6,10 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/commitquery" - "codeberg.org/lindenii/furgit/internal/testgit" - "codeberg.org/lindenii/furgit/object/fetch" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/commitquery" + "lindenii.org/go/furgit/internal/testgit" + "lindenii.org/go/furgit/object/fetch" + objectid "lindenii.org/go/furgit/object/id" ) func TestQueryMatchesGitMergeBaseAll(t *testing.T) { diff --git a/commitquery/queries_merge_bases_unit_test.go b/commitquery/queries_merge_bases_unit_test.go index 3772f882..47deed23 100644 --- a/commitquery/queries_merge_bases_unit_test.go +++ b/commitquery/queries_merge_bases_unit_test.go @@ -7,14 +7,14 @@ import ( "slices" "testing" - "codeberg.org/lindenii/furgit/commitquery" - giterrors "codeberg.org/lindenii/furgit/errors" - "codeberg.org/lindenii/furgit/internal/testgit" - "codeberg.org/lindenii/furgit/object/fetch" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/store/memory" - "codeberg.org/lindenii/furgit/object/tree" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/commitquery" + giterrors "lindenii.org/go/furgit/errors" + "lindenii.org/go/furgit/internal/testgit" + "lindenii.org/go/furgit/object/fetch" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/store/memory" + "lindenii.org/go/furgit/object/tree" + objecttype "lindenii.org/go/furgit/object/type" ) // commitBody serializes one minimal commit body. diff --git a/commitquery/queries_new.go b/commitquery/queries_new.go index 5eae7990..fd38b6a9 100644 --- a/commitquery/queries_new.go +++ b/commitquery/queries_new.go @@ -3,8 +3,8 @@ package commitquery import ( "runtime" - commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" - objectfetch "codeberg.org/lindenii/furgit/object/fetch" + commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" + objectfetch "lindenii.org/go/furgit/object/fetch" ) // New builds one concurrent-safe commit query service over one object fetcher diff --git a/commitquery/query.go b/commitquery/query.go index 65e90ec8..315096c6 100644 --- a/commitquery/query.go +++ b/commitquery/query.go @@ -1,9 +1,9 @@ package commitquery import ( - commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" - objectfetch "codeberg.org/lindenii/furgit/object/fetch" - objectid "codeberg.org/lindenii/furgit/object/id" + commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" + objectfetch "lindenii.org/go/furgit/object/fetch" + objectid "lindenii.org/go/furgit/object/id" ) // query stores one mutable reusable worker and its cached node arena. diff --git a/commitquery/query_is_ancestor.go b/commitquery/query_is_ancestor.go index c21892c8..41400456 100644 --- a/commitquery/query_is_ancestor.go +++ b/commitquery/query_is_ancestor.go @@ -1,6 +1,6 @@ package commitquery -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // IsAncestor reports whether ancestor is reachable from descendant through // commit parent edges. diff --git a/commitquery/query_load_by_oid.go b/commitquery/query_load_by_oid.go index f9c956ee..402354ed 100644 --- a/commitquery/query_load_by_oid.go +++ b/commitquery/query_load_by_oid.go @@ -3,7 +3,7 @@ package commitquery import ( stderrors "errors" - commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" + commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" ) // loadByOID populates one node from an object ID. diff --git a/commitquery/query_load_commit_at_graph_pos.go b/commitquery/query_load_commit_at_graph_pos.go index f63b6385..63b782ca 100644 --- a/commitquery/query_load_commit_at_graph_pos.go +++ b/commitquery/query_load_commit_at_graph_pos.go @@ -1,6 +1,6 @@ package commitquery -import commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" +import commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" // loadCommitAtGraphPos populates one node from one commit-graph record. func (query *query) loadCommitAtGraphPos(idx nodeIndex, pos commitgraphread.Position) error { diff --git a/commitquery/query_merge_base.go b/commitquery/query_merge_base.go index e1ba3126..83bf9846 100644 --- a/commitquery/query_merge_base.go +++ b/commitquery/query_merge_base.go @@ -1,6 +1,6 @@ package commitquery -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // MergeBase reports one merge base between left and right, if any. func (query *query) MergeBase(left, right objectid.ObjectID) (objectid.ObjectID, bool, error) { diff --git a/commitquery/query_merge_bases.go b/commitquery/query_merge_bases.go index 384ee019..bee839b4 100644 --- a/commitquery/query_merge_bases.go +++ b/commitquery/query_merge_bases.go @@ -3,7 +3,7 @@ package commitquery import ( "slices" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // MergeBases reports all merge bases in Git's merge-base --all order. diff --git a/commitquery/query_new.go b/commitquery/query_new.go index 0f23a321..9ac18ed8 100644 --- a/commitquery/query_new.go +++ b/commitquery/query_new.go @@ -1,9 +1,9 @@ package commitquery import ( - commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" - objectfetch "codeberg.org/lindenii/furgit/object/fetch" - objectid "codeberg.org/lindenii/furgit/object/id" + commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" + objectfetch "lindenii.org/go/furgit/object/fetch" + objectid "lindenii.org/go/furgit/object/id" ) // newQuery builds one empty mutable worker over one object fetcher and graph. diff --git a/commitquery/query_paint_down_to_common.go b/commitquery/query_paint_down_to_common.go index e152e159..c57fb695 100644 --- a/commitquery/query_paint_down_to_common.go +++ b/commitquery/query_paint_down_to_common.go @@ -1,6 +1,6 @@ package commitquery -import "codeberg.org/lindenii/furgit/internal/priorityqueue" +import "lindenii.org/go/furgit/internal/priorityqueue" // paintDownToCommon propagates left and right marks downward until common nodes. func (query *query) paintDownToCommon(left nodeIndex, rights []nodeIndex, minGeneration uint64) error { diff --git a/commitquery/query_resolve_commitish.go b/commitquery/query_resolve_commitish.go index 1e14a1c0..117b69f2 100644 --- a/commitquery/query_resolve_commitish.go +++ b/commitquery/query_resolve_commitish.go @@ -1,6 +1,6 @@ package commitquery -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // resolveCommitish peels one commit-ish object ID and resolves the commit. func (query *query) resolveCommitish(id objectid.ObjectID) (nodeIndex, error) { diff --git a/commitquery/query_resolve_graph_pos.go b/commitquery/query_resolve_graph_pos.go index dce8fc22..46ffd081 100644 --- a/commitquery/query_resolve_graph_pos.go +++ b/commitquery/query_resolve_graph_pos.go @@ -1,6 +1,6 @@ package commitquery -import commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" +import commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" // resolveGraphPos resolves one commit-graph position to one internal query node. func (query *query) resolveGraphPos(pos commitgraphread.Position) (nodeIndex, error) { diff --git a/commitquery/query_resolve_oid.go b/commitquery/query_resolve_oid.go index ad47829c..28cd1dd4 100644 --- a/commitquery/query_resolve_oid.go +++ b/commitquery/query_resolve_oid.go @@ -1,6 +1,6 @@ package commitquery -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // resolveOID resolves one commit object ID to one internal query node. func (query *query) resolveOID(id objectid.ObjectID) (nodeIndex, error) { diff --git a/config/config_test.go b/config/config_test.go index 86b8be50..f6cb2dd6 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -6,9 +6,9 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/config" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/config" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" ) func openConfig(t *testing.T, testRepo *testgit.TestRepo) *os.File { diff --git a/config/typed.go b/config/typed.go index 39eeb767..8041ab19 100644 --- a/config/typed.go +++ b/config/typed.go @@ -7,7 +7,7 @@ import ( "strconv" "strings" - "codeberg.org/lindenii/furgit/internal/intconv" + "lindenii.org/go/furgit/internal/intconv" ) // ValueKind describes the presence and form of a config value. diff --git a/diff/lines/diff_test.go b/diff/lines/diff_test.go index c5d5be9f..36eae07f 100644 --- a/diff/lines/diff_test.go +++ b/diff/lines/diff_test.go @@ -6,7 +6,7 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/diff/lines" + "lindenii.org/go/furgit/diff/lines" ) func TestDiff(t *testing.T) { //nolint:maintidx diff --git a/diff/trees/diff.go b/diff/trees/diff.go index 0f3cf1f2..4bb4cdfa 100644 --- a/diff/trees/diff.go +++ b/diff/trees/diff.go @@ -2,8 +2,8 @@ package trees import ( - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/tree" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/tree" ) // Diff compares two trees and returns recursive differences. diff --git a/diff/trees/diff_recursive.go b/diff/trees/diff_recursive.go index 98848b24..217260a1 100644 --- a/diff/trees/diff_recursive.go +++ b/diff/trees/diff_recursive.go @@ -1,8 +1,8 @@ package trees import ( - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/tree" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/tree" ) func diffRecursive(a, b *tree.Tree, prefix []byte, readTree func(objectid.ObjectID) (*tree.Tree, error), out *[]Entry) error { diff --git a/diff/trees/diff_test.go b/diff/trees/diff_test.go index 50989a4c..cb7568d8 100644 --- a/diff/trees/diff_test.go +++ b/diff/trees/diff_test.go @@ -4,12 +4,12 @@ import ( "errors" "testing" - "codeberg.org/lindenii/furgit/diff/trees" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/store/loose" - "codeberg.org/lindenii/furgit/object/tree" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/diff/trees" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/store/loose" + "lindenii.org/go/furgit/object/tree" + objecttype "lindenii.org/go/furgit/object/type" ) func TestDiffComplexNestedChanges(t *testing.T) { diff --git a/diff/trees/entry.go b/diff/trees/entry.go index 84813a79..e2815c53 100644 --- a/diff/trees/entry.go +++ b/diff/trees/entry.go @@ -1,6 +1,6 @@ package trees -import "codeberg.org/lindenii/furgit/object/tree" +import "lindenii.org/go/furgit/object/tree" // Entry is one recursive tree difference at a path. type Entry struct { diff --git a/errors/missing.go b/errors/missing.go index 9efc029a..18ea43cd 100644 --- a/errors/missing.go +++ b/errors/missing.go @@ -3,7 +3,7 @@ package errors import ( "fmt" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // ObjectMissingError indicates that a referenced object is absent from the diff --git a/errors/type.go b/errors/type.go index bf3ba110..f24030cc 100644 --- a/errors/type.go +++ b/errors/type.go @@ -3,8 +3,8 @@ package errors import ( "fmt" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // ObjectTypeError indicates that a referenced object has a different type than diff --git a/format/commitgraph/bloom/key.go b/format/commitgraph/bloom/key.go index a15df904..169109d3 100644 --- a/format/commitgraph/bloom/key.go +++ b/format/commitgraph/bloom/key.go @@ -1,6 +1,6 @@ package bloom -import "codeberg.org/lindenii/furgit/internal/intconv" +import "lindenii.org/go/furgit/internal/intconv" type key struct { hashes []uint32 diff --git a/format/commitgraph/bloom/murmur.go b/format/commitgraph/bloom/murmur.go index 363b63ae..75ca301b 100644 --- a/format/commitgraph/bloom/murmur.go +++ b/format/commitgraph/bloom/murmur.go @@ -1,6 +1,6 @@ package bloom -import "codeberg.org/lindenii/furgit/internal/intconv" +import "lindenii.org/go/furgit/internal/intconv" func murmur3SeededV2(seed uint32, data []byte) (uint32, error) { const ( diff --git a/format/commitgraph/bloom/settings.go b/format/commitgraph/bloom/settings.go index 764653bd..8c108977 100644 --- a/format/commitgraph/bloom/settings.go +++ b/format/commitgraph/bloom/settings.go @@ -3,7 +3,7 @@ package bloom import ( "encoding/binary" - "codeberg.org/lindenii/furgit/internal/intconv" + "lindenii.org/go/furgit/internal/intconv" ) // Settings describe the changed-paths Bloom filter parameters stored in diff --git a/format/commitgraph/read/bloom.go b/format/commitgraph/read/bloom.go index 53d724f9..4d2fe023 100644 --- a/format/commitgraph/read/bloom.go +++ b/format/commitgraph/read/bloom.go @@ -3,8 +3,8 @@ package read import ( "encoding/binary" - "codeberg.org/lindenii/furgit/format/commitgraph/bloom" - "codeberg.org/lindenii/furgit/internal/intconv" + "lindenii.org/go/furgit/format/commitgraph/bloom" + "lindenii.org/go/furgit/internal/intconv" ) // HasBloom reports whether any layer has changed-path Bloom data. diff --git a/format/commitgraph/read/commitat.go b/format/commitgraph/read/commitat.go index 827c72ce..6adf4fd6 100644 --- a/format/commitgraph/read/commitat.go +++ b/format/commitgraph/read/commitat.go @@ -3,8 +3,8 @@ package read import ( "encoding/binary" - "codeberg.org/lindenii/furgit/internal/intconv" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/intconv" + objectid "lindenii.org/go/furgit/object/id" ) // CommitAt returns decoded commit-graph metadata at one position. diff --git a/format/commitgraph/read/commits.go b/format/commitgraph/read/commits.go index 48984ecb..e0b71d51 100644 --- a/format/commitgraph/read/commits.go +++ b/format/commitgraph/read/commits.go @@ -1,6 +1,6 @@ package read -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Commit stores decoded commit-graph record data. type Commit struct { diff --git a/format/commitgraph/read/edges.go b/format/commitgraph/read/edges.go index 96ffeb6d..e9f286da 100644 --- a/format/commitgraph/read/edges.go +++ b/format/commitgraph/read/edges.go @@ -3,8 +3,8 @@ package read import ( "encoding/binary" - "codeberg.org/lindenii/furgit/format/commitgraph" - "codeberg.org/lindenii/furgit/internal/intconv" + "lindenii.org/go/furgit/format/commitgraph" + "lindenii.org/go/furgit/internal/intconv" ) func (reader *Reader) decodeExtraEdgeList(layer *layer, edgeStart uint32) ([]Position, error) { diff --git a/format/commitgraph/read/errors.go b/format/commitgraph/read/errors.go index 0a32a368..e190e62e 100644 --- a/format/commitgraph/read/errors.go +++ b/format/commitgraph/read/errors.go @@ -3,7 +3,7 @@ package read import ( "fmt" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // NotFoundError reports a missing commit graph entry by object ID. diff --git a/format/commitgraph/read/generation.go b/format/commitgraph/read/generation.go index 62e47996..538aa28e 100644 --- a/format/commitgraph/read/generation.go +++ b/format/commitgraph/read/generation.go @@ -3,8 +3,8 @@ package read import ( "encoding/binary" - "codeberg.org/lindenii/furgit/format/commitgraph" - "codeberg.org/lindenii/furgit/internal/intconv" + "lindenii.org/go/furgit/format/commitgraph" + "lindenii.org/go/furgit/internal/intconv" ) func (reader *Reader) readGenerationV2(layer *layer, index uint32, commitTime uint64) (uint64, error) { diff --git a/format/commitgraph/read/hash.go b/format/commitgraph/read/hash.go index 3a525afe..7572591e 100644 --- a/format/commitgraph/read/hash.go +++ b/format/commitgraph/read/hash.go @@ -5,7 +5,7 @@ import ( "fmt" "io" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // HashVersion returns the commit-graph hash version. diff --git a/format/commitgraph/read/iterators.go b/format/commitgraph/read/iterators.go index 0e31f7e5..6cf5d271 100644 --- a/format/commitgraph/read/iterators.go +++ b/format/commitgraph/read/iterators.go @@ -3,8 +3,8 @@ package read import ( "iter" - "codeberg.org/lindenii/furgit/internal/intconv" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/intconv" + objectid "lindenii.org/go/furgit/object/id" ) // AllPositions iterates all commit positions in native layer order. diff --git a/format/commitgraph/read/layer.go b/format/commitgraph/read/layer.go index 53ab1663..86d8a612 100644 --- a/format/commitgraph/read/layer.go +++ b/format/commitgraph/read/layer.go @@ -3,7 +3,7 @@ package read import ( "os" - "codeberg.org/lindenii/furgit/format/commitgraph/bloom" + "lindenii.org/go/furgit/format/commitgraph/bloom" ) type layer struct { diff --git a/format/commitgraph/read/layer_lookup.go b/format/commitgraph/read/layer_lookup.go index fafc594b..3cd40506 100644 --- a/format/commitgraph/read/layer_lookup.go +++ b/format/commitgraph/read/layer_lookup.go @@ -4,8 +4,8 @@ import ( "bytes" "encoding/binary" - "codeberg.org/lindenii/furgit/internal/intconv" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/intconv" + objectid "lindenii.org/go/furgit/object/id" ) func layerLookup(layer *layer, oid objectid.ObjectID) (uint32, bool) { diff --git a/format/commitgraph/read/layer_open.go b/format/commitgraph/read/layer_open.go index 21a97644..2bb80c47 100644 --- a/format/commitgraph/read/layer_open.go +++ b/format/commitgraph/read/layer_open.go @@ -4,9 +4,9 @@ import ( "os" "syscall" - "codeberg.org/lindenii/furgit/format/commitgraph" - "codeberg.org/lindenii/furgit/internal/intconv" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/format/commitgraph" + "lindenii.org/go/furgit/internal/intconv" + objectid "lindenii.org/go/furgit/object/id" ) func openLayer(root *os.Root, relPath string, algo objectid.Algorithm) (*layer, error) { diff --git a/format/commitgraph/read/layer_parse.go b/format/commitgraph/read/layer_parse.go index 13e36c0a..8afbef3c 100644 --- a/format/commitgraph/read/layer_parse.go +++ b/format/commitgraph/read/layer_parse.go @@ -3,10 +3,10 @@ package read import ( "encoding/binary" - "codeberg.org/lindenii/furgit/format/commitgraph" - "codeberg.org/lindenii/furgit/format/commitgraph/bloom" - "codeberg.org/lindenii/furgit/internal/intconv" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/format/commitgraph" + "lindenii.org/go/furgit/format/commitgraph/bloom" + "lindenii.org/go/furgit/internal/intconv" + objectid "lindenii.org/go/furgit/object/id" ) func parseLayer(layer *layer, algo objectid.Algorithm) error { //nolint:maintidx diff --git a/format/commitgraph/read/layer_pos.go b/format/commitgraph/read/layer_pos.go index 7b87b381..3f17e271 100644 --- a/format/commitgraph/read/layer_pos.go +++ b/format/commitgraph/read/layer_pos.go @@ -1,6 +1,6 @@ package read -import "codeberg.org/lindenii/furgit/internal/intconv" +import "lindenii.org/go/furgit/internal/intconv" func (reader *Reader) layerByPosition(pos Position) (*layer, error) { graphIdx, err := intconv.Uint64ToInt(uint64(pos.Graph)) diff --git a/format/commitgraph/read/lookup.go b/format/commitgraph/read/lookup.go index 5f1b08f6..f198c312 100644 --- a/format/commitgraph/read/lookup.go +++ b/format/commitgraph/read/lookup.go @@ -1,8 +1,8 @@ package read import ( - "codeberg.org/lindenii/furgit/internal/intconv" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/intconv" + objectid "lindenii.org/go/furgit/object/id" ) // Lookup resolves one object ID to one graph position. diff --git a/format/commitgraph/read/oidat.go b/format/commitgraph/read/oidat.go index 99259995..4c2ba243 100644 --- a/format/commitgraph/read/oidat.go +++ b/format/commitgraph/read/oidat.go @@ -1,8 +1,8 @@ package read import ( - "codeberg.org/lindenii/furgit/internal/intconv" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/intconv" + objectid "lindenii.org/go/furgit/object/id" ) // OIDAt returns object ID at one position. diff --git a/format/commitgraph/read/open.go b/format/commitgraph/read/open.go index d03c8572..94fd15c3 100644 --- a/format/commitgraph/read/open.go +++ b/format/commitgraph/read/open.go @@ -4,7 +4,7 @@ import ( "fmt" "os" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // Open opens commit-graph data from one objects root. diff --git a/format/commitgraph/read/open_chain.go b/format/commitgraph/read/open_chain.go index b55f3e57..e6f2e179 100644 --- a/format/commitgraph/read/open_chain.go +++ b/format/commitgraph/read/open_chain.go @@ -7,8 +7,8 @@ import ( "os" "strings" - "codeberg.org/lindenii/furgit/internal/intconv" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/intconv" + objectid "lindenii.org/go/furgit/object/id" ) func openChain(root *os.Root, algo objectid.Algorithm) (*Reader, error) { diff --git a/format/commitgraph/read/open_single.go b/format/commitgraph/read/open_single.go index 9ad6607f..0823f0c6 100644 --- a/format/commitgraph/read/open_single.go +++ b/format/commitgraph/read/open_single.go @@ -3,8 +3,8 @@ package read import ( "os" - "codeberg.org/lindenii/furgit/internal/intconv" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/intconv" + objectid "lindenii.org/go/furgit/object/id" ) func openSingle(root *os.Root, algo objectid.Algorithm) (*Reader, error) { diff --git a/format/commitgraph/read/parents.go b/format/commitgraph/read/parents.go index fcaad8b6..3fb08e58 100644 --- a/format/commitgraph/read/parents.go +++ b/format/commitgraph/read/parents.go @@ -1,6 +1,6 @@ package read -import "codeberg.org/lindenii/furgit/format/commitgraph" +import "lindenii.org/go/furgit/format/commitgraph" // ParentRef references one parent position. type ParentRef struct { diff --git a/format/commitgraph/read/position.go b/format/commitgraph/read/position.go index b2e1138b..55b0cb10 100644 --- a/format/commitgraph/read/position.go +++ b/format/commitgraph/read/position.go @@ -3,7 +3,7 @@ package read import ( "fmt" - "codeberg.org/lindenii/furgit/internal/intconv" + "lindenii.org/go/furgit/internal/intconv" ) // Position identifies one commit record by layer and row index. diff --git a/format/commitgraph/read/read_test.go b/format/commitgraph/read/read_test.go index c65b183e..7631ff40 100644 --- a/format/commitgraph/read/read_test.go +++ b/format/commitgraph/read/read_test.go @@ -7,11 +7,11 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/format/commitgraph/bloom" - "codeberg.org/lindenii/furgit/format/commitgraph/read" - "codeberg.org/lindenii/furgit/internal/intconv" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/format/commitgraph/bloom" + "lindenii.org/go/furgit/format/commitgraph/read" + "lindenii.org/go/furgit/internal/intconv" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" ) func fixtureRepoPath(t *testing.T, algo objectid.Algorithm, name string) string { diff --git a/format/commitgraph/read/reader.go b/format/commitgraph/read/reader.go index 03698eb1..2c97c25e 100644 --- a/format/commitgraph/read/reader.go +++ b/format/commitgraph/read/reader.go @@ -1,6 +1,6 @@ package read -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Reader provides read-only access to one mmap-backed commit-graph snapshot. // diff --git a/format/packfile/entry.go b/format/packfile/entry.go index 0f9c7c8d..e389d166 100644 --- a/format/packfile/entry.go +++ b/format/packfile/entry.go @@ -3,7 +3,7 @@ package packfile import ( "fmt" - objecttype "codeberg.org/lindenii/furgit/object/type" + objecttype "lindenii.org/go/furgit/object/type" ) // Entry is one parsed pack entry prefix, including any delta base reference diff --git a/format/packfile/entry_header.go b/format/packfile/entry_header.go index 05664268..b0349a04 100644 --- a/format/packfile/entry_header.go +++ b/format/packfile/entry_header.go @@ -3,7 +3,7 @@ package packfile import ( "fmt" - objecttype "codeberg.org/lindenii/furgit/object/type" + objecttype "lindenii.org/go/furgit/object/type" ) // EntryHeader is one parsed pack entry header prefix. diff --git a/go.mod b/go.mod index 390ca978..09ec9721 100644 --- a/go.mod +++ b/go.mod @@ -1,3 +1,3 @@ -module codeberg.org/lindenii/furgit +module lindenii.org/go/furgit go 1.26.0 diff --git a/internal/adler32/adler32_amd64.go b/internal/adler32/adler32_amd64.go index 49ed8b6e..119e080b 100644 --- a/internal/adler32/adler32_amd64.go +++ b/internal/adler32/adler32_amd64.go @@ -8,7 +8,7 @@ import ( "hash" "hash/adler32" - "codeberg.org/lindenii/furgit/internal/cpu" + "lindenii.org/go/furgit/internal/cpu" ) // Size of an Adler-32 checksum in bytes. diff --git a/internal/adler32/bench_test.go b/internal/adler32/bench_test.go index 1161221a..fa5a3f9e 100644 --- a/internal/adler32/bench_test.go +++ b/internal/adler32/bench_test.go @@ -3,7 +3,7 @@ package adler32_test import ( "testing" - "codeberg.org/lindenii/furgit/internal/adler32" + "lindenii.org/go/furgit/internal/adler32" ) const benchmarkSize = 64 * 1024 diff --git a/internal/compress/flate/deflate.go b/internal/compress/flate/deflate.go index d8a1ff2a..8c8457e2 100644 --- a/internal/compress/flate/deflate.go +++ b/internal/compress/flate/deflate.go @@ -11,7 +11,7 @@ import ( "io" "math" - "codeberg.org/lindenii/furgit/internal/compress/internal/le" + "lindenii.org/go/furgit/internal/compress/internal/le" ) const ( diff --git a/internal/compress/flate/example_test.go b/internal/compress/flate/example_test.go index 0861c4da..45f44edf 100644 --- a/internal/compress/flate/example_test.go +++ b/internal/compress/flate/example_test.go @@ -13,7 +13,7 @@ import ( "strings" "sync" - "codeberg.org/lindenii/furgit/internal/compress/flate" + "lindenii.org/go/furgit/internal/compress/flate" ) // In performance critical applications, Reset can be used to discard the diff --git a/internal/compress/flate/fast_encoder.go b/internal/compress/flate/fast_encoder.go index 39393020..7af14349 100644 --- a/internal/compress/flate/fast_encoder.go +++ b/internal/compress/flate/fast_encoder.go @@ -8,7 +8,7 @@ package flate import ( "fmt" - "codeberg.org/lindenii/furgit/internal/compress/internal/le" + "lindenii.org/go/furgit/internal/compress/internal/le" ) type fastEnc interface { diff --git a/internal/compress/flate/fuzz_test.go b/internal/compress/flate/fuzz_test.go index 5c361956..b3d0098f 100644 --- a/internal/compress/flate/fuzz_test.go +++ b/internal/compress/flate/fuzz_test.go @@ -10,7 +10,7 @@ import ( "strconv" "testing" - "codeberg.org/lindenii/furgit/internal/compress/internal/fuzz" + "lindenii.org/go/furgit/internal/compress/internal/fuzz" ) // Fuzzing tweaks: diff --git a/internal/compress/flate/huffman_bit_writer.go b/internal/compress/flate/huffman_bit_writer.go index aff3c960..18dff811 100644 --- a/internal/compress/flate/huffman_bit_writer.go +++ b/internal/compress/flate/huffman_bit_writer.go @@ -9,7 +9,7 @@ import ( "io" "math" - "codeberg.org/lindenii/furgit/internal/compress/internal/le" + "lindenii.org/go/furgit/internal/compress/internal/le" ) const ( diff --git a/internal/compress/flate/level1.go b/internal/compress/flate/level1.go index 41c312e8..d7bad88d 100644 --- a/internal/compress/flate/level1.go +++ b/internal/compress/flate/level1.go @@ -3,7 +3,7 @@ package flate import ( "fmt" - "codeberg.org/lindenii/furgit/internal/compress/internal/le" + "lindenii.org/go/furgit/internal/compress/internal/le" ) // fastGen maintains the table for matches, diff --git a/internal/compress/flate/matchlen_generic.go b/internal/compress/flate/matchlen_generic.go index 63c0637d..0ccaeb93 100644 --- a/internal/compress/flate/matchlen_generic.go +++ b/internal/compress/flate/matchlen_generic.go @@ -6,7 +6,7 @@ package flate import ( "math/bits" - "codeberg.org/lindenii/furgit/internal/compress/internal/le" + "lindenii.org/go/furgit/internal/compress/internal/le" ) // matchLen returns the maximum common prefix length of a and b. diff --git a/internal/compress/flate/stateless.go b/internal/compress/flate/stateless.go index 7e944bfb..8f86e2e6 100644 --- a/internal/compress/flate/stateless.go +++ b/internal/compress/flate/stateless.go @@ -5,7 +5,7 @@ import ( "math" "sync" - "codeberg.org/lindenii/furgit/internal/compress/internal/le" + "lindenii.org/go/furgit/internal/compress/internal/le" ) const ( diff --git a/internal/compress/zlib/reader.go b/internal/compress/zlib/reader.go index 78df4f56..da82b673 100644 --- a/internal/compress/zlib/reader.go +++ b/internal/compress/zlib/reader.go @@ -40,8 +40,8 @@ import ( "io" "sync" - "codeberg.org/lindenii/furgit/internal/compress/flate" - "codeberg.org/lindenii/furgit/internal/intconv" + "lindenii.org/go/furgit/internal/compress/flate" + "lindenii.org/go/furgit/internal/intconv" ) const ( diff --git a/internal/compress/zlib/reader_reset.go b/internal/compress/zlib/reader_reset.go index 0d531896..fe33fd6a 100644 --- a/internal/compress/zlib/reader_reset.go +++ b/internal/compress/zlib/reader_reset.go @@ -10,9 +10,9 @@ import ( "errors" "io" - "codeberg.org/lindenii/furgit/internal/adler32" - "codeberg.org/lindenii/furgit/internal/compress/flate" - "codeberg.org/lindenii/furgit/internal/intconv" + "lindenii.org/go/furgit/internal/adler32" + "lindenii.org/go/furgit/internal/compress/flate" + "lindenii.org/go/furgit/internal/intconv" ) // reset resets receiver to read a new zlib stream. diff --git a/internal/compress/zlib/reader_test.go b/internal/compress/zlib/reader_test.go index 2cfa8a97..99a68202 100644 --- a/internal/compress/zlib/reader_test.go +++ b/internal/compress/zlib/reader_test.go @@ -10,7 +10,7 @@ import ( "io" "testing" - "codeberg.org/lindenii/furgit/internal/compress/zlib" + "lindenii.org/go/furgit/internal/compress/zlib" ) type zlibTest struct { diff --git a/internal/compress/zlib/writer.go b/internal/compress/zlib/writer.go index 05808eb6..ee3ce329 100644 --- a/internal/compress/zlib/writer.go +++ b/internal/compress/zlib/writer.go @@ -11,7 +11,7 @@ import ( "io" "sync" - "codeberg.org/lindenii/furgit/internal/compress/flate" + "lindenii.org/go/furgit/internal/compress/flate" ) // These constants are copied from the [flate] package, so that code that imports diff --git a/internal/compress/zlib/writer_header.go b/internal/compress/zlib/writer_header.go index 43d3bdf5..6a5f09de 100644 --- a/internal/compress/zlib/writer_header.go +++ b/internal/compress/zlib/writer_header.go @@ -7,8 +7,8 @@ package zlib import ( "encoding/binary" - "codeberg.org/lindenii/furgit/internal/adler32" - "codeberg.org/lindenii/furgit/internal/compress/flate" + "lindenii.org/go/furgit/internal/adler32" + "lindenii.org/go/furgit/internal/compress/flate" ) // writeHeader writes the ZLIB header. diff --git a/internal/compress/zlib/writer_test.go b/internal/compress/zlib/writer_test.go index 541aac65..eddf4c0c 100644 --- a/internal/compress/zlib/writer_test.go +++ b/internal/compress/zlib/writer_test.go @@ -12,7 +12,7 @@ import ( "path/filepath" "testing" - "codeberg.org/lindenii/furgit/internal/compress/zlib" + "lindenii.org/go/furgit/internal/compress/zlib" ) //nolint:gochecknoglobals diff --git a/internal/iolimit/capped_capture_writer_test.go b/internal/iolimit/capped_capture_writer_test.go index e95d06ef..2793f8cb 100644 --- a/internal/iolimit/capped_capture_writer_test.go +++ b/internal/iolimit/capped_capture_writer_test.go @@ -4,7 +4,7 @@ import ( "bytes" "testing" - "codeberg.org/lindenii/furgit/internal/iolimit" + "lindenii.org/go/furgit/internal/iolimit" ) func TestCappedCaptureWriterWithinLimit(t *testing.T) { diff --git a/internal/iolimit/expect_length_reader_test.go b/internal/iolimit/expect_length_reader_test.go index e2cfeab0..6508e5eb 100644 --- a/internal/iolimit/expect_length_reader_test.go +++ b/internal/iolimit/expect_length_reader_test.go @@ -6,7 +6,7 @@ import ( "io" "testing" - "codeberg.org/lindenii/furgit/internal/iolimit" + "lindenii.org/go/furgit/internal/iolimit" ) func TestExpectLengthReaderExact(t *testing.T) { diff --git a/internal/lru/lru_test.go b/internal/lru/lru_test.go index 006a32b8..7093b4f9 100644 --- a/internal/lru/lru_test.go +++ b/internal/lru/lru_test.go @@ -4,7 +4,7 @@ import ( "slices" "testing" - "codeberg.org/lindenii/furgit/internal/lru" + "lindenii.org/go/furgit/internal/lru" ) type testValue struct { diff --git a/internal/priorityqueue/queue_test.go b/internal/priorityqueue/queue_test.go index f6ab7833..14ed1ff6 100644 --- a/internal/priorityqueue/queue_test.go +++ b/internal/priorityqueue/queue_test.go @@ -4,7 +4,7 @@ import ( "slices" "testing" - "codeberg.org/lindenii/furgit/internal/priorityqueue" + "lindenii.org/go/furgit/internal/priorityqueue" ) func TestQueueAscending(t *testing.T) { diff --git a/internal/progress/counters.go b/internal/progress/counters.go index 7c7a5085..1ed62b7a 100644 --- a/internal/progress/counters.go +++ b/internal/progress/counters.go @@ -3,7 +3,7 @@ package progress import ( "fmt" - "codeberg.org/lindenii/furgit/internal/intconv" + "lindenii.org/go/furgit/internal/intconv" ) func (meter *Meter) renderCounters() string { diff --git a/internal/progress/meter.go b/internal/progress/meter.go index bdf0e613..368ebed2 100644 --- a/internal/progress/meter.go +++ b/internal/progress/meter.go @@ -3,7 +3,7 @@ package progress import ( "time" - "codeberg.org/lindenii/furgit/common/iowrap" + "lindenii.org/go/furgit/common/iowrap" ) // Meter renders one in-place progress line. diff --git a/internal/progress/options.go b/internal/progress/options.go index 40dd9758..320b8934 100644 --- a/internal/progress/options.go +++ b/internal/progress/options.go @@ -3,7 +3,7 @@ package progress import ( "time" - "codeberg.org/lindenii/furgit/common/iowrap" + "lindenii.org/go/furgit/common/iowrap" ) // Options configures one progress meter. diff --git a/internal/progress/render.go b/internal/progress/render.go index ae188c0e..6cccee90 100644 --- a/internal/progress/render.go +++ b/internal/progress/render.go @@ -4,7 +4,7 @@ import ( "strings" "time" - "codeberg.org/lindenii/furgit/internal/utils" + "lindenii.org/go/furgit/internal/utils" ) func (meter *Meter) render(now time.Time, eol string) { diff --git a/internal/progress/set.go b/internal/progress/set.go index 06cf889d..42cfa235 100644 --- a/internal/progress/set.go +++ b/internal/progress/set.go @@ -3,7 +3,7 @@ package progress import ( "time" - "codeberg.org/lindenii/furgit/internal/intconv" + "lindenii.org/go/furgit/internal/intconv" ) // Set records current progress and renders when percent changed or the 1s tick diff --git a/internal/testgit/algorithms.go b/internal/testgit/algorithms.go index aea4dc12..78613dbe 100644 --- a/internal/testgit/algorithms.go +++ b/internal/testgit/algorithms.go @@ -3,7 +3,7 @@ package testgit import ( "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // ForEachAlgorithm runs a subtest for every supported algorithm. diff --git a/internal/testgit/repo.go b/internal/testgit/repo.go index 72831bd6..c8a608bb 100644 --- a/internal/testgit/repo.go +++ b/internal/testgit/repo.go @@ -1,7 +1,7 @@ // Package testgit provides helpers for integration tests with upstream git(1). package testgit -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // TestRepo is a temporary git repository harness for integration tests. type TestRepo struct { diff --git a/internal/testgit/repo_cat_file.go b/internal/testgit/repo_cat_file.go index 7dbd2c43..e0203980 100644 --- a/internal/testgit/repo_cat_file.go +++ b/internal/testgit/repo_cat_file.go @@ -3,7 +3,7 @@ package testgit import ( "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // CatFile returns raw output from git cat-file. diff --git a/internal/testgit/repo_commit_tree.go b/internal/testgit/repo_commit_tree.go index 3a5a75ac..421d6209 100644 --- a/internal/testgit/repo_commit_tree.go +++ b/internal/testgit/repo_commit_tree.go @@ -3,7 +3,7 @@ package testgit import ( "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // CommitTree creates a commit from a tree and message, optionally with parents. diff --git a/internal/testgit/repo_commit_tree_env.go b/internal/testgit/repo_commit_tree_env.go index fbddf26f..7645f068 100644 --- a/internal/testgit/repo_commit_tree_env.go +++ b/internal/testgit/repo_commit_tree_env.go @@ -5,7 +5,7 @@ import ( "strings" "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // CommitTreeWithEnv creates one commit from a tree and message, optionally with diff --git a/internal/testgit/repo_from_fixture.go b/internal/testgit/repo_from_fixture.go index 632de12a..1bebda56 100644 --- a/internal/testgit/repo_from_fixture.go +++ b/internal/testgit/repo_from_fixture.go @@ -5,7 +5,7 @@ import ( "os" "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // NewRepoFromFixture copies one existing repository fixture into a temp dir. diff --git a/internal/testgit/repo_hash_object.go b/internal/testgit/repo_hash_object.go index 75f1a7ab..4e2b1fc2 100644 --- a/internal/testgit/repo_hash_object.go +++ b/internal/testgit/repo_hash_object.go @@ -3,7 +3,7 @@ package testgit import ( "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // HashObject hashes and writes an object and returns its object ID. diff --git a/internal/testgit/repo_make_commit.go b/internal/testgit/repo_make_commit.go index 32a063f7..60f90a8a 100644 --- a/internal/testgit/repo_make_commit.go +++ b/internal/testgit/repo_make_commit.go @@ -3,7 +3,7 @@ package testgit import ( "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // MakeCommit creates a commit over a single-file tree and returns (blobID, treeID, commitID). diff --git a/internal/testgit/repo_make_many_objects_history.go b/internal/testgit/repo_make_many_objects_history.go index f71ead2c..4402a5bf 100644 --- a/internal/testgit/repo_make_many_objects_history.go +++ b/internal/testgit/repo_make_many_objects_history.go @@ -5,7 +5,7 @@ import ( "strings" "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) const ( diff --git a/internal/testgit/repo_make_single_file_tree.go b/internal/testgit/repo_make_single_file_tree.go index ace98e8a..aca44515 100644 --- a/internal/testgit/repo_make_single_file_tree.go +++ b/internal/testgit/repo_make_single_file_tree.go @@ -4,7 +4,7 @@ import ( "fmt" "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // MakeSingleFileTree writes one blob and one tree entry for it and returns (blobID, treeID). diff --git a/internal/testgit/repo_mktree.go b/internal/testgit/repo_mktree.go index 893d211e..4229cece 100644 --- a/internal/testgit/repo_mktree.go +++ b/internal/testgit/repo_mktree.go @@ -3,7 +3,7 @@ package testgit import ( "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // Mktree creates a tree from textual mktree input and returns its ID. diff --git a/internal/testgit/repo_new.go b/internal/testgit/repo_new.go index b7c9968b..b7732ad7 100644 --- a/internal/testgit/repo_new.go +++ b/internal/testgit/repo_new.go @@ -4,7 +4,7 @@ import ( "os" "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // RepoOptions controls git-init options for test repositories. diff --git a/internal/testgit/repo_open_commit_graph.go b/internal/testgit/repo_open_commit_graph.go index 4db7261b..ed354747 100644 --- a/internal/testgit/repo_open_commit_graph.go +++ b/internal/testgit/repo_open_commit_graph.go @@ -3,7 +3,7 @@ package testgit import ( "testing" - commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" + commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" ) // OpenCommitGraph opens the repository commit-graph and registers cleanup on diff --git a/internal/testgit/repo_open_object_store.go b/internal/testgit/repo_open_object_store.go index 256ee54a..066fd9d4 100644 --- a/internal/testgit/repo_open_object_store.go +++ b/internal/testgit/repo_open_object_store.go @@ -3,8 +3,8 @@ package testgit import ( "testing" - objectstore "codeberg.org/lindenii/furgit/object/store" - "codeberg.org/lindenii/furgit/repository" + objectstore "lindenii.org/go/furgit/object/store" + "lindenii.org/go/furgit/repository" ) // OpenObjectStore opens the repository object store and registers cleanup on diff --git a/internal/testgit/repo_open_repository.go b/internal/testgit/repo_open_repository.go index fbc98383..cea721e0 100644 --- a/internal/testgit/repo_open_repository.go +++ b/internal/testgit/repo_open_repository.go @@ -3,7 +3,7 @@ package testgit import ( "testing" - "codeberg.org/lindenii/furgit/repository" + "lindenii.org/go/furgit/repository" ) // OpenRepository opens the repository and registers cleanup on the caller. diff --git a/internal/testgit/repo_properties.go b/internal/testgit/repo_properties.go index d46e9030..e1047bbf 100644 --- a/internal/testgit/repo_properties.go +++ b/internal/testgit/repo_properties.go @@ -1,6 +1,6 @@ package testgit -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Algorithm returns the object ID algorithm configured for this repository. func (testRepo *TestRepo) Algorithm() objectid.Algorithm { diff --git a/internal/testgit/repo_refs.go b/internal/testgit/repo_refs.go index a92e1658..d44f77e6 100644 --- a/internal/testgit/repo_refs.go +++ b/internal/testgit/repo_refs.go @@ -4,7 +4,7 @@ import ( "strings" "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // UpdateRef updates a ref to point at id. diff --git a/internal/testgit/repo_remove_loose_object.go b/internal/testgit/repo_remove_loose_object.go index 345d9db7..95bdef57 100644 --- a/internal/testgit/repo_remove_loose_object.go +++ b/internal/testgit/repo_remove_loose_object.go @@ -4,7 +4,7 @@ import ( "fmt" "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // RemoveLooseObject removes one loose object file from the repository. diff --git a/internal/testgit/repo_rev_list.go b/internal/testgit/repo_rev_list.go index 6b0c4f76..babba8da 100644 --- a/internal/testgit/repo_rev_list.go +++ b/internal/testgit/repo_rev_list.go @@ -4,7 +4,7 @@ import ( "strings" "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // RevList runs "git rev-list" with args and parses one object ID per line. diff --git a/internal/testgit/repo_rev_parse.go b/internal/testgit/repo_rev_parse.go index fcdee605..22ae1c0e 100644 --- a/internal/testgit/repo_rev_parse.go +++ b/internal/testgit/repo_rev_parse.go @@ -3,7 +3,7 @@ package testgit import ( "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // RevParse resolves rev expressions to object IDs. diff --git a/internal/testgit/repo_tag_annotated.go b/internal/testgit/repo_tag_annotated.go index cf6e9b3d..7e374102 100644 --- a/internal/testgit/repo_tag_annotated.go +++ b/internal/testgit/repo_tag_annotated.go @@ -3,7 +3,7 @@ package testgit import ( "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // TagAnnotated creates an annotated tag object and returns the resulting tag object ID. diff --git a/network/protocol/pktline/append_data_preserves_dst_on_error_test.go b/network/protocol/pktline/append_data_preserves_dst_on_error_test.go index d127fb39..61dca553 100644 --- a/network/protocol/pktline/append_data_preserves_dst_on_error_test.go +++ b/network/protocol/pktline/append_data_preserves_dst_on_error_test.go @@ -5,7 +5,7 @@ import ( "errors" "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func TestAppendDataPreservesDstOnError(t *testing.T) { diff --git a/network/protocol/pktline/append_helpers_test.go b/network/protocol/pktline/append_helpers_test.go index 259ada16..e84b543f 100644 --- a/network/protocol/pktline/append_helpers_test.go +++ b/network/protocol/pktline/append_helpers_test.go @@ -3,7 +3,7 @@ package pktline_test import ( "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func TestAppendHelpers(t *testing.T) { diff --git a/network/protocol/pktline/chunk_writer_write_and_read_from_test.go b/network/protocol/pktline/chunk_writer_write_and_read_from_test.go index efe19e23..8c524277 100644 --- a/network/protocol/pktline/chunk_writer_write_and_read_from_test.go +++ b/network/protocol/pktline/chunk_writer_write_and_read_from_test.go @@ -6,7 +6,7 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func TestChunkWriterWriteAndReadFrom(t *testing.T) { diff --git a/network/protocol/pktline/decoder_data_control_and_0004_test.go b/network/protocol/pktline/decoder_data_control_and_0004_test.go index ab92b603..3aadb3fc 100644 --- a/network/protocol/pktline/decoder_data_control_and_0004_test.go +++ b/network/protocol/pktline/decoder_data_control_and_0004_test.go @@ -4,7 +4,7 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func TestDecoderDataControlAnd0004(t *testing.T) { diff --git a/network/protocol/pktline/decoder_invalid_0003_test.go b/network/protocol/pktline/decoder_invalid_0003_test.go index 716da3f2..aafdca34 100644 --- a/network/protocol/pktline/decoder_invalid_0003_test.go +++ b/network/protocol/pktline/decoder_invalid_0003_test.go @@ -5,7 +5,7 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func TestDecoderInvalid0003(t *testing.T) { diff --git a/network/protocol/pktline/decoder_peek_test.go b/network/protocol/pktline/decoder_peek_test.go index a67da881..16ae261c 100644 --- a/network/protocol/pktline/decoder_peek_test.go +++ b/network/protocol/pktline/decoder_peek_test.go @@ -4,7 +4,7 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func TestDecoderPeek(t *testing.T) { diff --git a/network/protocol/pktline/decoder_rejects_over_maximum_length_test.go b/network/protocol/pktline/decoder_rejects_over_maximum_length_test.go index 357bfc36..1b4ba540 100644 --- a/network/protocol/pktline/decoder_rejects_over_maximum_length_test.go +++ b/network/protocol/pktline/decoder_rejects_over_maximum_length_test.go @@ -5,7 +5,7 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func TestDecoderRejectsOverMaximumLength(t *testing.T) { diff --git a/network/protocol/pktline/decoder_resync_after_over_max_data_test.go b/network/protocol/pktline/decoder_resync_after_over_max_data_test.go index 42a7572e..a4731ff5 100644 --- a/network/protocol/pktline/decoder_resync_after_over_max_data_test.go +++ b/network/protocol/pktline/decoder_resync_after_over_max_data_test.go @@ -6,7 +6,7 @@ import ( "errors" "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func TestDecoderResyncAfterOverMaxData(t *testing.T) { diff --git a/network/protocol/pktline/decoder_resync_after_over_wire_max_test.go b/network/protocol/pktline/decoder_resync_after_over_wire_max_test.go index 9413823b..a250df14 100644 --- a/network/protocol/pktline/decoder_resync_after_over_wire_max_test.go +++ b/network/protocol/pktline/decoder_resync_after_over_wire_max_test.go @@ -5,7 +5,7 @@ import ( "errors" "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func TestDecoderResyncAfterOverWireMax(t *testing.T) { diff --git a/network/protocol/pktline/decoder_unexpected_eof_test.go b/network/protocol/pktline/decoder_unexpected_eof_test.go index e1bf4457..58a7b563 100644 --- a/network/protocol/pktline/decoder_unexpected_eof_test.go +++ b/network/protocol/pktline/decoder_unexpected_eof_test.go @@ -6,7 +6,7 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func TestDecoderUnexpectedEOF(t *testing.T) { diff --git a/network/protocol/pktline/encode_length_header_test.go b/network/protocol/pktline/encode_length_header_test.go index 38a980f0..f37b153c 100644 --- a/network/protocol/pktline/encode_length_header_test.go +++ b/network/protocol/pktline/encode_length_header_test.go @@ -4,7 +4,7 @@ import ( "errors" "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func TestEncodeLengthHeader(t *testing.T) { diff --git a/network/protocol/pktline/encoder.go b/network/protocol/pktline/encoder.go index a7b17108..fb12ecf6 100644 --- a/network/protocol/pktline/encoder.go +++ b/network/protocol/pktline/encoder.go @@ -4,7 +4,7 @@ import ( "fmt" "io" - "codeberg.org/lindenii/furgit/common/iowrap" + "lindenii.org/go/furgit/common/iowrap" ) // Encoder writes pkt-line frames to a flush-capable output transport. diff --git a/network/protocol/pktline/encoder_buffered_flush_and_f_flush_test.go b/network/protocol/pktline/encoder_buffered_flush_and_f_flush_test.go index d0f26878..f134c0fe 100644 --- a/network/protocol/pktline/encoder_buffered_flush_and_f_flush_test.go +++ b/network/protocol/pktline/encoder_buffered_flush_and_f_flush_test.go @@ -5,7 +5,7 @@ import ( "bytes" "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func TestEncoderBufferedFlushAndFFlush(t *testing.T) { diff --git a/network/protocol/pktline/encoder_buffered_flush_behavior_test.go b/network/protocol/pktline/encoder_buffered_flush_behavior_test.go index b6d14b4b..ac0a2b6b 100644 --- a/network/protocol/pktline/encoder_buffered_flush_behavior_test.go +++ b/network/protocol/pktline/encoder_buffered_flush_behavior_test.go @@ -5,7 +5,7 @@ import ( "bytes" "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func TestEncoderBufferedFlushBehavior(t *testing.T) { diff --git a/network/protocol/pktline/encoder_set_max_data_cannot_exceed_wire_limit_test.go b/network/protocol/pktline/encoder_set_max_data_cannot_exceed_wire_limit_test.go index d73baa4f..b7291b06 100644 --- a/network/protocol/pktline/encoder_set_max_data_cannot_exceed_wire_limit_test.go +++ b/network/protocol/pktline/encoder_set_max_data_cannot_exceed_wire_limit_test.go @@ -6,7 +6,7 @@ import ( "errors" "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func TestEncoderSetMaxDataCannotExceedWireLimit(t *testing.T) { diff --git a/network/protocol/pktline/encoder_writes_frames_test.go b/network/protocol/pktline/encoder_writes_frames_test.go index 1922b277..b4a8beb3 100644 --- a/network/protocol/pktline/encoder_writes_frames_test.go +++ b/network/protocol/pktline/encoder_writes_frames_test.go @@ -5,7 +5,7 @@ import ( "bytes" "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func TestEncoderWritesFrames(t *testing.T) { diff --git a/network/protocol/pktline/parse_length_header_test.go b/network/protocol/pktline/parse_length_header_test.go index b1a4c1e5..a8d9dd6d 100644 --- a/network/protocol/pktline/parse_length_header_test.go +++ b/network/protocol/pktline/parse_length_header_test.go @@ -4,7 +4,7 @@ import ( "errors" "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) func TestParseLengthHeader(t *testing.T) { diff --git a/network/protocol/sideband64k/append.go b/network/protocol/sideband64k/append.go index db6527f8..5df8b447 100644 --- a/network/protocol/sideband64k/append.go +++ b/network/protocol/sideband64k/append.go @@ -3,7 +3,7 @@ package sideband64k import ( "fmt" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) // AppendBand appends one side-band-64k data frame to dst. diff --git a/network/protocol/sideband64k/append_helpers_test.go b/network/protocol/sideband64k/append_helpers_test.go index 03196c38..f68c8a62 100644 --- a/network/protocol/sideband64k/append_helpers_test.go +++ b/network/protocol/sideband64k/append_helpers_test.go @@ -3,7 +3,7 @@ package sideband64k_test import ( "testing" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" + "lindenii.org/go/furgit/network/protocol/sideband64k" ) func TestAppendHelpers(t *testing.T) { diff --git a/network/protocol/sideband64k/append_preserves_dst_on_error_test.go b/network/protocol/sideband64k/append_preserves_dst_on_error_test.go index 6fed4e4a..33272999 100644 --- a/network/protocol/sideband64k/append_preserves_dst_on_error_test.go +++ b/network/protocol/sideband64k/append_preserves_dst_on_error_test.go @@ -5,7 +5,7 @@ import ( "errors" "testing" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" + "lindenii.org/go/furgit/network/protocol/sideband64k" ) func TestAppendBandPreservesDstOnError(t *testing.T) { diff --git a/network/protocol/sideband64k/chunk_writer_write_and_read_from_test.go b/network/protocol/sideband64k/chunk_writer_write_and_read_from_test.go index ef2b0fff..c1ace728 100644 --- a/network/protocol/sideband64k/chunk_writer_write_and_read_from_test.go +++ b/network/protocol/sideband64k/chunk_writer_write_and_read_from_test.go @@ -6,7 +6,7 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" + "lindenii.org/go/furgit/network/protocol/sideband64k" ) func TestChunkWriterWriteAndReadFrom(t *testing.T) { diff --git a/network/protocol/sideband64k/constants.go b/network/protocol/sideband64k/constants.go index 2a6a2e47..2f79d907 100644 --- a/network/protocol/sideband64k/constants.go +++ b/network/protocol/sideband64k/constants.go @@ -1,6 +1,6 @@ package sideband64k -import "codeberg.org/lindenii/furgit/network/protocol/pktline" +import "lindenii.org/go/furgit/network/protocol/pktline" const ( // PacketMax is the maximum on-wire pkt-line size used by side-band-64k. diff --git a/network/protocol/sideband64k/decoder.go b/network/protocol/sideband64k/decoder.go index e34f5d12..0986920d 100644 --- a/network/protocol/sideband64k/decoder.go +++ b/network/protocol/sideband64k/decoder.go @@ -4,7 +4,7 @@ import ( "fmt" "io" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) // ReadOptions controls sideband decoding behavior. diff --git a/network/protocol/sideband64k/decoder_data_control_and_keepalive_test.go b/network/protocol/sideband64k/decoder_data_control_and_keepalive_test.go index 9103c492..ff7e3dde 100644 --- a/network/protocol/sideband64k/decoder_data_control_and_keepalive_test.go +++ b/network/protocol/sideband64k/decoder_data_control_and_keepalive_test.go @@ -4,7 +4,7 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" + "lindenii.org/go/furgit/network/protocol/sideband64k" ) func TestDecoderDataControlAndKeepalive(t *testing.T) { diff --git a/network/protocol/sideband64k/decoder_invalid_band_test.go b/network/protocol/sideband64k/decoder_invalid_band_test.go index a4bc11a9..00c2bcaf 100644 --- a/network/protocol/sideband64k/decoder_invalid_band_test.go +++ b/network/protocol/sideband64k/decoder_invalid_band_test.go @@ -5,7 +5,7 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" + "lindenii.org/go/furgit/network/protocol/sideband64k" ) func TestDecoderInvalidBand(t *testing.T) { diff --git a/network/protocol/sideband64k/decoder_invalid_empty_payload_test.go b/network/protocol/sideband64k/decoder_invalid_empty_payload_test.go index df9faa71..54bd9246 100644 --- a/network/protocol/sideband64k/decoder_invalid_empty_payload_test.go +++ b/network/protocol/sideband64k/decoder_invalid_empty_payload_test.go @@ -5,7 +5,7 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" + "lindenii.org/go/furgit/network/protocol/sideband64k" ) func TestDecoderInvalidEmptyPayload(t *testing.T) { diff --git a/network/protocol/sideband64k/decoder_malformed_pktline_test.go b/network/protocol/sideband64k/decoder_malformed_pktline_test.go index 5e4e4551..900dcdb7 100644 --- a/network/protocol/sideband64k/decoder_malformed_pktline_test.go +++ b/network/protocol/sideband64k/decoder_malformed_pktline_test.go @@ -5,8 +5,8 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" + "lindenii.org/go/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/sideband64k" ) func TestDecoderInvalid0003(t *testing.T) { diff --git a/network/protocol/sideband64k/decoder_partial_read_test.go b/network/protocol/sideband64k/decoder_partial_read_test.go index 3f103787..fe2e2fc1 100644 --- a/network/protocol/sideband64k/decoder_partial_read_test.go +++ b/network/protocol/sideband64k/decoder_partial_read_test.go @@ -3,7 +3,7 @@ package sideband64k_test import ( "testing" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" + "lindenii.org/go/furgit/network/protocol/sideband64k" ) func TestDecoderHandlesPartialReads(t *testing.T) { diff --git a/network/protocol/sideband64k/decoder_peek_test.go b/network/protocol/sideband64k/decoder_peek_test.go index 31397762..00496dbc 100644 --- a/network/protocol/sideband64k/decoder_peek_test.go +++ b/network/protocol/sideband64k/decoder_peek_test.go @@ -4,7 +4,7 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" + "lindenii.org/go/furgit/network/protocol/sideband64k" ) func TestDecoderPeek(t *testing.T) { diff --git a/network/protocol/sideband64k/decoder_resync_after_over_max_data_test.go b/network/protocol/sideband64k/decoder_resync_after_over_max_data_test.go index b0ae600a..2573e8bf 100644 --- a/network/protocol/sideband64k/decoder_resync_after_over_max_data_test.go +++ b/network/protocol/sideband64k/decoder_resync_after_over_max_data_test.go @@ -6,7 +6,7 @@ import ( "errors" "testing" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" + "lindenii.org/go/furgit/network/protocol/sideband64k" ) func TestDecoderResyncAfterOverMaxData(t *testing.T) { diff --git a/network/protocol/sideband64k/decoder_resync_after_over_wire_max_test.go b/network/protocol/sideband64k/decoder_resync_after_over_wire_max_test.go index 73966925..6b5ba287 100644 --- a/network/protocol/sideband64k/decoder_resync_after_over_wire_max_test.go +++ b/network/protocol/sideband64k/decoder_resync_after_over_wire_max_test.go @@ -5,8 +5,8 @@ import ( "errors" "testing" - "codeberg.org/lindenii/furgit/network/protocol/pktline" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" + "lindenii.org/go/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/sideband64k" ) func TestDecoderResyncAfterOverWireMax(t *testing.T) { diff --git a/network/protocol/sideband64k/decoder_unexpected_eof_test.go b/network/protocol/sideband64k/decoder_unexpected_eof_test.go index d9d71fb9..5f5004b0 100644 --- a/network/protocol/sideband64k/decoder_unexpected_eof_test.go +++ b/network/protocol/sideband64k/decoder_unexpected_eof_test.go @@ -6,7 +6,7 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" + "lindenii.org/go/furgit/network/protocol/sideband64k" ) func TestDecoderUnexpectedEOF(t *testing.T) { diff --git a/network/protocol/sideband64k/encoder.go b/network/protocol/sideband64k/encoder.go index 6cdef38a..250407c6 100644 --- a/network/protocol/sideband64k/encoder.go +++ b/network/protocol/sideband64k/encoder.go @@ -3,8 +3,8 @@ package sideband64k import ( "fmt" - "codeberg.org/lindenii/furgit/common/iowrap" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/common/iowrap" + "lindenii.org/go/furgit/network/protocol/pktline" ) // Encoder writes side-band-64k frames to a flush-capable output transport. diff --git a/network/protocol/sideband64k/encoder_buffered_flush_behavior_test.go b/network/protocol/sideband64k/encoder_buffered_flush_behavior_test.go index 83103ea3..35368bf5 100644 --- a/network/protocol/sideband64k/encoder_buffered_flush_behavior_test.go +++ b/network/protocol/sideband64k/encoder_buffered_flush_behavior_test.go @@ -5,7 +5,7 @@ import ( "bytes" "testing" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" + "lindenii.org/go/furgit/network/protocol/sideband64k" ) func TestEncoderBufferedFlushBehavior(t *testing.T) { diff --git a/network/protocol/sideband64k/encoder_partial_write_test.go b/network/protocol/sideband64k/encoder_partial_write_test.go index 97c8f762..4e2ad81b 100644 --- a/network/protocol/sideband64k/encoder_partial_write_test.go +++ b/network/protocol/sideband64k/encoder_partial_write_test.go @@ -5,7 +5,7 @@ import ( "io" "testing" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" + "lindenii.org/go/furgit/network/protocol/sideband64k" ) func TestEncoderHandlesPartialWrites(t *testing.T) { diff --git a/network/protocol/sideband64k/encoder_set_max_data_cannot_exceed_wire_limit_test.go b/network/protocol/sideband64k/encoder_set_max_data_cannot_exceed_wire_limit_test.go index 2bfcf073..b6db67d6 100644 --- a/network/protocol/sideband64k/encoder_set_max_data_cannot_exceed_wire_limit_test.go +++ b/network/protocol/sideband64k/encoder_set_max_data_cannot_exceed_wire_limit_test.go @@ -5,7 +5,7 @@ import ( "errors" "testing" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" + "lindenii.org/go/furgit/network/protocol/sideband64k" ) func TestEncoderSetMaxDataCannotExceedWireLimit(t *testing.T) { diff --git a/network/protocol/sideband64k/encoder_writes_frames_test.go b/network/protocol/sideband64k/encoder_writes_frames_test.go index 85fe5845..29e32244 100644 --- a/network/protocol/sideband64k/encoder_writes_frames_test.go +++ b/network/protocol/sideband64k/encoder_writes_frames_test.go @@ -5,7 +5,7 @@ import ( "bytes" "testing" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" + "lindenii.org/go/furgit/network/protocol/sideband64k" ) func TestEncoderWritesFrames(t *testing.T) { diff --git a/network/protocol/v0v1/server/advertise_test.go b/network/protocol/v0v1/server/advertise_test.go index 3ad7a725..88f69317 100644 --- a/network/protocol/v0v1/server/advertise_test.go +++ b/network/protocol/v0v1/server/advertise_test.go @@ -4,9 +4,9 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - server "codeberg.org/lindenii/furgit/network/protocol/v0v1/server" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/testgit" + server "lindenii.org/go/furgit/network/protocol/v0v1/server" + objectid "lindenii.org/go/furgit/object/id" ) func TestAdvertiseRefsWritesVersionOneHeadCapsAndPeeledTag(t *testing.T) { diff --git a/network/protocol/v0v1/server/advertised_ref.go b/network/protocol/v0v1/server/advertised_ref.go index cf6ddcc8..a1b7b0c0 100644 --- a/network/protocol/v0v1/server/advertised_ref.go +++ b/network/protocol/v0v1/server/advertised_ref.go @@ -1,6 +1,6 @@ package server -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // AdvertisedRef is one ref entry in one v0/v1 server advertisement. type AdvertisedRef struct { diff --git a/network/protocol/v0v1/server/frame.go b/network/protocol/v0v1/server/frame.go index ad2a0801..6cbc09b9 100644 --- a/network/protocol/v0v1/server/frame.go +++ b/network/protocol/v0v1/server/frame.go @@ -1,6 +1,6 @@ package server -import "codeberg.org/lindenii/furgit/network/protocol/pktline" +import "lindenii.org/go/furgit/network/protocol/pktline" // FrameType identifies one low-level v0/v1 server pkt-line frame type. type FrameType = pktline.PacketType diff --git a/network/protocol/v0v1/server/helpers_test.go b/network/protocol/v0v1/server/helpers_test.go index 261bbdc5..2e93bbd5 100644 --- a/network/protocol/v0v1/server/helpers_test.go +++ b/network/protocol/v0v1/server/helpers_test.go @@ -5,7 +5,7 @@ import ( "strings" "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) type bufferWriteFlusher struct { diff --git a/network/protocol/v0v1/server/receivepack/capabilities.go b/network/protocol/v0v1/server/receivepack/capabilities.go index e0ff51a3..30ba9894 100644 --- a/network/protocol/v0v1/server/receivepack/capabilities.go +++ b/network/protocol/v0v1/server/receivepack/capabilities.go @@ -5,7 +5,7 @@ import ( "slices" "strings" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // Capabilities describes one receive-pack capability set. diff --git a/network/protocol/v0v1/server/receivepack/helpers_test.go b/network/protocol/v0v1/server/receivepack/helpers_test.go index 5db8e6a6..b896324f 100644 --- a/network/protocol/v0v1/server/receivepack/helpers_test.go +++ b/network/protocol/v0v1/server/receivepack/helpers_test.go @@ -5,7 +5,7 @@ import ( "strings" "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) type bufferWriteFlusher struct { diff --git a/network/protocol/v0v1/server/receivepack/parse_test.go b/network/protocol/v0v1/server/receivepack/parse_test.go index d54d8f8d..480e23db 100644 --- a/network/protocol/v0v1/server/receivepack/parse_test.go +++ b/network/protocol/v0v1/server/receivepack/parse_test.go @@ -5,11 +5,11 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - "codeberg.org/lindenii/furgit/network/protocol/pktline" - common "codeberg.org/lindenii/furgit/network/protocol/v0v1/server" - receivepack "codeberg.org/lindenii/furgit/network/protocol/v0v1/server/receivepack" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/testgit" + "lindenii.org/go/furgit/network/protocol/pktline" + common "lindenii.org/go/furgit/network/protocol/v0v1/server" + receivepack "lindenii.org/go/furgit/network/protocol/v0v1/server/receivepack" + objectid "lindenii.org/go/furgit/object/id" ) func TestReadRequestParsesCommandsAndPushOptions(t *testing.T) { diff --git a/network/protocol/v0v1/server/receivepack/report_status.go b/network/protocol/v0v1/server/receivepack/report_status.go index d852a161..81a56507 100644 --- a/network/protocol/v0v1/server/receivepack/report_status.go +++ b/network/protocol/v0v1/server/receivepack/report_status.go @@ -3,7 +3,7 @@ package receivepack import ( "fmt" - "codeberg.org/lindenii/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/pktline" ) // WriteReportStatus writes one classic report-status response. diff --git a/network/protocol/v0v1/server/receivepack/report_status_test.go b/network/protocol/v0v1/server/receivepack/report_status_test.go index 3cde5103..d5553041 100644 --- a/network/protocol/v0v1/server/receivepack/report_status_test.go +++ b/network/protocol/v0v1/server/receivepack/report_status_test.go @@ -6,12 +6,12 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - "codeberg.org/lindenii/furgit/network/protocol/pktline" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" - common "codeberg.org/lindenii/furgit/network/protocol/v0v1/server" - receivepack "codeberg.org/lindenii/furgit/network/protocol/v0v1/server/receivepack" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/testgit" + "lindenii.org/go/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/sideband64k" + common "lindenii.org/go/furgit/network/protocol/v0v1/server" + receivepack "lindenii.org/go/furgit/network/protocol/v0v1/server/receivepack" + objectid "lindenii.org/go/furgit/object/id" ) func TestWriteReportStatusWritesClassicStatus(t *testing.T) { diff --git a/network/protocol/v0v1/server/receivepack/session.go b/network/protocol/v0v1/server/receivepack/session.go index 5299b42d..fb290c42 100644 --- a/network/protocol/v0v1/server/receivepack/session.go +++ b/network/protocol/v0v1/server/receivepack/session.go @@ -4,9 +4,9 @@ import ( "fmt" "strings" - "codeberg.org/lindenii/furgit/common/iowrap" - common "codeberg.org/lindenii/furgit/network/protocol/v0v1/server" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/common/iowrap" + common "lindenii.org/go/furgit/network/protocol/v0v1/server" + objectid "lindenii.org/go/furgit/object/id" ) // Session is one stateful server-side receive-pack protocol session. diff --git a/network/protocol/v0v1/server/receivepack/types.go b/network/protocol/v0v1/server/receivepack/types.go index b281a86b..56d92556 100644 --- a/network/protocol/v0v1/server/receivepack/types.go +++ b/network/protocol/v0v1/server/receivepack/types.go @@ -1,6 +1,6 @@ package receivepack -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Command is one requested reference update. type Command struct { diff --git a/network/protocol/v0v1/server/session.go b/network/protocol/v0v1/server/session.go index a66cc37a..675782d0 100644 --- a/network/protocol/v0v1/server/session.go +++ b/network/protocol/v0v1/server/session.go @@ -3,10 +3,10 @@ package server import ( "io" - "codeberg.org/lindenii/furgit/common/iowrap" - "codeberg.org/lindenii/furgit/network/protocol/pktline" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/common/iowrap" + "lindenii.org/go/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/sideband64k" + objectid "lindenii.org/go/furgit/object/id" ) // Options configures one server-side v0/v1 session. diff --git a/network/receivepack/advertise.go b/network/receivepack/advertise.go index 0fa010bf..45b48f8e 100644 --- a/network/receivepack/advertise.go +++ b/network/receivepack/advertise.go @@ -3,9 +3,9 @@ package receivepack import ( "errors" - common "codeberg.org/lindenii/furgit/network/protocol/v0v1/server" - "codeberg.org/lindenii/furgit/ref" - refstore "codeberg.org/lindenii/furgit/ref/store" + common "lindenii.org/go/furgit/network/protocol/v0v1/server" + "lindenii.org/go/furgit/ref" + refstore "lindenii.org/go/furgit/ref/store" ) func advertisedRefs(opts Options) ([]common.AdvertisedRef, error) { diff --git a/network/receivepack/commands.go b/network/receivepack/commands.go index a9edec1a..cf5b185b 100644 --- a/network/receivepack/commands.go +++ b/network/receivepack/commands.go @@ -1,8 +1,8 @@ package receivepack import ( - protoreceive "codeberg.org/lindenii/furgit/network/protocol/v0v1/server/receivepack" - "codeberg.org/lindenii/furgit/network/receivepack/service" + protoreceive "lindenii.org/go/furgit/network/protocol/v0v1/server/receivepack" + "lindenii.org/go/furgit/network/receivepack/service" ) func translateCommands(commands []protoreceive.Command) []service.Command { diff --git a/network/receivepack/hook.go b/network/receivepack/hook.go index 9c323bcc..4e0d4a49 100644 --- a/network/receivepack/hook.go +++ b/network/receivepack/hook.go @@ -3,12 +3,12 @@ package receivepack import ( "context" - "codeberg.org/lindenii/furgit/common/iowrap" - commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" - "codeberg.org/lindenii/furgit/network/receivepack/service" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/common/iowrap" + commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" + "lindenii.org/go/furgit/network/receivepack/service" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + refstore "lindenii.org/go/furgit/ref/store" ) type HookIO struct { diff --git a/network/receivepack/hooks/chain.go b/network/receivepack/hooks/chain.go index f98c06f8..14a1e512 100644 --- a/network/receivepack/hooks/chain.go +++ b/network/receivepack/hooks/chain.go @@ -4,7 +4,7 @@ import ( "context" "fmt" - receivepack "codeberg.org/lindenii/furgit/network/receivepack" + receivepack "lindenii.org/go/furgit/network/receivepack" ) // Chain combines hooks by running them in order and intersecting their diff --git a/network/receivepack/hooks/reject_force_push.go b/network/receivepack/hooks/reject_force_push.go index 5840a031..bd74f2f6 100644 --- a/network/receivepack/hooks/reject_force_push.go +++ b/network/receivepack/hooks/reject_force_push.go @@ -5,11 +5,11 @@ import ( "errors" "fmt" - "codeberg.org/lindenii/furgit/commitquery" - receivepack "codeberg.org/lindenii/furgit/network/receivepack" - "codeberg.org/lindenii/furgit/object/fetch" - objectmix "codeberg.org/lindenii/furgit/object/store/mix" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/commitquery" + receivepack "lindenii.org/go/furgit/network/receivepack" + "lindenii.org/go/furgit/object/fetch" + objectmix "lindenii.org/go/furgit/object/store/mix" + refstore "lindenii.org/go/furgit/ref/store" ) // RejectForcePush rejects updates whose new value is not a fast-forward of the diff --git a/network/receivepack/int_test.go b/network/receivepack/int_test.go index 2440f9c8..610a5b5c 100644 --- a/network/receivepack/int_test.go +++ b/network/receivepack/int_test.go @@ -9,16 +9,16 @@ import ( "testing" "time" - "codeberg.org/lindenii/furgit/internal/testgit" - "codeberg.org/lindenii/furgit/network/protocol/pktline" - "codeberg.org/lindenii/furgit/network/protocol/sideband64k" - receivepack "codeberg.org/lindenii/furgit/network/receivepack" - receivepackhooks "codeberg.org/lindenii/furgit/network/receivepack/hooks" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - objectdual "codeberg.org/lindenii/furgit/object/store/dual" - objectloose "codeberg.org/lindenii/furgit/object/store/loose" - objectpacked "codeberg.org/lindenii/furgit/object/store/packed" + "lindenii.org/go/furgit/internal/testgit" + "lindenii.org/go/furgit/network/protocol/pktline" + "lindenii.org/go/furgit/network/protocol/sideband64k" + receivepack "lindenii.org/go/furgit/network/receivepack" + receivepackhooks "lindenii.org/go/furgit/network/receivepack/hooks" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + objectdual "lindenii.org/go/furgit/object/store/dual" + objectloose "lindenii.org/go/furgit/object/store/loose" + objectpacked "lindenii.org/go/furgit/object/store/packed" ) func TestReceivePackDeleteOnlyAtomicDeleteSucceeds(t *testing.T) { diff --git a/network/receivepack/options.go b/network/receivepack/options.go index 30792765..41489249 100644 --- a/network/receivepack/options.go +++ b/network/receivepack/options.go @@ -1,10 +1,10 @@ package receivepack import ( - commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - refstore "codeberg.org/lindenii/furgit/ref/store" + commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + refstore "lindenii.org/go/furgit/ref/store" ) // Options configures one receive-pack invocation. diff --git a/network/receivepack/receivepack.go b/network/receivepack/receivepack.go index d58e9fa0..9c66f07a 100644 --- a/network/receivepack/receivepack.go +++ b/network/receivepack/receivepack.go @@ -4,10 +4,10 @@ import ( "context" "io" - "codeberg.org/lindenii/furgit/common/iowrap" - common "codeberg.org/lindenii/furgit/network/protocol/v0v1/server" - protoreceive "codeberg.org/lindenii/furgit/network/protocol/v0v1/server/receivepack" - "codeberg.org/lindenii/furgit/network/receivepack/service" + "lindenii.org/go/furgit/common/iowrap" + common "lindenii.org/go/furgit/network/protocol/v0v1/server" + protoreceive "lindenii.org/go/furgit/network/protocol/v0v1/server/receivepack" + "lindenii.org/go/furgit/network/receivepack/service" ) // TODO: Some more designing to do. In particular, we'd like to have access to diff --git a/network/receivepack/results.go b/network/receivepack/results.go index d43bee73..b877d5ae 100644 --- a/network/receivepack/results.go +++ b/network/receivepack/results.go @@ -1,8 +1,8 @@ package receivepack import ( - protoreceive "codeberg.org/lindenii/furgit/network/protocol/v0v1/server/receivepack" - "codeberg.org/lindenii/furgit/network/receivepack/service" + protoreceive "lindenii.org/go/furgit/network/protocol/v0v1/server/receivepack" + "lindenii.org/go/furgit/network/receivepack/service" ) func translateResult(result *service.Result) protoreceive.ReportStatusResult { diff --git a/network/receivepack/service/apply.go b/network/receivepack/service/apply.go index fdf3eef6..199465d5 100644 --- a/network/receivepack/service/apply.go +++ b/network/receivepack/service/apply.go @@ -1,8 +1,8 @@ package service import ( - "codeberg.org/lindenii/furgit/internal/utils" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/internal/utils" + refstore "lindenii.org/go/furgit/ref/store" ) func (service *Service) applyAtomic(result *Result, commands []Command) error { diff --git a/network/receivepack/service/command.go b/network/receivepack/service/command.go index 9ad50c4f..4d0e3466 100644 --- a/network/receivepack/service/command.go +++ b/network/receivepack/service/command.go @@ -1,6 +1,6 @@ package service -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Command is one protocol-independent requested ref update. type Command struct { diff --git a/network/receivepack/service/command_result.go b/network/receivepack/service/command_result.go index 37549f08..2afe7e68 100644 --- a/network/receivepack/service/command_result.go +++ b/network/receivepack/service/command_result.go @@ -1,6 +1,6 @@ package service -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // CommandResult is one per-command execution result. type CommandResult struct { diff --git a/network/receivepack/service/execute.go b/network/receivepack/service/execute.go index 92d34a63..e66821d6 100644 --- a/network/receivepack/service/execute.go +++ b/network/receivepack/service/execute.go @@ -3,8 +3,8 @@ package service import ( "context" - "codeberg.org/lindenii/furgit/internal/utils" - objectstore "codeberg.org/lindenii/furgit/object/store" + "lindenii.org/go/furgit/internal/utils" + objectstore "lindenii.org/go/furgit/object/store" ) // Execute validates one receive-pack request, optionally ingests its pack into diff --git a/network/receivepack/service/hook.go b/network/receivepack/service/hook.go index 3826e6fb..a93c5a80 100644 --- a/network/receivepack/service/hook.go +++ b/network/receivepack/service/hook.go @@ -3,11 +3,11 @@ package service import ( "context" - "codeberg.org/lindenii/furgit/common/iowrap" - commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/common/iowrap" + commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + refstore "lindenii.org/go/furgit/ref/store" ) type HookIO struct { diff --git a/network/receivepack/service/ingest_quarantine.go b/network/receivepack/service/ingest_quarantine.go index 75f3a790..dc0fef50 100644 --- a/network/receivepack/service/ingest_quarantine.go +++ b/network/receivepack/service/ingest_quarantine.go @@ -1,8 +1,8 @@ package service import ( - "codeberg.org/lindenii/furgit/internal/utils" - objectstore "codeberg.org/lindenii/furgit/object/store" + "lindenii.org/go/furgit/internal/utils" + objectstore "lindenii.org/go/furgit/object/store" ) func (service *Service) ingestQuarantine( diff --git a/network/receivepack/service/options.go b/network/receivepack/service/options.go index b6e71d64..7a6288b9 100644 --- a/network/receivepack/service/options.go +++ b/network/receivepack/service/options.go @@ -1,10 +1,10 @@ package service import ( - "codeberg.org/lindenii/furgit/common/iowrap" - commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" - objectstore "codeberg.org/lindenii/furgit/object/store" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/common/iowrap" + commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" + objectstore "lindenii.org/go/furgit/object/store" + refstore "lindenii.org/go/furgit/ref/store" ) // Options configures one protocol-independent receive-pack service. diff --git a/network/receivepack/service/run_hook.go b/network/receivepack/service/run_hook.go index c8b1b76c..c9c9b3a5 100644 --- a/network/receivepack/service/run_hook.go +++ b/network/receivepack/service/run_hook.go @@ -3,8 +3,8 @@ package service import ( "context" - "codeberg.org/lindenii/furgit/internal/utils" - objectstore "codeberg.org/lindenii/furgit/object/store" + "lindenii.org/go/furgit/internal/utils" + objectstore "lindenii.org/go/furgit/object/store" ) func (service *Service) runHook( diff --git a/network/receivepack/service/service_test.go b/network/receivepack/service/service_test.go index 94e105da..0f648892 100644 --- a/network/receivepack/service/service_test.go +++ b/network/receivepack/service/service_test.go @@ -6,14 +6,14 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - "codeberg.org/lindenii/furgit/network/receivepack/service" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - objectdual "codeberg.org/lindenii/furgit/object/store/dual" - objectloose "codeberg.org/lindenii/furgit/object/store/loose" - "codeberg.org/lindenii/furgit/object/store/memory" - objectpacked "codeberg.org/lindenii/furgit/object/store/packed" + "lindenii.org/go/furgit/internal/testgit" + "lindenii.org/go/furgit/network/receivepack/service" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + objectdual "lindenii.org/go/furgit/object/store/dual" + objectloose "lindenii.org/go/furgit/object/store/loose" + "lindenii.org/go/furgit/object/store/memory" + objectpacked "lindenii.org/go/furgit/object/store/packed" ) func TestExecutePackExpectedWithoutObjectIngress(t *testing.T) { diff --git a/network/receivepack/service/update.go b/network/receivepack/service/update.go index 753e3b02..86dfa10d 100644 --- a/network/receivepack/service/update.go +++ b/network/receivepack/service/update.go @@ -1,6 +1,6 @@ package service -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // PlannedUpdate is one requested ref update planned for this execution. type PlannedUpdate struct { diff --git a/network/receivepack/version.go b/network/receivepack/version.go index 9a4544dc..d3eecc73 100644 --- a/network/receivepack/version.go +++ b/network/receivepack/version.go @@ -3,7 +3,7 @@ package receivepack import ( "strings" - common "codeberg.org/lindenii/furgit/network/protocol/v0v1/server" + common "lindenii.org/go/furgit/network/protocol/v0v1/server" ) func parseVersion(gitProtocol string) common.Version { diff --git a/object/blob/parse_test.go b/object/blob/parse_test.go index 09d5d5d0..9f2057f7 100644 --- a/object/blob/parse_test.go +++ b/object/blob/parse_test.go @@ -4,9 +4,9 @@ import ( "bytes" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - "codeberg.org/lindenii/furgit/object/blob" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/testgit" + "lindenii.org/go/furgit/object/blob" + objectid "lindenii.org/go/furgit/object/id" ) func TestBlobParseFromGit(t *testing.T) { diff --git a/object/blob/serialize.go b/object/blob/serialize.go index 5594b200..78d7a4d0 100644 --- a/object/blob/serialize.go +++ b/object/blob/serialize.go @@ -3,8 +3,8 @@ package blob import ( "errors" - objectheader "codeberg.org/lindenii/furgit/object/header" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectheader "lindenii.org/go/furgit/object/header" + objecttype "lindenii.org/go/furgit/object/type" ) // BytesWithoutHeader renders the raw blob body bytes. diff --git a/object/blob/serialize_test.go b/object/blob/serialize_test.go index 99725eaf..709ccf91 100644 --- a/object/blob/serialize_test.go +++ b/object/blob/serialize_test.go @@ -3,9 +3,9 @@ package blob_test import ( "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - "codeberg.org/lindenii/furgit/object/blob" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/testgit" + "lindenii.org/go/furgit/object/blob" + objectid "lindenii.org/go/furgit/object/id" ) func TestBlobSerialize(t *testing.T) { diff --git a/object/blob/test.go b/object/blob/test.go index 9e538219..b2c086f6 100644 --- a/object/blob/test.go +++ b/object/blob/test.go @@ -1,6 +1,6 @@ package blob -import objecttype "codeberg.org/lindenii/furgit/object/type" +import objecttype "lindenii.org/go/furgit/object/type" // ObjectType returns TypeBlob. func (blob *Blob) ObjectType() objecttype.Type { diff --git a/object/commit/commit.go b/object/commit/commit.go index 0f7649e1..dd77dbc1 100644 --- a/object/commit/commit.go +++ b/object/commit/commit.go @@ -3,12 +3,12 @@ // It parses commits into ordinary Go values for reading and construction. It // does not preserve the exact original byte layout needed for signature // verification; callers that need signature-verification payload fidelity -// should use [codeberg.org/lindenii/furgit/object/signed/commit]. +// should use [lindenii.org/go/furgit/object/signed/commit]. package commit import ( - objectid "codeberg.org/lindenii/furgit/object/id" - objectsignature "codeberg.org/lindenii/furgit/object/signature" + objectid "lindenii.org/go/furgit/object/id" + objectsignature "lindenii.org/go/furgit/object/signature" ) // Commit represents a fully materialized Git commit object. diff --git a/object/commit/parse.go b/object/commit/parse.go index 9dcc930d..3d018a6a 100644 --- a/object/commit/parse.go +++ b/object/commit/parse.go @@ -5,8 +5,8 @@ import ( "errors" "fmt" - objectid "codeberg.org/lindenii/furgit/object/id" - objectsignature "codeberg.org/lindenii/furgit/object/signature" + objectid "lindenii.org/go/furgit/object/id" + objectsignature "lindenii.org/go/furgit/object/signature" ) // Parse decodes a commit object body. diff --git a/object/commit/parse_test.go b/object/commit/parse_test.go index ad2c7aed..a44092bb 100644 --- a/object/commit/parse_test.go +++ b/object/commit/parse_test.go @@ -5,9 +5,9 @@ import ( "fmt" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - "codeberg.org/lindenii/furgit/object/commit" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/testgit" + "lindenii.org/go/furgit/object/commit" + objectid "lindenii.org/go/furgit/object/id" ) func TestCommitParseFromGit(t *testing.T) { diff --git a/object/commit/serialize.go b/object/commit/serialize.go index 0642d656..6f9a486b 100644 --- a/object/commit/serialize.go +++ b/object/commit/serialize.go @@ -5,8 +5,8 @@ import ( "errors" "fmt" - objectheader "codeberg.org/lindenii/furgit/object/header" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectheader "lindenii.org/go/furgit/object/header" + objecttype "lindenii.org/go/furgit/object/type" ) // BytesWithoutHeader renders the raw commit body bytes. diff --git a/object/commit/serialize_test.go b/object/commit/serialize_test.go index 6a3486cd..fbd8bdba 100644 --- a/object/commit/serialize_test.go +++ b/object/commit/serialize_test.go @@ -3,9 +3,9 @@ package commit_test import ( "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - "codeberg.org/lindenii/furgit/object/commit" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/testgit" + "lindenii.org/go/furgit/object/commit" + objectid "lindenii.org/go/furgit/object/id" ) func TestCommitSerialize(t *testing.T) { diff --git a/object/commit/type.go b/object/commit/type.go index b8aa11e8..e250e977 100644 --- a/object/commit/type.go +++ b/object/commit/type.go @@ -1,6 +1,6 @@ package commit -import objecttype "codeberg.org/lindenii/furgit/object/type" +import objecttype "lindenii.org/go/furgit/object/type" // ObjectType returns TypeCommit. func (commit *Commit) ObjectType() objecttype.Type { diff --git a/object/doc.go b/object/doc.go index f675b963..787dacfc 100644 --- a/object/doc.go +++ b/object/doc.go @@ -2,6 +2,6 @@ // for Git object values. // // Concrete object forms such as [blob], [tree], [commit], and [tag] live in -// subpackages. Use [codeberg.org/lindenii/furgit/object/stored] when object +// subpackages. Use [lindenii.org/go/furgit/object/stored] when object // values need to be paired with the object IDs they were loaded under. package object diff --git a/object/fetch/exact_blob.go b/object/fetch/exact_blob.go index ef4b84fe..761e4f1c 100644 --- a/object/fetch/exact_blob.go +++ b/object/fetch/exact_blob.go @@ -1,11 +1,11 @@ package fetch import ( - giterrors "codeberg.org/lindenii/furgit/errors" - "codeberg.org/lindenii/furgit/object/blob" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/stored" - objecttype "codeberg.org/lindenii/furgit/object/type" + giterrors "lindenii.org/go/furgit/errors" + "lindenii.org/go/furgit/object/blob" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/stored" + objecttype "lindenii.org/go/furgit/object/type" ) // ExactBlob reads, parses, and wraps the blob at id. diff --git a/object/fetch/exact_blob_reader.go b/object/fetch/exact_blob_reader.go index 4a313d3e..302eb730 100644 --- a/object/fetch/exact_blob_reader.go +++ b/object/fetch/exact_blob_reader.go @@ -3,8 +3,8 @@ package fetch import ( "io" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // ExactBlobReader returns a reader for the content of the blob at id, diff --git a/object/fetch/exact_commit.go b/object/fetch/exact_commit.go index 9483b2b1..b99a5550 100644 --- a/object/fetch/exact_commit.go +++ b/object/fetch/exact_commit.go @@ -1,11 +1,11 @@ package fetch import ( - giterrors "codeberg.org/lindenii/furgit/errors" - "codeberg.org/lindenii/furgit/object/commit" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/stored" - objecttype "codeberg.org/lindenii/furgit/object/type" + giterrors "lindenii.org/go/furgit/errors" + "lindenii.org/go/furgit/object/commit" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/stored" + objecttype "lindenii.org/go/furgit/object/type" ) // ExactCommit reads, parses, and wraps the commit at id. diff --git a/object/fetch/exact_object.go b/object/fetch/exact_object.go index 2e4a8217..24279aeb 100644 --- a/object/fetch/exact_object.go +++ b/object/fetch/exact_object.go @@ -1,9 +1,9 @@ package fetch import ( - "codeberg.org/lindenii/furgit/object" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/stored" + "lindenii.org/go/furgit/object" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/stored" ) // ExactObject reads, parses, and wraps the object at id without constraining diff --git a/object/fetch/exact_reader.go b/object/fetch/exact_reader.go index d588480d..9064aff4 100644 --- a/object/fetch/exact_reader.go +++ b/object/fetch/exact_reader.go @@ -3,9 +3,9 @@ package fetch import ( "io" - giterrors "codeberg.org/lindenii/furgit/errors" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + giterrors "lindenii.org/go/furgit/errors" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // exactReader reads one object's content stream and verifies that its header diff --git a/object/fetch/exact_tag.go b/object/fetch/exact_tag.go index 230e7d57..9d35b4f2 100644 --- a/object/fetch/exact_tag.go +++ b/object/fetch/exact_tag.go @@ -1,11 +1,11 @@ package fetch import ( - giterrors "codeberg.org/lindenii/furgit/errors" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/stored" - "codeberg.org/lindenii/furgit/object/tag" - objecttype "codeberg.org/lindenii/furgit/object/type" + giterrors "lindenii.org/go/furgit/errors" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/stored" + "lindenii.org/go/furgit/object/tag" + objecttype "lindenii.org/go/furgit/object/type" ) // ExactTag reads, parses, and wraps the tag at id. diff --git a/object/fetch/exact_tree.go b/object/fetch/exact_tree.go index 8bfc87ea..b2b96da8 100644 --- a/object/fetch/exact_tree.go +++ b/object/fetch/exact_tree.go @@ -1,11 +1,11 @@ package fetch import ( - giterrors "codeberg.org/lindenii/furgit/errors" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/stored" - "codeberg.org/lindenii/furgit/object/tree" - objecttype "codeberg.org/lindenii/furgit/object/type" + giterrors "lindenii.org/go/furgit/errors" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/stored" + "lindenii.org/go/furgit/object/tree" + objecttype "lindenii.org/go/furgit/object/type" ) // ExactTree reads, parses, and wraps the tree at id. diff --git a/object/fetch/fetcher.go b/object/fetch/fetcher.go index fcd64d88..de719793 100644 --- a/object/fetch/fetcher.go +++ b/object/fetch/fetcher.go @@ -1,6 +1,6 @@ package fetch -import objectstore "codeberg.org/lindenii/furgit/object/store" +import objectstore "lindenii.org/go/furgit/object/store" // Fetcher provides ordinary object access above an object store. // diff --git a/object/fetch/header.go b/object/fetch/header.go index 0a535dd9..5ff41ae7 100644 --- a/object/fetch/header.go +++ b/object/fetch/header.go @@ -1,8 +1,8 @@ package fetch import ( - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // Header returns the object type and content size at id. diff --git a/object/fetch/object_errors.go b/object/fetch/object_errors.go index 08de6f75..62f9eb55 100644 --- a/object/fetch/object_errors.go +++ b/object/fetch/object_errors.go @@ -3,9 +3,9 @@ package fetch import ( stderrors "errors" - giterrors "codeberg.org/lindenii/furgit/errors" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" + giterrors "lindenii.org/go/furgit/errors" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" ) // wrapObjectReadError maps raw object-store lookup failures to fetcher-level diff --git a/object/fetch/object_parse.go b/object/fetch/object_parse.go index 0a61bb3d..2cacda79 100644 --- a/object/fetch/object_parse.go +++ b/object/fetch/object_parse.go @@ -3,8 +3,8 @@ package fetch import ( "fmt" - "codeberg.org/lindenii/furgit/object" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/object" + objectid "lindenii.org/go/furgit/object/id" ) func (r *Fetcher) parseObject(id objectid.ObjectID) (object.Object, error) { diff --git a/object/fetch/path.go b/object/fetch/path.go index e3c468db..682fbdcb 100644 --- a/object/fetch/path.go +++ b/object/fetch/path.go @@ -3,8 +3,8 @@ package fetch import ( "fmt" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/tree" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/tree" ) // PathEmptyError indicates that Path received no segments. diff --git a/object/fetch/peel_to_blob.go b/object/fetch/peel_to_blob.go index 121bb70b..ec1d9626 100644 --- a/object/fetch/peel_to_blob.go +++ b/object/fetch/peel_to_blob.go @@ -1,12 +1,12 @@ package fetch import ( - giterrors "codeberg.org/lindenii/furgit/errors" - "codeberg.org/lindenii/furgit/object/blob" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/stored" - "codeberg.org/lindenii/furgit/object/tag" - objecttype "codeberg.org/lindenii/furgit/object/type" + giterrors "lindenii.org/go/furgit/errors" + "lindenii.org/go/furgit/object/blob" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/stored" + "lindenii.org/go/furgit/object/tag" + objecttype "lindenii.org/go/furgit/object/type" ) // PeelToBlob peels tags until it reaches a blob. diff --git a/object/fetch/peel_to_blob_id.go b/object/fetch/peel_to_blob_id.go index 82f23c91..063811cb 100644 --- a/object/fetch/peel_to_blob_id.go +++ b/object/fetch/peel_to_blob_id.go @@ -1,9 +1,9 @@ package fetch import ( - giterrors "codeberg.org/lindenii/furgit/errors" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + giterrors "lindenii.org/go/furgit/errors" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // PeelToBlobID peels tags until it reaches a blob object ID. diff --git a/object/fetch/peel_to_blob_reader.go b/object/fetch/peel_to_blob_reader.go index dedffd01..870ead57 100644 --- a/object/fetch/peel_to_blob_reader.go +++ b/object/fetch/peel_to_blob_reader.go @@ -3,7 +3,7 @@ package fetch import ( "io" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // PeelToBlobReader returns a reader for the content of the peeled blob at id, diff --git a/object/fetch/peel_to_commit.go b/object/fetch/peel_to_commit.go index 569ea7a8..c485e7a5 100644 --- a/object/fetch/peel_to_commit.go +++ b/object/fetch/peel_to_commit.go @@ -1,12 +1,12 @@ package fetch import ( - giterrors "codeberg.org/lindenii/furgit/errors" - "codeberg.org/lindenii/furgit/object/commit" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/stored" - "codeberg.org/lindenii/furgit/object/tag" - objecttype "codeberg.org/lindenii/furgit/object/type" + giterrors "lindenii.org/go/furgit/errors" + "lindenii.org/go/furgit/object/commit" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/stored" + "lindenii.org/go/furgit/object/tag" + objecttype "lindenii.org/go/furgit/object/type" ) // PeelToCommit peels tags until it reaches a commit. diff --git a/object/fetch/peel_to_commit_id.go b/object/fetch/peel_to_commit_id.go index 9d7fdbc9..7abe1879 100644 --- a/object/fetch/peel_to_commit_id.go +++ b/object/fetch/peel_to_commit_id.go @@ -1,9 +1,9 @@ package fetch import ( - giterrors "codeberg.org/lindenii/furgit/errors" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + giterrors "lindenii.org/go/furgit/errors" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // PeelToCommitID peels tags until it reaches a commit object ID. diff --git a/object/fetch/peel_to_tree.go b/object/fetch/peel_to_tree.go index 8898746b..2af230e6 100644 --- a/object/fetch/peel_to_tree.go +++ b/object/fetch/peel_to_tree.go @@ -1,13 +1,13 @@ package fetch import ( - giterrors "codeberg.org/lindenii/furgit/errors" - "codeberg.org/lindenii/furgit/object/commit" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/stored" - "codeberg.org/lindenii/furgit/object/tag" - "codeberg.org/lindenii/furgit/object/tree" - objecttype "codeberg.org/lindenii/furgit/object/type" + giterrors "lindenii.org/go/furgit/errors" + "lindenii.org/go/furgit/object/commit" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/stored" + "lindenii.org/go/furgit/object/tag" + "lindenii.org/go/furgit/object/tree" + objecttype "lindenii.org/go/furgit/object/type" ) // PeelToTree peels tags until it reaches a tree or commit. If it reaches a diff --git a/object/fetch/peel_to_tree_id.go b/object/fetch/peel_to_tree_id.go index 8482d28e..9f9ac823 100644 --- a/object/fetch/peel_to_tree_id.go +++ b/object/fetch/peel_to_tree_id.go @@ -1,9 +1,9 @@ package fetch import ( - giterrors "codeberg.org/lindenii/furgit/errors" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + giterrors "lindenii.org/go/furgit/errors" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // PeelToTreeID peels tags until it reaches a tree object ID, or a commit whose diff --git a/object/fetch/size.go b/object/fetch/size.go index da59e12a..9323da1a 100644 --- a/object/fetch/size.go +++ b/object/fetch/size.go @@ -1,6 +1,6 @@ package fetch -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Size returns the object content size at id. // diff --git a/object/fetch/treefs.go b/object/fetch/treefs.go index 39ea7ad5..c0353fff 100644 --- a/object/fetch/treefs.go +++ b/object/fetch/treefs.go @@ -3,8 +3,8 @@ package fetch import ( "io/fs" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/tree" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/tree" ) // TreeFS exposes one Git tree as an fs.FS view backed by a Fetcher. diff --git a/object/fetch/treefs_entry.go b/object/fetch/treefs_entry.go index e577d86c..a55f52ea 100644 --- a/object/fetch/treefs_entry.go +++ b/object/fetch/treefs_entry.go @@ -5,8 +5,8 @@ import ( "fmt" "io/fs" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/tree" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/tree" ) func (treeFS *TreeFS) resolvePath(op treeFSOp, name string) (treeEntryValue, error) { diff --git a/object/fetch/treefs_info.go b/object/fetch/treefs_info.go index f1db7e9a..0aaa7365 100644 --- a/object/fetch/treefs_info.go +++ b/object/fetch/treefs_info.go @@ -4,7 +4,7 @@ import ( "io/fs" "time" - "codeberg.org/lindenii/furgit/object/tree" + "lindenii.org/go/furgit/object/tree" ) type treeFSInfo struct { diff --git a/object/fetch/treefs_new.go b/object/fetch/treefs_new.go index f1096a3c..a5fc61bc 100644 --- a/object/fetch/treefs_new.go +++ b/object/fetch/treefs_new.go @@ -1,6 +1,6 @@ package fetch -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // TreeFS returns a new filesystem view rooted at root, which may be any // tree-ish object accepted by PeelToTreeID. diff --git a/object/fetch/treefs_open.go b/object/fetch/treefs_open.go index fc0f7635..8a4424e2 100644 --- a/object/fetch/treefs_open.go +++ b/object/fetch/treefs_open.go @@ -5,7 +5,7 @@ import ( "io" "io/fs" - "codeberg.org/lindenii/furgit/object/tree" + "lindenii.org/go/furgit/object/tree" ) // Open opens name for reading. diff --git a/object/fetch/treefs_readfile.go b/object/fetch/treefs_readfile.go index b248135f..310c4e7e 100644 --- a/object/fetch/treefs_readfile.go +++ b/object/fetch/treefs_readfile.go @@ -4,7 +4,7 @@ import ( "fmt" "io" - "codeberg.org/lindenii/furgit/object/tree" + "lindenii.org/go/furgit/object/tree" ) // ReadFile reads the blob contents at name. diff --git a/object/fetch/treefs_test.go b/object/fetch/treefs_test.go index a4f28a01..07569791 100644 --- a/object/fetch/treefs_test.go +++ b/object/fetch/treefs_test.go @@ -5,11 +5,11 @@ import ( "io/fs" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - "codeberg.org/lindenii/furgit/object/fetch" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/tree" - "codeberg.org/lindenii/furgit/repository" + "lindenii.org/go/furgit/internal/testgit" + "lindenii.org/go/furgit/object/fetch" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/tree" + "lindenii.org/go/furgit/repository" ) func TestTreeFS(t *testing.T) { diff --git a/object/header/append.go b/object/header/append.go index 6d824740..9ffa3382 100644 --- a/object/header/append.go +++ b/object/header/append.go @@ -3,7 +3,7 @@ package objectheader import ( "strconv" - objecttype "codeberg.org/lindenii/furgit/object/type" + objecttype "lindenii.org/go/furgit/object/type" ) // Append appends a canonical loose-object header ("type size\\x00") to dst. diff --git a/object/header/encode.go b/object/header/encode.go index a03c1f05..29028ba4 100644 --- a/object/header/encode.go +++ b/object/header/encode.go @@ -1,6 +1,6 @@ package objectheader -import objecttype "codeberg.org/lindenii/furgit/object/type" +import objecttype "lindenii.org/go/furgit/object/type" // Encode returns a canonical loose-object header ("type size\\x00"). func Encode(ty objecttype.Type, size int64) ([]byte, bool) { diff --git a/object/header/parse.go b/object/header/parse.go index cad521e5..25a8afbe 100644 --- a/object/header/parse.go +++ b/object/header/parse.go @@ -4,7 +4,7 @@ import ( "bytes" "strconv" - objecttype "codeberg.org/lindenii/furgit/object/type" + objecttype "lindenii.org/go/furgit/object/type" ) // Parse parses a canonical loose-object header ("type size\\x00"). diff --git a/object/id/objectid_test.go b/object/id/objectid_test.go index 9d179fb5..d7eabe08 100644 --- a/object/id/objectid_test.go +++ b/object/id/objectid_test.go @@ -5,7 +5,7 @@ import ( "strings" "testing" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) func TestParseAlgorithm(t *testing.T) { diff --git a/object/object.go b/object/object.go index 2021a3de..903a8823 100644 --- a/object/object.go +++ b/object/object.go @@ -1,6 +1,6 @@ package object -import objecttype "codeberg.org/lindenii/furgit/object/type" +import objecttype "lindenii.org/go/furgit/object/type" // Object is a Git object. type Object interface { diff --git a/object/parse_with_header.go b/object/parse_with_header.go index 9bcf5a4c..2b38da72 100644 --- a/object/parse_with_header.go +++ b/object/parse_with_header.go @@ -3,8 +3,8 @@ package object import ( "fmt" - objectheader "codeberg.org/lindenii/furgit/object/header" - objectid "codeberg.org/lindenii/furgit/object/id" + objectheader "lindenii.org/go/furgit/object/header" + objectid "lindenii.org/go/furgit/object/id" ) // ParseWithHeader parses a loose object in "type size\x00body" format. diff --git a/object/parse_without_header.go b/object/parse_without_header.go index c889cb40..e73bbd49 100644 --- a/object/parse_without_header.go +++ b/object/parse_without_header.go @@ -3,12 +3,12 @@ package object import ( "fmt" - "codeberg.org/lindenii/furgit/object/blob" - "codeberg.org/lindenii/furgit/object/commit" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/tag" - "codeberg.org/lindenii/furgit/object/tree" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/object/blob" + "lindenii.org/go/furgit/object/commit" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/tag" + "lindenii.org/go/furgit/object/tree" + objecttype "lindenii.org/go/furgit/object/type" ) // ParseWithoutHeader parses a typed object body. diff --git a/object/signature/parse.go b/object/signature/parse.go index a6880eee..2a2b6116 100644 --- a/object/signature/parse.go +++ b/object/signature/parse.go @@ -6,7 +6,7 @@ import ( "fmt" "strconv" - "codeberg.org/lindenii/furgit/internal/intconv" + "lindenii.org/go/furgit/internal/intconv" ) // Parse parses a canonical Git signature line: diff --git a/object/signed/commit/commit.go b/object/signed/commit/commit.go index cd0ff197..64b0b0bf 100644 --- a/object/signed/commit/commit.go +++ b/object/signed/commit/commit.go @@ -1,6 +1,6 @@ package signedcommit -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Commit represents the payload and signatures parsed from a raw comit object. type Commit struct { diff --git a/object/signed/commit/integration_test.go b/object/signed/commit/integration_test.go index 82b34b14..a48089be 100644 --- a/object/signed/commit/integration_test.go +++ b/object/signed/commit/integration_test.go @@ -7,9 +7,9 @@ import ( "path/filepath" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - signedcommit "codeberg.org/lindenii/furgit/object/signed/commit" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + signedcommit "lindenii.org/go/furgit/object/signed/commit" ) func setupSSHSignedCommit( diff --git a/object/signed/commit/parse.go b/object/signed/commit/parse.go index fa498093..ffd79bb1 100644 --- a/object/signed/commit/parse.go +++ b/object/signed/commit/parse.go @@ -3,7 +3,7 @@ package signedcommit import ( "bytes" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // Parse parses one raw commit object body for signature extraction. diff --git a/object/signed/commit/signature_algorithms.go b/object/signed/commit/signature_algorithms.go index ac763706..2f83894c 100644 --- a/object/signed/commit/signature_algorithms.go +++ b/object/signed/commit/signature_algorithms.go @@ -1,6 +1,6 @@ package signedcommit -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Algorithms returns the algorithms for which the commit carries signatures. func (commit *Commit) Algorithms() []objectid.Algorithm { diff --git a/object/signed/commit/signature_append.go b/object/signed/commit/signature_append.go index 7f9144b7..d2589907 100644 --- a/object/signed/commit/signature_append.go +++ b/object/signed/commit/signature_append.go @@ -1,6 +1,6 @@ package signedcommit -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // AppendSignature appends the unfolded signature for algo to dst. func (commit *Commit) AppendSignature(dst []byte, algo objectid.Algorithm) ([]byte, bool) { diff --git a/object/signed/commit/unit_test.go b/object/signed/commit/unit_test.go index 88d4fa3b..f0a5059a 100644 --- a/object/signed/commit/unit_test.go +++ b/object/signed/commit/unit_test.go @@ -4,8 +4,8 @@ import ( "slices" "testing" - objectid "codeberg.org/lindenii/furgit/object/id" - signedcommit "codeberg.org/lindenii/furgit/object/signed/commit" + objectid "lindenii.org/go/furgit/object/id" + signedcommit "lindenii.org/go/furgit/object/signed/commit" ) func TestParseUpstreamMultiplySignedCommit(t *testing.T) { diff --git a/object/signed/doc.go b/object/signed/doc.go index fb6fc3f8..b1616a5b 100644 --- a/object/signed/doc.go +++ b/object/signed/doc.go @@ -2,6 +2,6 @@ // // Its subpackages extract verification payloads and embedded signatures from // raw commit and tag object bodies, without depending on the parsed -// object models in [codeberg.org/lindenii/furgit/object/commit] and -// [codeberg.org/lindenii/furgit/object/tag]. +// object models in [lindenii.org/go/furgit/object/commit] and +// [lindenii.org/go/furgit/object/tag]. package signed diff --git a/object/signed/tag/integration_test.go b/object/signed/tag/integration_test.go index af32aa02..ce424078 100644 --- a/object/signed/tag/integration_test.go +++ b/object/signed/tag/integration_test.go @@ -7,9 +7,9 @@ import ( "path/filepath" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - signedtag "codeberg.org/lindenii/furgit/object/signed/tag" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + signedtag "lindenii.org/go/furgit/object/signed/tag" ) func setupSSHSignedTag( diff --git a/object/signed/tag/parse.go b/object/signed/tag/parse.go index b2061d3f..64c974f2 100644 --- a/object/signed/tag/parse.go +++ b/object/signed/tag/parse.go @@ -4,7 +4,7 @@ import ( "bytes" "slices" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) var signatureBeginLines = [][]byte{ //nolint:gochecknoglobals diff --git a/object/signed/tag/signature_algorithms.go b/object/signed/tag/signature_algorithms.go index bc178bce..feb6054d 100644 --- a/object/signed/tag/signature_algorithms.go +++ b/object/signed/tag/signature_algorithms.go @@ -1,6 +1,6 @@ package signedtag -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Algorithms returns the algorithms for which the tag carries signatures. func (tag *Tag) Algorithms() []objectid.Algorithm { diff --git a/object/signed/tag/signature_append.go b/object/signed/tag/signature_append.go index 101816eb..a6752c72 100644 --- a/object/signed/tag/signature_append.go +++ b/object/signed/tag/signature_append.go @@ -1,6 +1,6 @@ package signedtag -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // AppendSignature appends the signature for algo to dst. func (tag *Tag) AppendSignature(dst []byte, algo objectid.Algorithm) ([]byte, bool) { diff --git a/object/signed/tag/tag.go b/object/signed/tag/tag.go index 2ebf9369..62b34ffc 100644 --- a/object/signed/tag/tag.go +++ b/object/signed/tag/tag.go @@ -1,6 +1,6 @@ package signedtag -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Tag represents the payload and signatures parsed from a raw tag object. type Tag struct { diff --git a/object/signed/tag/unit_test.go b/object/signed/tag/unit_test.go index dd4ae66f..1d06df89 100644 --- a/object/signed/tag/unit_test.go +++ b/object/signed/tag/unit_test.go @@ -3,8 +3,8 @@ package signedtag_test import ( "testing" - objectid "codeberg.org/lindenii/furgit/object/id" - signedtag "codeberg.org/lindenii/furgit/object/signed/tag" + objectid "lindenii.org/go/furgit/object/id" + signedtag "lindenii.org/go/furgit/object/signed/tag" ) func TestParseSignedTag(t *testing.T) { diff --git a/object/store/chain/bytes.go b/object/store/chain/bytes.go index dc9b7906..aabed063 100644 --- a/object/store/chain/bytes.go +++ b/object/store/chain/bytes.go @@ -4,9 +4,9 @@ import ( "errors" "fmt" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + objecttype "lindenii.org/go/furgit/object/type" ) // ReadBytesFull reads a full serialized object from the first backend that has it. diff --git a/object/store/chain/chain.go b/object/store/chain/chain.go index 218c8abd..93249f41 100644 --- a/object/store/chain/chain.go +++ b/object/store/chain/chain.go @@ -2,7 +2,7 @@ // backends. package chain -import objectstore "codeberg.org/lindenii/furgit/object/store" +import objectstore "lindenii.org/go/furgit/object/store" // Chain queries multiple object databases in order. // diff --git a/object/store/chain/header.go b/object/store/chain/header.go index f6c92459..3d70d494 100644 --- a/object/store/chain/header.go +++ b/object/store/chain/header.go @@ -4,9 +4,9 @@ import ( "errors" "fmt" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + objecttype "lindenii.org/go/furgit/object/type" ) // ReadHeader reads object header data from the first backend that has it. diff --git a/object/store/chain/new.go b/object/store/chain/new.go index dd499d38..c5e36a93 100644 --- a/object/store/chain/new.go +++ b/object/store/chain/new.go @@ -1,6 +1,6 @@ package chain -import objectstore "codeberg.org/lindenii/furgit/object/store" +import objectstore "lindenii.org/go/furgit/object/store" // New creates an ordered object database chain. // diff --git a/object/store/chain/reader.go b/object/store/chain/reader.go index 3991ee9a..feff84e9 100644 --- a/object/store/chain/reader.go +++ b/object/store/chain/reader.go @@ -5,9 +5,9 @@ import ( "fmt" "io" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + objecttype "lindenii.org/go/furgit/object/type" ) // ReadReaderFull reads a full serialized object stream from the first backend that has it. diff --git a/object/store/chain/size.go b/object/store/chain/size.go index f0099028..3f9ea591 100644 --- a/object/store/chain/size.go +++ b/object/store/chain/size.go @@ -4,8 +4,8 @@ import ( "errors" "fmt" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" ) // ReadSize reads object content length from the first backend that has it. diff --git a/object/store/doc.go b/object/store/doc.go index 45acc47c..b0b47419 100644 --- a/object/store/doc.go +++ b/object/store/doc.go @@ -3,7 +3,7 @@ // Reading stores only respond to object-ID queries in terms of headers (type // and size), raw bytes, and streaming payloads, but they do not parse commits, // trees, blobs, or tags into typed values. Turning stored objects into typed -// objects is the job of [codeberg.org/lindenii/furgit/object/fetch]. +// objects is the job of [lindenii.org/go/furgit/object/fetch]. // // This package does not define one unified writing interface. Backends have // very different write models: writing one loose object is natural, while diff --git a/object/store/dual/dual.go b/object/store/dual/dual.go index 3072ae77..f2e0b9e3 100644 --- a/object/store/dual/dual.go +++ b/object/store/dual/dual.go @@ -1,6 +1,6 @@ package dual -import objectstore "codeberg.org/lindenii/furgit/object/store" +import objectstore "lindenii.org/go/furgit/object/store" type objectSide interface { objectstore.Reader diff --git a/object/store/dual/dual_test.go b/object/store/dual/dual_test.go index 1d25a775..40fc5bcf 100644 --- a/object/store/dual/dual_test.go +++ b/object/store/dual/dual_test.go @@ -7,13 +7,13 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - "codeberg.org/lindenii/furgit/object/store/dual" - "codeberg.org/lindenii/furgit/object/store/loose" - "codeberg.org/lindenii/furgit/object/store/packed" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + "lindenii.org/go/furgit/object/store/dual" + "lindenii.org/go/furgit/object/store/loose" + "lindenii.org/go/furgit/object/store/packed" + objecttype "lindenii.org/go/furgit/object/type" ) func fixturePath(t *testing.T, algo objectid.Algorithm, name string) string { diff --git a/object/store/dual/new.go b/object/store/dual/new.go index ef38bc7a..7602620e 100644 --- a/object/store/dual/new.go +++ b/object/store/dual/new.go @@ -1,8 +1,8 @@ package dual import ( - objectstore "codeberg.org/lindenii/furgit/object/store" - objectmix "codeberg.org/lindenii/furgit/object/store/mix" + objectstore "lindenii.org/go/furgit/object/store" + objectmix "lindenii.org/go/furgit/object/store/mix" ) // New creates one dual object store from borrowed object-wise and pack-wise diff --git a/object/store/dual/quarantine.go b/object/store/dual/quarantine.go index fb1048af..0bb1e1f5 100644 --- a/object/store/dual/quarantine.go +++ b/object/store/dual/quarantine.go @@ -3,10 +3,10 @@ package dual import ( "io" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - objectmix "codeberg.org/lindenii/furgit/object/store/mix" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + objectmix "lindenii.org/go/furgit/object/store/mix" + objecttype "lindenii.org/go/furgit/object/type" ) // quarantine is one coordinated dual quarantine over both stores. diff --git a/object/store/dual/quarantine_begin.go b/object/store/dual/quarantine_begin.go index 5c6bc934..a849da18 100644 --- a/object/store/dual/quarantine_begin.go +++ b/object/store/dual/quarantine_begin.go @@ -1,6 +1,6 @@ package dual -import objectstore "codeberg.org/lindenii/furgit/object/store" +import objectstore "lindenii.org/go/furgit/object/store" // BeginQuarantine creates one coordinated dual quarantine spanning both stores. // diff --git a/object/store/dual/reader.go b/object/store/dual/reader.go index 7b499d5d..dbcd6bce 100644 --- a/object/store/dual/reader.go +++ b/object/store/dual/reader.go @@ -3,8 +3,8 @@ package dual import ( "io" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // ReadBytesFull reads a full serialized object as "type size\0content" from diff --git a/object/store/dual/writer_object.go b/object/store/dual/writer_object.go index 7aefe9ea..35dffa83 100644 --- a/object/store/dual/writer_object.go +++ b/object/store/dual/writer_object.go @@ -3,8 +3,8 @@ package dual import ( "io" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // WriteReaderContent writes one typed object content stream to the object-wise diff --git a/object/store/dual/writer_pack.go b/object/store/dual/writer_pack.go index 5ac8648b..41cb1e9c 100644 --- a/object/store/dual/writer_pack.go +++ b/object/store/dual/writer_pack.go @@ -3,7 +3,7 @@ package dual import ( "io" - objectstore "codeberg.org/lindenii/furgit/object/store" + objectstore "lindenii.org/go/furgit/object/store" ) // WritePack ingests one pack stream into the pack-wise store. diff --git a/object/store/loose/helpers_test.go b/object/store/loose/helpers_test.go index 97cec9d7..eb434d20 100644 --- a/object/store/loose/helpers_test.go +++ b/object/store/loose/helpers_test.go @@ -5,11 +5,11 @@ import ( "os" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectheader "codeberg.org/lindenii/furgit/object/header" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/store/loose" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/testgit" + objectheader "lindenii.org/go/furgit/object/header" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/store/loose" + objecttype "lindenii.org/go/furgit/object/type" ) func openLooseStore(t *testing.T, testRepo *testgit.TestRepo, algo objectid.Algorithm) *loose.Store { diff --git a/object/store/loose/parse.go b/object/store/loose/parse.go index dfb420ba..77deb512 100644 --- a/object/store/loose/parse.go +++ b/object/store/loose/parse.go @@ -6,9 +6,9 @@ import ( "io" "os" - "codeberg.org/lindenii/furgit/internal/compress/zlib" - objectheader "codeberg.org/lindenii/furgit/object/header" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/compress/zlib" + objectheader "lindenii.org/go/furgit/object/header" + objecttype "lindenii.org/go/furgit/object/type" ) // decodeAll inflates the full loose object payload from file. diff --git a/object/store/loose/paths.go b/object/store/loose/paths.go index 0593cc0d..c8e09e14 100644 --- a/object/store/loose/paths.go +++ b/object/store/loose/paths.go @@ -7,8 +7,8 @@ import ( "os" "path/filepath" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" ) // objectPath returns the loose object path for id relative to the objects root. diff --git a/object/store/loose/quarantine.go b/object/store/loose/quarantine.go index 52fb8120..79112a68 100644 --- a/object/store/loose/quarantine.go +++ b/object/store/loose/quarantine.go @@ -3,7 +3,7 @@ package loose import ( "os" - objectstore "codeberg.org/lindenii/furgit/object/store" + objectstore "lindenii.org/go/furgit/object/store" ) var _ objectstore.ObjectQuarantiner = (*Store)(nil) diff --git a/object/store/loose/quarantine_begin.go b/object/store/loose/quarantine_begin.go index dd27f968..89fef075 100644 --- a/object/store/loose/quarantine_begin.go +++ b/object/store/loose/quarantine_begin.go @@ -7,7 +7,7 @@ import ( "io/fs" "os" - objectstore "codeberg.org/lindenii/furgit/object/store" + objectstore "lindenii.org/go/furgit/object/store" ) // BeginObjectQuarantine creates one quarantined loose store rooted privately diff --git a/object/store/loose/quarantine_test.go b/object/store/loose/quarantine_test.go index 4fd1b8f9..8f382c24 100644 --- a/object/store/loose/quarantine_test.go +++ b/object/store/loose/quarantine_test.go @@ -4,10 +4,10 @@ import ( "bytes" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + objecttype "lindenii.org/go/furgit/object/type" ) func TestLooseQuarantinePromotePublishesWrittenObjects(t *testing.T) { diff --git a/object/store/loose/read_bytes.go b/object/store/loose/read_bytes.go index 5ed3b82b..3fa74935 100644 --- a/object/store/loose/read_bytes.go +++ b/object/store/loose/read_bytes.go @@ -1,8 +1,8 @@ package loose import ( - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // readBytesParsed reads, inflates, and parses a loose object in one pass. diff --git a/object/store/loose/read_header.go b/object/store/loose/read_header.go index 37bf40de..28730b1b 100644 --- a/object/store/loose/read_header.go +++ b/object/store/loose/read_header.go @@ -3,9 +3,9 @@ package loose import ( "bufio" - "codeberg.org/lindenii/furgit/internal/compress/zlib" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/compress/zlib" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // ReadHeader reads an object's type and declared content length. diff --git a/object/store/loose/read_reader.go b/object/store/loose/read_reader.go index c8c8d736..a8f4efde 100644 --- a/object/store/loose/read_reader.go +++ b/object/store/loose/read_reader.go @@ -7,10 +7,10 @@ import ( "io" "os" - "codeberg.org/lindenii/furgit/internal/compress/zlib" - "codeberg.org/lindenii/furgit/internal/iolimit" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/compress/zlib" + "lindenii.org/go/furgit/internal/iolimit" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) type objectReader struct { diff --git a/object/store/loose/read_size.go b/object/store/loose/read_size.go index 2ececc49..ca9c0f4b 100644 --- a/object/store/loose/read_size.go +++ b/object/store/loose/read_size.go @@ -1,6 +1,6 @@ package loose -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // ReadSize reads an object's declared content length. // diff --git a/object/store/loose/read_test.go b/object/store/loose/read_test.go index fcb4fe17..cc935d61 100644 --- a/object/store/loose/read_test.go +++ b/object/store/loose/read_test.go @@ -7,11 +7,11 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - "codeberg.org/lindenii/furgit/object/store/loose" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + "lindenii.org/go/furgit/object/store/loose" + objecttype "lindenii.org/go/furgit/object/type" ) func TestLooseStoreReadAgainstGit(t *testing.T) { diff --git a/object/store/loose/store.go b/object/store/loose/store.go index ea466284..55f1340f 100644 --- a/object/store/loose/store.go +++ b/object/store/loose/store.go @@ -4,7 +4,7 @@ package loose import ( "os" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // Store reads loose Git objects from an objects directory root. diff --git a/object/store/loose/write_bytes.go b/object/store/loose/write_bytes.go index ffc65117..4237f1ca 100644 --- a/object/store/loose/write_bytes.go +++ b/object/store/loose/write_bytes.go @@ -3,8 +3,8 @@ package loose import ( "bytes" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // WriteBytesFull writes a full serialized object as "type size\0content". diff --git a/object/store/loose/write_reader.go b/object/store/loose/write_reader.go index f686f279..5c8db17c 100644 --- a/object/store/loose/write_reader.go +++ b/object/store/loose/write_reader.go @@ -4,9 +4,9 @@ import ( "fmt" "io" - objectheader "codeberg.org/lindenii/furgit/object/header" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectheader "lindenii.org/go/furgit/object/header" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // WriteReaderContent writes one loose object from typed content bytes read from src. diff --git a/object/store/loose/write_test.go b/object/store/loose/write_test.go index 30d8dbdb..302415ac 100644 --- a/object/store/loose/write_test.go +++ b/object/store/loose/write_test.go @@ -4,10 +4,10 @@ import ( "bytes" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectheader "codeberg.org/lindenii/furgit/object/header" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/testgit" + objectheader "lindenii.org/go/furgit/object/header" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) func TestLooseStoreWriteReaderContentAgainstGit(t *testing.T) { diff --git a/object/store/loose/write_writer.go b/object/store/loose/write_writer.go index 0d6b5b80..a4cc7bf0 100644 --- a/object/store/loose/write_writer.go +++ b/object/store/loose/write_writer.go @@ -5,7 +5,7 @@ import ( "hash" "os" - "codeberg.org/lindenii/furgit/internal/compress/zlib" + "lindenii.org/go/furgit/internal/compress/zlib" ) const tempObjectFilePrefix = "tmp_obj_" diff --git a/object/store/loose/write_writer_accept.go b/object/store/loose/write_writer_accept.go index bf55966a..3640f827 100644 --- a/object/store/loose/write_writer_accept.go +++ b/object/store/loose/write_writer_accept.go @@ -4,7 +4,7 @@ import ( "bytes" "errors" - objectheader "codeberg.org/lindenii/furgit/object/header" + objectheader "lindenii.org/go/furgit/object/header" ) // acceptFull validates and accounts raw full-object input. diff --git a/object/store/loose/write_writer_finalize.go b/object/store/loose/write_writer_finalize.go index 71e275db..9427278c 100644 --- a/object/store/loose/write_writer_finalize.go +++ b/object/store/loose/write_writer_finalize.go @@ -5,7 +5,7 @@ import ( "io/fs" "path/filepath" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // Close flushes and closes the underlying zlib stream and temp file. diff --git a/object/store/memory/algorithm.go b/object/store/memory/algorithm.go index bf7f3a82..ac847019 100644 --- a/object/store/memory/algorithm.go +++ b/object/store/memory/algorithm.go @@ -1,6 +1,6 @@ package memory -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Algorithm returns the object ID algorithm used by the store. func (store *Store) Algorithm() objectid.Algorithm { diff --git a/object/store/memory/object.go b/object/store/memory/object.go index a85175c7..4cc043f0 100644 --- a/object/store/memory/object.go +++ b/object/store/memory/object.go @@ -1,6 +1,6 @@ package memory -import objecttype "codeberg.org/lindenii/furgit/object/type" +import objecttype "lindenii.org/go/furgit/object/type" // storedObject is one in-memory object entry. type storedObject struct { diff --git a/object/store/memory/read_bytes.go b/object/store/memory/read_bytes.go index 48d3694a..06603105 100644 --- a/object/store/memory/read_bytes.go +++ b/object/store/memory/read_bytes.go @@ -1,10 +1,10 @@ package memory import ( - objectheader "codeberg.org/lindenii/furgit/object/header" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectheader "lindenii.org/go/furgit/object/header" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + objecttype "lindenii.org/go/furgit/object/type" ) // ReadBytesFull reads one full object, including the object header. diff --git a/object/store/memory/read_header.go b/object/store/memory/read_header.go index da3acd1c..27f2169b 100644 --- a/object/store/memory/read_header.go +++ b/object/store/memory/read_header.go @@ -1,9 +1,9 @@ package memory import ( - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + objecttype "lindenii.org/go/furgit/object/type" ) // ReadHeader reads one object header. diff --git a/object/store/memory/read_reader.go b/object/store/memory/read_reader.go index 425c3034..48e7f64f 100644 --- a/object/store/memory/read_reader.go +++ b/object/store/memory/read_reader.go @@ -4,8 +4,8 @@ import ( "bytes" "io" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // ReadReaderFull reads one full object through a reader. diff --git a/object/store/memory/read_size.go b/object/store/memory/read_size.go index 7045bd61..20453fce 100644 --- a/object/store/memory/read_size.go +++ b/object/store/memory/read_size.go @@ -1,6 +1,6 @@ package memory -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // ReadSize reads one object size. func (store *Store) ReadSize(id objectid.ObjectID) (int64, error) { diff --git a/object/store/memory/store.go b/object/store/memory/store.go index ff66da50..619b79d1 100644 --- a/object/store/memory/store.go +++ b/object/store/memory/store.go @@ -1,7 +1,7 @@ package memory import ( - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // Store is one in-memory object store. diff --git a/object/store/memory/write_bytes.go b/object/store/memory/write_bytes.go index 241169d9..92070efe 100644 --- a/object/store/memory/write_bytes.go +++ b/object/store/memory/write_bytes.go @@ -3,9 +3,9 @@ package memory import ( "bytes" - objectheader "codeberg.org/lindenii/furgit/object/header" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectheader "lindenii.org/go/furgit/object/header" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // WriteBytesContent writes one typed object content byte slice. diff --git a/object/store/memory/write_reader.go b/object/store/memory/write_reader.go index 0fa6a13f..527e669b 100644 --- a/object/store/memory/write_reader.go +++ b/object/store/memory/write_reader.go @@ -5,9 +5,9 @@ import ( "fmt" "io" - objectheader "codeberg.org/lindenii/furgit/object/header" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectheader "lindenii.org/go/furgit/object/header" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // WriteReaderContent writes one typed object content stream. diff --git a/object/store/memory/write_test.go b/object/store/memory/write_test.go index 9f38a14b..4257dced 100644 --- a/object/store/memory/write_test.go +++ b/object/store/memory/write_test.go @@ -4,11 +4,11 @@ import ( "bytes" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectheader "codeberg.org/lindenii/furgit/object/header" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/store/memory" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/testgit" + objectheader "lindenii.org/go/furgit/object/header" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/store/memory" + objecttype "lindenii.org/go/furgit/object/type" ) func TestStoreWriteReaderContent(t *testing.T) { diff --git a/object/store/mix/bytes.go b/object/store/mix/bytes.go index 5b62ff06..504cb907 100644 --- a/object/store/mix/bytes.go +++ b/object/store/mix/bytes.go @@ -4,9 +4,9 @@ import ( "errors" "fmt" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + objecttype "lindenii.org/go/furgit/object/type" ) // ReadBytesFull reads a full serialized object from one backend that has it. diff --git a/object/store/mix/header.go b/object/store/mix/header.go index d57375ec..1045c359 100644 --- a/object/store/mix/header.go +++ b/object/store/mix/header.go @@ -4,9 +4,9 @@ import ( "errors" "fmt" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + objecttype "lindenii.org/go/furgit/object/type" ) // ReadHeader reads object header data from one backend that has it. diff --git a/object/store/mix/mix.go b/object/store/mix/mix.go index 65ed97c8..7daf39c8 100644 --- a/object/store/mix/mix.go +++ b/object/store/mix/mix.go @@ -5,7 +5,7 @@ package mix import ( "sync" - objectstore "codeberg.org/lindenii/furgit/object/store" + objectstore "lindenii.org/go/furgit/object/store" ) // Mix queries multiple object databases with an MRU backend preference. diff --git a/object/store/mix/mru.go b/object/store/mix/mru.go index b48f1448..6f419f1d 100644 --- a/object/store/mix/mru.go +++ b/object/store/mix/mru.go @@ -1,6 +1,6 @@ package mix -import objectstore "codeberg.org/lindenii/furgit/object/store" +import objectstore "lindenii.org/go/furgit/object/store" type backendNode struct { backend objectstore.Reader diff --git a/object/store/mix/new.go b/object/store/mix/new.go index abc6c8ee..3afe4d21 100644 --- a/object/store/mix/new.go +++ b/object/store/mix/new.go @@ -1,6 +1,6 @@ package mix -import objectstore "codeberg.org/lindenii/furgit/object/store" +import objectstore "lindenii.org/go/furgit/object/store" // New creates a Mix from backends. // diff --git a/object/store/mix/reader.go b/object/store/mix/reader.go index 8d515c50..c6429ad3 100644 --- a/object/store/mix/reader.go +++ b/object/store/mix/reader.go @@ -5,9 +5,9 @@ import ( "fmt" "io" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + objecttype "lindenii.org/go/furgit/object/type" ) // ReadReaderFull reads a full serialized object stream from one backend that diff --git a/object/store/mix/refresh.go b/object/store/mix/refresh.go index bbae6efe..c575df0e 100644 --- a/object/store/mix/refresh.go +++ b/object/store/mix/refresh.go @@ -3,7 +3,7 @@ package mix import ( "errors" - objectstore "codeberg.org/lindenii/furgit/object/store" + objectstore "lindenii.org/go/furgit/object/store" ) // Refresh forwards refresh calls to refresh-capable backends. diff --git a/object/store/mix/size.go b/object/store/mix/size.go index 4feb142e..f5f2f04c 100644 --- a/object/store/mix/size.go +++ b/object/store/mix/size.go @@ -4,8 +4,8 @@ import ( "errors" "fmt" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" ) // ReadSize reads object content length from one backend that has it. diff --git a/object/store/packed/internal/ingest/cache.go b/object/store/packed/internal/ingest/cache.go index 9a15f55f..1684a99b 100644 --- a/object/store/packed/internal/ingest/cache.go +++ b/object/store/packed/internal/ingest/cache.go @@ -1,8 +1,8 @@ package ingest import ( - "codeberg.org/lindenii/furgit/internal/lru" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/lru" + objecttype "lindenii.org/go/furgit/object/type" ) // deltaBaseCacheKey identifies one resolved base by record index. diff --git a/object/store/packed/internal/ingest/delta_header.go b/object/store/packed/internal/ingest/delta_header.go index 110cf83b..4104c1b2 100644 --- a/object/store/packed/internal/ingest/delta_header.go +++ b/object/store/packed/internal/ingest/delta_header.go @@ -1,6 +1,6 @@ package ingest -import deltaapply "codeberg.org/lindenii/furgit/format/packfile/delta/apply" +import deltaapply "lindenii.org/go/furgit/format/packfile/delta/apply" // finalizeStreamPackHash consumes trailer bytes and verifies stream integrity. // readDeltaHeaderSizes reads source and destination sizes from one delta payload. diff --git a/object/store/packed/internal/ingest/drain.go b/object/store/packed/internal/ingest/drain.go index 7179a823..4bc4b9e3 100644 --- a/object/store/packed/internal/ingest/drain.go +++ b/object/store/packed/internal/ingest/drain.go @@ -4,10 +4,10 @@ import ( "fmt" "io" - "codeberg.org/lindenii/furgit/internal/compress/zlib" - objectheader "codeberg.org/lindenii/furgit/object/header" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/compress/zlib" + objectheader "lindenii.org/go/furgit/object/header" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // drainEntryPayload inflates one entry payload from stream and returns diff --git a/object/store/packed/internal/ingest/entry.go b/object/store/packed/internal/ingest/entry.go index 363e213c..4292a242 100644 --- a/object/store/packed/internal/ingest/entry.go +++ b/object/store/packed/internal/ingest/entry.go @@ -3,7 +3,7 @@ package ingest import ( "fmt" - objecttype "codeberg.org/lindenii/furgit/object/type" + objecttype "lindenii.org/go/furgit/object/type" ) // scanOneEntry scans one pack entry from stream and appends one record. diff --git a/object/store/packed/internal/ingest/entry_header.go b/object/store/packed/internal/ingest/entry_header.go index c74fdc16..9fe9f82f 100644 --- a/object/store/packed/internal/ingest/entry_header.go +++ b/object/store/packed/internal/ingest/entry_header.go @@ -1,8 +1,8 @@ package ingest import ( - "codeberg.org/lindenii/furgit/internal/intconv" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/intconv" + objecttype "lindenii.org/go/furgit/object/type" ) // encodePackEntryHeader encodes one non-delta packed entry header. diff --git a/object/store/packed/internal/ingest/entry_prefix.go b/object/store/packed/internal/ingest/entry_prefix.go index a107b4e8..9011cb4c 100644 --- a/object/store/packed/internal/ingest/entry_prefix.go +++ b/object/store/packed/internal/ingest/entry_prefix.go @@ -3,9 +3,9 @@ package ingest import ( "fmt" - "codeberg.org/lindenii/furgit/internal/intconv" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/intconv" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // parseEntryPrefix parses one entry prefix from stream. diff --git a/object/store/packed/internal/ingest/finalize.go b/object/store/packed/internal/ingest/finalize.go index 6fe4edb2..6f219b25 100644 --- a/object/store/packed/internal/ingest/finalize.go +++ b/object/store/packed/internal/ingest/finalize.go @@ -6,7 +6,7 @@ import ( "io/fs" "strings" - "codeberg.org/lindenii/furgit/internal/intconv" + "lindenii.org/go/furgit/internal/intconv" ) // finalizeArtifacts links temporary files to final names and returns Result. diff --git a/object/store/packed/internal/ingest/hash.go b/object/store/packed/internal/ingest/hash.go index 4b739c20..7ae65526 100644 --- a/object/store/packed/internal/ingest/hash.go +++ b/object/store/packed/internal/ingest/hash.go @@ -3,9 +3,9 @@ package ingest import ( "fmt" - objectheader "codeberg.org/lindenii/furgit/object/header" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectheader "lindenii.org/go/furgit/object/header" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // hashCanonicalObject hashes canonical object bytes (header+content). diff --git a/object/store/packed/internal/ingest/header.go b/object/store/packed/internal/ingest/header.go index 6b90becc..4512df0c 100644 --- a/object/store/packed/internal/ingest/header.go +++ b/object/store/packed/internal/ingest/header.go @@ -5,7 +5,7 @@ import ( "fmt" "io" - "codeberg.org/lindenii/furgit/format/packfile" + "lindenii.org/go/furgit/format/packfile" ) const packHeaderSize = 12 diff --git a/object/store/packed/internal/ingest/idx_write.go b/object/store/packed/internal/ingest/idx_write.go index fa139264..20a0514e 100644 --- a/object/store/packed/internal/ingest/idx_write.go +++ b/object/store/packed/internal/ingest/idx_write.go @@ -8,8 +8,8 @@ import ( "io" "slices" - "codeberg.org/lindenii/furgit/internal/intconv" - "codeberg.org/lindenii/furgit/internal/progress" + "lindenii.org/go/furgit/internal/intconv" + "lindenii.org/go/furgit/internal/progress" ) const ( diff --git a/object/store/packed/internal/ingest/ingest_test.go b/object/store/packed/internal/ingest/ingest_test.go index 1631ec34..57acd6e8 100644 --- a/object/store/packed/internal/ingest/ingest_test.go +++ b/object/store/packed/internal/ingest/ingest_test.go @@ -10,9 +10,9 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/store/packed/internal/ingest" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/store/packed/internal/ingest" ) type noExtraReadReader struct { diff --git a/object/store/packed/internal/ingest/options.go b/object/store/packed/internal/ingest/options.go index 06c334c0..b2a4810a 100644 --- a/object/store/packed/internal/ingest/options.go +++ b/object/store/packed/internal/ingest/options.go @@ -1,8 +1,8 @@ package ingest import ( - "codeberg.org/lindenii/furgit/common/iowrap" - objectstore "codeberg.org/lindenii/furgit/object/store" + "lindenii.org/go/furgit/common/iowrap" + objectstore "lindenii.org/go/furgit/object/store" ) // Options controls one pack ingest operation. diff --git a/object/store/packed/internal/ingest/progress_write.go b/object/store/packed/internal/ingest/progress_write.go index afb39305..1b981387 100644 --- a/object/store/packed/internal/ingest/progress_write.go +++ b/object/store/packed/internal/ingest/progress_write.go @@ -1,6 +1,6 @@ package ingest -import "codeberg.org/lindenii/furgit/internal/utils" +import "lindenii.org/go/furgit/internal/utils" func writeProgressf(state *ingestState, format string, args ...any) { utils.BestEffortFprintf(state.opts.Progress, format, args...) diff --git a/object/store/packed/internal/ingest/record_content.go b/object/store/packed/internal/ingest/record_content.go index c66a1234..df382d6d 100644 --- a/object/store/packed/internal/ingest/record_content.go +++ b/object/store/packed/internal/ingest/record_content.go @@ -3,7 +3,7 @@ package ingest import ( "fmt" - objecttype "codeberg.org/lindenii/furgit/object/type" + objecttype "lindenii.org/go/furgit/object/type" ) // readBaseRecordContent reads canonical base content for one non-delta record. diff --git a/object/store/packed/internal/ingest/record_delta.go b/object/store/packed/internal/ingest/record_delta.go index bc40367f..886f145a 100644 --- a/object/store/packed/internal/ingest/record_delta.go +++ b/object/store/packed/internal/ingest/record_delta.go @@ -3,8 +3,8 @@ package ingest import ( "fmt" - deltaapply "codeberg.org/lindenii/furgit/format/packfile/delta/apply" - objecttype "codeberg.org/lindenii/furgit/object/type" + deltaapply "lindenii.org/go/furgit/format/packfile/delta/apply" + objecttype "lindenii.org/go/furgit/object/type" ) // applyDeltaRecord applies one delta record onto base content. diff --git a/object/store/packed/internal/ingest/record_inflate.go b/object/store/packed/internal/ingest/record_inflate.go index b8eca25b..95795cfc 100644 --- a/object/store/packed/internal/ingest/record_inflate.go +++ b/object/store/packed/internal/ingest/record_inflate.go @@ -5,7 +5,7 @@ import ( "fmt" "io" - "codeberg.org/lindenii/furgit/internal/intconv" + "lindenii.org/go/furgit/internal/intconv" ) // inflateRecordPayload inflates one record's zlib payload from pack file. diff --git a/object/store/packed/internal/ingest/record_resolve.go b/object/store/packed/internal/ingest/record_resolve.go index 7a9471dc..924f9455 100644 --- a/object/store/packed/internal/ingest/record_resolve.go +++ b/object/store/packed/internal/ingest/record_resolve.go @@ -3,7 +3,7 @@ package ingest import ( "fmt" - objecttype "codeberg.org/lindenii/furgit/object/type" + objecttype "lindenii.org/go/furgit/object/type" ) // resolveRecord resolves one record and returns canonical type/content. diff --git a/object/store/packed/internal/ingest/records.go b/object/store/packed/internal/ingest/records.go index 75f157fa..17802140 100644 --- a/object/store/packed/internal/ingest/records.go +++ b/object/store/packed/internal/ingest/records.go @@ -1,8 +1,8 @@ package ingest import ( - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // objectRecord stores metadata for one packed object entry. diff --git a/object/store/packed/internal/ingest/resolve_all.go b/object/store/packed/internal/ingest/resolve_all.go index 90464015..af51ae1c 100644 --- a/object/store/packed/internal/ingest/resolve_all.go +++ b/object/store/packed/internal/ingest/resolve_all.go @@ -3,7 +3,7 @@ package ingest import ( "errors" - "codeberg.org/lindenii/furgit/internal/progress" + "lindenii.org/go/furgit/internal/progress" ) // resolveAll resolves all delta records and finalizes ObjectID/RealType for every record. diff --git a/object/store/packed/internal/ingest/result.go b/object/store/packed/internal/ingest/result.go index 9a285f09..79943a39 100644 --- a/object/store/packed/internal/ingest/result.go +++ b/object/store/packed/internal/ingest/result.go @@ -1,6 +1,6 @@ package ingest -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Result describes one successful ingest transaction. type Result struct { diff --git a/object/store/packed/internal/ingest/rev_write.go b/object/store/packed/internal/ingest/rev_write.go index 16d27085..fc504007 100644 --- a/object/store/packed/internal/ingest/rev_write.go +++ b/object/store/packed/internal/ingest/rev_write.go @@ -4,8 +4,8 @@ import ( "encoding/binary" "slices" - "codeberg.org/lindenii/furgit/internal/intconv" - "codeberg.org/lindenii/furgit/internal/progress" + "lindenii.org/go/furgit/internal/intconv" + "lindenii.org/go/furgit/internal/progress" ) const ( diff --git a/object/store/packed/internal/ingest/rewrite_header_trailer.go b/object/store/packed/internal/ingest/rewrite_header_trailer.go index f1f18a39..08df208a 100644 --- a/object/store/packed/internal/ingest/rewrite_header_trailer.go +++ b/object/store/packed/internal/ingest/rewrite_header_trailer.go @@ -4,8 +4,8 @@ import ( "encoding/binary" "io" - "codeberg.org/lindenii/furgit/internal/intconv" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/intconv" + objectid "lindenii.org/go/furgit/object/id" ) // rewritePackHeaderAndTrailer rewrites object count and trailer hash using ReadAt/WriteAt. diff --git a/object/store/packed/internal/ingest/scan.go b/object/store/packed/internal/ingest/scan.go index ddd1eaf3..677d7ca4 100644 --- a/object/store/packed/internal/ingest/scan.go +++ b/object/store/packed/internal/ingest/scan.go @@ -3,8 +3,8 @@ package ingest import ( "fmt" - "codeberg.org/lindenii/furgit/internal/progress" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/progress" + objectid "lindenii.org/go/furgit/object/id" ) // streamPackAndScan copies src into temp .pack while scanning packed entries. diff --git a/object/store/packed/internal/ingest/state.go b/object/store/packed/internal/ingest/state.go index 0412eb32..8b1f4c50 100644 --- a/object/store/packed/internal/ingest/state.go +++ b/object/store/packed/internal/ingest/state.go @@ -4,7 +4,7 @@ import ( "io" "os" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) const ( diff --git a/object/store/packed/internal/ingest/thin_append.go b/object/store/packed/internal/ingest/thin_append.go index 779d477f..6fec67f6 100644 --- a/object/store/packed/internal/ingest/thin_append.go +++ b/object/store/packed/internal/ingest/thin_append.go @@ -5,9 +5,9 @@ import ( "hash/crc32" "io" - "codeberg.org/lindenii/furgit/internal/intconv" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/intconv" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // appendBaseObject appends one base object as a new packed non-delta entry. diff --git a/object/store/packed/internal/ingest/thin_fix.go b/object/store/packed/internal/ingest/thin_fix.go index 5d701c52..19b8dced 100644 --- a/object/store/packed/internal/ingest/thin_fix.go +++ b/object/store/packed/internal/ingest/thin_fix.go @@ -4,9 +4,9 @@ import ( "errors" "fmt" - "codeberg.org/lindenii/furgit/internal/intconv" - "codeberg.org/lindenii/furgit/internal/progress" - objectstore "codeberg.org/lindenii/furgit/object/store" + "lindenii.org/go/furgit/internal/intconv" + "lindenii.org/go/furgit/internal/progress" + objectstore "lindenii.org/go/furgit/object/store" ) // maybeFixThin appends missing bases and rewrites pack header/trailer when needed. diff --git a/object/store/packed/internal/ingest/thin_unresolved.go b/object/store/packed/internal/ingest/thin_unresolved.go index 757cc0e2..d7177689 100644 --- a/object/store/packed/internal/ingest/thin_unresolved.go +++ b/object/store/packed/internal/ingest/thin_unresolved.go @@ -4,8 +4,8 @@ import ( "bytes" "slices" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // unresolvedThinBaseIDs returns sorted unique unresolved ref base IDs. diff --git a/object/store/packed/internal/ingest/write.go b/object/store/packed/internal/ingest/write.go index efd27323..6d25eafb 100644 --- a/object/store/packed/internal/ingest/write.go +++ b/object/store/packed/internal/ingest/write.go @@ -5,7 +5,7 @@ import ( "io" "os" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // WritePack ingests one pack stream into destination and writes pack artifacts. diff --git a/object/store/packed/internal/ingest/write_empty.go b/object/store/packed/internal/ingest/write_empty.go index 0d3401f0..f783b84b 100644 --- a/object/store/packed/internal/ingest/write_empty.go +++ b/object/store/packed/internal/ingest/write_empty.go @@ -5,7 +5,7 @@ import ( "errors" "io" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) func discardZeroObjectPack( diff --git a/object/store/packed/internal/reading/delta_build_chain.go b/object/store/packed/internal/reading/delta_build_chain.go index a0e3151d..719bdb16 100644 --- a/object/store/packed/internal/reading/delta_build_chain.go +++ b/object/store/packed/internal/reading/delta_build_chain.go @@ -3,7 +3,7 @@ package reading import ( "fmt" - objecttype "codeberg.org/lindenii/furgit/object/type" + objecttype "lindenii.org/go/furgit/object/type" ) // deltaBuildChain walks one object's chain and builds a reconstruction chain. diff --git a/object/store/packed/internal/reading/delta_cache.go b/object/store/packed/internal/reading/delta_cache.go index 04bd3ff3..6bef5697 100644 --- a/object/store/packed/internal/reading/delta_cache.go +++ b/object/store/packed/internal/reading/delta_cache.go @@ -1,8 +1,8 @@ package reading import ( - "codeberg.org/lindenii/furgit/internal/lru" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/lru" + objecttype "lindenii.org/go/furgit/object/type" ) const defaultDeltaCacheMaxBytes = 32 << 20 diff --git a/object/store/packed/internal/reading/delta_chain.go b/object/store/packed/internal/reading/delta_chain.go index 6e82873e..54d8b956 100644 --- a/object/store/packed/internal/reading/delta_chain.go +++ b/object/store/packed/internal/reading/delta_chain.go @@ -1,6 +1,6 @@ package reading -import objecttype "codeberg.org/lindenii/furgit/object/type" +import objecttype "lindenii.org/go/furgit/object/type" // deltaChain describes how to reconstruct one requested object. type deltaChain struct { diff --git a/object/store/packed/internal/reading/delta_resolve_chain.go b/object/store/packed/internal/reading/delta_resolve_chain.go index ec9c39e2..7a0d8178 100644 --- a/object/store/packed/internal/reading/delta_resolve_chain.go +++ b/object/store/packed/internal/reading/delta_resolve_chain.go @@ -3,8 +3,8 @@ package reading import ( "fmt" - deltaapply "codeberg.org/lindenii/furgit/format/packfile/delta/apply" - objecttype "codeberg.org/lindenii/furgit/object/type" + deltaapply "lindenii.org/go/furgit/format/packfile/delta/apply" + objecttype "lindenii.org/go/furgit/object/type" ) // deltaResolveChain resolves one object chain into content bytes. diff --git a/object/store/packed/internal/reading/delta_resolve_chain_start.go b/object/store/packed/internal/reading/delta_resolve_chain_start.go index 17274027..50e9eb50 100644 --- a/object/store/packed/internal/reading/delta_resolve_chain_start.go +++ b/object/store/packed/internal/reading/delta_resolve_chain_start.go @@ -3,7 +3,7 @@ package reading import ( "fmt" - objecttype "codeberg.org/lindenii/furgit/object/type" + objecttype "lindenii.org/go/furgit/object/type" ) // deltaResolveChainStart finds the nearest cached chain node or inflates the diff --git a/object/store/packed/internal/reading/delta_resolve_content.go b/object/store/packed/internal/reading/delta_resolve_content.go index 71eb69cf..1ea91d74 100644 --- a/object/store/packed/internal/reading/delta_resolve_content.go +++ b/object/store/packed/internal/reading/delta_resolve_content.go @@ -1,6 +1,6 @@ package reading -import objecttype "codeberg.org/lindenii/furgit/object/type" +import objecttype "lindenii.org/go/furgit/object/type" // deltaResolveContent resolves one object's content bytes from its pack location. func (store *Store) deltaResolveContent(start location) (objecttype.Type, []byte, error) { diff --git a/object/store/packed/internal/reading/delta_size.go b/object/store/packed/internal/reading/delta_size.go index 8a85fad9..d16ad9b0 100644 --- a/object/store/packed/internal/reading/delta_size.go +++ b/object/store/packed/internal/reading/delta_size.go @@ -3,7 +3,7 @@ package reading import ( "bufio" - deltaapply "codeberg.org/lindenii/furgit/format/packfile/delta/apply" + deltaapply "lindenii.org/go/furgit/format/packfile/delta/apply" ) // deltaDeclaredSizeAt returns the resolved object size declared by one delta diff --git a/object/store/packed/internal/reading/entry_inflate.go b/object/store/packed/internal/reading/entry_inflate.go index 82b2a7a8..c0afcac5 100644 --- a/object/store/packed/internal/reading/entry_inflate.go +++ b/object/store/packed/internal/reading/entry_inflate.go @@ -6,8 +6,8 @@ import ( "io" "math" - "codeberg.org/lindenii/furgit/internal/compress/zlib" - "codeberg.org/lindenii/furgit/internal/iolimit" + "lindenii.org/go/furgit/internal/compress/zlib" + "lindenii.org/go/furgit/internal/iolimit" ) // zlibReaderAt opens a zlib reader starting at data offset within pack. diff --git a/object/store/packed/internal/reading/entry_parse.go b/object/store/packed/internal/reading/entry_parse.go index ecbfb6cb..d2c7e0fb 100644 --- a/object/store/packed/internal/reading/entry_parse.go +++ b/object/store/packed/internal/reading/entry_parse.go @@ -3,10 +3,10 @@ package reading import ( "fmt" - packfmt "codeberg.org/lindenii/furgit/format/packfile" - "codeberg.org/lindenii/furgit/internal/intconv" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + packfmt "lindenii.org/go/furgit/format/packfile" + "lindenii.org/go/furgit/internal/intconv" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // entryMeta describes one parsed pack entry header. diff --git a/object/store/packed/internal/reading/helpers_test.go b/object/store/packed/internal/reading/helpers_test.go index 5a37d2f1..645ccfca 100644 --- a/object/store/packed/internal/reading/helpers_test.go +++ b/object/store/packed/internal/reading/helpers_test.go @@ -7,11 +7,11 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectheader "codeberg.org/lindenii/furgit/object/header" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/store/packed" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/testgit" + objectheader "lindenii.org/go/furgit/object/header" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/store/packed" + objecttype "lindenii.org/go/furgit/object/type" ) func openPackedStore(t *testing.T, testRepo *testgit.TestRepo, algo objectid.Algorithm) *packed.Store { diff --git a/object/store/packed/internal/reading/idx.go b/object/store/packed/internal/reading/idx.go index 3c91e1a2..6cf61614 100644 --- a/object/store/packed/internal/reading/idx.go +++ b/object/store/packed/internal/reading/idx.go @@ -3,7 +3,7 @@ package reading import ( "os" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // idxFile stores one mapped and validated idx v2 file. diff --git a/object/store/packed/internal/reading/idx_lookup.go b/object/store/packed/internal/reading/idx_lookup.go index bb02fb20..62846258 100644 --- a/object/store/packed/internal/reading/idx_lookup.go +++ b/object/store/packed/internal/reading/idx_lookup.go @@ -5,7 +5,7 @@ import ( "encoding/binary" "fmt" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // lookup resolves one object ID to its pack offset within this index. diff --git a/object/store/packed/internal/reading/idx_open.go b/object/store/packed/internal/reading/idx_open.go index 8f73c867..bb61e156 100644 --- a/object/store/packed/internal/reading/idx_open.go +++ b/object/store/packed/internal/reading/idx_open.go @@ -5,8 +5,8 @@ import ( "os" "syscall" - "codeberg.org/lindenii/furgit/internal/intconv" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/intconv" + objectid "lindenii.org/go/furgit/object/id" ) // openIndex returns one opened and parsed index, caching it by pack basename. diff --git a/object/store/packed/internal/reading/new.go b/object/store/packed/internal/reading/new.go index d8a12db3..c9f69b57 100644 --- a/object/store/packed/internal/reading/new.go +++ b/object/store/packed/internal/reading/new.go @@ -4,7 +4,7 @@ import ( "fmt" "os" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // New creates a packed-object store rooted at an objects/pack directory. diff --git a/object/store/packed/internal/reading/pack.go b/object/store/packed/internal/reading/pack.go index 431ed5f9..73e74aa9 100644 --- a/object/store/packed/internal/reading/pack.go +++ b/object/store/packed/internal/reading/pack.go @@ -6,8 +6,8 @@ import ( "os" "syscall" - packfmt "codeberg.org/lindenii/furgit/format/packfile" - "codeberg.org/lindenii/furgit/internal/intconv" + packfmt "lindenii.org/go/furgit/format/packfile" + "lindenii.org/go/furgit/internal/intconv" ) // packFile stores one mapped and validated .pack file. diff --git a/object/store/packed/internal/reading/pack_idx_checksum.go b/object/store/packed/internal/reading/pack_idx_checksum.go index b2ad09f1..ff3a3601 100644 --- a/object/store/packed/internal/reading/pack_idx_checksum.go +++ b/object/store/packed/internal/reading/pack_idx_checksum.go @@ -4,7 +4,7 @@ import ( "bytes" "fmt" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // verifyMappedPackMatchesMappedIdx compares one mapped pack trailer hash with diff --git a/object/store/packed/internal/reading/read_bytes.go b/object/store/packed/internal/reading/read_bytes.go index f0821687..af0db3f1 100644 --- a/object/store/packed/internal/reading/read_bytes.go +++ b/object/store/packed/internal/reading/read_bytes.go @@ -3,9 +3,9 @@ package reading import ( "fmt" - objectheader "codeberg.org/lindenii/furgit/object/header" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectheader "lindenii.org/go/furgit/object/header" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // ReadBytesContent reads an object's type and content bytes. diff --git a/object/store/packed/internal/reading/read_header.go b/object/store/packed/internal/reading/read_header.go index d627a6b3..5a9f0e09 100644 --- a/object/store/packed/internal/reading/read_header.go +++ b/object/store/packed/internal/reading/read_header.go @@ -1,8 +1,8 @@ package reading import ( - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // ReadHeader reads an object's type and declared content size. diff --git a/object/store/packed/internal/reading/read_header_resolve.go b/object/store/packed/internal/reading/read_header_resolve.go index a2916b73..87346535 100644 --- a/object/store/packed/internal/reading/read_header_resolve.go +++ b/object/store/packed/internal/reading/read_header_resolve.go @@ -3,7 +3,7 @@ package reading import ( "fmt" - objecttype "codeberg.org/lindenii/furgit/object/type" + objecttype "lindenii.org/go/furgit/object/type" ) // resolveHeaderAt resolves one object's canonical type and declared content size. diff --git a/object/store/packed/internal/reading/read_reader.go b/object/store/packed/internal/reading/read_reader.go index 3fa0f592..0d8c4c9e 100644 --- a/object/store/packed/internal/reading/read_reader.go +++ b/object/store/packed/internal/reading/read_reader.go @@ -5,10 +5,10 @@ import ( "fmt" "io" - "codeberg.org/lindenii/furgit/internal/iolimit" - objectheader "codeberg.org/lindenii/furgit/object/header" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/iolimit" + objectheader "lindenii.org/go/furgit/object/header" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // ReadReaderContent reads an object's type, declared content size, and content diff --git a/object/store/packed/internal/reading/read_size.go b/object/store/packed/internal/reading/read_size.go index 3c1e05b1..cf2d0594 100644 --- a/object/store/packed/internal/reading/read_size.go +++ b/object/store/packed/internal/reading/read_size.go @@ -3,8 +3,8 @@ package reading import ( "fmt" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // ReadSize reads an object's declared content size. diff --git a/object/store/packed/internal/reading/read_test.go b/object/store/packed/internal/reading/read_test.go index 8a92b603..46aca326 100644 --- a/object/store/packed/internal/reading/read_test.go +++ b/object/store/packed/internal/reading/read_test.go @@ -9,10 +9,10 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - "codeberg.org/lindenii/furgit/object/store/packed" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + "lindenii.org/go/furgit/object/store/packed" ) func TestPackedStoreReadAgainstGit(t *testing.T) { diff --git a/object/store/packed/internal/reading/store.go b/object/store/packed/internal/reading/store.go index cb4829ab..13eec11e 100644 --- a/object/store/packed/internal/reading/store.go +++ b/object/store/packed/internal/reading/store.go @@ -5,8 +5,8 @@ import ( "sync" "sync/atomic" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" ) // Store reads Git objects from pack/index files under an objects/pack root. diff --git a/object/store/packed/internal/reading/store_lookup.go b/object/store/packed/internal/reading/store_lookup.go index 9d863113..8ef2adb3 100644 --- a/object/store/packed/internal/reading/store_lookup.go +++ b/object/store/packed/internal/reading/store_lookup.go @@ -3,8 +3,8 @@ package reading import ( "errors" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" ) // lookup resolves one object ID to its pack location. diff --git a/object/store/packed/new.go b/object/store/packed/new.go index cdc1b50f..057cf149 100644 --- a/object/store/packed/new.go +++ b/object/store/packed/new.go @@ -3,8 +3,8 @@ package packed import ( "os" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/store/packed/internal/reading" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/store/packed/internal/reading" ) // New creates a packed-object store rooted at an objects/pack directory. diff --git a/object/store/packed/quarantine.go b/object/store/packed/quarantine.go index a8f6d08c..7de6ecbd 100644 --- a/object/store/packed/quarantine.go +++ b/object/store/packed/quarantine.go @@ -3,7 +3,7 @@ package packed import ( "os" - objectstore "codeberg.org/lindenii/furgit/object/store" + objectstore "lindenii.org/go/furgit/object/store" ) var _ objectstore.PackQuarantiner = (*Store)(nil) diff --git a/object/store/packed/quarantine_begin.go b/object/store/packed/quarantine_begin.go index 06b9a8a6..5ee3cfeb 100644 --- a/object/store/packed/quarantine_begin.go +++ b/object/store/packed/quarantine_begin.go @@ -7,7 +7,7 @@ import ( "io/fs" "os" - objectstore "codeberg.org/lindenii/furgit/object/store" + objectstore "lindenii.org/go/furgit/object/store" ) // BeginPackQuarantine creates one quarantined packed store rooted privately diff --git a/object/store/packed/quarantine_test.go b/object/store/packed/quarantine_test.go index 036da535..68ab06c4 100644 --- a/object/store/packed/quarantine_test.go +++ b/object/store/packed/quarantine_test.go @@ -7,11 +7,11 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - "codeberg.org/lindenii/furgit/object/store/packed" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + "lindenii.org/go/furgit/object/store/packed" + objecttype "lindenii.org/go/furgit/object/type" ) func fixturePath(t *testing.T, algo objectid.Algorithm, name string) string { diff --git a/object/store/packed/reader.go b/object/store/packed/reader.go index 45b9e8d9..d244fb72 100644 --- a/object/store/packed/reader.go +++ b/object/store/packed/reader.go @@ -3,10 +3,10 @@ package packed import ( "io" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - "codeberg.org/lindenii/furgit/object/store/packed/internal/reading" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + "lindenii.org/go/furgit/object/store/packed/internal/reading" + objecttype "lindenii.org/go/furgit/object/type" ) var _ objectstore.Reader = (*Store)(nil) diff --git a/object/store/packed/store.go b/object/store/packed/store.go index 2fe84c81..9b3dbbd0 100644 --- a/object/store/packed/store.go +++ b/object/store/packed/store.go @@ -3,8 +3,8 @@ package packed import ( "os" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/store/packed/internal/reading" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/store/packed/internal/reading" ) // Store reads Git objects from pack/index files under an objects/pack root. diff --git a/object/store/packed/writer.go b/object/store/packed/writer.go index a96ea750..040a8989 100644 --- a/object/store/packed/writer.go +++ b/object/store/packed/writer.go @@ -3,8 +3,8 @@ package packed import ( "io" - objectstore "codeberg.org/lindenii/furgit/object/store" - "codeberg.org/lindenii/furgit/object/store/packed/internal/ingest" + objectstore "lindenii.org/go/furgit/object/store" + "lindenii.org/go/furgit/object/store/packed/internal/ingest" ) var _ objectstore.PackWriter = (*Store)(nil) diff --git a/object/store/reader.go b/object/store/reader.go index 52a556bd..cd382ae1 100644 --- a/object/store/reader.go +++ b/object/store/reader.go @@ -3,8 +3,8 @@ package objectstore import ( "io" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // Reader reads Git objects by object ID. diff --git a/object/store/writer_object.go b/object/store/writer_object.go index a18a5d84..af98a714 100644 --- a/object/store/writer_object.go +++ b/object/store/writer_object.go @@ -3,8 +3,8 @@ package objectstore import ( "io" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) // ObjectWriter writes individual Git objects. diff --git a/object/store/writer_pack.go b/object/store/writer_pack.go index 0f78c429..b5366428 100644 --- a/object/store/writer_pack.go +++ b/object/store/writer_pack.go @@ -3,7 +3,7 @@ package objectstore import ( "io" - "codeberg.org/lindenii/furgit/common/iowrap" + "lindenii.org/go/furgit/common/iowrap" ) // PackWriteOptions controls one pack write operation. diff --git a/object/stored/id.go b/object/stored/id.go index 956d069e..d5723f8b 100644 --- a/object/stored/id.go +++ b/object/stored/id.go @@ -1,6 +1,6 @@ package stored -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // ID returns the object ID. func (stored *Stored[T]) ID() objectid.ObjectID { diff --git a/object/stored/new.go b/object/stored/new.go index 8b0ef881..8070a27f 100644 --- a/object/stored/new.go +++ b/object/stored/new.go @@ -1,8 +1,8 @@ package stored import ( - "codeberg.org/lindenii/furgit/object" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/object" + objectid "lindenii.org/go/furgit/object/id" ) // New creates one stored object wrapper. diff --git a/object/stored/stored.go b/object/stored/stored.go index eb776f31..26bd3275 100644 --- a/object/stored/stored.go +++ b/object/stored/stored.go @@ -1,8 +1,8 @@ package stored import ( - "codeberg.org/lindenii/furgit/object" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/object" + objectid "lindenii.org/go/furgit/object/id" ) // Stored represents a stored object, diff --git a/object/tag/parse.go b/object/tag/parse.go index 2876ec6d..bb84046b 100644 --- a/object/tag/parse.go +++ b/object/tag/parse.go @@ -5,9 +5,9 @@ import ( "errors" "fmt" - objectid "codeberg.org/lindenii/furgit/object/id" - objectsignature "codeberg.org/lindenii/furgit/object/signature" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objectsignature "lindenii.org/go/furgit/object/signature" + objecttype "lindenii.org/go/furgit/object/type" ) // Parse decodes a tag object body. diff --git a/object/tag/parse_test.go b/object/tag/parse_test.go index 18f38aaa..4966bf75 100644 --- a/object/tag/parse_test.go +++ b/object/tag/parse_test.go @@ -4,10 +4,10 @@ import ( "bytes" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/tag" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/tag" + objecttype "lindenii.org/go/furgit/object/type" ) func TestTagParseFromGit(t *testing.T) { diff --git a/object/tag/serialize.go b/object/tag/serialize.go index 301984cc..2fe8a115 100644 --- a/object/tag/serialize.go +++ b/object/tag/serialize.go @@ -5,8 +5,8 @@ import ( "errors" "fmt" - objectheader "codeberg.org/lindenii/furgit/object/header" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectheader "lindenii.org/go/furgit/object/header" + objecttype "lindenii.org/go/furgit/object/type" ) // BytesWithoutHeader renders the raw tag body bytes. diff --git a/object/tag/serialize_test.go b/object/tag/serialize_test.go index 3a87e5ad..bc1bad84 100644 --- a/object/tag/serialize_test.go +++ b/object/tag/serialize_test.go @@ -3,9 +3,9 @@ package tag_test import ( "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/tag" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/tag" ) func TestTagSerialize(t *testing.T) { diff --git a/object/tag/tag.go b/object/tag/tag.go index 4fcc88b0..a48de26b 100644 --- a/object/tag/tag.go +++ b/object/tag/tag.go @@ -3,13 +3,13 @@ // It parses annotated tags into ordinary Go values for reading and // construction. It does not preserve the exact original byte layout needed for // signature verification; callers that need signature-verification payload -// fidelity should use [codeberg.org/lindenii/furgit/object/signed/tag]. +// fidelity should use [lindenii.org/go/furgit/object/signed/tag]. package tag import ( - objectid "codeberg.org/lindenii/furgit/object/id" - objectsignature "codeberg.org/lindenii/furgit/object/signature" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objectsignature "lindenii.org/go/furgit/object/signature" + objecttype "lindenii.org/go/furgit/object/type" ) // Tag represents a fully materialized Git annotated tag object. diff --git a/object/tag/type.go b/object/tag/type.go index 215103ab..8b1da3ef 100644 --- a/object/tag/type.go +++ b/object/tag/type.go @@ -1,6 +1,6 @@ package tag -import objecttype "codeberg.org/lindenii/furgit/object/type" +import objecttype "lindenii.org/go/furgit/object/type" // ObjectType returns TypeTag. func (tag *Tag) ObjectType() objecttype.Type { diff --git a/object/tree/entry.go b/object/tree/entry.go index b3089b74..3c96d6b5 100644 --- a/object/tree/entry.go +++ b/object/tree/entry.go @@ -4,7 +4,7 @@ import ( "bytes" "slices" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // TreeEntry represents a single entry in a tree. diff --git a/object/tree/helpers_test.go b/object/tree/helpers_test.go index 3da92ce4..0344183a 100644 --- a/object/tree/helpers_test.go +++ b/object/tree/helpers_test.go @@ -6,8 +6,8 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - "codeberg.org/lindenii/furgit/object/tree" + "lindenii.org/go/furgit/internal/testgit" + "lindenii.org/go/furgit/object/tree" ) func buildGitMktreeInput(entries []tree.TreeEntry) string { diff --git a/object/tree/parse.go b/object/tree/parse.go index bb874828..8a649fa5 100644 --- a/object/tree/parse.go +++ b/object/tree/parse.go @@ -5,7 +5,7 @@ import ( "fmt" "strconv" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // Parse decodes a tree object body into a fully materialized Tree. diff --git a/object/tree/parse_test.go b/object/tree/parse_test.go index 2b98ede7..b1602433 100644 --- a/object/tree/parse_test.go +++ b/object/tree/parse_test.go @@ -4,9 +4,9 @@ import ( "bytes" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/tree" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/tree" ) func TestTreeParseFromGit(t *testing.T) { diff --git a/object/tree/serialize.go b/object/tree/serialize.go index 922cd145..9eed9c68 100644 --- a/object/tree/serialize.go +++ b/object/tree/serialize.go @@ -4,8 +4,8 @@ import ( "errors" "strconv" - objectheader "codeberg.org/lindenii/furgit/object/header" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectheader "lindenii.org/go/furgit/object/header" + objecttype "lindenii.org/go/furgit/object/type" ) // BytesWithoutHeader renders the raw tree body bytes. diff --git a/object/tree/serialize_test.go b/object/tree/serialize_test.go index f7bc64b6..dfad3c5d 100644 --- a/object/tree/serialize_test.go +++ b/object/tree/serialize_test.go @@ -3,9 +3,9 @@ package tree_test import ( "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/tree" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/tree" ) func TestTreeSerialize(t *testing.T) { diff --git a/object/tree/type.go b/object/tree/type.go index 416544af..1db48661 100644 --- a/object/tree/type.go +++ b/object/tree/type.go @@ -1,6 +1,6 @@ package tree -import objecttype "codeberg.org/lindenii/furgit/object/type" +import objecttype "lindenii.org/go/furgit/object/type" // ObjectType returns TypeTree. func (tree *Tree) ObjectType() objecttype.Type { diff --git a/reachability/connected.go b/reachability/connected.go index 692d8501..dcf9884a 100644 --- a/reachability/connected.go +++ b/reachability/connected.go @@ -1,6 +1,6 @@ package reachability -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // CheckConnected verifies that all objects reachable from wants (under the // selected domain) can be fully traversed without missing-object/type/parse diff --git a/reachability/integration_test.go b/reachability/integration_test.go index 2df938aa..c144fb15 100644 --- a/reachability/integration_test.go +++ b/reachability/integration_test.go @@ -9,11 +9,11 @@ import ( "strings" "testing" - giterrors "codeberg.org/lindenii/furgit/errors" - "codeberg.org/lindenii/furgit/internal/testgit" - objectfetch "codeberg.org/lindenii/furgit/object/fetch" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/reachability" + giterrors "lindenii.org/go/furgit/errors" + "lindenii.org/go/furgit/internal/testgit" + objectfetch "lindenii.org/go/furgit/object/fetch" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/reachability" ) func TestWalkCommitsMatchesGitRevList(t *testing.T) { diff --git a/reachability/reachability.go b/reachability/reachability.go index fd4d00e5..f8fc83df 100644 --- a/reachability/reachability.go +++ b/reachability/reachability.go @@ -1,8 +1,8 @@ package reachability import ( - commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" - objectfetch "codeberg.org/lindenii/furgit/object/fetch" + commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" + objectfetch "lindenii.org/go/furgit/object/fetch" ) // Reachability provides graph traversal over objects in one object store. diff --git a/reachability/unit_test.go b/reachability/unit_test.go index 469c79ff..bbee0ebf 100644 --- a/reachability/unit_test.go +++ b/reachability/unit_test.go @@ -7,14 +7,14 @@ import ( "slices" "testing" - giterrors "codeberg.org/lindenii/furgit/errors" - "codeberg.org/lindenii/furgit/internal/testgit" - objectfetch "codeberg.org/lindenii/furgit/object/fetch" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/store/memory" - "codeberg.org/lindenii/furgit/object/tree" - objecttype "codeberg.org/lindenii/furgit/object/type" - "codeberg.org/lindenii/furgit/reachability" + giterrors "lindenii.org/go/furgit/errors" + "lindenii.org/go/furgit/internal/testgit" + objectfetch "lindenii.org/go/furgit/object/fetch" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/store/memory" + "lindenii.org/go/furgit/object/tree" + objecttype "lindenii.org/go/furgit/object/type" + "lindenii.org/go/furgit/reachability" ) type memStore struct { diff --git a/reachability/walk.go b/reachability/walk.go index 8e0a0902..771ced20 100644 --- a/reachability/walk.go +++ b/reachability/walk.go @@ -1,7 +1,7 @@ package reachability import ( - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // Walk is one single-use iterator traversal. diff --git a/reachability/walk_expand_commits.go b/reachability/walk_expand_commits.go index c612ddf1..dbfbc0fb 100644 --- a/reachability/walk_expand_commits.go +++ b/reachability/walk_expand_commits.go @@ -3,8 +3,8 @@ package reachability import ( "fmt" - "codeberg.org/lindenii/furgit/errors" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/errors" + objecttype "lindenii.org/go/furgit/object/type" ) func (walk *Walk) expandCommits(item walkItem) ([]walkItem, error) { diff --git a/reachability/walk_expand_commits_graph.go b/reachability/walk_expand_commits_graph.go index 863906f9..27ea32b5 100644 --- a/reachability/walk_expand_commits_graph.go +++ b/reachability/walk_expand_commits_graph.go @@ -3,9 +3,9 @@ package reachability import ( "errors" - commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) func (walk *Walk) expandCommitsFromGraph(id objectid.ObjectID) ([]walkItem, bool, error) { diff --git a/reachability/walk_expand_objects.go b/reachability/walk_expand_objects.go index 8f0e1d02..87b93b6b 100644 --- a/reachability/walk_expand_objects.go +++ b/reachability/walk_expand_objects.go @@ -3,9 +3,9 @@ package reachability import ( "fmt" - "codeberg.org/lindenii/furgit/errors" - objecttree "codeberg.org/lindenii/furgit/object/tree" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/errors" + objecttree "lindenii.org/go/furgit/object/tree" + objecttype "lindenii.org/go/furgit/object/type" ) func (walk *Walk) expandObjects(item walkItem) ([]walkItem, error) { diff --git a/reachability/walk_item.go b/reachability/walk_item.go index da30e127..0f271790 100644 --- a/reachability/walk_item.go +++ b/reachability/walk_item.go @@ -1,8 +1,8 @@ package reachability import ( - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) type walkItem struct { diff --git a/reachability/walk_seq.go b/reachability/walk_seq.go index 669166f5..0991db84 100644 --- a/reachability/walk_seq.go +++ b/reachability/walk_seq.go @@ -4,7 +4,7 @@ import ( "errors" "iter" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // Seq returns the traversal sequence. It is single-use. diff --git a/reachability/walk_stack.go b/reachability/walk_stack.go index 0a5084df..2c033b3f 100644 --- a/reachability/walk_stack.go +++ b/reachability/walk_stack.go @@ -1,6 +1,6 @@ package reachability -import objecttype "codeberg.org/lindenii/furgit/object/type" +import objecttype "lindenii.org/go/furgit/object/type" func (walk *Walk) initialStack() []walkItem { if len(walk.wants) == 0 { diff --git a/reachability/walk_verify.go b/reachability/walk_verify.go index c4ac6ecf..afca11e3 100644 --- a/reachability/walk_verify.go +++ b/reachability/walk_verify.go @@ -1,9 +1,9 @@ package reachability import ( - "codeberg.org/lindenii/furgit/errors" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/errors" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) func (walk *Walk) validateCommitObject(id objectid.ObjectID) error { diff --git a/ref/detached.go b/ref/detached.go index e9b30906..5fb1ed13 100644 --- a/ref/detached.go +++ b/ref/detached.go @@ -1,6 +1,6 @@ package ref -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Detached points directly to an object ID. type Detached struct { diff --git a/ref/name/refname_test.go b/ref/name/refname_test.go index a37314f4..02d2f3f4 100644 --- a/ref/name/refname_test.go +++ b/ref/name/refname_test.go @@ -6,7 +6,7 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/ref/name" + "lindenii.org/go/furgit/ref/name" ) func TestValidateNameAgainstGit(t *testing.T) { diff --git a/ref/store/batch.go b/ref/store/batch.go index 11423cec..27b9fef4 100644 --- a/ref/store/batch.go +++ b/ref/store/batch.go @@ -1,6 +1,6 @@ package refstore -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Batch stages reference operations for one non-atomic apply. // diff --git a/ref/store/chain/chain.go b/ref/store/chain/chain.go index a332f64c..21cebe65 100644 --- a/ref/store/chain/chain.go +++ b/ref/store/chain/chain.go @@ -2,7 +2,7 @@ // of backends. package chain -import refstore "codeberg.org/lindenii/furgit/ref/store" +import refstore "lindenii.org/go/furgit/ref/store" // Chain queries multiple reference stores in order. // diff --git a/ref/store/chain/list.go b/ref/store/chain/list.go index c577ca85..8fb817ae 100644 --- a/ref/store/chain/list.go +++ b/ref/store/chain/list.go @@ -3,7 +3,7 @@ package chain import ( "fmt" - "codeberg.org/lindenii/furgit/ref" + "lindenii.org/go/furgit/ref" ) // List lists references from every backend and deduplicates by ref name. diff --git a/ref/store/chain/new.go b/ref/store/chain/new.go index 1c8a3a28..7f226dd4 100644 --- a/ref/store/chain/new.go +++ b/ref/store/chain/new.go @@ -1,6 +1,6 @@ package chain -import refstore "codeberg.org/lindenii/furgit/ref/store" +import refstore "lindenii.org/go/furgit/ref/store" // New creates an ordered reference store chain. // diff --git a/ref/store/chain/resolve.go b/ref/store/chain/resolve.go index 06c3d8f5..96010a84 100644 --- a/ref/store/chain/resolve.go +++ b/ref/store/chain/resolve.go @@ -4,8 +4,8 @@ import ( "errors" "fmt" - "codeberg.org/lindenii/furgit/ref" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/ref" + refstore "lindenii.org/go/furgit/ref/store" ) // Resolve resolves a reference from the first backend that has it. diff --git a/ref/store/files/batch.go b/ref/store/files/batch.go index d8037bbb..6f8fa2a3 100644 --- a/ref/store/files/batch.go +++ b/ref/store/files/batch.go @@ -1,6 +1,6 @@ package files -import refstore "codeberg.org/lindenii/furgit/ref/store" +import refstore "lindenii.org/go/furgit/ref/store" // Batch stages files-store updates for one non-atomic apply. type Batch struct { diff --git a/ref/store/files/batch_apply.go b/ref/store/files/batch_apply.go index 1847b544..3c8a68b3 100644 --- a/ref/store/files/batch_apply.go +++ b/ref/store/files/batch_apply.go @@ -1,6 +1,6 @@ package files -import refstore "codeberg.org/lindenii/furgit/ref/store" +import refstore "lindenii.org/go/furgit/ref/store" // Apply validates and applies the queued updates. func (batch *Batch) Apply() ([]refstore.BatchResult, error) { diff --git a/ref/store/files/batch_begin.go b/ref/store/files/batch_begin.go index c8a0dca7..2f0a365e 100644 --- a/ref/store/files/batch_begin.go +++ b/ref/store/files/batch_begin.go @@ -1,6 +1,6 @@ package files -import refstore "codeberg.org/lindenii/furgit/ref/store" +import refstore "lindenii.org/go/furgit/ref/store" // BeginBatch creates one new files batch. // diff --git a/ref/store/files/batch_queue_ops.go b/ref/store/files/batch_queue_ops.go index 441bcaba..429229aa 100644 --- a/ref/store/files/batch_queue_ops.go +++ b/ref/store/files/batch_queue_ops.go @@ -1,6 +1,6 @@ package files -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Create queues a detached reference creation. func (batch *Batch) Create(name string, newID objectid.ObjectID) error { diff --git a/ref/store/files/batch_rejection.go b/ref/store/files/batch_rejection.go index 7f31536c..a59aa2db 100644 --- a/ref/store/files/batch_rejection.go +++ b/ref/store/files/batch_rejection.go @@ -3,7 +3,7 @@ package files import ( "errors" - refstore "codeberg.org/lindenii/furgit/ref/store" + refstore "lindenii.org/go/furgit/ref/store" ) func isBatchRejected(err error) bool { diff --git a/ref/store/files/batch_test.go b/ref/store/files/batch_test.go index 80575e5e..6eb8ff82 100644 --- a/ref/store/files/batch_test.go +++ b/ref/store/files/batch_test.go @@ -4,9 +4,9 @@ import ( "errors" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + refstore "lindenii.org/go/furgit/ref/store" ) func TestBatchApplyRejectsStaleDeleteAndAppliesIndependentDelete(t *testing.T) { diff --git a/ref/store/files/helpers_test.go b/ref/store/files/helpers_test.go index c46cc9fc..da1b81eb 100644 --- a/ref/store/files/helpers_test.go +++ b/ref/store/files/helpers_test.go @@ -7,9 +7,9 @@ import ( "testing" "time" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/ref/store/files" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/ref/store/files" ) const testPackedRefsTimeout = time.Second diff --git a/ref/store/files/new.go b/ref/store/files/new.go index 391930fb..1a11098b 100644 --- a/ref/store/files/new.go +++ b/ref/store/files/new.go @@ -5,7 +5,7 @@ import ( "os" "time" - objectid "codeberg.org/lindenii/furgit/object/id" + objectid "lindenii.org/go/furgit/object/id" ) // New creates one files ref store rooted at one repository gitdir. diff --git a/ref/store/files/packed_delete_test.go b/ref/store/files/packed_delete_test.go index 184eb79c..ce87efd5 100644 --- a/ref/store/files/packed_delete_test.go +++ b/ref/store/files/packed_delete_test.go @@ -8,9 +8,9 @@ import ( "testing" "time" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + refstore "lindenii.org/go/furgit/ref/store" ) func TestFilesTransactionPackedDeleteFailureLeavesRefsUnchanged(t *testing.T) { diff --git a/ref/store/files/packed_parse.go b/ref/store/files/packed_parse.go index 3662f6ed..63e48bbe 100644 --- a/ref/store/files/packed_parse.go +++ b/ref/store/files/packed_parse.go @@ -6,8 +6,8 @@ import ( "io" "strings" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/ref" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/ref" ) func parsePackedRefs(r io.Reader, algo objectid.Algorithm) (map[string]ref.Detached, []ref.Detached, error) { diff --git a/ref/store/files/packed_read.go b/ref/store/files/packed_read.go index 20800709..dafd7f1a 100644 --- a/ref/store/files/packed_read.go +++ b/ref/store/files/packed_read.go @@ -5,7 +5,7 @@ import ( "fmt" "os" - "codeberg.org/lindenii/furgit/ref" + "lindenii.org/go/furgit/ref" ) func (store *Store) readPackedRefs() (*packedRefs, error) { diff --git a/ref/store/files/packed_refs.go b/ref/store/files/packed_refs.go index f3e91d83..21bcc791 100644 --- a/ref/store/files/packed_refs.go +++ b/ref/store/files/packed_refs.go @@ -1,7 +1,7 @@ package files import ( - "codeberg.org/lindenii/furgit/ref" + "lindenii.org/go/furgit/ref" ) type packedRefs struct { diff --git a/ref/store/files/read_list.go b/ref/store/files/read_list.go index 5a828276..61739192 100644 --- a/ref/store/files/read_list.go +++ b/ref/store/files/read_list.go @@ -5,8 +5,8 @@ import ( "path" "slices" - "codeberg.org/lindenii/furgit/ref" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/ref" + refstore "lindenii.org/go/furgit/ref/store" ) // List lists references from the visible files ref namespace. diff --git a/ref/store/files/read_loose.go b/ref/store/files/read_loose.go index e9b1435a..146db0f2 100644 --- a/ref/store/files/read_loose.go +++ b/ref/store/files/read_loose.go @@ -6,9 +6,9 @@ import ( "os" "strings" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/ref" - refstore "codeberg.org/lindenii/furgit/ref/store" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/ref" + refstore "lindenii.org/go/furgit/ref/store" ) func (store *Store) readLooseRef(name string) (ref.Ref, error) { //nolint:ireturn diff --git a/ref/store/files/read_resolve.go b/ref/store/files/read_resolve.go index a998f970..558a9c89 100644 --- a/ref/store/files/read_resolve.go +++ b/ref/store/files/read_resolve.go @@ -3,8 +3,8 @@ package files import ( "errors" - "codeberg.org/lindenii/furgit/ref" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/ref" + refstore "lindenii.org/go/furgit/ref/store" ) // Resolve resolves one reference name from the files store visible namespace. diff --git a/ref/store/files/read_resolve_fully.go b/ref/store/files/read_resolve_fully.go index de58eb6d..e2a465af 100644 --- a/ref/store/files/read_resolve_fully.go +++ b/ref/store/files/read_resolve_fully.go @@ -4,7 +4,7 @@ import ( "fmt" "strings" - "codeberg.org/lindenii/furgit/ref" + "lindenii.org/go/furgit/ref" ) // ResolveToDetached resolves symbolic references through the visible files store diff --git a/ref/store/files/resolve_list_test.go b/ref/store/files/resolve_list_test.go index d52c5aa2..c039da4f 100644 --- a/ref/store/files/resolve_list_test.go +++ b/ref/store/files/resolve_list_test.go @@ -4,9 +4,9 @@ import ( "slices" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/ref" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/ref" ) func TestFilesResolveAndListOverlay(t *testing.T) { diff --git a/ref/store/files/root_loose_path.go b/ref/store/files/root_loose_path.go index 7764073b..40f97801 100644 --- a/ref/store/files/root_loose_path.go +++ b/ref/store/files/root_loose_path.go @@ -3,7 +3,7 @@ package files import ( "path" - "codeberg.org/lindenii/furgit/ref/name" + "lindenii.org/go/furgit/ref/name" ) func (store *Store) loosePath(name string) refPath { diff --git a/ref/store/files/store.go b/ref/store/files/store.go index 66d46d06..ee83ffa2 100644 --- a/ref/store/files/store.go +++ b/ref/store/files/store.go @@ -7,8 +7,8 @@ import ( "os" "time" - objectid "codeberg.org/lindenii/furgit/object/id" - refstore "codeberg.org/lindenii/furgit/ref/store" + objectid "lindenii.org/go/furgit/object/id" + refstore "lindenii.org/go/furgit/ref/store" ) // Store reads and writes one Git files ref namespace rooted at one repository diff --git a/ref/store/files/transaction.go b/ref/store/files/transaction.go index fec43e1d..bbf6607f 100644 --- a/ref/store/files/transaction.go +++ b/ref/store/files/transaction.go @@ -1,7 +1,7 @@ package files import ( - refstore "codeberg.org/lindenii/furgit/ref/store" + refstore "lindenii.org/go/furgit/ref/store" ) // Transaction stages files-store updates for one atomic commit. diff --git a/ref/store/files/transaction_begin.go b/ref/store/files/transaction_begin.go index cdd3bad1..5da0c43d 100644 --- a/ref/store/files/transaction_begin.go +++ b/ref/store/files/transaction_begin.go @@ -1,6 +1,6 @@ package files -import refstore "codeberg.org/lindenii/furgit/ref/store" +import refstore "lindenii.org/go/furgit/ref/store" // BeginTransaction creates one new files transaction. // diff --git a/ref/store/files/transaction_dirs_test.go b/ref/store/files/transaction_dirs_test.go index c010ae69..0cf54c28 100644 --- a/ref/store/files/transaction_dirs_test.go +++ b/ref/store/files/transaction_dirs_test.go @@ -3,8 +3,8 @@ package files_test import ( "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" ) func TestFilesTransactionEmptyDirectoriesDoNotBlock(t *testing.T) { diff --git a/ref/store/files/transaction_names_test.go b/ref/store/files/transaction_names_test.go index b362cb08..39fc68ed 100644 --- a/ref/store/files/transaction_names_test.go +++ b/ref/store/files/transaction_names_test.go @@ -3,10 +3,10 @@ package files_test import ( "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/ref" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/ref" + refstore "lindenii.org/go/furgit/ref/store" ) func TestFilesTransactionValidateUpdateNames(t *testing.T) { diff --git a/ref/store/files/transaction_pseudoref_test.go b/ref/store/files/transaction_pseudoref_test.go index ea57e92f..33e05d70 100644 --- a/ref/store/files/transaction_pseudoref_test.go +++ b/ref/store/files/transaction_pseudoref_test.go @@ -4,9 +4,9 @@ import ( "errors" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + refstore "lindenii.org/go/furgit/ref/store" ) func TestFilesTransactionPseudorefLifecycle(t *testing.T) { diff --git a/ref/store/files/transaction_queue_ops.go b/ref/store/files/transaction_queue_ops.go index 63f48254..958ced5d 100644 --- a/ref/store/files/transaction_queue_ops.go +++ b/ref/store/files/transaction_queue_ops.go @@ -1,6 +1,6 @@ package files -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Create queues a detached reference creation. func (tx *Transaction) Create(name string, newID objectid.ObjectID) error { diff --git a/ref/store/files/transaction_symbolic_test.go b/ref/store/files/transaction_symbolic_test.go index 360686d6..ed29ae23 100644 --- a/ref/store/files/transaction_symbolic_test.go +++ b/ref/store/files/transaction_symbolic_test.go @@ -4,9 +4,9 @@ import ( "errors" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + refstore "lindenii.org/go/furgit/ref/store" ) func TestFilesTransactionDirectSymbolicDeletes(t *testing.T) { diff --git a/ref/store/files/transaction_update_test.go b/ref/store/files/transaction_update_test.go index a29d586e..d8e89cb0 100644 --- a/ref/store/files/transaction_update_test.go +++ b/ref/store/files/transaction_update_test.go @@ -5,10 +5,10 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/ref" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/ref" + refstore "lindenii.org/go/furgit/ref/store" ) func TestFilesTransactionPackedUpdateCreatesLooseOverride(t *testing.T) { diff --git a/ref/store/files/update_direct_read.go b/ref/store/files/update_direct_read.go index 50e15026..0f9ccc2c 100644 --- a/ref/store/files/update_direct_read.go +++ b/ref/store/files/update_direct_read.go @@ -4,9 +4,9 @@ import ( "errors" "fmt" - "codeberg.org/lindenii/furgit/ref" - "codeberg.org/lindenii/furgit/ref/name" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/ref" + "lindenii.org/go/furgit/ref/name" + refstore "lindenii.org/go/furgit/ref/store" ) func (executor *refUpdateExecutor) directRead(name string) (directRefState, error) { diff --git a/ref/store/files/update_direct_ref.go b/ref/store/files/update_direct_ref.go index 3b429be0..79136da6 100644 --- a/ref/store/files/update_direct_ref.go +++ b/ref/store/files/update_direct_ref.go @@ -1,6 +1,6 @@ package files -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" type directRefKind uint8 diff --git a/ref/store/files/update_operation_queue.go b/ref/store/files/update_operation_queue.go index ef7ced2f..ecfdee28 100644 --- a/ref/store/files/update_operation_queue.go +++ b/ref/store/files/update_operation_queue.go @@ -1,6 +1,6 @@ package files -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" type queuedUpdate struct { name string diff --git a/ref/store/files/update_prepare_resolve.go b/ref/store/files/update_prepare_resolve.go index 19d209b0..a0437332 100644 --- a/ref/store/files/update_prepare_resolve.go +++ b/ref/store/files/update_prepare_resolve.go @@ -1,6 +1,6 @@ package files -import refstore "codeberg.org/lindenii/furgit/ref/store" +import refstore "lindenii.org/go/furgit/ref/store" func (executor *refUpdateExecutor) resolvePreparedUpdates(ops []queuedUpdate) ([]preparedUpdate, error) { prepared := make([]preparedUpdate, 0, len(ops)) diff --git a/ref/store/files/update_resolve_target_ordinary.go b/ref/store/files/update_resolve_target_ordinary.go index cf8e1978..73dc9e48 100644 --- a/ref/store/files/update_resolve_target_ordinary.go +++ b/ref/store/files/update_resolve_target_ordinary.go @@ -4,7 +4,7 @@ import ( "fmt" "strings" - refstore "codeberg.org/lindenii/furgit/ref/store" + refstore "lindenii.org/go/furgit/ref/store" ) func (executor *refUpdateExecutor) resolveOrdinaryTarget(name string, allowMissing bool) (resolvedUpdateTarget, error) { diff --git a/ref/store/files/update_validate.go b/ref/store/files/update_validate.go index ac3429aa..53758e19 100644 --- a/ref/store/files/update_validate.go +++ b/ref/store/files/update_validate.go @@ -4,9 +4,9 @@ import ( "fmt" "strings" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/ref/name" - refstore "codeberg.org/lindenii/furgit/ref/store" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/ref/name" + refstore "lindenii.org/go/furgit/ref/store" ) func (executor *refUpdateExecutor) validateQueuedUpdate(op queuedUpdate) error { diff --git a/ref/store/files/update_verify_current.go b/ref/store/files/update_verify_current.go index 51ed1b42..aa69ae76 100644 --- a/ref/store/files/update_verify_current.go +++ b/ref/store/files/update_verify_current.go @@ -3,7 +3,7 @@ package files import ( "strings" - refstore "codeberg.org/lindenii/furgit/ref/store" + refstore "lindenii.org/go/furgit/ref/store" ) func (executor *refUpdateExecutor) verifyPreparedUpdateCurrent(item preparedUpdate) error { diff --git a/ref/store/files/update_verify_refnames.go b/ref/store/files/update_verify_refnames.go index 8bc34a62..04bdcf21 100644 --- a/ref/store/files/update_verify_refnames.go +++ b/ref/store/files/update_verify_refnames.go @@ -3,7 +3,7 @@ package files import ( "strings" - refstore "codeberg.org/lindenii/furgit/ref/store" + refstore "lindenii.org/go/furgit/ref/store" ) func verifyRefnameAvailable(name string, existing map[string]struct{}, writes []string, deleted map[string]struct{}) error { diff --git a/ref/store/files/worktree_test.go b/ref/store/files/worktree_test.go index ae3dc299..f8a3e8e0 100644 --- a/ref/store/files/worktree_test.go +++ b/ref/store/files/worktree_test.go @@ -5,9 +5,9 @@ import ( "slices" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + refstore "lindenii.org/go/furgit/ref/store" ) func TestFilesWorktreeRefsMatchGit(t *testing.T) { diff --git a/ref/store/memory/batch.go b/ref/store/memory/batch.go index df3d554d..5e742fea 100644 --- a/ref/store/memory/batch.go +++ b/ref/store/memory/batch.go @@ -1,8 +1,8 @@ package memory import ( - objectid "codeberg.org/lindenii/furgit/object/id" - refstore "codeberg.org/lindenii/furgit/ref/store" + objectid "lindenii.org/go/furgit/object/id" + refstore "lindenii.org/go/furgit/ref/store" ) // Batch stages in-memory updates for one subset commit. diff --git a/ref/store/memory/read.go b/ref/store/memory/read.go index 5f8095bb..c9b2c7e6 100644 --- a/ref/store/memory/read.go +++ b/ref/store/memory/read.go @@ -6,8 +6,8 @@ import ( "slices" "strings" - "codeberg.org/lindenii/furgit/ref" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/ref" + refstore "lindenii.org/go/furgit/ref/store" ) // Resolve resolves one reference name diff --git a/ref/store/memory/ref.go b/ref/store/memory/ref.go index 67d9268f..f5492e63 100644 --- a/ref/store/memory/ref.go +++ b/ref/store/memory/ref.go @@ -1,6 +1,6 @@ package memory -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Because the public one includes the ref's name/identity. diff --git a/ref/store/memory/store.go b/ref/store/memory/store.go index d77f72e2..0cdbc010 100644 --- a/ref/store/memory/store.go +++ b/ref/store/memory/store.go @@ -3,8 +3,8 @@ package memory import ( "sync" - objectid "codeberg.org/lindenii/furgit/object/id" - refstore "codeberg.org/lindenii/furgit/ref/store" + objectid "lindenii.org/go/furgit/object/id" + refstore "lindenii.org/go/furgit/ref/store" ) // Store reads and writes one in-memory Git reference namespace. diff --git a/ref/store/memory/store_test.go b/ref/store/memory/store_test.go index b9705770..38adf9b6 100644 --- a/ref/store/memory/store_test.go +++ b/ref/store/memory/store_test.go @@ -4,11 +4,11 @@ import ( "errors" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/ref" - refstore "codeberg.org/lindenii/furgit/ref/store" - "codeberg.org/lindenii/furgit/ref/store/memory" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/ref" + refstore "lindenii.org/go/furgit/ref/store" + "lindenii.org/go/furgit/ref/store/memory" ) // Unlike the public ResolveToDetached, diff --git a/ref/store/memory/transaction.go b/ref/store/memory/transaction.go index 81ae01ef..62abaf90 100644 --- a/ref/store/memory/transaction.go +++ b/ref/store/memory/transaction.go @@ -1,8 +1,8 @@ package memory import ( - objectid "codeberg.org/lindenii/furgit/object/id" - refstore "codeberg.org/lindenii/furgit/ref/store" + objectid "lindenii.org/go/furgit/object/id" + refstore "lindenii.org/go/furgit/ref/store" ) // Transaction stages in-memory updates for one atomic commit. diff --git a/ref/store/memory/update.go b/ref/store/memory/update.go index 78a7ca2d..5c336fb7 100644 --- a/ref/store/memory/update.go +++ b/ref/store/memory/update.go @@ -5,9 +5,9 @@ import ( "fmt" "strings" - objectid "codeberg.org/lindenii/furgit/object/id" - refname "codeberg.org/lindenii/furgit/ref/name" - refstore "codeberg.org/lindenii/furgit/ref/store" + objectid "lindenii.org/go/furgit/object/id" + refname "lindenii.org/go/furgit/ref/name" + refstore "lindenii.org/go/furgit/ref/store" ) type updateKind uint8 diff --git a/ref/store/reading.go b/ref/store/reading.go index bf610d9b..94a92fca 100644 --- a/ref/store/reading.go +++ b/ref/store/reading.go @@ -1,6 +1,6 @@ package refstore -import "codeberg.org/lindenii/furgit/ref" +import "lindenii.org/go/furgit/ref" // Reader reads Git references. // diff --git a/ref/store/transaction.go b/ref/store/transaction.go index 30f6ab50..d31cd7e1 100644 --- a/ref/store/transaction.go +++ b/ref/store/transaction.go @@ -1,6 +1,6 @@ package refstore -import objectid "codeberg.org/lindenii/furgit/object/id" +import objectid "lindenii.org/go/furgit/object/id" // Transaction stages reference updates for one atomic commit. // diff --git a/repository/algorithm.go b/repository/algorithm.go index 1098f0b8..b4b551b4 100644 --- a/repository/algorithm.go +++ b/repository/algorithm.go @@ -3,8 +3,8 @@ package repository import ( "fmt" - "codeberg.org/lindenii/furgit/config" - objectid "codeberg.org/lindenii/furgit/object/id" + "lindenii.org/go/furgit/config" + objectid "lindenii.org/go/furgit/object/id" ) // detectObjectAlgorithm uses a repository's configuration to detect diff --git a/repository/commit_graph.go b/repository/commit_graph.go index 4f210b56..a809be02 100644 --- a/repository/commit_graph.go +++ b/repository/commit_graph.go @@ -4,8 +4,8 @@ import ( "errors" "os" - commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" - objectid "codeberg.org/lindenii/furgit/object/id" + commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" + objectid "lindenii.org/go/furgit/object/id" ) func openCommitGraph(root *os.Root, algo objectid.Algorithm) (*commitgraphread.Reader, error) { diff --git a/repository/commit_queries.go b/repository/commit_queries.go index bd004418..c5f11953 100644 --- a/repository/commit_queries.go +++ b/repository/commit_queries.go @@ -1,6 +1,6 @@ package repository -import "codeberg.org/lindenii/furgit/commitquery" +import "lindenii.org/go/furgit/commitquery" // CommitQueries returns commit queries backed by the repository's object store // and optional commit-graph. diff --git a/repository/config.go b/repository/config.go index a6cf28e3..0d6dbd5e 100644 --- a/repository/config.go +++ b/repository/config.go @@ -4,7 +4,7 @@ import ( "fmt" "os" - "codeberg.org/lindenii/furgit/config" + "lindenii.org/go/furgit/config" ) // parseRepositoryConfig loads the configuration of the repository through diff --git a/repository/fetcher.go b/repository/fetcher.go index 9cb0133c..601398d8 100644 --- a/repository/fetcher.go +++ b/repository/fetcher.go @@ -1,6 +1,6 @@ package repository -import "codeberg.org/lindenii/furgit/object/fetch" +import "lindenii.org/go/furgit/object/fetch" // Fetcher returns an object fetcher backed by the repository's object store. // diff --git a/repository/objects.go b/repository/objects.go index b1e975ee..dfc592b2 100644 --- a/repository/objects.go +++ b/repository/objects.go @@ -4,11 +4,11 @@ import ( "fmt" "os" - objectid "codeberg.org/lindenii/furgit/object/id" - objectstore "codeberg.org/lindenii/furgit/object/store" - objectdual "codeberg.org/lindenii/furgit/object/store/dual" - objectloose "codeberg.org/lindenii/furgit/object/store/loose" - objectpacked "codeberg.org/lindenii/furgit/object/store/packed" + objectid "lindenii.org/go/furgit/object/id" + objectstore "lindenii.org/go/furgit/object/store" + objectdual "lindenii.org/go/furgit/object/store/dual" + objectloose "lindenii.org/go/furgit/object/store/loose" + objectpacked "lindenii.org/go/furgit/object/store/packed" ) // openObjectStore opens the roots and object stores of both diff --git a/repository/open.go b/repository/open.go index 04aaa00c..3562379b 100644 --- a/repository/open.go +++ b/repository/open.go @@ -4,9 +4,9 @@ import ( "fmt" "os" - "codeberg.org/lindenii/furgit/commitquery" - "codeberg.org/lindenii/furgit/object/fetch" - reffiles "codeberg.org/lindenii/furgit/ref/store/files" + "lindenii.org/go/furgit/commitquery" + "lindenii.org/go/furgit/object/fetch" + reffiles "lindenii.org/go/furgit/ref/store/files" ) // Open opens a repository and wires its stores and helpers from the on-disk diff --git a/repository/reachability.go b/repository/reachability.go index d9ac9faf..2d400ef8 100644 --- a/repository/reachability.go +++ b/repository/reachability.go @@ -1,6 +1,6 @@ package repository -import "codeberg.org/lindenii/furgit/reachability" +import "lindenii.org/go/furgit/reachability" // Reachability returns graph traversal helpers backed by the repository's // object store and optional commit-graph. diff --git a/repository/refs.go b/repository/refs.go index ab983baf..f778f144 100644 --- a/repository/refs.go +++ b/repository/refs.go @@ -1,6 +1,6 @@ package repository -import refstore "codeberg.org/lindenii/furgit/ref/store" +import refstore "lindenii.org/go/furgit/ref/store" // RefStore returns the configured ref store. // diff --git a/repository/refs_test.go b/repository/refs_test.go index cde0e94e..566dc6cc 100644 --- a/repository/refs_test.go +++ b/repository/refs_test.go @@ -3,10 +3,10 @@ package repository_test import ( "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" - "codeberg.org/lindenii/furgit/ref" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" + "lindenii.org/go/furgit/ref" ) func TestOpenFilesRefFormat(t *testing.T) { diff --git a/repository/refs_timeout.go b/repository/refs_timeout.go index 275613ba..1414cea9 100644 --- a/repository/refs_timeout.go +++ b/repository/refs_timeout.go @@ -3,7 +3,7 @@ package repository import ( "time" - "codeberg.org/lindenii/furgit/config" + "lindenii.org/go/furgit/config" ) func detectPackedRefsTimeout(cfg *config.Config) time.Duration { diff --git a/repository/repository.go b/repository/repository.go index bfba5008..311f164a 100644 --- a/repository/repository.go +++ b/repository/repository.go @@ -10,15 +10,15 @@ package repository import ( "os" - "codeberg.org/lindenii/furgit/commitquery" - "codeberg.org/lindenii/furgit/config" - commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" - "codeberg.org/lindenii/furgit/object/fetch" - objectid "codeberg.org/lindenii/furgit/object/id" - objectdual "codeberg.org/lindenii/furgit/object/store/dual" - objectloose "codeberg.org/lindenii/furgit/object/store/loose" - objectpacked "codeberg.org/lindenii/furgit/object/store/packed" - refstore "codeberg.org/lindenii/furgit/ref/store" + "lindenii.org/go/furgit/commitquery" + "lindenii.org/go/furgit/config" + commitgraphread "lindenii.org/go/furgit/format/commitgraph/read" + "lindenii.org/go/furgit/object/fetch" + objectid "lindenii.org/go/furgit/object/id" + objectdual "lindenii.org/go/furgit/object/store/dual" + objectloose "lindenii.org/go/furgit/object/store/loose" + objectpacked "lindenii.org/go/furgit/object/store/packed" + refstore "lindenii.org/go/furgit/ref/store" ) // Repository represents a typical on-disk Git repository by composing its diff --git a/repository/stored_test.go b/repository/stored_test.go index 5604b418..d6b054f7 100644 --- a/repository/stored_test.go +++ b/repository/stored_test.go @@ -5,9 +5,9 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/tree" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/tree" ) func TestReadStoredTyped(t *testing.T) { diff --git a/repository/traversal_test.go b/repository/traversal_test.go index 034119ac..d6c392dd 100644 --- a/repository/traversal_test.go +++ b/repository/traversal_test.go @@ -7,13 +7,13 @@ import ( "strings" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - "codeberg.org/lindenii/furgit/object/blob" - "codeberg.org/lindenii/furgit/object/commit" - objectid "codeberg.org/lindenii/furgit/object/id" - "codeberg.org/lindenii/furgit/object/tag" - "codeberg.org/lindenii/furgit/object/tree" - "codeberg.org/lindenii/furgit/repository" + "lindenii.org/go/furgit/internal/testgit" + "lindenii.org/go/furgit/object/blob" + "lindenii.org/go/furgit/object/commit" + objectid "lindenii.org/go/furgit/object/id" + "lindenii.org/go/furgit/object/tag" + "lindenii.org/go/furgit/object/tree" + "lindenii.org/go/furgit/repository" ) func TestRepositoryDepthFirstEnumerationFromHEAD(t *testing.T) { diff --git a/repository/write_loose_test.go b/repository/write_loose_test.go index 218a70cd..64948224 100644 --- a/repository/write_loose_test.go +++ b/repository/write_loose_test.go @@ -4,9 +4,9 @@ import ( "bytes" "testing" - "codeberg.org/lindenii/furgit/internal/testgit" - objectid "codeberg.org/lindenii/furgit/object/id" - objecttype "codeberg.org/lindenii/furgit/object/type" + "lindenii.org/go/furgit/internal/testgit" + objectid "lindenii.org/go/furgit/object/id" + objecttype "lindenii.org/go/furgit/object/type" ) func TestWriteLooseBytesContent(t *testing.T) { -- cgit v1.3.1-10-gc9f91 From 090722278295d59208a4d1fea1a985a930ceb51b Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Wed, 27 May 2026 06:24:07 +0000 Subject: Update remaining package import URLs --- .forgejo/ISSUE_TEMPLATE/bug.yaml | 2 +- .github/ISSUE_TEMPLATE/bug.yaml | 2 +- .golangci.yaml | 2 +- README.md | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.forgejo/ISSUE_TEMPLATE/bug.yaml b/.forgejo/ISSUE_TEMPLATE/bug.yaml index d2929cf8..2f616c71 100644 --- a/.forgejo/ISSUE_TEMPLATE/bug.yaml +++ b/.forgejo/ISSUE_TEMPLATE/bug.yaml @@ -26,7 +26,7 @@ body: placeholder: | package main - import "codeberg.org/lindenii/furgit" + import "lindenii.org/go/furgit" func main() { // do something diff --git a/.github/ISSUE_TEMPLATE/bug.yaml b/.github/ISSUE_TEMPLATE/bug.yaml index a9b33e94..5bc6d94f 100644 --- a/.github/ISSUE_TEMPLATE/bug.yaml +++ b/.github/ISSUE_TEMPLATE/bug.yaml @@ -28,7 +28,7 @@ body: placeholder: | package main - import "codeberg.org/lindenii/furgit" + import "lindenii.org/go/furgit" func main() { // do something diff --git a/.golangci.yaml b/.golangci.yaml index 254682fe..6ba5839e 100644 --- a/.golangci.yaml +++ b/.golangci.yaml @@ -39,7 +39,7 @@ linters: - $all allow: - $gostd - - codeberg.org/lindenii/furgit + - lindenii.org/go/furgit - golang.org/x gosec: excludes: diff --git a/README.md b/README.md index 2f2175b6..09c5eb65 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ # Furgit [![builds.sr.ht status](https://builds.sr.ht/~runxiyu/furgit/commits/master.svg)](https://builds.sr.ht/~runxiyu/furgit/commits/master) -[![Go Reference](https://pkg.go.dev/badge/codeberg.org/lindenii/furgit.svg)](https://pkg.go.dev/codeberg.org/lindenii/furgit) +[![Go Reference](https://pkg.go.dev/badge/lindenii.org/go/furgit.svg)](https://pkg.go.dev/lindenii.org/go/furgit) A low‐level Git plumbing library in Go. -- cgit v1.3.1-10-gc9f91 -- cgit v1.3.1-10-gc9f91 From c0541a3845867b468dfa2429cefa2c919cd2f724 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Fri, 29 May 2026 07:34:22 +0000 Subject: object/store/packed: FixThin when ThinBase != nil --- object/store/packed/writer.go | 1 + 1 file changed, 1 insertion(+) diff --git a/object/store/packed/writer.go b/object/store/packed/writer.go index 040a8989..f57313d2 100644 --- a/object/store/packed/writer.go +++ b/object/store/packed/writer.go @@ -13,6 +13,7 @@ var _ objectstore.PackWriter = (*Store)(nil) func (store *Store) WritePack(src io.Reader, opts objectstore.PackWriteOptions) error { _, err := ingest.WritePack(store.root, store.algo, src, ingest.Options{ WriteRev: store.opts.WriteRev, + FixThin: opts.ThinBase != nil, ThinBase: opts.ThinBase, Progress: opts.Progress, RequireTrailingEOF: opts.RequireTrailingEOF, -- cgit v1.3.1-10-gc9f91 From 47a4bcf464c9153fdf4ff957cc14de6cc95b69eb Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Fri, 29 May 2026 07:55:16 +0000 Subject: repository: Returning nil sets repo to nil and panics the defer --- repository/open.go | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/repository/open.go b/repository/open.go index 3562379b..622b5e43 100644 --- a/repository/open.go +++ b/repository/open.go @@ -27,21 +27,21 @@ func Open(root *os.Root) (repo *Repository, err error) { cfg, err := parseRepositoryConfig(root) if err != nil { - return nil, err + return repo, err } repo.config = cfg algo, err := detectObjectAlgorithm(cfg) if err != nil { - return nil, err + return repo, err } repo.algo = algo objects, objectsRoot, objectsPackRoot, objectsLoose, objectsPacked, err := openObjectStore(root, algo) if err != nil { - return nil, err + return repo, err } repo.objects = objects @@ -53,7 +53,7 @@ func Open(root *os.Root) (repo *Repository, err error) { commitGraph, err := openCommitGraph(objectsRoot, algo) if err != nil { - return nil, err + return repo, err } repo.commitGraph = commitGraph @@ -61,14 +61,14 @@ func Open(root *os.Root) (repo *Repository, err error) { refRoot, err := root.OpenRoot(".") if err != nil { - return nil, fmt.Errorf("repository: open root for refs: %w", err) + return repo, fmt.Errorf("repository: open root for refs: %w", err) } refs, err := reffiles.New(refRoot, algo, detectPackedRefsTimeout(cfg)) if err != nil { _ = refRoot.Close() - return nil, err + return repo, err } repo.refs = refs -- cgit v1.3.1-10-gc9f91 From b165e1a1a9b178f7e41fc6afa0ca942bbf763e89 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Thu, 4 Jun 2026 07:05:42 +0000 Subject: network/receivepack/service: unpacking indicator makes no sense --- network/receivepack/service/ingest_quarantine.go | 3 --- 1 file changed, 3 deletions(-) diff --git a/network/receivepack/service/ingest_quarantine.go b/network/receivepack/service/ingest_quarantine.go index dc0fef50..8be73e33 100644 --- a/network/receivepack/service/ingest_quarantine.go +++ b/network/receivepack/service/ingest_quarantine.go @@ -57,7 +57,6 @@ func (service *Service) ingestQuarantine( } utils.BestEffortFprintf(service.opts.Progress, "creating quarantine: done.\n") - utils.BestEffortFprintf(service.opts.Progress, "unpacking...\r") err = quarantine.WritePack(req.Pack, objectstore.PackWriteOptions{ ThinBase: service.opts.ExistingObjects, @@ -75,7 +74,5 @@ func (service *Service) ingestQuarantine( return nil, false } - utils.BestEffortFprintf(service.opts.Progress, "unpacking: done.\n") - return quarantine, true } -- cgit v1.3.1-10-gc9f91 From 26d0a8ed33c492114fce42d875c8f742adab1dd1 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Sat, 6 Jun 2026 03:37:14 +0000 Subject: git.runxiyu.org main mirror for now --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 09c5eb65..200aa2cb 100644 --- a/README.md +++ b/README.md @@ -47,10 +47,10 @@ version for this Program. ## Repos and mirrors -* [Codeberg](https://codeberg.org/lindenii/furgit) +* [git.runxiyu.org](https://git.runxiyu.org/furgit.git//) +* [Codeberg mirror](https://codeberg.org/lindenii/furgit) * [SourceHut mirror](https://git.sr.ht/~runxiyu/furgit) * [hjgit mirror](https://hjgit.org/runxiyu/furgit/HEAD/info.html) -* [git.runxiyu.org mirror](https://git.runxiyu.org/furgit.git//) * [cgit.space mirror](https://cgit.space/~runxiyu/furgit.git/) * [tangled mirror](https://tangled.org/@runxiyu.tngl.sh/furgit) * [GitHub mirror](https://github.com/runxiyu/furgit) -- cgit v1.3.1-10-gc9f91 From e0355f8d96a46a800d870200f1de07beeae252b3 Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Sun, 7 Jun 2026 15:58:33 +0000 Subject: legacy -> v0.1.9 --- BENCHMARKS.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/BENCHMARKS.md b/BENCHMARKS.md index 36dfdb39..db0589fc 100644 --- a/BENCHMARKS.md +++ b/BENCHMARKS.md @@ -1,7 +1,7 @@ # Benchmarks * See [gitbench](https://git.sr.ht/~runxiyu/gitbench). -* `legacy` branch furgit is slightly faster due to buffer reuse and custom +* `v0.1.9` furgit is slightly faster due to buffer reuse and custom ZLIB. These will be re‐added. * Alpine edge, i5‐10210U, `performance` governor, `linux.git`. * go-git may become much faster when -- cgit v1.3.1-10-gc9f91 From f6407ac3ac624e4ce2e68e135f9550e99f0222ab Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Sun, 7 Jun 2026 15:59:09 +0000 Subject: this is legacy --- README.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 200aa2cb..06fa0507 100644 --- a/README.md +++ b/README.md @@ -1,11 +1,12 @@ # Furgit -[![builds.sr.ht status](https://builds.sr.ht/~runxiyu/furgit/commits/master.svg)](https://builds.sr.ht/~runxiyu/furgit/commits/master) +[![builds.sr.ht status](https://builds.sr.ht/~runxiyu/furgit/commits/legacy.svg)](https://builds.sr.ht/~runxiyu/furgit/commits/legacy) [![Go Reference](https://pkg.go.dev/badge/lindenii.org/go/furgit.svg)](https://pkg.go.dev/lindenii.org/go/furgit) A low‐level Git plumbing library in Go. -A refactor is pending on the `next` branch. +This `legacy` branch will probably be deprecated sometime. +See `main`. ## Status -- cgit v1.3.1-10-gc9f91