config: multiple values in RemoteConfig (URLs and Fetch)

* Change `URL string` to `URL []string` in `RemoteConfig`, since
git allows multiple URLs per remote. See:
http://marc.info/?l=git&m=116231242118202&w=2

* Fix marshalling of multiple fetch refspecs.

_examples/remotes/main.go

···
 	Info("git remote add example https://github.com/git-fixtures/basic.git")
 	_, err = r.CreateRemote(&config.RemoteConfig{
 		Name: "example",
-		URL:  "https://github.com/git-fixtures/basic.git",
+		URLs: []string{"https://github.com/git-fixtures/basic.git"},
 	})
 
 	CheckIfError(err)

config/config.go

···
 type RemoteConfig struct {
 	// Name of the remote
 	Name string
-	// URL the URL of a remote repository
-	URL string
+	// URLs the URLs of a remote repository. It must be non-empty. Fetch will
+	// always use the first URL, while push will use all of them.
+	URLs []string
 	// Fetch the default set of "refspec" for fetch operation
 	Fetch []RefSpec
 
···
 		return ErrRemoteConfigEmptyName
 	}
 
-	if c.URL == "" {
+	if len(c.URLs) == 0 {
 		return ErrRemoteConfigEmptyURL
 	}
 
···
 		}
 
 		fetch = append(fetch, rs)
+	}
+
+	var urls []string
+	for _, f := range c.raw.Options.GetAll(urlKey) {
+		urls = append(urls, f)
 	}
 
 	c.Name = c.raw.Name
-	c.URL = c.raw.Option(urlKey)
+	c.URLs = urls
 	c.Fetch = fetch
 
 	return nil
···
 	}
 
 	c.raw.Name = c.Name
-	c.raw.SetOption(urlKey, c.URL)
+	c.raw.RemoveOption(urlKey)
+	for _, url := range c.URLs {
+		c.raw.AddOption(urlKey, url)
+	}
+
+	c.raw.RemoveOption(fetchKey)
 	for _, rs := range c.Fetch {
-		c.raw.SetOption(fetchKey, rs.String())
+		c.raw.AddOption(fetchKey, rs.String())
 	}
 
 	return c.raw

config/config_test.go

