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,9 +37,13 @@ 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 list of repository remotes
 	Remotes map[string]*RemoteConfig
+	// Submodules list of repository submodules
+	Submodules map[string]*Submodule
 
 	// contains the raw information of a config file, the main goal is preserve
 	// the parsed information from the original format, to avoid missing
@@ -50,8 +54,9 @@ type Config struct {
 // NewConfig returns a new empty Config
 func NewConfig() *Config {
 	return &Config{
-		Remotes: make(map[string]*RemoteConfig, 0),
-		raw:     format.New(),
+		Remotes:    make(map[string]*RemoteConfig, 0),
+		Submodules: make(map[string]*Submodule, 0),
+		raw:        format.New(),
 	}
 }
 
@@ -71,11 +76,13 @@ func (c *Config) Validate() error {
 }
 
 const (
-	remoteSection = "remote"
-	coreSection   = "core"
-	fetchKey      = "fetch"
-	urlKey        = "url"
-	bareKey       = "bare"
+	remoteSection    = "remote"
+	submoduleSection = "submodule"
+	coreSection      = "core"
+	fetchKey         = "fetch"
+	urlKey           = "url"
+	bareKey          = "bare"
+	worktreeKey      = "worktree"
 )
 
 // Unmarshal parses a git-config file and stores it
@@ -89,6 +96,7 @@ func (c *Config) Unmarshal(b []byte) error {
 	}
 
 	c.unmarshalCore()
+	c.unmarshalSubmodules()
 	return c.unmarshalRemotes()
 }
 
@@ -97,6 +105,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 {
@@ -113,10 +123,21 @@ func (c *Config) unmarshalRemotes() error {
 	return nil
 }
 
+func (c *Config) unmarshalSubmodules() {
+	s := c.raw.Section(submoduleSection)
+	for _, sub := range s.Subsections {
+		m := &Submodule{}
+		m.unmarshal(sub)
+
+		c.Submodules[m.Name] = m
+	}
+}
+
 // Marshal returns Config encoded as a git-config file
 func (c *Config) Marshal() ([]byte, error) {
 	c.marshalCore()
 	c.marshalRemotes()
+	c.marshalSubmodules()
 
 	buf := bytes.NewBuffer(nil)
 	if err := format.NewEncoder(buf).Encode(c.raw); err != nil {
@@ -129,6 +150,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() {
@@ -142,6 +167,21 @@ func (c *Config) marshalRemotes() {
 	}
 }
 
+func (c *Config) marshalSubmodules() {
+	s := c.raw.Section(submoduleSection)
+	s.Subsections = make(format.Subsections, len(c.Submodules))
+
+	var i int
+	for _, r := range c.Submodules {
+		section := r.marshal()
+		// the submodule section at config is a subset of the .gitmodule file
+		// we should remove the non-valid options for the config file.
+		section.RemoveOption(pathKey)
+		s.Subsections[i] = section
+		i++
+	}
+}
+
 // RemoteConfig contains the configuration for a given remote repository
 type RemoteConfig struct {
 	// Name of the remote

config/config_test.go

@@ -9,9 +9,14 @@ 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/*
+[submodule "qux"]
+        path = qux
+        url = https://github.com/foo/qux.git
+		branch = bar
 [branch "master"]
         remote = origin
         merge = refs/heads/master
@@ -22,15 +27,51 @@ 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/*"})
+	c.Assert(cfg.Submodules, HasLen, 1)
+	c.Assert(cfg.Submodules["qux"].Name, Equals, "qux")
+	c.Assert(cfg.Submodules["qux"].URL, Equals, "https://github.com/foo/qux.git")
+	c.Assert(cfg.Submodules["qux"].Branch, Equals, "bar")
+
+}
+
+func (s *ConfigSuite) TestMarshall(c *C) {
+	output := []byte(`[core]
+	bare = true
+	worktree = bar
+[remote "origin"]
+	url = [email protected]:mcuadros/go-git.git
+[submodule "qux"]
+	url = https://github.com/foo/qux.git
+`)
+
+	cfg := NewConfig()
+	cfg.Core.IsBare = true
+	cfg.Core.Worktree = "bar"
+	cfg.Remotes["origin"] = &RemoteConfig{
+		Name: "origin",
+		URL:  "[email protected]:mcuadros/go-git.git",
+	}
+
+	cfg.Submodules["qux"] = &Submodule{
+		Name: "qux",
+		URL:  "https://github.com/foo/qux.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

config/modules.go

@@ -30,9 +30,8 @@ func NewModules() *Modules {
 }
 
 const (
-	submoduleSection = "submodule"
-	pathKey          = "path"
-	branchKey        = "branch"
+	pathKey   = "path"
+	branchKey = "branch"
 )
 
 // Unmarshal parses a git-config file and stores it

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)
 		}