shithub: furgit

Info  •  Files  •  Log  •  Branches

repository: Split

--- a/repository/open.go

+++ b/repository/open.go

@@ -1,23 +1,7 @@

 package repository

-import (

-	"errors"

-	"fmt"

-	"os"

+import "os"

-	"codeberg.org/lindenii/furgit/config"

-	"codeberg.org/lindenii/furgit/objectid"

-	"codeberg.org/lindenii/furgit/objectstore"

-	objectloose "codeberg.org/lindenii/furgit/objectstore/loose"

-	objectmix "codeberg.org/lindenii/furgit/objectstore/mix"

-	objectpacked "codeberg.org/lindenii/furgit/objectstore/packed"

-	"codeberg.org/lindenii/furgit/refstore"

-	refchain "codeberg.org/lindenii/furgit/refstore/chain"

-	refloose "codeberg.org/lindenii/furgit/refstore/loose"

-	refpacked "codeberg.org/lindenii/furgit/refstore/packed"

-	reftable "codeberg.org/lindenii/furgit/refstore/reftable"

-)

-

 // Open opens a repository and wires object/ref stores from its on-disk format.

 //

 // Open borrows root during construction and does not close it.

@@ -60,153 +44,4 @@

 	repo.refs = refs

 	return repo, nil

-}

-

-func parseRepositoryConfig(root *os.Root) (*config.Config, error) {

-	configFile, err := root.Open("config")

-	if err != nil {

-		return nil, fmt.Errorf("repository: open config: %w", err)

-	}

-

-	defer func() { _ = configFile.Close() }()

-

-	cfg, err := config.ParseConfig(configFile)

-	if err != nil {

-		return nil, fmt.Errorf("repository: parse config: %w", err)

-	}

-

-	return cfg, nil

-}

-

-func detectObjectAlgorithm(cfg *config.Config) (objectid.Algorithm, error) {

-	algoName := cfg.Lookup("extensions", "", "objectformat").Value

-	if algoName == "" {

-		algoName = objectid.AlgorithmSHA1.String()

-	}

-

-	algo, ok := objectid.ParseAlgorithm(algoName)

-	if !ok {

-		return objectid.AlgorithmUnknown, fmt.Errorf("repository: unsupported object format %q", algoName)

-	}

-

-	return algo, nil

-}

-

-func openObjectStore(root *os.Root, algo objectid.Algorithm) (objectstore.Store, *objectloose.Store, error) {

-	objectsRoot, err := root.OpenRoot("objects")

-	if err != nil {

-		return nil, nil, fmt.Errorf("repository: open objects: %w", err)

-	}

-

-	looseStore, err := objectloose.New(objectsRoot, algo)

-	if err != nil {

-		return nil, nil, err

-	}

-

-	backends := []objectstore.Store{looseStore}

-

-	packRoot, err := objectsRoot.OpenRoot("pack")

-	if err == nil {

-		var packedStore *objectpacked.Store

-

-		packedStore, err = objectpacked.New(packRoot, algo)

-		if err != nil {

-			_ = looseStore.Close()

-

-			return nil, nil, err

-		}

-

-		backends = append(backends, packedStore)

-	} else if !errors.Is(err, os.ErrNotExist) {

-		_ = looseStore.Close()

-

-		return nil, nil, fmt.Errorf("repository: open objects/pack: %w", err)

-	}

-

-	objectsChain := objectmix.New(backends...)

-

-	objectsRootForWriting, err := root.OpenRoot("objects")

-	if err != nil {

-		_ = objectsChain.Close()

-

-		return nil, nil, fmt.Errorf("repository: open objects for loose writing: %w", err)

-	}

-

-	objectsLooseForWritingOnly, err := objectloose.New(objectsRootForWriting, algo)

-	if err != nil {

-		_ = objectsRootForWriting.Close()

-		_ = objectsChain.Close()

-

-		return nil, nil, err

-	}

-

-	return objectsChain, objectsLooseForWritingOnly, nil

-}

-

