Submodules init and update

_examples/clone/main.go

@@ -17,8 +17,9 @@ func main() {
 	Info("git clone %s %s", url, directory)
 
 	r, err := git.PlainClone(directory, false, &git.CloneOptions{
-		URL:   url,
-		Depth: 1,
+		URL:                 url,
+		RecursiveSubmodules: true,
+		Depth:               1,
 	})
 
 	CheckIfError(err)

common.go

@@ -1,23 +1,8 @@
 package git
 
-import (
-	"strings"
+import "strings"
 
-	"srcd.works/go-git.v4/config"
-	"srcd.works/go-git.v4/plumbing/storer"
-)
-
-// Storer is a generic storage of objects, references and any information
-// related to a particular repository. The package srcd.works/go-git.v4/storage
-// contains two implementation a filesystem base implementation (such as `.git`)
-// and a memory implementations being ephemeral
-type Storer interface {
-	storer.EncodedObjectStorer
-	storer.ReferenceStorer
-	storer.ShallowStorer
-	storer.IndexStorer
-	config.ConfigStorer
-}
+const defaultDotGitPath = ".git"
 
 // countLines returns the number of lines in a string à la git, this is
 // The newline character is assumed to be '\n'.  The empty string

config/config.go

@@ -37,6 +37,8 @@ type Config struct {
 		// IsBare if true this repository is assumed to be bare and has no
 		// working directory associated with it
 		IsBare bool
+		// Worktree is the path to the root of the working tree
+		Worktree string
 	}
 	// Remote list of repository remotes
 	Remotes map[string]*RemoteConfig
@@ -76,6 +78,7 @@ const (
 	fetchKey      = "fetch"
 	urlKey        = "url"
 	bareKey       = "bare"
+	worktreeKey   = "worktree"
 )
 
 // Unmarshal parses a git-config file and stores it
@@ -97,6 +100,8 @@ func (c *Config) unmarshalCore() {
 	if s.Options.Get(bareKey) == "true" {
 		c.Core.IsBare = true
 	}
+
+	c.Core.Worktree = s.Options.Get(worktreeKey)
 }
 
 func (c *Config) unmarshalRemotes() error {
@@ -129,6 +134,10 @@ func (c *Config) Marshal() ([]byte, error) {
 func (c *Config) marshalCore() {
 	s := c.raw.Section(coreSection)
 	s.SetOption(bareKey, fmt.Sprintf("%t", c.Core.IsBare))
+
+	if c.Core.Worktree != "" {
+		s.SetOption(worktreeKey, c.Core.Worktree)
+	}
 }
 
 func (c *Config) marshalRemotes() {

config/config_test.go

@@ -9,6 +9,7 @@ var _ = Suite(&ConfigSuite{})
 func (s *ConfigSuite) TestUnmarshall(c *C) {
 	input := []byte(`[core]
         bare = true
+		worktree = foo
 [remote "origin"]
         url = [email protected]:mcuadros/go-git.git
         fetch = +refs/heads/*:refs/remotes/origin/*
@@ -22,15 +23,39 @@ func (s *ConfigSuite) TestUnmarshall(c *C) {
 	c.Assert(err, IsNil)
 
 	c.Assert(cfg.Core.IsBare, Equals, true)
+	c.Assert(cfg.Core.Worktree, Equals, "foo")
 	c.Assert(cfg.Remotes, HasLen, 1)
 	c.Assert(cfg.Remotes["origin"].Name, Equals, "origin")
 	c.Assert(cfg.Remotes["origin"].URL, Equals, "[email protected]:mcuadros/go-git.git")
 	c.Assert(cfg.Remotes["origin"].Fetch, DeepEquals, []RefSpec{"+refs/heads/*:refs/remotes/origin/*"})
 }
 
+func (s *ConfigSuite) TestMarshall(c *C) {
+	output := []byte(`[core]
+	bare = true
+	worktree = bar
+[remote "origin"]
+	url = [email protected]:mcuadros/go-git.git
+`)
+
+	cfg := NewConfig()
+	cfg.Core.IsBare = true
+	cfg.Core.Worktree = "bar"
+	cfg.Remotes["origin"] = &RemoteConfig{
+		Name: "origin",
+		URL:  "[email protected]:mcuadros/go-git.git",
+	}
+
+	b, err := cfg.Marshal()
+	c.Assert(err, IsNil)
+
+	c.Assert(string(b), Equals, string(output))
+}
+
 func (s *ConfigSuite) TestUnmarshallMarshall(c *C) {
 	input := []byte(`[core]
 	bare = true
+	worktree = foo
 	custom = ignored
 [remote "origin"]
 	url = [email protected]:mcuadros/go-git.git

doc.go

@@ -7,4 +7,4 @@
 // It is highly extensible, we have been following the open/close principle in
 // its design to facilitate extensions, mainly focusing the efforts on the
 // persistence of the objects.
-package git
+package git // import "srcd.works/go-git.v4"

options.go

@@ -32,6 +32,10 @@ type CloneOptions struct {
 	SingleBranch bool
 	// Limit fetching to the specified number of commits
 	Depth int
+	// RecursiveSubmodules after the clone is created, initialize all submodules
+	// within, using their default settings. This option is ignored if the
+	// cloned repository does not have a worktree
+	RecursiveSubmodules bool
 	// Progress is where the human readable information sent by the server is
 	// stored, if nil nothing is stored and the capability (if supported)
 	// no-progress, is sent to the server to avoid send this information

plumbing/format/index/encoder.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"hash"
 	"io"
+	"sort"
 	"time"
 
 	"srcd.works/go-git.v4/utils/binary"
@@ -61,6 +62,8 @@ func (e *Encoder) encodeHeader(idx *Index) error {
 }
 
 func (e *Encoder) encodeEntries(idx *Index) error {
+	sort.Sort(ByName(idx.Entries))
+
 	for _, entry := range idx.Entries {
 		if err := e.encodeEntry(&entry); err != nil {
 			return err
@@ -139,3 +142,9 @@ func (e *Encoder) padEntry(wrote int) error {
 func (e *Encoder) encodeFooter() error {
 	return binary.Write(e.w, e.hash.Sum(nil))
 }
+
+type ByName []Entry
+
+func (l ByName) Len() int           { return len(l) }
+func (l ByName) Swap(i, j int)      { l[i], l[j] = l[j], l[i] }
+func (l ByName) Less(i, j int) bool { return l[i].Name < l[j].Name }

plumbing/format/index/encoder_test.go

@@ -23,6 +23,11 @@ func (s *IndexSuite) TestEncode(c *C) {
 			Stage:      TheirMode,
 			Hash:       plumbing.NewHash("e25b29c8946e0e192fae2edc1dabf7be71e8ecf3"),
 			Name:       "foo",
+		}, {
+			CreatedAt:  time.Now(),
+			ModifiedAt: time.Now(),
+			Name:       "bar",
+			Size:       82,
 		}, {
 			CreatedAt:  time.Now(),
 			ModifiedAt: time.Now(),
@@ -42,6 +47,11 @@ func (s *IndexSuite) TestEncode(c *C) {
 	c.Assert(err, IsNil)
 
 	c.Assert(idx, DeepEquals, output)
+
+	c.Assert(output.Entries[0].Name, Equals, strings.Repeat(" ", 20))
+	c.Assert(output.Entries[1].Name, Equals, "bar")
+	c.Assert(output.Entries[2].Name, Equals, "foo")
+
 }
 
 func (s *IndexSuite) TestEncodeUnsuportedVersion(c *C) {

plumbing/format/index/index.go

@@ -36,9 +36,14 @@ const (
 // in the worktree, having information about the working files. Changes in
 // worktree are detected using this Index. The Index is also used during merges
 type Index struct {
-	Version     uint32
-	Entries     []Entry
-	Cache       *Tree
+	// Version is index version
+	Version uint32
+	// Entries collection of entries represented by this Index. The order of
+	// this collection is not guaranteed
+	Entries []Entry
+	// Cache represents the 'Cached tree' extension
+	Cache *Tree
+	// ResolveUndo represents the 'Resolve undo' extension
 	ResolveUndo *ResolveUndo
 }
 
@@ -84,7 +89,7 @@ type TreeEntry struct {
 	// Path component (relative to its parent directory)
 	Path string
 	// Entries is the number of entries in the index that is covered by the tree
-	// this entry represents
+	// this entry represents.
 	Entries int
 	// Trees is the number that represents the number of subtrees this tree has
 	Trees int

plumbing/object/file.go

@@ -81,7 +81,7 @@ func (iter *FileIter) Next() (*File, error) {
 			return nil, err
 		}
 
-		if entry.Mode.IsDir() {
+		if entry.Mode.IsDir() || entry.Mode == SubmoduleMode {
 			continue
 		}
 

plumbing/object/file_test.go

@@ -247,3 +247,29 @@ func (s *FileSuite) TestFileIter(c *C) {
 
 	c.Assert(count, Equals, 1)
 }
+
+func (s *FileSuite) TestFileIterSubmodule(c *C) {
+	st, err := filesystem.NewStorage(fixtures.ByTag("submodule").One().DotGit())
+	c.Assert(err, IsNil)
+
+	hash := plumbing.NewHash("a692ec699bff9117c1ed91752afbb7d9d272ebef")
+	commit, err := GetCommit(st, hash)
+	c.Assert(err, IsNil)
+
+	tree, err := commit.Tree()
+	c.Assert(err, IsNil)
+
+	expected := []string{
+		".gitmodules",
+	}
+
+	var count int
+	i := tree.Files()
+	i.ForEach(func(f *File) error {
+		c.Assert(f.Name, Equals, expected[count])
+		count++
+		return nil
+	})
+
+	c.Assert(count, Equals, 1)
+}

plumbing/object/tree.go

@@ -375,11 +375,6 @@ func (w *TreeWalker) Next() (name string, entry TreeEntry, err error) {
 			return
 		}
 
-		if entry.Mode == SubmoduleMode {
-			err = nil
-			continue
-		}
-
 		if entry.Mode.IsDir() {
 			obj, err = GetTree(w.s, entry.Hash)
 		}

plumbing/object/tree_test.go

@@ -4,7 +4,10 @@ import (
 	"io"
 	"os"
 
+	fixtures "github.com/src-d/go-git-fixtures"
+
 	"srcd.works/go-git.v4/plumbing"
+	"srcd.works/go-git.v4/storage/filesystem"
 
 	. "gopkg.in/check.v1"
 	"srcd.works/go-git.v4/plumbing/storer"
@@ -262,6 +265,41 @@ func (s *TreeSuite) TestTreeWalkerNextNonRecursive(c *C) {
 	c.Assert(count, Equals, 8)
 }
 
+func (s *TreeSuite) TestTreeWalkerNextSubmodule(c *C) {
+	st, err := filesystem.NewStorage(fixtures.ByTag("submodule").One().DotGit())
+	c.Assert(err, IsNil)
+
+	hash := plumbing.NewHash("a692ec699bff9117c1ed91752afbb7d9d272ebef")
+	commit, err := GetCommit(st, hash)
+	c.Assert(err, IsNil)
+
+	tree, err := commit.Tree()
+	c.Assert(err, IsNil)
+
+	expected := []string{
+		".gitmodules",
+		"basic",
+		"itself",
+	}
+
+	var count int
+	walker := NewTreeWalker(tree, true)
+	for {
+		name, entry, err := walker.Next()
+		if err == io.EOF {
+			break
+		}
+
+		c.Assert(err, IsNil)
+		c.Assert(entry, NotNil)
+		c.Assert(name, Equals, expected[count])
+
+		count++
+	}
+
+	c.Assert(count, Equals, 3)
+}
+
 var treeWalkerExpects = []struct {
 	Path, Mode, Name, Hash, Tree string
 }{{

remote.go

@@ -16,6 +16,7 @@ import (
 	"srcd.works/go-git.v4/plumbing/storer"
 	"srcd.works/go-git.v4/plumbing/transport"
 	"srcd.works/go-git.v4/plumbing/transport/client"
+	"srcd.works/go-git.v4/storage"
 	"srcd.works/go-git.v4/storage/memory"
 	"srcd.works/go-git.v4/utils/ioutil"
 )
@@ -25,10 +26,10 @@ var NoErrAlreadyUpToDate = errors.New("already up-to-date")
 // Remote represents a connection to a remote repository
 type Remote struct {
 	c *config.RemoteConfig
-	s Storer
+	s storage.Storer
 }
 
-func newRemote(s Storer, c *config.RemoteConfig) *Remote {
+func newRemote(s storage.Storer, c *config.RemoteConfig) *Remote {
 	return &Remote{s: s, c: c}
 }
 
@@ -321,7 +322,9 @@ func getHaves(localRefs storer.ReferenceStorer) ([]plumbing.Hash, error) {
 	return haves, nil
 }
 
-func getWants(spec []config.RefSpec, localStorer Storer, remoteRefs storer.ReferenceStorer) ([]plumbing.Hash, error) {
+func getWants(
+	spec []config.RefSpec, localStorer storage.Storer, remoteRefs storer.ReferenceStorer,
+) ([]plumbing.Hash, error) {
 	wantTags := true
 	for _, s := range spec {
 		if !s.IsWildcard() {

remote_test.go

@@ -11,6 +11,7 @@ import (
 	"srcd.works/go-git.v4/config"
 	"srcd.works/go-git.v4/plumbing"
 	"srcd.works/go-git.v4/plumbing/storer"
+	"srcd.works/go-git.v4/storage"
 	"srcd.works/go-git.v4/storage/filesystem"
 	"srcd.works/go-git.v4/storage/memory"
 
@@ -126,7 +127,7 @@ func (s *RemoteSuite) TestFetchWithProgress(c *C) {
 }
 
 type mockPackfileWriter struct {
-	Storer
+	storage.Storer
 	PackfileWriterCalled bool
 }