From ae999ede139f5fa5601ffb7c55979608b112d274 Mon Sep 17 00:00:00 2001
From: Máximo Cuadros <mcuadros@gmail.com>
Date: Fri, 12 Aug 2016 19:11:27 +0200
Subject: storage: Storage entity support, and DotGit support for References

---
 storage/filesystem/object.go | 142 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 142 insertions(+)
 create mode 100644 storage/filesystem/object.go

(limited to 'storage/filesystem/object.go')

diff --git a/storage/filesystem/object.go b/storage/filesystem/object.go
new file mode 100644
index 0000000..f3a1dda
--- /dev/null
+++ b/storage/filesystem/object.go
@@ -0,0 +1,142 @@
+package filesystem
+
+import (
+	"fmt"
+	"os"
+
+	"gopkg.in/src-d/go-git.v4/core"
+	"gopkg.in/src-d/go-git.v4/formats/packfile"
+	"gopkg.in/src-d/go-git.v4/storage/filesystem/internal/dotgit"
+	"gopkg.in/src-d/go-git.v4/storage/filesystem/internal/index"
+	"gopkg.in/src-d/go-git.v4/utils/fs"
+)
+
+// ObjectStorage is an implementation of core.ObjectStorage that stores
+// data on disk in the standard git format (this is, the .git directory).
+//
+// Zero values of this type are not safe to use, see the New function below.
+//
+// Currently only reads are supported, no writting.
+//
+// Also values from this type are not yet able to track changes on disk, this is,
+// Gitdir values will get outdated as soon as repositories change on disk.
+type ObjectStorage struct {
+	dir   *dotgit.DotGit
+	index index.Index
+}
+
+func (s *ObjectStorage) NewObject() core.Object {
+	return &core.MemoryObject{}
+}
+
+// Set adds a new object to the storage. As this functionality is not
+// yet supported, this method always returns a "not implemented yet"
+// error an zero hash.
+func (s *ObjectStorage) Set(core.Object) (core.Hash, error) {
+	return core.ZeroHash, fmt.Errorf("not implemented yet")
+}
+
+// Get returns the object with the given hash, by searching for it in
+// the packfile.
+func (s *ObjectStorage) Get(h core.Hash) (core.Object, error) {
+	offset, err := s.index.Get(h)
+	if err != nil {
+		return nil, err
+	}
+
+	fs, path, err := s.dir.Packfile()
+	if err != nil {
+		return nil, err
+	}
+
+	f, err := fs.Open(path)
+	if err != nil {
+		return nil, err
+	}
+
+	defer func() {
+		errClose := f.Close()
+		if err == nil {
+			err = errClose
+		}
+	}()
+
+	_, err = f.Seek(offset, os.SEEK_SET)
+	if err != nil {
+		return nil, err
+	}
+
+	r := packfile.NewSeekable(f)
+	r.HashToOffset = map[core.Hash]int64(s.index)
+	p := packfile.NewParser(r)
+
+	obj := s.NewObject()
+	return obj, p.FillObject(obj)
+}
+
+// Iter returns an iterator for all the objects in the packfile with the
+// given type.
+func (s *ObjectStorage) Iter(t core.ObjectType) (core.ObjectIter, error) {
+	var objects []core.Object
+
+	for hash := range s.index {
+		object, err := s.Get(hash)
+		if err != nil {
+			return nil, err
+		}
+		if object.Type() == t {
+			objects = append(objects, object)
+		}
+	}
+
+	return core.NewObjectSliceIter(objects), nil
+}
+
+func buildIndex(dir *dotgit.DotGit) (index.Index, error) {
+	fs, idxfile, err := dir.Idxfile()
+	if err != nil {
+		if err == dotgit.ErrIdxNotFound {
+			return buildIndexFromPackfile(dir)
+		}
+		return nil, err
+	}
+
+	return buildIndexFromIdxfile(fs, idxfile)
+}
+
+func buildIndexFromPackfile(dir *dotgit.DotGit) (index.Index, error) {
+	fs, packfile, err := dir.Packfile()
+	if err != nil {
+		return nil, err
+	}
+
+	f, err := fs.Open(packfile)
+	if err != nil {
+		return nil, err
+	}
+
+	defer func() {
+		errClose := f.Close()
+		if err == nil {
+			err = errClose
+		}
+	}()
+
+	return index.NewFromPackfile(f)
+}
+
+func buildIndexFromIdxfile(fs fs.FS, path string) (index.Index, error) {
+	f, err := fs.Open(path)
+	if err != nil {
+		return nil, err
+	}
+
+	defer func() {
+		errClose := f.Close()
+		if err == nil {
+			err = errClose
+		}
+	}()
+
+	return index.NewFromIdx(f)
+}
-- 
cgit