-func openRefStore(root *os.Root, algo objectid.Algorithm) (out refstore.Store, err error) {

-	hasReftable, err := hasReftableStack(root)

-	if err != nil {

-		return nil, err

-	}

-

-	if hasReftable {

-		reftableRoot, err := root.OpenRoot("reftable")

-		if err != nil {

-			return nil, fmt.Errorf("repository: open reftable: %w", err)

-		}

-

-		reftableStore, err := reftable.New(reftableRoot, algo)

-		if err != nil {

-			_ = reftableRoot.Close()

-

-			return nil, err

-		}

-

-		return reftableStore, nil

-	}

-

-	looseRoot, err := root.OpenRoot(".")

-	if err != nil {

-		return nil, fmt.Errorf("repository: open root for loose refs: %w", err)

-	}

-

-	looseStore, err := refloose.New(looseRoot, algo)

-	if err != nil {

-		_ = looseRoot.Close()

-

-		return nil, err

-	}

-

-	backends := []refstore.Store{looseStore}

-

-	_, err = root.Stat("packed-refs")

-	if err == nil {

-		packedStore, packedErr := refpacked.New(root, algo)

-		if packedErr != nil {

-			_ = looseStore.Close()

-

-			return nil, packedErr

-		}

-

-		backends = append(backends, packedStore)

-	} else if !errors.Is(err, os.ErrNotExist) {

-		_ = looseStore.Close()

-

-		return nil, fmt.Errorf("repository: stat packed-refs: %w", err)

-	}

-

-	return refchain.New(backends...), nil

-}

-

-func hasReftableStack(root *os.Root) (bool, error) {

-	_, err := root.Stat("reftable/tables.list")

-	if err == nil {

-		return true, nil

-	}

-

-	if errors.Is(err, os.ErrNotExist) {

-		return false, nil

-	}

-

-	return false, fmt.Errorf("repository: stat reftable/tables.list: %w", err)

 }

--- /dev/null

+++ b/repository/open_config.go

@@ -1,0 +1,39 @@

+package repository

+

+import (

+	"fmt"

+	"os"

+

+	"codeberg.org/lindenii/furgit/config"

+	"codeberg.org/lindenii/furgit/objectid"

+)

+

+func parseRepositoryConfig(root *os.Root) (*config.Config, error) {

+	configFile, err := root.Open("config")

+	if err != nil {

+		return nil, fmt.Errorf("repository: open config: %w", err)

+	}

+

+	defer func() { _ = configFile.Close() }()

+

+	cfg, err := config.ParseConfig(configFile)

+	if err != nil {

+		return nil, fmt.Errorf("repository: parse config: %w", err)

+	}

+

+	return cfg, nil

+}

+

+func detectObjectAlgorithm(cfg *config.Config) (objectid.Algorithm, error) {

+	algoName := cfg.Lookup("extensions", "", "objectformat").Value

+	if algoName == "" {

+		algoName = objectid.AlgorithmSHA1.String()

+	}

+

+	algo, ok := objectid.ParseAlgorithm(algoName)

+	if !ok {

+		return objectid.AlgorithmUnknown, fmt.Errorf("repository: unsupported object format %q", algoName)

+	}

+

+	return algo, nil

+}

--- /dev/null

+++ b/repository/open_objects.go

@@ -1,0 +1,64 @@

+package repository

+

+import (

+	"errors"

+	"fmt"

+	"os"

+

+	"codeberg.org/lindenii/furgit/objectid"

+	"codeberg.org/lindenii/furgit/objectstore"

+	objectloose "codeberg.org/lindenii/furgit/objectstore/loose"

+	objectmix "codeberg.org/lindenii/furgit/objectstore/mix"

+	objectpacked "codeberg.org/lindenii/furgit/objectstore/packed"

+)

+

