Add support for alternates from the environment

Add support for alternates in the environment by allowing users to
specify the contents of the environment variable
GIT_ALTERNATE_OBJECT_DIRECTORIES and parsing that to discover additional
alternates. Add tests for the handling of the paths, which is reasonably
complex.

Author: bk2204

backend.go

@@ -5,13 +5,24 @@ import (
 	"io"
 	"os"
 	"path"
+	"regexp"
+	"strconv"
+	"strings"
 
 	"github.com/git-lfs/gitobj/pack"
 	"github.com/git-lfs/gitobj/storage"
 )
 
 // NewFilesystemBackend initializes a new filesystem-based backend.
 func NewFilesystemBackend(root, tmp string) (storage.Backend, error) {
+	return NewFilesystemBackendWithAlternates(root, tmp, "")
+}
+
+// NewFilesystemBackendWithAlternates initializes a new filesystem-based
+// backend, optionally with additional alternates as specified in the
+// `alternates` variable. The syntax is that of the Git environment variable
+// GIT_ALTERNATE_OBJECT_DIRECTORIES.
+func NewFilesystemBackendWithAlternates(root, tmp, alternates string) (storage.Backend, error) {
 	fsobj := newFileStorer(root, tmp)
 	packs, err := pack.NewStorage(root)
 	if err != nil {
@@ -23,6 +34,11 @@ func NewFilesystemBackend(root, tmp string) (storage.Backend, error) {
 		return nil, err
 	}
 
+	storage, err = addAlternatesFromEnvironment(storage, alternates)
+	if err != nil {
+		return nil, err
+	}
+
 	return &filesystemBackend{
 		fs:       fsobj,
 		backends: storage,
@@ -68,6 +84,66 @@ func addAlternateDirectory(s []storage.Storage, dir string) ([]storage.Storage,
 	return s, nil
 }
 
+func addAlternatesFromEnvironment(s []storage.Storage, env string) ([]storage.Storage, error) {
+	if len(env) == 0 {
+		return s, nil
+	}
+
+	for _, dir := range splitAlternateString(env, alternatesSeparator) {
+		var err error
+		s, err = addAlternateDirectory(s, dir)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return s, nil
+}
+
+var (
+	octalEscape  = regexp.MustCompile("\\\\[0-7]{1,3}")
+	hexEscape    = regexp.MustCompile("\\\\x[0-9a-fA-F]{2}")
+	replacements = []struct {
+		olds string
+		news string
+	}{
+		{`\a`, "\a"},
+		{`\b`, "\b"},
+		{`\t`, "\t"},
+		{`\n`, "\n"},
+		{`\v`, "\v"},
+		{`\f`, "\f"},
+		{`\r`, "\r"},
+		{`\\`, "\\"},
+		{`\"`, "\""},
+		{`\'`, "'"},
+	}
+)
+
+func splitAlternateString(env string, separator string) []string {
+	dirs := strings.Split(env, separator)
+	for i, s := range dirs {
+		if !strings.HasPrefix(s, `"`) || !strings.HasSuffix(s, `"`) {
+			continue
+		}
+
+		// Strip leading and trailing quotation marks
+		s = s[1 : len(s)-1]
+		for _, repl := range replacements {
+			s = strings.Replace(s, repl.olds, repl.news, -1)
+		}
+		s = octalEscape.ReplaceAllStringFunc(s, func(inp string) string {
+			val, _ := strconv.ParseUint(inp[1:], 8, 64)
+			return string([]byte{byte(val)})
+		})
+		s = hexEscape.ReplaceAllStringFunc(s, func(inp string) string {
+			val, _ := strconv.ParseUint(inp[2:], 16, 64)
+			return string([]byte{byte(val)})
+		})
+		dirs[i] = s
+	}
+	return dirs
+}
+
 // NewMemoryBackend initializes a new memory-based backend.
 //
 // A value of "nil" is acceptable and indicates that no entries should be added

backend_nix.go

@@ -0,0 +1,5 @@
+// +build !windows
+
+package gitobj
+
+const alternatesSeparator = ":"

backend_test.go

@@ -5,6 +5,7 @@ import (
 	"encoding/hex"
 	"io"
 	"io/ioutil"
+	"reflect"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -62,3 +63,26 @@ func TestNewMemoryBackendWithWritableData(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, []byte{0x1}, contents)
 }
+
+func TestSplitAlternatesString(t *testing.T) {
+	testCases := []struct {
+		input    string
+		expected []string
+	}{
+		{"abc", []string{"abc"}},
+		{"abc:def", []string{"abc", "def"}},
+		{`"abc":def`, []string{"abc", "def"}},
+		{`"i\alike\bcomplicated\tstrings":def`, []string{"i\alike\bcomplicated\tstrings", "def"}},
+		{`abc:"i\nlike\vcomplicated\fstrings\r":def`, []string{"abc", "i\nlike\vcomplicated\fstrings\r", "def"}},
+		{`abc:"uni\xc2\xa9ode":def`, []string{"abc", "uni©ode", "def"}},
+		{`abc:"uni\302\251ode\10\0":def`, []string{"abc", "uni©ode\x08\x00", "def"}},
+		{`abc:"cookie\\monster\"":def`, []string{"abc", "cookie\\monster\"", "def"}},
+	}
+
+	for _, test := range testCases {
+		actual := splitAlternateString(test.input, ":")
+		if !reflect.DeepEqual(actual, test.expected) {
+			t.Errorf("unexpected output for %q: got %v, expected %v", test.input, actual, test.expected)
+		}
+	}
+}

backend_windows.go

@@ -0,0 +1,5 @@
+// +build windows
+
+package gitobj
+
+const alternatesSeparator = ";"

object_db.go

@@ -36,7 +36,16 @@ type ObjectDatabase struct {
 //
 //  /absolute/repo/path/.git/objects
 func FromFilesystem(root, tmp string) (*ObjectDatabase, error) {
-	b, err := NewFilesystemBackend(root, tmp)
+	return FromFilesystemWithAlternates(root, tmp, "")
+}
+
+// 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)
 	if err != nil {
 		return nil, err
 	}