object_db: add support for multiple hash algorithms

Currently, our object DB has support for one major type of option:
alternates.  However, we also need to deal with the Git SHA-256
transition as well so we can support objects in repositories using
SHA-256.

Since we have multiple types of options, let's switch to an
options-style initializer as well.  This is a breaking API change, so
we'll need to bump the major version and update go.mod and our package
declarations accordingly.

Create a Hasher method which tells us which hash algorithm is in use in
this repository.  We can then either hash our objects or query our
hasher for properties such as the size.

Because we'll also want to look up a hash algorithm before we have an
object DB opened, let's make that Hasher method a wrapper around an
internal function that we can use in this case to instantiate a hash
algorithm based on its ID and use it in our object DB method.

Note that this doesn't intrinsically add support for parsing these
objects, which will come in a future commit, but it does lay the
groundwork for that.

Author: bk2204

backend.go

@@ -9,8 +9,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/git-lfs/gitobj/pack"
-	"github.com/git-lfs/gitobj/storage"
+	"github.com/git-lfs/gitobj/v2/pack"
+	"github.com/git-lfs/gitobj/v2/storage"
 )
 
 // NewFilesystemBackend initializes a new filesystem-based backend.

file_storer.go

@@ -8,7 +8,7 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/git-lfs/gitobj/errors"
+	"github.com/git-lfs/gitobj/v2/errors"
 )
 
 // fileStorer implements the storer interface by writing to the .git/objects

go.mod

@@ -1,4 +1,4 @@
-module github.com/git-lfs/gitobj
+module github.com/git-lfs/gitobj/v2
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect

memory_storer.go

@@ -6,7 +6,7 @@ import (
 	"io"
 	"sync"
 
-	"github.com/git-lfs/gitobj/errors"
+	"github.com/git-lfs/gitobj/v2/errors"
 )
 
 // memoryStorer is an implementation of the storer interface that holds data for

memory_storer_test.go

@@ -8,7 +8,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/git-lfs/gitobj/errors"
+	"github.com/git-lfs/gitobj/v2/errors"
 	"github.com/stretchr/testify/assert"
 )
 

object_db.go

@@ -2,13 +2,16 @@ package gitobj
 
 import (
 	"bytes"
+	"crypto/sha1"
+	"crypto/sha256"
 	"fmt"
+	"hash"
 	"io"
 	"io/ioutil"
 	"os"
 	"sync/atomic"
 
-	"github.com/git-lfs/gitobj/storage"
+	"github.com/git-lfs/gitobj/v2/storage"
 )
 
 // ObjectDatabase enables the reading and writing of objects against a storage
@@ -29,41 +32,80 @@ type ObjectDatabase struct {
 
 	// temp directory, defaults to os.TempDir
 	tmp string
+
+	// objectFormat is the object format (hash algorithm)
+	objectFormat ObjectFormatAlgorithm
+}
+
+type options struct {
+	alternates   string
+	objectFormat ObjectFormatAlgorithm
+}
+
+type Option func(*options)
+
+type ObjectFormatAlgorithm string
+
+const (
+	ObjectFormatSHA1   = ObjectFormatAlgorithm("sha1")
+	ObjectFormatSHA256 = ObjectFormatAlgorithm("sha256")
+)
+
+// Alternates is an Option to specify the string of alternate repositories that
+// are searched for objects.  The format is the same as for
+// GIT_ALTERNATE_OBJECT_DIRECTORIES.
+func Alternates(alternates string) Option {
+	return func(args *options) {
+		args.alternates = alternates
+	}
+}
+
+// ObjectFormat is an Option to specify the hash algorithm (object format) in
+// use in Git.  If not specified, it defaults to ObjectFormatSHA1.
+func ObjectFormat(algo ObjectFormatAlgorithm) Option {
+	return func(args *options) {
+		args.objectFormat = algo
+	}
 }
 
 // FromFilesystem constructs an *ObjectDatabase instance that is backed by a
 // directory on the filesystem. Specifically, this should point to:
 //
 //  /absolute/repo/path/.git/objects
-func FromFilesystem(root, tmp string) (*ObjectDatabase, error) {
-	return FromFilesystemWithAlternates(root, tmp, "")
-}
+func FromFilesystem(root, tmp string, setters ...Option) (*ObjectDatabase, error) {
+	args := &options{objectFormat: ObjectFormatSHA1}
 
-// FromFilesystemWithAlternates constructs an *ObjectDatabase instance that is
-// backed by a directory on the filesystem, optionally with one or more
-// alternates. Specifically, this should point to:
-//
-//  /absolute/repo/path/.git/objects
-func FromFilesystemWithAlternates(root, tmp, alternates string) (*ObjectDatabase, error) {
-	b, err := NewFilesystemBackendWithAlternates(root, tmp, alternates)
+	for _, setter := range setters {
+		setter(args)
+	}
+
+	b, err := NewFilesystemBackendWithAlternates(root, tmp, args.alternates)
 	if err != nil {
 		return nil, err
 	}
 
-	ro, rw := b.Storage()
-	return &ObjectDatabase{
-		tmp: tmp,
-		ro:  ro,
-		rw:  rw,
-	}, nil
+	odb, err := FromBackend(b, setters...)
+	if err != nil {
+		return nil, err
+	}
+	odb.tmp = tmp
+	return odb, nil
 }
 
-func FromBackend(b storage.Backend) (*ObjectDatabase, error) {
+func FromBackend(b storage.Backend, setters ...Option) (*ObjectDatabase, error) {
+	args := &options{objectFormat: ObjectFormatSHA1}
+
+	for _, setter := range setters {
+		setter(args)
+	}
+
 	ro, rw := b.Storage()
-	return &ObjectDatabase{
-		ro: ro,
-		rw: rw,
-	}, nil
+	odb := &ObjectDatabase{
+		ro:           ro,
+		rw:           rw,
+		objectFormat: args.objectFormat,
+	}
+	return odb, nil
 }
 
 // Close closes the *ObjectDatabase, freeing any open resources (namely: the
@@ -227,6 +269,11 @@ func (o *ObjectDatabase) Root() (string, bool) {
 	return "", false
 }
 
+// Hasher returns a new hash instance suitable for this object database.
+func (o *ObjectDatabase) Hasher() hash.Hash {
+	return hasher(o.objectFormat)
+}
+
 // encode encodes and saves an object to the storage backend and uses an
 // in-memory buffer to calculate the object's encoded body.
 func (d *ObjectDatabase) encode(object Object) (sha []byte, n int64, err error) {
@@ -337,3 +384,14 @@ func (o *ObjectDatabase) cleanup(f *os.File) {
 	f.Close()
 	os.Remove(f.Name())
 }
+
+func hasher(algo ObjectFormatAlgorithm) hash.Hash {
+	switch algo {
+	case ObjectFormatSHA1:
+		return sha1.New()
+	case ObjectFormatSHA256:
+		return sha256.New()
+	default:
+		return nil
+	}
+}

pack/set.go

@@ -8,7 +8,7 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/git-lfs/gitobj/errors"
+	"github.com/git-lfs/gitobj/v2/errors"
 )
 
 // Set allows access of objects stored across a set of packfiles.

storage/multi_storage.go

@@ -3,7 +3,7 @@ package storage
 import (
 	"io"
 
-	"github.com/git-lfs/gitobj/errors"
+	"github.com/git-lfs/gitobj/v2/errors"
 )
 
 // Storage implements an interface for reading, but not writing, objects in an