+func openObjectStore(root *os.Root, algo objectid.Algorithm) (objectstore.Store, *objectloose.Store, error) {

+	objectsRoot, err := root.OpenRoot("objects")

+	if err != nil {

+		return nil, nil, fmt.Errorf("repository: open objects: %w", err)

+	}

+

+	looseStore, err := objectloose.New(objectsRoot, algo)

+	if err != nil {

+		return nil, nil, err

+	}

+

+	backends := []objectstore.Store{looseStore}

+

+	packRoot, err := objectsRoot.OpenRoot("pack")

+	if err == nil {

+		var packedStore *objectpacked.Store

+

+		packedStore, err = objectpacked.New(packRoot, algo)

+		if err != nil {

+			_ = looseStore.Close()

+

+			return nil, nil, err

+		}

+

+		backends = append(backends, packedStore)

+	} else if !errors.Is(err, os.ErrNotExist) {

+		_ = looseStore.Close()

+

+		return nil, nil, fmt.Errorf("repository: open objects/pack: %w", err)

+	}

+

+	objectsChain := objectmix.New(backends...)

+

+	objectsRootForWriting, err := root.OpenRoot("objects")

+	if err != nil {

+		_ = objectsChain.Close()

+

+		return nil, nil, fmt.Errorf("repository: open objects for loose writing: %w", err)

+	}

+

+	objectsLooseForWritingOnly, err := objectloose.New(objectsRootForWriting, algo)

+	if err != nil {

+		_ = objectsRootForWriting.Close()

+		_ = objectsChain.Close()

+

+		return nil, nil, err

+	}

+

+	return objectsChain, objectsLooseForWritingOnly, nil

+}

--- /dev/null

+++ b/repository/open_refs.go

@@ -1,0 +1,82 @@

+package repository

+

+import (

+	"errors"

+	"fmt"

+	"os"

+

+	"codeberg.org/lindenii/furgit/objectid"

+	"codeberg.org/lindenii/furgit/refstore"

+	refchain "codeberg.org/lindenii/furgit/refstore/chain"

+	refloose "codeberg.org/lindenii/furgit/refstore/loose"

+	refpacked "codeberg.org/lindenii/furgit/refstore/packed"

+	reftable "codeberg.org/lindenii/furgit/refstore/reftable"

+)

+

+func openRefStore(root *os.Root, algo objectid.Algorithm) (out refstore.Store, err error) {

+	hasReftable, err := hasReftableStack(root)

+	if err != nil {

+		return nil, err

+	}

+

+	if hasReftable {

+		reftableRoot, err := root.OpenRoot("reftable")

+		if err != nil {

+			return nil, fmt.Errorf("repository: open reftable: %w", err)

+		}

+

+		reftableStore, err := reftable.New(reftableRoot, algo)

+		if err != nil {

+			_ = reftableRoot.Close()

+

+			return nil, err

+		}

+

+		return reftableStore, nil

+	}

+

+	looseRoot, err := root.OpenRoot(".")

+	if err != nil {

+		return nil, fmt.Errorf("repository: open root for loose refs: %w", err)

+	}

+

+	looseStore, err := refloose.New(looseRoot, algo)

+	if err != nil {

+		_ = looseRoot.Close()

+

+		return nil, err

+	}

+

+	backends := []refstore.Store{looseStore}

+

+	_, err = root.Stat("packed-refs")

+	if err == nil {

+		packedStore, packedErr := refpacked.New(root, algo)

+		if packedErr != nil {

+			_ = looseStore.Close()

+

+			return nil, packedErr

+		}

+

+		backends = append(backends, packedStore)

+	} else if !errors.Is(err, os.ErrNotExist) {

+		_ = looseStore.Close()

+

+		return nil, fmt.Errorf("repository: stat packed-refs: %w", err)

+	}

+

+	return refchain.New(backends...), nil

+}

+

+func hasReftableStack(root *os.Root) (bool, error) {

+	_, err := root.Stat("reftable/tables.list")

+	if err == nil {

+		return true, nil

+	}

+

+	if errors.Is(err, os.ErrNotExist) {

+		return false, nil

+	}

+

+	return false, fmt.Errorf("repository: stat reftable/tables.list: %w", err)

+}

-- 

⑨