···
 [remote "origin"]
         url = [e-mail]:mcuadros/go-git.git
         fetch = +refs/heads/*:refs/remotes/origin/*
+[remote "alt"]
+		url = [e-mail]:mcuadros/go-git.git
+		url = [e-mail]:src-d/go-git.git
+		fetch = +refs/heads/*:refs/remotes/origin/*
+		fetch = +refs/pull/*:refs/remotes/origin/pull/*
 [submodule "qux"]
         path = qux
         url = https://github.com/foo/qux.git
···
 
 	c.Assert(cfg.Core.IsBare, Equals, true)
 	c.Assert(cfg.Core.Worktree, Equals, "foo")
-	c.Assert(cfg.Remotes, HasLen, 1)
+	c.Assert(cfg.Remotes, HasLen, 2)
 	c.Assert(cfg.Remotes["origin"].Name, Equals, "origin")
-	c.Assert(cfg.Remotes["origin"].URL, Equals, "[e-mail]:mcuadros/go-git.git")
+	c.Assert(cfg.Remotes["origin"].URLs, DeepEquals, []string{"[e-mail]:mcuadros/go-git.git"})
 	c.Assert(cfg.Remotes["origin"].Fetch, DeepEquals, []RefSpec{"+refs/heads/*:refs/remotes/origin/*"})
+	c.Assert(cfg.Remotes["alt"].Name, Equals, "alt")
+	c.Assert(cfg.Remotes["alt"].URLs, DeepEquals, []string{"[e-mail]:mcuadros/go-git.git", "[e-mail]:src-d/go-git.git"})
+	c.Assert(cfg.Remotes["alt"].Fetch, DeepEquals, []RefSpec{"+refs/heads/*:refs/remotes/origin/*", "+refs/pull/*:refs/remotes/origin/pull/*"})
 	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")
···
 	worktree = bar
 [remote "origin"]
 	url = [e-mail]:mcuadros/go-git.git
+[remote "alt"]
+	url = [e-mail]:mcuadros/go-git.git
+	url = [e-mail]:src-d/go-git.git
+	fetch = +refs/heads/*:refs/remotes/origin/*
+	fetch = +refs/pull/*:refs/remotes/origin/pull/*
 [submodule "qux"]
 	url = https://github.com/foo/qux.git
 `)
···
 	cfg.Core.Worktree = "bar"
 	cfg.Remotes["origin"] = &RemoteConfig{
 		Name: "origin",
-		URL:  "[e-mail]:mcuadros/go-git.git",
+		URLs: []string{"[e-mail]:mcuadros/go-git.git"},
+	}
+
+	cfg.Remotes["alt"] = &RemoteConfig{
+		Name:  "alt",
+		URLs:  []string{"[e-mail]:mcuadros/go-git.git", "[e-mail]:src-d/go-git.git"},
+		Fetch: []RefSpec{"+refs/heads/*:refs/remotes/origin/*", "+refs/pull/*:refs/remotes/origin/pull/*"},
 	}
 
 	cfg.Submodules["qux"] = &Submodule{
···
 }
 
 func (s *ConfigSuite) TestRemoteConfigValidateDefault(c *C) {
-	config := &RemoteConfig{Name: "foo", URL: "http://foo/bar"}
+	config := &RemoteConfig{Name: "foo", URLs: []string{"http://foo/bar"}}
 	c.Assert(config.Validate(), IsNil)
 
 	fetch := config.Fetch

example_test.go

···
 	// Add a new remote, with the default fetch refspec
 	_, err := r.CreateRemote(&config.RemoteConfig{
 		Name: "example",
-		URL:  "https://github.com/git-fixtures/basic.git",
+		URLs: []string{"https://github.com/git-fixtures/basic.git"},
 	})
 
 	if err != nil {

remote.go

···
 }
 
 func (r *Remote) String() string {
-	fetch := r.c.URL
-	push := r.c.URL
+	var fetch, push string
+	if len(r.c.URLs) > 0 {
+		fetch = r.c.URLs[0]
+		push = r.c.URLs[0]
+	}
 
 	return fmt.Sprintf("%s\t%s (fetch)\n%[1]s\t%[3]s (push)", r.c.Name, fetch, push)
 }
···
 		return fmt.Errorf("remote names don't match: %s != %s", o.RemoteName, r.c.Name)
 	}
 
-	s, err := newSendPackSession(r.c.URL, o.Auth)
+	s, err := newSendPackSession(r.c.URLs[0], o.Auth)
 	if err != nil {
 		return err
 	}
···
 		o.RefSpecs = r.c.Fetch
 	}
 
-	s, err := newUploadPackSession(r.c.URL, o.Auth)
+	s, err := newUploadPackSession(r.c.URLs[0], o.Auth)
 	if err != nil {
 		return nil, err
 	}

remote_test.go

···
 var _ = Suite(&RemoteSuite{})
 
 func (s *RemoteSuite) TestFetchInvalidEndpoint(c *C) {
-	r := newRemote(nil, &config.RemoteConfig{Name: "foo", URL: "http://\\"})
+	r := newRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"http://\\"}})
 	err := r.Fetch(&FetchOptions{RemoteName: "foo"})
 	c.Assert(err, ErrorMatches, ".*invalid character.*")
 }
 
 func (s *RemoteSuite) TestFetchNonExistentEndpoint(c *C) {
-	r := newRemote(nil, &config.RemoteConfig{Name: "foo", URL: "ssh://non-existent/foo.git"})
+	r := newRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"ssh://non-existent/foo.git"}})
 	err := r.Fetch(&FetchOptions{})
 	c.Assert(err, NotNil)
 }
 
 func (s *RemoteSuite) TestFetchInvalidSchemaEndpoint(c *C) {
-	r := newRemote(nil, &config.RemoteConfig{Name: "foo", URL: "qux://foo"})
+	r := newRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"qux://foo"}})
 	err := r.Fetch(&FetchOptions{})
 	c.Assert(err, ErrorMatches, ".*unsupported scheme.*")
 }
 
 func (s *RemoteSuite) TestFetchInvalidFetchOptions(c *C) {
-	r := newRemote(nil, &config.RemoteConfig{Name: "foo", URL: "qux://foo"})
+	r := newRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"qux://foo"}})
 	invalid := config.RefSpec("^*$ñ")
 	err := r.Fetch(&FetchOptions{RefSpecs: []config.RefSpec{invalid}})
 	c.Assert(err, Equals, config.ErrRefSpecMalformedSeparator)
···
 
 func (s *RemoteSuite) TestFetchWildcard(c *C) {
 	r := newRemote(memory.NewStorage(), &config.RemoteConfig{
-		URL: s.GetBasicLocalRepositoryURL(),
+		URLs: []string{s.GetBasicLocalRepositoryURL()},
 	})
 
 	s.testFetch(c, r, &FetchOptions{
···
 
 func (s *RemoteSuite) TestFetchWildcardTags(c *C) {
 	r := newRemote(memory.NewStorage(), &config.RemoteConfig{
-		URL: s.GetLocalRepositoryURL(fixtures.ByTag("tags").One()),
+		URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())},
 	})
 
 	s.testFetch(c, r, &FetchOptions{
···
 
 func (s *RemoteSuite) TestFetch(c *C) {
 	r := newRemote(memory.NewStorage(), &config.RemoteConfig{
-		URL: s.GetLocalRepositoryURL(fixtures.ByTag("tags").One()),
+		URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())},
 	})
 
 	s.testFetch(c, r, &FetchOptions{
···
 
 func (s *RemoteSuite) TestFetchContext(c *C) {
 	r := newRemote(memory.NewStorage(), &config.RemoteConfig{
-		URL: s.GetLocalRepositoryURL(fixtures.ByTag("tags").One()),
+		URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())},
 	})
 
 	ctx, cancel := context.WithCancel(context.Background())
···
 		},
 	})
 	c.Assert(err, NotNil)
-
 }
 
 func (s *RemoteSuite) TestFetchWithAllTags(c *C) {
 	r := newRemote(memory.NewStorage(), &config.RemoteConfig{
-		URL: s.GetLocalRepositoryURL(fixtures.ByTag("tags").One()),
+		URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())},
 	})
 
 	s.testFetch(c, r, &FetchOptions{
···
 
 func (s *RemoteSuite) TestFetchWithNoTags(c *C) {
 	r := newRemote(memory.NewStorage(), &config.RemoteConfig{
-		URL: s.GetLocalRepositoryURL(fixtures.ByTag("tags").One()),
+		URLs: []string{s.GetLocalRepositoryURL(fixtures.ByTag("tags").One())},
 	})
 
 	s.testFetch(c, r, &FetchOptions{
···
 
 func (s *RemoteSuite) TestFetchWithDepth(c *C) {
 	r := newRemote(memory.NewStorage(), &config.RemoteConfig{
-		URL: s.GetBasicLocalRepositoryURL(),
+		URLs: []string{s.GetBasicLocalRepositoryURL()},
 	})
 
 	s.testFetch(c, r, &FetchOptions{
···
 	sto := memory.NewStorage()
 	buf := bytes.NewBuffer(nil)
 
-	r := newRemote(sto, &config.RemoteConfig{Name: "foo", URL: url})
+	r := newRemote(sto, &config.RemoteConfig{Name: "foo", URLs: []string{url}})
 
 	refspec := config.RefSpec("+refs/heads/*:refs/remotes/origin/*")
 	err := r.Fetch(&FetchOptions{
···
 	mock := &mockPackfileWriter{Storer: fss}
 
 	url := s.GetBasicLocalRepositoryURL()
-	r := newRemote(mock, &config.RemoteConfig{Name: "foo", URL: url})
+	r := newRemote(mock, &config.RemoteConfig{Name: "foo", URLs: []string{url}})
 
 	refspec := config.RefSpec("+refs/heads/*:refs/remotes/origin/*")
 	err = r.Fetch(&FetchOptions{
···
 
 func (s *RemoteSuite) TestFetchNoErrAlreadyUpToDateButStillUpdateLocalRemoteRefs(c *C) {
 	r := newRemote(memory.NewStorage(), &config.RemoteConfig{
-		URL: s.GetBasicLocalRepositoryURL(),
+		URLs: []string{s.GetBasicLocalRepositoryURL()},
 	})
 
 	o := &FetchOptions{
···
 }
 
 func (s *RemoteSuite) doTestFetchNoErrAlreadyUpToDate(c *C, url string) {
-	r := newRemote(memory.NewStorage(), &config.RemoteConfig{URL: url})
+	r := newRemote(memory.NewStorage(), &config.RemoteConfig{URLs: []string{url}})
 
 	o := &FetchOptions{
 		RefSpecs: []config.RefSpec{
···
 func (s *RemoteSuite) TestString(c *C) {
 	r := newRemote(nil, &config.RemoteConfig{
 		Name: "foo",
-		URL:  "https://github.com/git-fixtures/basic.git",
+		URLs: []string{"https://github.com/git-fixtures/basic.git"},
 	})
 
 	c.Assert(r.String(), Equals, ""+
···
 
 	r := newRemote(sto, &config.RemoteConfig{
 		Name: DefaultRemoteName,
-		URL:  url,
+		URLs: []string{url},
 	})
 
 	rs := config.RefSpec("refs/heads/*:refs/heads/*")
···
 
 	r := newRemote(sto, &config.RemoteConfig{
 		Name: DefaultRemoteName,
-		URL:  url,
+		URLs: []string{url},
 	})
 
 	ctx, cancel := context.WithCancel(context.Background())
···
 
 	r := newRemote(sto, &config.RemoteConfig{
 		Name: DefaultRemoteName,
-		URL:  url,
+		URLs: []string{url},
 	})
 
 	err = r.Push(&PushOptions{
···
 
 	r := newRemote(sto, &config.RemoteConfig{
 		Name: DefaultRemoteName,
-		URL:  fs.Root(),
+		URLs: []string{fs.Root()},
 	})
 
 	err = r.Push(&PushOptions{
···
 	url := dstFs.Root()
 	r := newRemote(sto, &config.RemoteConfig{
 		Name: DefaultRemoteName,
-		URL:  url,
+		URLs: []string{url},
 	})
 
 	oldRef, err := dstSto.Reference(plumbing.ReferenceName("refs/heads/branch"))
···
 }
 
 func (s *RemoteSuite) TestPushInvalidEndpoint(c *C) {
-	r := newRemote(nil, &config.RemoteConfig{Name: "foo", URL: "http://\\"})
+	r := newRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"http://\\"}})
 	err := r.Push(&PushOptions{RemoteName: "foo"})
 	c.Assert(err, ErrorMatches, ".*invalid character.*")
 }
 
 func (s *RemoteSuite) TestPushNonExistentEndpoint(c *C) {
-	r := newRemote(nil, &config.RemoteConfig{Name: "foo", URL: "ssh://non-existent/foo.git"})
+	r := newRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"ssh://non-existent/foo.git"}})
 	err := r.Push(&PushOptions{})
 	c.Assert(err, NotNil)
 }
 
 func (s *RemoteSuite) TestPushInvalidSchemaEndpoint(c *C) {
-	r := newRemote(nil, &config.RemoteConfig{Name: "origin", URL: "qux://foo"})
+	r := newRemote(nil, &config.RemoteConfig{Name: "origin", URLs: []string{"qux://foo"}})
 	err := r.Push(&PushOptions{})
 	c.Assert(err, ErrorMatches, ".*unsupported scheme.*")
 }
 
 func (s *RemoteSuite) TestPushInvalidFetchOptions(c *C) {
-	r := newRemote(nil, &config.RemoteConfig{Name: "foo", URL: "qux://foo"})
+	r := newRemote(nil, &config.RemoteConfig{Name: "foo", URLs: []string{"qux://foo"}})
 	invalid := config.RefSpec("^*$ñ")
 	err := r.Push(&PushOptions{RefSpecs: []config.RefSpec{invalid}})
 	c.Assert(err, Equals, config.ErrRefSpecMalformedSeparator)
···
 func (s *RemoteSuite) TestPushInvalidRefSpec(c *C) {
 	r := newRemote(nil, &config.RemoteConfig{
 		Name: DefaultRemoteName,
-		URL:  "some-url",
+		URLs: []string{"some-url"},
 	})
 
 	rs := config.RefSpec("^*$**")
···
 func (s *RemoteSuite) TestPushWrongRemoteName(c *C) {
 	r := newRemote(nil, &config.RemoteConfig{
 		Name: DefaultRemoteName,
-		URL:  "some-url",
+		URLs: []string{"some-url"},
 	})
 
 	err := r.Push(&PushOptions{

repository.go

···
 
 	c := &config.RemoteConfig{
 		Name: o.RemoteName,
-		URL:  o.URL,
+		URLs: []string{o.URL},
 	}
 
 	if _, err := r.CreateRemote(c); err != nil {

repository_test.go

···
 	r, _ := Init(memory.NewStorage(), nil)
 	remote, err := r.CreateRemote(&config.RemoteConfig{
 		Name: "foo",
-		URL:  "http://foo/foo.git",
+		URLs: []string{"http://foo/foo.git"},
 	})
 
 	c.Assert(err, IsNil)
···
 	r, _ := Init(memory.NewStorage(), nil)
 	_, err := r.CreateRemote(&config.RemoteConfig{
 		Name: "foo",
-		URL:  "http://foo/foo.git",
+		URLs: []string{"http://foo/foo.git"},
 	})
 
 	c.Assert(err, IsNil)
···
 	r, _ := Init(memory.NewStorage(), nil)
 	_, err := r.CreateRemote(&config.RemoteConfig{
 		Name: DefaultRemoteName,
-		URL:  s.GetBasicLocalRepositoryURL(),
+		URLs: []string{s.GetBasicLocalRepositoryURL()},
 	})
 	c.Assert(err, IsNil)
 	c.Assert(r.Fetch(&FetchOptions{}), IsNil)
···
 	r, _ := Init(memory.NewStorage(), nil)
 	_, err := r.CreateRemote(&config.RemoteConfig{
 		Name: DefaultRemoteName,
-		URL:  s.GetBasicLocalRepositoryURL(),
+		URLs: []string{s.GetBasicLocalRepositoryURL()},
 	})
 	c.Assert(err, IsNil)
 
···
 	c.Assert(cfg.Core.IsBare, Equals, true)
 	c.Assert(cfg.Remotes, HasLen, 1)
 	c.Assert(cfg.Remotes["origin"].Name, Equals, "origin")
-	c.Assert(cfg.Remotes["origin"].URL, Not(Equals), "")
+	c.Assert(cfg.Remotes["origin"].URLs, HasLen, 1)
 }
 
 func (s *RepositorySuite) TestCloneSingleBranchAndNonHEAD(c *C) {
···
 
 	_, err = s.Repository.CreateRemote(&config.RemoteConfig{
 		Name: "test",
-		URL:  url,
+		URLs: []string{url},
 	})
 	c.Assert(err, IsNil)
 
···
 
 	_, err = s.Repository.CreateRemote(&config.RemoteConfig{
 		Name: "foo",
-		URL:  url,
+		URLs: []string{url},
 	})
 	c.Assert(err, IsNil)
 

storage/filesystem/config_test.go

···
 	"os"
 
 	"github.com/src-d/go-git-fixtures"
+	"gopkg.in/src-d/go-git.v4/config"
 	"gopkg.in/src-d/go-git.v4/storage/filesystem/internal/dotgit"
 
 	. "gopkg.in/check.v1"
···
 	c.Assert(remotes, HasLen, 1)
 	remote := remotes["origin"]
 	c.Assert(remote.Name, Equals, "origin")
-	c.Assert(remote.URL, Equals, "https://github.com/git-fixtures/basic")
-	c.Assert(remote.Fetch, HasLen, 1)
-	c.Assert(remote.Fetch[0].String(), Equals, "+refs/heads/*:refs/remotes/origin/*")
+	c.Assert(remote.URLs, DeepEquals, []string{"https://github.com/git-fixtures/basic"})
+	c.Assert(remote.Fetch, DeepEquals, []config.RefSpec{config.RefSpec("+refs/heads/*:refs/remotes/origin/*")})
 }
 
 func (s *ConfigSuite) TearDownTest(c *C) {

storage/test/storage_suite.go

···
 	expected.Core.IsBare = true
 	expected.Remotes["foo"] = &config.RemoteConfig{
 		Name: "foo",
-		URL:  "http://foo/bar.git",
+		URLs: []string{"http://foo/bar.git"},
 	}
 
 	err := s.Storer.SetConfig(expected)

submodule.go

···
 
 	_, err = r.CreateRemote(&config.RemoteConfig{
 		Name: DefaultRemoteName,
-		URL:  s.c.URL,
+		URLs: []string{s.c.URL},
 	})
 
 	return r, err

worktree_test.go

···
 	r, _ := Init(memory.NewStorage(), fs)
 	r.CreateRemote(&config.RemoteConfig{
 		Name: DefaultRemoteName,
-		URL:  s.GetBasicLocalRepositoryURL(),
+		URLs: []string{s.GetBasicLocalRepositoryURL()},
 	})
 
 	w, err := r.Worktree()
···
 	r, _ := Init(memory.NewStorage(), memfs.New())
 	r.CreateRemote(&config.RemoteConfig{
 		Name: DefaultRemoteName,
-		URL:  s.GetBasicLocalRepositoryURL(),
+		URLs: []string{s.GetBasicLocalRepositoryURL()},
 	})
 
 	err := r.Fetch(&FetchOptions{})
···
 
 	r.CreateRemote(&config.RemoteConfig{
 		Name: DefaultRemoteName,
-		URL:  s.GetBasicLocalRepositoryURL(),
+		URLs: []string{s.GetBasicLocalRepositoryURL()},
 	})
 
 	w, err := r.Worktree()
···
 	r, _ := PlainInit(dir, false)
 	r.CreateRemote(&config.RemoteConfig{
 		Name: DefaultRemoteName,
-		URL:  path,
+		URLs: []string{path},
 	})
 
 	w, err := r.Worktree()